tutortan training computer

5 Tips to Effective SEO Keyword Research Analysis

2007-07-18T09:25:00.000-07:00

Keyword research and analysis can be a daunting task, when done correctly, and expert keyword research is the foundation to a successful SEO campaign. Many new website owners think the keyword research analysis process is easy. They think free tools, such as the Overture Search Term Suggestion Tool is the profít pill that will bring them ínstant results.
Unfortunately, the frëe tools will only give you a rough guide and a quick indication whether a hunch is worth further research. These frëe keyword research tools are limited to basic information. When performed correctly, expert keyword research exposes so much more - all the gems that are tucked away deep.
Real keyword research requires research AND analysis. There are so many aspects to the process that cannot be left to chance. Attempting to do the keyword research on your own is like going to a veterinarian to fix your car. My advise to all clients I do SEO consulting services for is to simply leave this task to the experts who have the correct keyword research tools and expertise.
Following are 5 tips for effective keyword research analysis:
1. Latent Semantic Indexing (LSI) - Use multi-word phrases
Latent Semantic Indexing (LSI) is a vital element in Search Engine Optimization (SEO) for better keyword rankings in search results. LSI is based on the relationship, the "clustering" or positioning, the variations of terms and the iterations of your keyword phrases.
Expertly knowing LSI and how it can be most useful and beneficial for your SEO and the importance it has with the algorithm updates to search engines like Google, MSN and Yahoo which will benefit your keyword research for best practice SEO.
LSI is NOT new. Those doing keyword research over the years have always known to use synonyms and "long tail" keyword terms which is a simpler "explanation" to LSI. More often than not, these long tail, less generic terms bring more traffíc to your site than the main keyword phrases. The real bottom line is that Latent Semantic Indexing is currently a MUST in keyword research and SEO.
2. Page Specific Keyword Research - Target your niche keyword phrases for each site page
Probably the most common mistake in keyword research is using a plethora of keywords and pasting the same meta keyword tag on every web site page. This is SO not effective! Your keyword research needs to be page specific and only focusing on 2 to 5 keywords per page. It's more work, but combined with best practice SEO, gives each site page a chance for higher ranking on its own.
3. Country Specific Keyword Research and Search Engine Reference
Keep in mind that keyword search terms can be country specific. Even though a country is English speaking, there are different keyword terms you must research - and then reference that country's search engine when doing your initial keyword research. For instance, UK and Australia may have different expressions, terminology and spellings (i.e. colour, personalised). Referencing the terms in the corresponding search engine is an important element to keyword research that is often forgotten. So for example, be sure to chëck the search terms on google.co.uk or au.yahoo.com. And, of course, if you have 3 to 4 really comprehensive research tools in your arsenal, you will be able to search for historical, global and country specific search terms easily and effectively.
4. Keyword Analysis - Cross referencing in the search engines
Once the majority of the keyword research has been done for a site page, it's time to plug those terms into the search engines to determine:
If it is really the desired niche keyword for that page
To assess the competitiveness of your keywords. Along with checking the competitiveness of your keywords you should look at the strength of the competition.
Are the other sites listed for your keywords truly your competitors?
Are the sites listed for your keyword even related to your industry, products or services?
These critical analyses of keyword phrases are often forgotten. Since the keyword research and analysis is the foundation of a successful SEO campaign, you certainly don't want to build your on-page optimization on the wrong niche keywords!
5. Ongoing Keyword Research - Repeat your keyword research on a consistent basis
While you may think that you have completed your keyword research analysis and laid a solid foundation for your SEO, you need to keep monitoring your keywords and tweak as necessary. Keywords can change from month to month as keyword search terms change, genres change and/or if your niche is within social portal networking sites - to name just a few. Maintaining ongoing keyword research is essential for best practice SEO.
Most Successful Strategy to Streamline Your Keyword Research Efforts:
Yes, many website owners will opt to do the keyword research and analysis themselves with only a marginal effect on an SEO campaign. It's not the most successful strategy to use for the most effective results.
To be certain of your keyword data, accurate keyword analysis should be performed - and cross referenced - across multiple expert keyword tools.
Effective keyword research lays the ground work for effective SEO results and can help you kick-start the ranking process - perhaps even giving you a step up on your competitors.
The most successful strategy to streamline your keyword research efforts is to hire an expert. Focus your business efforts on your strengths and expertise and allow the SEO experts to effectively perform the keyword research analysis correctly.

21 Essential SEO Tips & Techniques

2007-06-29T22:07:00.000-07:00

Small businesses are growing more aware of the need to understand and implement at least the basics of search engine optimization. But if you read a variety of small businesses blogs and Web sites, you'll quickly see that there's a lot of uncertainty over what makes up "the basics." Without access to high-level consulting and without a lot of experience knowing what SEO resources can be trusted, there's also a lot of misinformation about SEO strategies and tactics.
This article is the second in a two-part SEO checklist specifically for small business owners and webmasters. Last week, I shared 20 "don'ts." Naturally, this week addresses the "Do's"—things to make sure you include whether you're hiring an SEO company or doing it yourself.
Small Business SEO Checklist: The Do's
1. Commit yourself to the process. SEO isn't a one-time event. Search engine algorithms change regularly, so the tactics that worked last year may not work this year. SEO requires a long-term outlook and commitment.
2. Be patient. SEO isn't about instant gratification. Results often take months to see, and this is especially true the smaller you are, and the newer you are to doing business online.
3. Ask a lot of questions when hiring an SEO company. It's your job to know what kind of tactics the company uses. Ask for specifics. Ask if there are any risks involved. Then get online yourself and do your own research—about the company, about the tactics they discussed, and so forth.
4. Become a student of SEO. If you're taking the do-it-yourself route, you'll have to become a student of SEO and learn as much as you can. Luckily for you, there are plenty of great Web resources (like Search Engine Land) and several terrific books you can read. Aaron Wall's SEO Book, Jennifer Laycock's Small Business Guide to Search Engine Marketing, and Search Engine Optimization: An Hour a Day by Jennifer Grappone and Gradiva Couzin are three I've read and recommend.
5. Have web analytics in place at the start. You should have clearly defined goals for your SEO efforts, and you'll need web analytics software in place so you can track what's working and what's not.
6. Build a great web site. I'm sure you want to show up on the first page of results. Ask yourself, "Is my site really one of the 10 best sites in the world on this topic?" Be honest. If it's not, make it better.
7. Include a site map page. Spiders can't index pages that can't be crawled. A site map will help spiders find all the important pages on your site, and help the spider understand your site's hierarchy. This is especially helpful if your site has a hard-to-crawl navigation menu. If your site is large, make several site map pages. Keep each one to less than 100 links. I tell clients 75 is the max to be safe.
8. Make SEO-friendly URLs. Use keywords in your URLs and file names, such as yourdomain.com/red-widgets.html. Don't overdo it, though. A file with 3+ hyphens tends to look spammy and users may be hesitant to click on it. Related bonus tip: Use hyphens in URLs and file names, not underscores. Hyphens are treated as a "space," while underscores are not.
9. Do keyword research at the start of the project. If you're on a tight budget, use the free versions of Keyword Discovery or WordTracker, both of which also have more powerful paid versions. Ignore the numbers these tools show; what's important is the relative volume of one keyword to another. Another good free tool is Google's AdWords Keyword Tool, which doesn't show exact numbers.
10. Open up a PPC account. Whether it's Google's AdWords or Yahoo's Search Marketing or something else, this is a great way to get actual search volume for your keywords. Yes, it costs money, but if you have the budget it's worth the investment. It's also the solution if you didn't like the "Be patient" suggestion above and are looking for instant visibility.
11. Use a unique and relevant title and meta description on every page. The page title is the single most important on-page SEO factor. It's rare to rank highly for a primary term (2-3 words) without that term being part of the page title. The meta description tag won't help you rank, but it will often appear as the text snippet below your listing, so it should include the relevant keyword(s) and be written so as to encourage searchers to click on your listing. Related bonus tip: You can ignore the Keywords meta altogether if you'd like; it's close to inconsequential. If you use it, put misspellings in there, and any related keywords that don't appear on the page.
12. Write for users first. Google, Yahoo, etc., have pretty powerful bots crawling the web, but to my knowledge these bots have never bought anything online, signed up for a newsletter, or picked up the phone to call about your services. Humans do those things, so write your page copy with humans in mind. Yes, you need keywords in the text, but don't stuff each page like a Thanksgiving turkey. Keep it readable.
13. Create great, unique content. This is important for everyone, but it's a particular challenge for online retailers. If you're selling the same widget that 50 other retailers are selling, and everyone is using the boilerplate descriptions from the manufacturer, this is a great opportunity. Write your own product descriptions, using the keyword research you did earlier (see #9 above) to target actual words searchers use, and make product pages that blow the competition away. Plus, retailer or not, great content is a great way to get inbound links.
14. Use your keywords as anchor text when linking internally. Anchor text helps tells spiders what the linked-to page is about. Links that say "click here" do nothing for your search engine visibility.
15. Build links intelligently. Submit your site to quality, trusted directories such as Yahoo, DMOZ, Business.com, Aviva, and Best of the web. Seek links from authority sites in your industry. If local search matters to you (more on that coming up), seek links from trusted sites in your geographic area—the Chamber of Commerce, etc. Analyze the inbound links to your competitors to find links you can acquire, too.
16. Use press releases wisely. Developing a relationship with media covering your industry or your local region can be a great source of exposure, including getting links from trusted media web sites. Distributing releases online can be an effective link building tactic, and opens the door for exposure in news search sites. Related bonus tip: Only issue a release when you have something newsworthy to report. Don't waste journalists' time.
17. Start a blog and participate with other related blogs. Search engines, Google especially, love blogs for the fresh content and highly-structured data. Beyond that, there's no better way to join the conversations that are already taking place about your industry and/or company. Reading and commenting on other blogs can also increase your exposure and help you acquire new links. Related bonus tip: Put your blog at yourdomain.com/blog so your main domain gets the benefit of any links to your blog posts. If that's not possible, use blog.yourdomain.com.
18. Use social media marketing wisely. If your small business has a visual element, join the appropriate communities on Flickr and post high-quality photos there. If you're a service-oriented business, use Yahoo Answers to position yourself as an expert in your industry. With any social media site you use, the first rule is don't spam! Be an active, contributing member of the site. The idea is to interact with potential customers, not annoy them.
19. Take advantage of local search opportunities. Online research for offline buying is a growing trend. Optimize your site to catch local traffic by showing your address and local phone number prominently. Write a detailed Directions/Location page using neighborhoods and landmarks in the page text. Submit your site to the free local listings services that the major search engines offer. Make sure your site is listed in local/social directories such as CitySearch, Yelp, Local.com, etc., and encourage customers to leave reviews of your business on these sites, too.
20. Take advantage of the tools the search engines give you. Sign up for Google's webmaster Central and Yahoo's Site Explorer to learn more about how the search engines see your site, including how many inbound links they're aware of.
21. Diversify your traffic sources. Google may bring you 70% of your traffic today, but what if the next big algorithm update hits you hard? What if your Google visibility goes away tomorrow? Newsletters and other subscriber-based content can help you hold on to traffic/customers no matter what the search engines do. In fact, many of the DOs on this list—creating great content, starting a blog, using social media and local search, etc.—will help you grow an audience of loyal prospects and customers that may help you survive the whims of search engines.
Just like last week, this list could continue well beyond these 21 "DOs." Your additions are welcome in the comments.
With this checklist and last week's list of "Don'ts," you should be able to develop a good plan of attack for your SEO efforts for your small business.
Matt McGee is the SEO Manager for Marchex, Inc., a search and media company offering search marketing services through its TrafficLeader subsidiary. The Small Is Beautiful column appears on Thursdays at Search Engine Land.

Determining the Size of a Class Object

2007-06-17T09:53:00.000-07:00

There are many factors that decide the size of an object of a class in C++. These factors are:
Size of all non-static data members
Order of data members
Byte alignment or byte padding
Size of its immediate base class
The existence of virtual function(s) (Dynamic polymorphism using virtual functions).
Compiler being used
Mode of inheritance (virtual inheritance)
Size of all non-static data membersOnly non-static data members will be counted for calculating sizeof class/object. class A {
private:
float iMem1;
const int iMem2;
static int iMem3;
char iMem4;
};
For an object of class A, the size will be the size of float iMem1 + size of int iMem2 + size of char iMem3. Static members are really not part of the class object. They won't be included in object's layout. <2>Order of data members
The order in which one specifies data members also alters the size of the class. class C {
char c;
int int1;
int int2;
int i;
long l;
short s;
};
The size of this class is 24 bytes. Even though char c will consume only 1 byte, 4 bytes will be allocated for it, and the remaining 3 bytes will be wasted (holes). This is because the next member is an int, which takes 4 bytes. If we don't go to the next (4th) byte for storing this integer member, the memory access/modify cycle for this integer will be 2 read cycles. So the compiler will do this for us, unless we specify some byte padding/packing. If I re-write the above class in different order, keeping all my data members like below: class C {
int int1;
int int2;
int i;
long l;
short s;
char c;
};
Now the size of this class is 20 bytes. In this case, it is storing c, the char, in one of the slots in the hole in the extra four bytes.
Byte alignment or byte paddingAs mentioned above, if we specify 1 byte alignment, the size of the class above (class C) will be 19 in both cases.
Size of its immediate base classThe size of a class also includes size of its immediate base class. Lets take an example: Class B {
...
int iMem1;
int iMem2;
}
Class D: public B {
...
int iMem;
}
In this case, sizeof(D) is will also include the size of B. So it will be 12 bytes.
The existence of virtual function(s)Existence of virtual function(s) will add 4 bytes of virtual table pointer in the class, which will be added to size of class. Again, in this case, if the base class of the class already has virtual function(s) either directly or through its base class, then this additional virtual function won't add anything to the size of the class. Virtual table pointer will be common across the class hierarchy. That is class Base {
public:
...
virtual void SomeFunction(...);
private:
int iAMem
};
class Derived : public Base {
...
virtual void SomeOtherFunction(...);
private:
int iBMem
};
In the example above, sizeof(Base) will be 8 bytes--that is sizeof(int iAMem) + sizeof(vptr). sizeof(Derived) will be 12 bytes, that is sizeof(int iBMem) + sizeof(Derived). Notice that the existence of virtual functions in class Derived won't add anything more. Now Derived will set the vptr to its own virtual function table.
Compiler being usedIn some scenarios, the size of a class object can be compiler specific. Lets take one example: class BaseClass {
int a;
char c;
};
class DerivedClass : public BaseClass {
char d;
int i;
};
If compiled with the Microsoft C++ compiler, the size of DerivedClass is 16 bytes. If compiled with gcc (either c++ or g++), size of DerivedClass is 12 bytes. The reason for sizeof(DerivedClass) being 16 bytes in MC++ is that it starts each class with a 4 byte aligned address so that accessing the member of that class will be easy (again, the memory read/write cycle).
Mode of inheritance (virtual inheritance)In C++, sometimes we have to use virtual inheritance for some reasons. (One classic example is the implementation of final class in C++.) When we use virtual inheritance, there will be the overhead of 4 bytes for a virtual base class pointer in that class. class ABase{
int iMem;
};
class BBase : public virtual ABase {
int iMem;
};
class CBase : public virtual ABase {
int iMem;
};
class ABCDerived : public BBase, public CBase {
int iMem;
};
And if you check the size of these classes, it will be:
Size of ABase : 4
Size of BBase : 12
Size of CBase : 12
Size of ABCDerived : 24 Because BBase and CBase are dervied from ABase virtually, they will also have an virtual base pointer. So, 4 bytes will be added to the size of the class (BBase and CBase). That is sizeof ABase + size of int + sizeof Virtual Base pointer.

Class Design in C++ Understanding Interfaces

2007-06-04T10:16:00.000-07:00

When you're designing a class in C++, the first thing you should decide is the public interface for the class. The public interface determines how your class will be used by other programmers (or you), and once designed and implemented it should generally stay pretty constant. You may decide to add to the interface, but once you've started using the class, it will be hard to remove functions from the public interface (unless they aren't used and weren't necessary in the first place). But that doesn't mean that you should include more functionality in your class than necessary just so that you can later decide what to remove from the interface. If you do this, you'll just make the class harder to use. People will ask questions like, "why are there four ways of doing this? Which one is better? How can I choose between them?" It's usually easier to keep things simple and provide one way of doing each thing unless there's a compelling reason why your class should offer multiple methods with the same basic functionality. At the same time, just because adding methods to the public interface (probably) won't break anything that doesn't mean that you should start off with a tiny interface. First of all, if anybody decides to inherit from your class and you then choose a function with the same name, you're in for a boatload of confusion. First, if you don't declare the function virtual, then an object of the subclass will have the function chosen depending on the static type of the pointer. This can be messy. Moreover, if you do declare it virtual, then you have the issue that it might provide a different type of functionality than was intended by the original implementation of that function. Finally, you just can't add a pure virtual function to a class that's already in use because nobody who has inherited from it will have implemented that function. The public interface, then, should remain as constant as possible. In fact, a good approach to designing classes is to write the interface before the implementation because it's what determines how your class interacts with the rest of the world (which is more important for the program as a whole than how the class is actually implemented). Moreover, if you write the interface first, you can get a feel for how the class will work with other classes before you actually dive into the implementation details.
Inheritance and Class DesignThe second issue of your class design is what should be available to programmers who wish to create subclasses. This interface is primarily determined by virtual functions, but you can also include protected methods that are designed for use by the class or its subclasses (remember that protected methods are visible to subclasses while private methods are not). A key consideration is whether it makes sense for a function to be virtual. A function should be virtual when the implementation is likely to differ from subclass to subclass. Vice-versa, whenever a function should not change, then it should be made non-virtual. The key idea is to think about whether to make a function virtual by asking if the function should always be the same for every class. For example, if you have a class is designed to allow users to monitor network traffic and you want to allow subclasses that implement different ways of analyzing the traffic, you might use the following interface: class TrafficWatch
{
public:
// Packet is some class that implements information about network
// packets
void addPacket (const Packet& network_packet);
int getAveragePacketSize ();
int getMaxPacket ();
virtual bool isOverloaded ();
};
In this class, some methods will not change from implementation to implementation; adding a packet should always be handled the same way, and the average packet size isn't going to change either. On the other hand, someone might have a very different idea of what it means to have an overloaded network. This will change from situation to situation and we don't want to prevent someone from changing how this is computed--for some, anything over 10 Mbits/sec of traffic might be an overloaded network, and for others, it would require 100 Mbits/sec on some specific network cables. Finally, when publicly inheriting from any class or designing for inheritance, remember that you should strive for it to be clear that inheritance models is-a. At heart, the is-a relationship means that the subclass should be able to appear anywhere the parent class could appear. From the standpoint of the user of the class, it should not matter whether a class is the parent class or a subclass. To design an is-a relationship, make sure that it makes sense for the class to include certain functions to be sure that it doesn't include that subclasses might not actually need. One example of having an extra function is that of a Bird class that implements a fly function. The problem is that not all birds can fly--penguins and emus, for instance. This suggests that a more prudent design choice might be to have two subclasses of birds, one for birds that can fly and one for flightless birds. Of course, it might be overkill to have two subclasses of bird depending on how complex your class hierarchy will be. If you know that nobody would ever expect use your class for a flightless bird, then it's not so bad. Of course, you won't always know what someone will use your class for and it's much easier to think carefully before you start to implement an entire class hierachy than it will be to go back and change it once people are using it.

Introduction to SEO

2007-05-23T10:03:00.000-07:00

A search engine is through which most of your potential visitors will discover your site. But for that to happen you first need the search engines in turn to discover your site.
It is only when the search engines 'understand' that your site is one of the best online places to find the kind of quality content that your site provides, is when they 'recommend' your site to people interested in similar content.
If all that sounds a bit abstract, allow me to elaborate.
Search Engines like Google, Yahoo and MSN routinely search the web for content and try to relate content to some keywords which they consider the focus of your content. So for example this tutorial on SEO is related to the term SEO. A web surfer looking for articles on SEO will query these search engines for the term 'SEO' and will get results based upon what search engines think are good sites for content related to the term 'SEO'.
In fact, a search on Google for SEO yields about 17,600,000 results at the time of the writing of this tutorial. Our web surfer looking for SEO related content would definitely not look beyond 15 or at most 20 initial links. The question then is how does the search engine decide which links to place before the other ones on such a search result.
Search Engines rank the pages for the specific search term and then show the pages in the order of those rankings. Google associates what is called a PageRank for each site. PageRank measures from 1 to 10, with a PageRank of 10 specifying a highly relevant site, and the relevancy decreasing in the order of the PageRank. Other search engines like Yahoo and MSN have similar ranking strategies. SERP (Search Engine Result Page) rankings in Google depend on the PageRank and also on how well the web site relates to your searched words. Given two web sites which relate equally well to your search term, the web site with a higher PageRank will be ranked higher in the SERP's.
Search Engine Optimization or SEO refers to how you can optimize your site such that your site is more aligned to the criteria that search engines use to rank web sites.
There is a lot of content online which will tell you a lot of stuff that you can do for SEO. Unfortunately most of these articles will tell you stuff that will waste a lot of your time and will not yield any desirable results. Worse, quite a few will tell you stuff that is outright wrong and are considered search engine spamming by major search engines. Using such techniques can result in your site being black-listed from their SERP's. Fortunately, there are still a lot of right things that you can do so that search engines rank your site favorably on your targeted search term.
The best part is, right here on this tutorial we tell you everything you should be doing and everything you shouldn't be doing for SEO.

Is Google Killing SEO?

2007-05-16T08:10:00.000-07:00

Paid search listings could become more relevant than organic listings because of the emphasis on inbound links in search algorithms.
It just occurred to me that Google is killing organic SEO. Google's paid search algorithm is allowing the user to be the ultimate SEO. Based on user search behavior -- the type of links clicked on and the amount of time spent on a landing page after leaving Google -- your paid search ads become more relevant, undermining traditional SEO efforts to bring client sites to the top of the SERPs.
Google's paid search algorithm acts almost like a rating system. Google will discover the most popular sites based on user preferences, allowing it to serve highly relevant results based on paid search landing pages. As a result, search engines will likely start serving more sponsored links, and the organic links will start to fade away.
GoogleBot likes info The object of B2B and ecommerce commercial websites is to sell products and services online. These sites have an increasingly difficult time ranking well on Google because the GoogleBot eats up information and spits out products and services. Therefore, organic links are becoming less relevant and have low quality.
The antidote to low-quality organic links is pay-per-click advertising and strategic ad placements such as links on great information sites. These promotions are very effective, especially when displayed on vertical search engines (VSEs). In fact, this could become the ultimate way to do SEO in the future.
Saga of the broken algosI'm not the only guy who sees a weakness in the Google search algorithm. In his article, "Are User-Generated Websites Breaking The Search Engines' Algorithms?" Tim Daly suggested that paid search listings could become more relevant than organic listings because of the emphasis on inbound links in search algorithms.
Google rewards sites with links coming from important, authoritative sites. The company's reasoning is that a site with numerous quality inbound links must be popular, ergo it is a quality site. Sites with higher PageRank scores are given higher rankings than those with a lower PageRank. Once Google gained popularity based on PageRank, all the other search engines followed suit, so this ranking system dominates. Perhaps at the time, it was an excellent ranking variable, but it's becoming outdated today.
As Daly shows with his example of Wikipedia's dominance in the SERPs, an abundance of quality links does not necessarily an authoritative site make. This is a subjective take, based on the weight given to inbound links by Google's PageRank. As demonstrated by the questionable accuracy of some Wikipedia content, it takes more than links alone to prove authority.
Bridge over troubled watersResearch shows that general search engines are losing ground to vertical search engines (VSEs). Outsell reported a 31.9 percent search failure rate among business users on major search engines. This means that roughly one-third of user queries yield unsatisfactory results.
Convera went further by saying general search does not meet the needs of today's business and professional users. General search queries result in time inefficiencies and unmet needs as critical information becomes increasingly difficult to find quickly on the web.
In contrast to general search engines, vertical search engines have built-in preference mechanisms and are constantly rolling out improved features. In my opinion, bidding is the best qualifier. VSE users naturally weed out faulty search engine algorithms. Clients bidding high on irrelevant keywords for the sake of attracting traffic would have their budgets zapped, resulting in a dreadful ROI, and business users wouldn't stand for this.
VSEs also have built-in merchant rating systems similar to those of a power seller on eBay. This further refines the search relevance.

Some Things To Consider When Evaluating Your Website

2007-05-15T04:51:00.000-07:00

You have either put a lot of effort into your website or you have paid someone else a lot of money to put the effort in for you. Either way, whatever the purpose of the website, you want to get the most out of it. The question now becomes, how you can tell if your website is likely to succeed.
Why?
The first thing to do is to ask yourself why you have set up the website. Are you trying to sell a product or provide information or something else? What do you want to happen when a visitor lands on your pages? "For a man without a destination no wind is favourable" (An old saying attributed to many). If you do not know exactly what you want to happen, how can you expect the visitors to your website to know and do it? You are the one who ought to have the site set up to direct people to their destination. If you don't know what that is, then all is lost.

Your visitors probably know why they visited your site. You too must know why they came and help them do what they came to do. If your website does not provide what they need they will move on to another one. Just because you are getting all the traffic you could hope for does not mean that your site will succeed.
Your Website's Conversion Rate
You will need to measure your success rate. There are a number of ways to do this. One is the Conversion rate. Simply put, the conversion rate is the rate at which you convert visitors into buyers. Or if you are not selling it is the rate at which you convince people to do whatever it is you need them to do. It could be to sign up for your newsletter of subscribe to something else, etc. If you have one hundred visitors to your website per day and you convert two, your conversion rate is two percent.
It is a reasonably good measure of the quality of your website. If your site is not converting, you will know that you need to make changes to the site. However, it could also mean that you marketing or advertising campaign is sending untargeted traffic to your site. In other words sending visitors who are not in the least bit interested in what you have to offer.
SEO & Traffic Generation
The whole point of Search Engine Optimisation (SEO) is traffic generation. The idea is that you optimise or fine tune your website so that it gets to the top of the search results when people enter a search term that is contained in your website. You do this to get traffic. If your site is not properly optimised people are unlikely to find it. Unless of course you have found some narrow niche that nobody else has heard of, which will not bring a lot of visitors. SEO involves using the correct keywords in the correct way and arranging the contents and menus in the right way and most important of all is link building.
To rank highly, at the time of writing, the single most important thing to do to rank highly in the search engines is to increase the number of links to your site from quality websites which have content related to the subject of your site.
Content
It may sound obvious to most people but, the content of your website should be based on the subject of your product. For example if your website is set up to sell computers then it should contain articles about computers and computing etc. not gardening articles. If you have articles on unrelated subjects they will only serve to confuse your visitors and undermine your website's and your own credibility as a sourct of products and information about computers or whatever your website is promoting.
The content should be keyword rich but not saturated or you may show up on spam radar. The content should be broken up into manageable paragraphs and properly laid out with headers for each section, making it easier to read and navigate.
Navigation
Getting the visitors to your website is only half og th battle. You then must give them what they want. What do they want? Well, the first thing they want is to find their way around your website without pulling their hair out in frustration. These days there is far too much competition on the internet for that to happen. They will move to another website at the first sign of difficulty.
Arrange all the links and buttons in a way that is easy to read and understand. Do not over fill each page. If there is too much choice people do not make a choice they just get confused and... you guessed it. They move to another website.
The first page they land on, usually the index page should be interesting. It should be obvious to them that they have landed on a page with the content they came for and the way to navigate to that content should be very clear. Do not try to give them everything on the front page.
How easy is it for your visitors to accomplish what they came to do? Do they need to fill out pages of information or can the do their business in a few clicks? If people have to figure out the puzzle that your website is they will move on unless you have something so attractive and necessary that they will stay at all costs. If you have a product like that then you can not charge enough for it.
It is always a good idea to have a professional web designer look over the site and point out any obvious flaws. I say obvious flaws because not all corrections are obvious and are often discovered through trial and error. You should keep tweaking the website in a continuous attempt to improve it. There is always room for improvement. Though it is also said that you should not fix something that works. I think that the best thing is to make gradual changes and if they are not a major improvement, at least they will not be a major disaster.
If you are not confident enough to do the coding and graphics etc. for your own site, there are many professional web designers out there who live for it. So don't let it stop you from getting you name, product or information out there.

About the Author: Steven Collins is a web designer at Desktop Web Design.

How to Make your URLs SEO Friendly

2007-05-11T11:04:00.000-07:00

Without search engine optimization many websites stand the chance of not being fully indexed by search spiders therefore risking not being ranked high enough (if at all) in the search engine results pages (SERPs). The resulting poor conversion rate makes the website a dead weight, demoralizes your staff and could threaten your business.
URL Rewriting
This situation is quite easy to avoid by performing some cosmetic operations to the site. One of these operations, URL rewriting, is considered by some rather difficult and a bit time-consuming but can be extremely effective and rewarding in the long run.
Why It Is Nice to Have Clean URL'sThere are two very strong reasons for you to rewrite your URLs, the first of which is related to Search Engine Optimization. Search engines are much more at ease with URLs that don't contain long query strings.A URL like http://www.example.com/4/basic.html can be indexed very easily whereas its dynamic form, http://www.example.com/cgi-bin/gen.pl?id=4&view=basic, can potentially confuse search engines and cause them to miss important information contained in the URL and you to miss those anticipated high rankings.With clean URLs, the search engines can distinguish folder names and can establish real links to keywords. Query string parameters continue to be an impediment in many search engine's attempts to fully index sites. Several SEO professionals agree that dynamic (or, dirty) URLs are not very appealing to web spiders, while static URLs have greater visibility in their electronic eyes.
The second strong reason for URL rewriting would be the increased usability for web users and "maintainability" for webmasters. Clean URLs are much easier to remember. A regular web surfer will not remember a URL full of parameters, and would obviously be discouraged by the idea of typing the entire URL. This is less prone to happen with clean URLs. Easily remembered URLs help you create a more intuitive Web site and make it easier for your visitors to anticipate where they can find information they need.Webmasters tend to find that maintaining static URLs is a much easier task than working with dynamic ones. Static URLs are more abstract, and thus more difficult to hack. The dynamic URLs are more transparent, allowing possible hackers to see the technology used to build them and thus facilitating attacks.Also, given the length of dynamic URLs, it is very possible for webmasters to make mistakes during maintenance sessions, resulting in broken links. Also, when static URLs are used, the links to the site's pages will still remain valid should it be necessary to migrate a site from one programming language to another (e.g. from Perl to Java).
Dashes vs. UnderscoresWebsites that still use underscores for their URLs are becoming scarcer and scarcer. Some say that people who still use underscores are "old school" while dashes seem be used far more often these days.A usability related reason for using dashes rather than underscores is the elimination of the confusion created between a space and an underscore when the URL is viewed as a link, or when printing such a URL.More to the point, the chances that a combination of keywords contained in your Web site is included in the SERPs increase exponentially when using dashes.For exemple: a URL that contains "seo_techniques" will be shown by the search engine only if the user searches for seo_techniques (this kind of search is rarely performed); whereas searches for "seo", "techniques", or "seo techniques" gives your URL containing "seo-techniques" a better chance of being displayed on the SERPs. The dash will help you more than you can imagine, by greatly improving your visibility on the Web.
How to Rewrite URLs
The principle of URL rewriting is actually setting a "system" on the host server that will allow it (the server) to know how to interpret the new URL format. What actually happens when one decides to rewrite the URLs of a website is called masking the dynamic URLs with static ones. This means that the URLs that previously contained query strings with elements such as "?", "+", "&", "$", "=", or "%" will contain the more search engine friendly "/" (slash) element, presenting themselves in a simplified form.To help you with cleaning your URLs here are some rewriting tools and engines, some free of charge, others fee based.
Online / Open Source Tools
free online URL rewriting
open Source URL Rewriter for .NET / IIS / ASP.NET
open Source rewrite-module tuned for ASP.NET 2.0
mod_rewrite This is the most common non-fee-based rewriting engine. It is a module from the Apache HTTP Server that allows the easy manipulation of URLs. The use of this module requires the enabling of the RewriteEngine on your Apache server. Then, rewrite rules must be defined, (you can even set conditions for each rule), thus allowing the rewrite requests as they come in.In terms of SEO, mod_rewrite can be helpful if you have complex URLs that contain more than 2 parameters. In other words, if one of your dynamic URLs is accessed, the mechanism behind mod_rewrite will "translate" it into a shorter, friendlier, static-looking URL.
Fee-Based Tools
ISAPI_RewriteThe Internet Server Application Program Interface (ISAPI) is another URL manipulation engine that functions in a similar way to Apache's mod_rewrite, the difference being it is designed specifically for Microsoft's IIS (Internet Information Server).
IISRewriteIISRewrite is a stripped down implementation of Apache's mod_rewrite modules for IIS. It is a rule-based rewriting engine that allows a Webmaster to manipulate URLs on the fly in IIS.
URL ExamplesHere are some examples of how URLs can look before and after rewriting:Example 1:
Dynamic URL: http://www.companyname.com/products/items.php?id=x&model=y&variety=z (before rewriting)
Static URL: http://www.companyname.com/x/y/z.html (after rewriting) Example 2:
Dynamic URL: http://www.example.com/cgi-bin/gen.pl?id=4&view=basic (before writing)
Static URL: http://www.example.com/4/basic.html (after writing)
ConclusionsURL rewriting can put you on the right track in the race for high organic rankings when combined with other SEO techniques. Be aware that rewritten (and, presumably, better looking and more effective in terms of search engine ranking) URLs cannot substitute or make up for a poorly designed Web site.Don't expect miracles. Nevertheless, when you decide that your site needs a makeover and start rewriting your URLs, make sure that:
You keep them as short as possible (to increase usability),
You use dashes rather than underscores (to give your site a better chance of ranking as high as possible in the SERPs),
You use lowercase letters rather than uppercase ones (to avoid those case sensitive situations),
The technology you have used cannot be detected in any of your URLs (to prevent possible hacker attacks).

What is a text editor?

2007-05-08T08:46:00.000-07:00

A text editor is used to edit plain text files. Text editors differ from word processors, such as Microsoft Word or WordPerfect, in that they do not add additional formatting information to documents. You might write a paper in Word, because it contains tools to change fonts, margins, and layout, but Word by default puts that formatting and layout information directly into the file, which will confuse the compiler. If you open a .doc file in a text editor, you will notice that most of the file is formatting codes. Text editors, however, do not add formatting codes, which makes it easier to compile your code.
Why should I use a text editor?
Text editors have a feature set different from that of a traditional word processing program. For example, most won't let you include pictures, or include tables, or double-space your writing. The features of text editors vary from implementation to implementation, but there are several kinds of features that most editors have. Below are listed some of the most common and useful features.

Syntax highlighting

Syntax highlighting is a very useful feature. It means that the editor will highlight certain words or types or syntax specific to a language. For example, if you have C++ highlighting turned on, the editor might make all C++ control flow keywords appear green. This makes it much easier to follow the flow of your program. As another example, the editor might have all quoted text show up as light blue. This way, if you forget to include an opening or closing quotation mark, you will quickly realize it because of the color of the text on your screen. A text editor might also indicate mismatched parentheses or brackets by turning them red; if you have a closing brace with no corresponding opening one, the color will tell you that you made a syntax error somewhere.//Here is an example of what text might look like in your editor.
//This text is colored because it is a comment.
if (x > 5)
{
//The closing parenthesis is red because it is unmatched.
x = 5 - ((3 + y) * (8 + (z / 24))));
}
Versatility
How does the editor know which words to highlight? Good question. The editor knows what language you are programming in. It does this by either having you tell it, or, like Vim, detecting the suffix of the file. If you are working on a file named code.cc, it will see the .cc and know to use C++ rules, but if you are working on one called code.html, it will apply HTML rules instead. Some editors know hundreds of languages, ranging from the commonplace (C, Java, Perl) to the truly obscure (TADS, ABAQUS). This means that you can use the same editor to program in practically any language you can think of and still enjoy the same feature and command set that you've become accustomed to.

automatic indenting

automatic indenting is probably the most useful feature of a text editor. would you rather deal with code that looks like this (taken from a fifteen-puzzle):int get_col (int tile_id)
{
/*Cycle through...*/
int i = 0, j = 0;
while (i < Dim)
{
if (board[i][j] == tile_id)
{
return i;
}
/*If you've hit the end of the row, move to the beginning of the
* next.*/
if (i == Dim-1)
{
j++;
i = 0;
/*Otherwise move to the next space in the row.*/
}
else
{
i++;
}
}
/*This is only to get rid of the warning.*/
return i;
}
or code that looks like this?:

int get_col ( int tile_id)
{
/*Cycle through...*/
int i = 0, j = 0;
while (i < Dim) {
if (board[i][j] == tile_id) {
return i;
}
/*If you've hit the end of the row, move to the beginning of the next*/
if (i == Dim-1) {
j++;
i = 0;
/*Otherwise move to the next space in the row.*/} else {
i++;
/*This is only to get rid of the warning.*/
return i;

I thought so. A text editor will spare you the trouble of having to put in all the tabs yourself by adding them automatically. This has the benefit of letting you follow the control flow through indentation, so that you can make sure you are in the right block of code as you write.

Quick navigation features

If your program is anything above trivial, you'll want to be able to move through it quickly to find certain functions, instances of certain variables, or particular lines. Text editors typically have more sophisticated movement capability than word processors. For example, say you're compiling a program and find that you have a syntax error on line 312. In Vim, all you have to do is type 312G, and the cursor will move to line 312. (How does Vim know you don't want to type the characters 312G into the document? More on that in the links at the end of the article.)

Which text editor should I use? What's the difference between them? How do I get one? How much do they cost?

There are many, many different editors available, with Vim and Emacs being two of the most popular, portable, and powerful. Most editors (Vim and Emacs included) are free, but some are shareware. I use Vim, but each editor has its adherents. For a good listing of some of the best editors available for your platform, check out this FAQ on text editors. (It's aimed at STATA users, but all the editors listed are just fine for writing C++ code.)

What is a compiler?

2007-05-05T07:55:00.000-07:00

A compiler is necessary to make your source code (..c, .cpp, or .cc files) into a running program. If you're just starting out, you'll need to make sure that you have one before you start programming. There are many compilers available on the internet and sold commercially in stores or online. If you have Mac OS X, Linux, or other *nix variant (such as Unix or FreeBSD), you likely have a compiler such as gcc or g++ installed already.
Compiler terminology
Compile Colloquially, to convert a source code file into an executable, but strictly speaking, compilation is an intermediate step
Link The act of taking compiled code and turning it into an executable
Build A build refers to the process of creating the end executable (what is often colloquially refered to as compilation). Tools exits to help reduce the complexity of the build process--makefiles, for instance.
Compiler Generally, compiler refers to both a compiler and a "linker"
Linker The program that generates the executable by linking
IDE Integrated Development Environment, a combination of a text editor and a compiler, such that you can compile and run your programs directly within the IDE. IDEs usually have facilities to help you quickly jump to compiler errors.
Understanding the Compilation Process
The compilation and linking process A brief description of exactly what happens when you compile a program, covering the above terms in more detail
Dealing with Compilation Errors Some suggestions for hunting down compiler and linker errors in your code
Understanding Compiler Warnings Learn what compiler warnings mean and the hows and whys of fixing them
What compilers are available?
Windows/DOS
Borland Find out how to download and set up Borland's free command-line compiler
DJGPP Read about DJGPP, a DOS-based compiler
Dev-C++ and Digital Mars Read about Dev-C++, a good windows based compiler, and Digital Mars
Windows Only
Microsoft Visual C++ Read about Visual C++
*nix
g++ is a C++ compiler that comes with most *nix distributions.
gcc is a C compiler that comes with most *nix distributions.
Macintosh
Apple's own Macintosh Programmer's Workshop is a compiler I've never used, but it is direct from apple and free.
Codewarrior My experiences with Codewarrior are limited to Java programming, though it's gotten good reviews in the past. It's a full IDE rather than just a compiler, meaning that it has a text editor and debugger integrated with the compiler so you can do all your work from one place.

Affiliate Program Management

2007-05-02T21:27:00.000-07:00

Affiliate marketing programs provide a powerful and popular way for many companies to generate significant revenue from the Internet, but not every company is properly positioned for a successful program. At 10x Marketing we believe that each company ought to be accurately evaluated before engaging in an affiliate program. Our assessment service is designed to help companies know whether or not an affiliate marketing program is right for them. At the end of this assessment you'll have a good understanding of your chances of success and the risks involved with this type of Internet marketing.What is an Affiliate Program?Affiliate programs are a type of eCommerce program which generate traffic to a company’s website by convincing affiliate sites to link to them. The parent company pays each affiliate company a percentage of the sale for every online customer it gets as a result of a direct link from the affiliate’s website to its own. The affiliate company is essentially paid a commission for generating traffic, leads, or sales to the parent company’s website.
For example, a company that sells fitness gear would provide a link to the site of a fitness club that offers related (but not competing) products and services. The fitness gear company would then receive a commission of the sales gained from any buyers they direct to the fitness club. Since the fitness club gets more revenue from the new customers, both companies benefit.How Can 10x Marketing Help Me Run an Affiliate Program?10x Marketing employs an experienced Affiliate Marketing Team that excels in designing and implementing successful affiliate programs, one of several traffic generation services. Our team provides the following benefits and advantages to your company:
Set up, manage, and monitor your entire affiliate program.
Design professional ads to attract potential customers on a regular basis.
Recruit new affiliates to your program that continually drive business to you.
Help you to design your site specifically to convert those visitors into buyers of your products and services.
Keep you up-to-date by monitoring, maintaining, and reporting the success of your program on a regular basis.
In short, 10x Marketing has the experience, tools, and expertise to help you with all of your affiliate marketing needs. We also welcome new affiliates to our current programs. Give us a call. We'll be happy to answer any questions you may have.
How Do I Start?Contact us to see if Internet marketing is right for your company. There's no obligation and no better time to start generating more revenue from the Internet.

10x Marketing eBLAST Services

2007-05-02T21:25:00.000-07:00

10x Marketing offers eBLAST (E-mail Business Leads and Sales Tool), which combines both e-mail marketing and newsletter services to provide small to large businesses with the following:
Wider client audiences
Better client relationships
Industry expert status
The opportunity to obtain and retain mind share
The chance to educate and inform clients and associates in regards to products/services
Why E-mail Marketing?The chart below compares the ROI percentages obtained via various online advertising methods. Observe that opt-in-e-mail, or e-mail marketing, comes second only to pay-per-click marketing (PPC), which is also a valuable marketing option for any business.E-mail marketing is five times more effective than direct mailing and 25 times more effective than banner ads. E-mail marketing generates immediate results, which are easily tracked and measured. Best of all, e-mail marketing is generally preferred—by both senders and recipients—to direct mail, telemarketing, radio, or TV (Source: ConstantContact.com).
10x Marketing's eBLAST newsletter services include:
eBLAST Core Services
eBLAST Stats Services
eBLAST Plus Services
Additional Services
eBLAST Core ServicesThe initial eBLAST core services work like this: 10x Marketing receives your client list, removes all duplicate entries, and validates all e-mail addresses. This list is inserted into a database. Then, you choose the HTML template of your choice, on which 10x will also provide links that will allow your clients and associates to subscribe to, forward, or unsubscribe to your newsletter. You then create a short e-mail text and 10x performs a series of test runs to make sure that every eBLAST will be sent according to plan. After the eBLAST trial-runs, editorial adjustments will be made as needed and 10x will begin to send regularly scheduled eBLASTS. All eBLAST statistics will be monitored and reports regarding these statistics will be sent to you for business related analysis.
eBLAST Stat ServicesThe eBLAST stats services include all of the eBLAST core services, plus a statistics sub-account, which provides you with a login that allows you to view your eBLAST statistics at any time. The eBLAST stats services also include a private label opt-out footer complete with your company’s logo, 5,000 credits (or e-mails) per month and an e-mail capture form on your website. The option to buy additional discounted credits is also an eBLAST stats option.
eBLAST Plus ServicesThe eBLAST plus services include the eBLAST core services plus a full access sub-account which includes a login to view real-time statistics, a login to send your own blasts (this is optional), a private label opt-out footer with your logo, 5,000 credits per month, up to 2 hours consulting and/or technical support, up to 2 hours custom design work, up to 5 hours of writing services (or 1 feature article), and an e-mail capture form on your company’s website. The option to buy additional discounted credits is also available with the eBLAST plus services package.
Additional ServicesAdditional eBLAST newsletter services include:
A custom designed e-mail template
E-mail personalization up to 25 fields
Private label opt-out footer with client’s logo
E-mail capture form on client’s website
Writing or Editing E-mail Templates
Copy Writing
Initial Story Planning
Research
Interviewing
Writing
Archiving
PDF Version
HTML Version
PDF and HTML Version
Add archives to client’s website
Questions?For more information, please contact a 10x Marketing representative.

Search Engine Marketing

2007-05-02T21:23:00.000-07:00

While email remains the most popular activity on the Internet with about 95% of all Internet users engaging in email activities, it is important to understand that using search engines is the second most popular activity among all Internet users worldwide. About 88% of all Internet users use search engines to find what they're looking for on the Internet. There is little doubt that potential customers are currently using search engines to search for the products and services your company sells. The real question then is, "What are you doing to help them find you, instead of your competitors?"
"My media director would say that if you aren't putting money into search engines you are letting business walk out the door."
Bruce Carlisle, CEOSFInteractive
Imagine if everybody who visited your website was actively searching for the exact things you sell. What would that be worth to you? This is precisely what search engine marketing does for your business.
There are basically two ways to use search engines to your advantage. The first is to obtain free traffic or natural search results by getting your website listed among the top 10 results of specific searches. The second way to use search engines to your advantage is to buy your way to the front page of specific searches. This strategy is called pay-per-click or sometimes cost-per-click.
If you know how to use search engines to your advantage, you can get your website listed on the first page of a given search and redirect pre-qualified visitors to your website on a regular basis.
The result of this effort, if done properly, will be more visitors, more buyers, and more revenue for your company from the Internet. Contact 10x Marketing today and begin taking advantage of this highly profitable way to improve your bottom line.
How Do I Start?Contact us to see if Internet marketing is right for your company. There's no obligation and no better time to start generating more revenue from the Internet.

Solving Cool Problems with Genetic Algorithms

2007-05-01T07:56:00.000-07:00

representable as strings (hence the name Genetic Algorithm - the programming model is based on DNA). In terms of practical value, genetic algorithms are useful for solving problems in which the solutions are difficult to find by following a specific algorithm designed to solve the problem (using genetic algorithms in place of predesigned algorithms such as Djikstra's algorithm for path finding just wouldn't make sense). It functions as a sort of systematized brute force approach. Problems genetic algorithms are valuable for solving include scheduling problems, constraint satisfaction problems, and other problems that require searching a large number of possibilities. Genetic algorithms can be applied to protein folding or even tuning Linux kernel performance.
A simpler example just to get the point across is finding a five digit number that acts as the best solution to an expression; for example, if you wish to find the number that makes the expression x^2+2x-11 equal to 0, you could of course use brute force to solve the equation, but a genetic algorithm can also be used, and if you have a very complex expression, it may be of great value to use a genetic algorithm, especially when one considers the time saved over brute force. In a sense, all genetic algorithm problems boil down to solving complex expressions or sets of expressions, as all problems are representable in that fashion. Genetic algorithms work from the same basis as evolutionary theory. A genetic algorithm has several components: a pool of solutions, a method of evaluating the effectiveness of each solution, a breeding function that combines the best solutions into new solutions, and a mutation function. The pool of solutions do not compete for resources; rather, each solution is tested by an evaluation function (called the "fitness" function), which then gives it a ranking based on its effectiveness at solving the problem compared to the other solutions. The best solution strings are the ones that are ranked highest (that are the most "fit"); the breeding function takes two of the better performing solutions and combines them together into a new solution. The breeding function should repeat the process of randomly selecting two solutions and breeding them; the better performing functions should be given the higher percentage chance of being selected. The breeding function generally works by taking slices of each solution and splicing them together into a new one. Solutions are often represented as strings, so generally, a breeding function will take fragments of random lengths from each string and concatenate them together to form a new string. Each fragment should be placed into the location in the new string that corresponds to its location in the old string. For example, if a string fragment is from positions 5 to 8 in the first string being bred, it should be placed into positions 5 through 8 in the new child solution. After the strings have been bred, and the set of potential solutions has been refilled, it is important to have the mutation function. The mutation function is important because it introduces an element of randomness that allows variation in the solution sets, which otherwise would stagnate and have no advantage over a hand-crafted solution. Mutations may diminish the strength of some solutions, but in general it will increase the overall value of the solution set; by including a very small mutation rate, you introduce new traits that might never have otherwise existed within the pool. This allows you to explore a larger group of possibilities and avoid stagnation. In fact, many other AI techniques forgo the idea of breeding solutions and work simply by making small "mutations" or changes to a potential solution to a problem. Genetic algorithms can do some amazing things and solve very complex problems. Nevertheless, this techniques will require having way of evaluating possible solutions -- this is one of the most difficult problems with genetic algorithms. The second challenge is finding a good way to represent solutions to the problem as strings. Once these are sorted out, a genetic algorithm may be a good approach to your problem.

Binary Trees: Part 1

2007-04-30T09:30:00.000-07:00

The binary tree is a fundamental data structure used in computer science. The binary tree is a useful data structure for rapidly storing sorted data and rapidly retrieving stored data. A binary tree is composed of parent nodes, or leaves, each of which stores data and also links to up to two other child nodes (leaves) which can be visualized spatially as below the first node with one placed to the left and with one placed to the right. It is the relationship between the leaves linked to and the linking leaf, also known as the parent node, which makes the binary tree such an efficient data structure. It is the leaf on the left which has a lesser key value (ie, the value used to search for a leaf in the tree), and it is the leaf on the right which has an equal or greater key value. As a result, the leaves on the farthest left of the tree have the lowest values, whereas the leaves on the right of the tree have the greatest values. More importantly, as each leaf connects to two other leaves, it is the beginning of a new, smaller, binary tree. Due to this nature, it is possible to easily access and insert data in a binary tree using search and insert functions recursively called on successive leaves.
The typical graphical representation of a binary tree is essentially that of an upside down tree. It begins with a root node, which contains the original key value. The root node has two child nodes; each child node might have its own child nodes. Ideally, the tree would be structured so that it is a perfectly balanced tree, with each node having the same number of child nodes to its left and to its right. A perfectly balanced tree allows for the fastest average insertion of data or retrieval of data. The worst case scenario is a tree in which each node only has one child node, so it becomes as if it were a linked list in terms of speed. The typical representation of a binary tree looks like the following:
10
/ \
6 14
/ \ / \
5 8 11 18The node storing the 10, represented here merely as 10, is the root node, linking to the left and right child nodes, with the left node storing a lower value than the parent node, and the node on the right storing a greater value than the parent node. Notice that if one removed the root node and the right child nodes, that the node storing the value 6 would be the equivalent a new, smaller, binary tree.The structure of a binary tree makes the insertion and search functions simple to implement using recursion. In fact, the two insertion and search functions are also both very similar. To insert data into a binary tree involves a function searching for an unused node in the proper position in the tree in which to insert the key value. The insert function is generally a recursive function that continues moving down the levels of a binary tree until there is an unused leaf in a position which follows the rules of placing nodes. The rules are that a lower value should be to the left of the node, and a greater or equal value should be to the right. Following the rules, an insert function should check each node to see if it is empty, if so, it would insert the data to be stored along with the key value (in most implementations, an empty node will simply be a NULL pointer from a parent node, so the function would also have to create the node). If the node is filled already, the insert function should check to see if the key value to be inserted is less than the key value of the current node, and if so, the insert function should be recursively called on the left child node, or if the key value to be inserted is greater than or equal to the key value of the current node the insert function should be recursively called on the right child node. The search function works along a similar fashion. It should check to see if the key value of the current node is the value to be searched. If not, it should check to see if the value to be searched for is less than the value of the node, in which case it should be recursively called on the left child node, or if it is greater than the value of the node, it should be recursively called on the right child node. Of course, it is also necessary to check to ensure that the left or right child node actually exists before calling the function on the node.Because binary trees have log (base 2) n layers, the average search time for a binary tree is log (base 2) n. To fill an entire binary tree, sorted, takes roughly log (base 2) n * n. Lets take a look at the necessary code for a simple implementation of a binary tree. First, it is necessary to have a struct, or class, defined as a node.struct node
{
int key_value;
struct node *left;
struct node *right;
};
The struct has the ability to store the key_value and contains the two child nodes which define the node as part of a tree. In fact, the node itself is very similar to the node in a linked list. A basic knowledge of the code for a linked list will be very helpful in understanding the techniques of binary trees. Essentially, pointers are necessary to allow the arbitrary creation of new nodes in the tree.There are several important operations on binary trees, including inserting elmeents, searching for elements, removing elements, and deleting the tree. We'll look at three of those four operations in this tutorial, leaving removing elements for later. We'll also need to keep track of the root node of the binary tree, which will give us access to the rest of the data: struct node *root = 0;
It is necessary to initialize root to 0 for the other functions to be able to recognize that the tree does not yet exist. The destroy_tree shown below which will actually free all of the nodes of in the tree stored under the node leaf: tree. void destroy_tree(struct node *leaf)
{
if( leaf != 0 )
{
destroy_tree(leaf->left);
destroy_tree(leaf->right);
free( leaf );
}
}The function destroy_tree goes to the bottom of each part of the tree, that is, searching while there is a non-null node, deletes that leaf, and then it works its way back up. The function deletes the leftmost node, then the right child node from the leftmost node's parent node, then it deletes the parent node, then works its way back to deleting the other child node of the parent of the node it just deleted, and it continues this deletion working its way up to the node of the tree upon which delete_tree was originally called. In the example tree above, the order of deletion of nodes would be 5 8 6 11 18 14 10. Note that it is necessary to delete all the child nodes to avoid wasting memory. The following insert function will create a new tree if necessary; it relies on pointers to pointers in order to handle the case of a non-existent tree (the root pointing to NULL). In particular, by taking a pointer to a pointer, it is possible to allocate memory if the root pointer is NULL. insert(int key, struct node **leaf)
{
if( *leaf == 0 )
{
*leaf = malloc( sizeof( struct node ) );
leaf->left->key_value = key;
/* initialize the children to null */
leaf->left->left = 0;
leaf->left->right = 0;
}
else if(key < (*leaf)->key_value)
{
insert( key, (*leaf)->left );
}
else if(key > (*leaf)->key_value)
{
insert( key, (*leaf)->left );
}
}The insert function searches, moving down the tree of children nodes, following the prescribed rules, left for a lower value to be inserted and right for a greater value, until it reaches a NULL node--an empty node--which it allocates memory for and initializes with the key value while setting the new node's child node pointers to NULL. After creating the new node, the insert function will no longer call itself. Note, also, that if the element is already in the tree, it will not be added twice. struct node *search(int key, struct node *leaf)
{
if( leaf != 0 )
{
if(key==leaf->key_value)
{
return leaf;
}
else if(keykey_value)
{
return search(key, leaf->left);
}
else
{
return search(key, leaf->right);
}
}
else return 0;
}The search function shown above recursively moves down the tree until it either reaches a node with a key value equal to the value for which the function is searching or until the function reaches an uninitialized node, meaning that the value being searched for is not stored in the binary tree. It returns a pointer to the node to the previous instance of the function which called it.

Debugging Strategies, Tips, and Gotchas

2007-04-29T06:59:00.000-07:00

Debugging can be tedious and painful if you don't set up your programs to help you debug them. In the spirit of "an apple a day keeps the doctor away", this article suggests approaches to writing code that's more debuggable, how to catch problems before they start, and gives you some time-wasting gotchas to watch out for and gives you some gotchas to watch out for.
Use the Right ToolsIt should go without saying that you should always be using the best tools available; if you're hunting a segmentation fault, you want use a debugger. Anything less than that is unnecessary pain. If you're dealing with bizarre memory issues (or hard-to-diagnose segfaults), use Valgrind on Linux or Purify for Windows.
Debug the ProblemMy first instinct when debugging is to ask, "is my code too complicated?" Sometimes we'll all come up with a solution to a problem only to realize that the solution is really hard to get working. So hard, in fact, that it might be easier to solve the original problem in another way. When I see someone struggling to debug a complex mass of code, my first thought is to ask whether there's a cleaner solution. Often, once you've written bad code, you have a much better idea of what the good code should look like. Remember that just because you've written it doesn't mean you should keep it! The trick is always to decide if you're trying to solve the original problem or to solve a particular choice of solution. If it's the solution, then it's possible that your problems don't stem from the problem at all--maybe you're over-thinking the problem or trying a wrong-headed approach. For instance, I recently needed to parse a file and import some of the data into an access database to prototype an analysis tool. My first instinct was to write a Ruby script that interfaced directly with Access and inserted all of the data into the database using SQL queries. As I looked at the support for doing this in Ruby, I quickly realized that my "solution" to the problem was going to take a lot longer than the problem should have taken. I reversed course, wrote a script that just output a comma-separated value file, and had my data fully imported in about an hour.
An Aside on Bad CodePeople are often reluctant to throw out bad code that they've written and re-write it. One reason is that code that's written feels like completed work, and throwing it out feels like going backward. But when you're debugging, rewriting the code can seem more appealing because you're probably saving yourself time spent debugging by spending a bit more time coding. The trick is to avoid throwing out the baby with the bath water--remove the bad code, don't start the whole program over again (unless it's rotten to the core). Rewrite only the parts that really need it. Your second draft will probably be both cleaner and less buggy than the first, and you may avoid issues like having to go back later and rewrite the code just so that you can figure out how it was supposed to work. On the other hand, when you're absolutely sure that code that looks horrible is the right code to use, you'll want to explain your rationale in a comment so someone (or you) doesn't come back later and hack it apart.
Minimize Potential Problems by Avoiding Copy-Paste SyndromeNothing is more frustrating than to realize that you're debugging the same problem multiple times. Whenever you copy and paste large chunks of code, you leave yourself open to the unknown demons inhabiting that code. If you haven't debugged it yet, odds are that you're going to have to. And if you forgot that you copied that code somewhere else, you're probably going to be debugging the same code more than once. (There are other reasons to avoid copy-paste syndrome; even worse than debugging the same code twice is finding the bug in only one piece of copy-pasted code.) The best way to avoid copy-paste syndrome is to use functions to encapsulate as much of your repeat code as possible. Some things can't easily be avoided in C++; you're going to write a lot of for loops no matter what you're doing, so you can't abstract away the whole looping process. But if you have the same loop body in multiple places, that might be a sign that it should be pulled into a separate function. As a bonus, this makes other future changes to your code easier and allows you to reuse the function without having to find a chunk of code to copy.
When to Copy CodeAlthough copying code is usually dangerous, there are times when it may be the best choice. For instance, if you need to make small, irregular tweaks to a chunk of code, but the bulk of it needs to remain the same, then copying, pasting, and careful editing might make sense. By copying the code, you avoid the chance that you introduce new bugs by mistyping the code. It should go without saying that you should have carefully debugged the code you plan to copy before you do so! (But I said it, and I'm not even paid by the word.) The second reason to copy code is when you have long variable names and a bad text editor. The best solution is generally to get a better text editor with keyword completion.
Make Big Problems Found Late Small Problems Found Early
Testing EarlyOne advantage of pulling out code and putting it into functions is that you can then separately test those functions. This means that you can sometimes avoid debugging big problems caused by simple bugs in the original functions. Nothing is more frustrating than writing perfectly correct code given how you thought a function (or a class) worked, only to find out that it doesn't work that way. This kind of unit testing requires some discipline and a good sense of what can go wrong with your code. Another advantage of early testing--especially if you write some or all of your tests up-front, before the code--is that you'll pay more attention to the specific interface to your class. If you can't test error handling because you're using an assert instead of an exception or error code, that might be an indication that you should be using some form of error reporting rather than asserts. (Of course, this won't always be the case--there are times when you just want to verify that your asserts work correctly.) Beyond error-reporting, writing tests is the first time you can test your code's interface, which is often as valuable as testing that the code works. If the interface to your class is clunky, or your functions have impossible-to-understand, let alone remember, argument lists, it might be time to rethink what you're doing before you write the underlying code.
Compiler WarningsMany potential bugs can be caught by your compiler. Some such errors include using uninitialized variables, accidentally replacing a check for equality with an assignment in a conditional, or, in C++, errors related to mixing types such as pointers and ints. Since this has been covered before, I suggest checking out the article why you should pay attention to compiler warnings.
Printf LiesBecause I/O is usually buffered by the operating system, using printfs in your debugging process is risky. When possible, use a debugger to figure out what lines of code are the problem rather than narrowing in on the issue with code littered by printfs and cout. (And beware the stray printf that slips in during debugging and, ahem, slips into the final version.)
Flush OutputNevertheless, there are times when you actually need to keep track of some state in a log file--perhaps you simply have too much data that you need to collect, and you need the data from program start-up to the moment the bug occurs. To ensure you collect all of the data, be sure to flush it: you can use fflush in C, or output an endl in C++. fflush takes the FILE pointer you are writing into; for instance, to flush stderr, you would write fflush( stderr);
Check Your Helper FunctionsThis should be obvious, but it's easy to forget in the heat of the moment: always verify that your helper functions work, especially when seemingly simple code is failing. When possible, isolate each helper function and test it individually, then test each of its helper functions. There's nothing more frustrating than realizing that your original logic was right, but your assumption about a helper function was wrong.
When Cause Doesn't Immediately Lead to EffectEven if a helper function doesn't seem to be the immediate source of a problem, its side effects may cause latent problems. For instance, if you have a helper function that can return NULL and you pass its output into a library function dealing with C-strings, you may see the immediate cause as dereferencing a NULL pointer in strcat, but the real cause was the buggy function you wrote earlier (or the fact that you didn't check for NULL after calling it).
Remember That Code May Be Used in More Than One PlaceAnother problem that can come up when debugging is that you discover the problem appears to be the result of a particular function call, set a break point inside that function, and then discover that there are hundreds of calls to the same function throughout the code. Or worse, you don't notice this until wasting hours of time trying to figure out what's going on or thinking that the reason for the problem is that the function is being called incorrectly. (When, in fact, it's being called correctly but with different arguments than the point at which the bug occurred.) The most obvious solution is to check the call stack after hitting a break point or to set the breakpoint right before the call that is actually the problem. Unfortunately, this doesn't always help if the same call works thousands of times but fails on the 1001st call. Potential solutions include counting the number of calls to a function and then stepping through that many breakpoints set inside the function, or using a static variable as a counter.

Makefiles

2007-04-28T09:30:00.000-07:00

Makefiles are something of an arcane topic--one joke goes that there is only one makefile in the world and that all other makefiles are merely extensions of it. I assure you, however, that this is not true; I have written my own makefiles from time to time. In this article, I'll explain exactly how you can do it too!
Understanding Make -- BackgroundIf you've used make before, you can safely skip this section, which contains a bit of background on using make. A makefile is simply a way of associating short names, called targets, with a series of commands to execute when the action is requested. For instance, a common makefile target is "clean," which generally performs actions that clean up after the compiler--removing object files and the resulting executable. Make, when invoked from the command line, reads a makefile for its configuration. If not specified by the user, make will default to reading the file "Makefile" in the current directory. Generally, make is either invoked alone, which results in the default target, or with an explicit target. (In all of the below examples, % will be used to indicate the prompt.) To execute the default target: % make
to execute a particular target, such as clean: % make clean
Besides giving you short build commands, make can check the timestamps on files and determine which ones need to be recompiled; we'll look at this in more detail in the section on targets and dependencies. Just be aware that by using make, you can considerably reduce the number of times you recompile.
Elements of a MakefileMost makefiles have at least two basic components: macros and target definitions. Macros are useful in the same way constants are: they allow you to quickly change major facets of your program that appear in multiple places. For instance, you can create a macro to substitute the name of your compiler. Then if you move from using gcc to another compiler, you can quickly change your builds with only a one-line change.
CommentsNote that it's possible to include comments in makefiles: simply preface a comment with a pound sign, #, and the rest of the line will be ignored.
MacrosMacros are written in a simple x=y form. For instance, to set your C compiler to gcc, you might write: CC=gcc
To actually convert a macro into its value in a target, you simply enclose it within $(): for instance, to convert CC into the name of the compiler: $(CC) a_source_file.c
might expand to gcc a_source_file.c
It is possible to specify one macro in terms of another; for instance, you could have a macro for the compiler options, OPT, and the compiler, CC, combined into a compile-command, COMP: COMP = $(CC) $(OPT)
There are some macros that are specified by default; you can list them by typing % make -p
For instance, CC defaults to the cc compiler. Note that any environment variables that you have set will be imported as macros into your makefile (and will override the defaults).
TargetsTargets are the heart of what a makefile does: they convert a command-line input into a series of actions. For instance, the "make clean" command tells make to execute the code that follows the "clean" target. Targets have three components: the name of the target, the dependencies of the target, and finally the actions associated with the target: target: [dependencies]

...
Note that each command must be proceeded by a tab (yes, a tab, not four, or eight, spaces). Be sure to prevent your text editor from expanding the tabs! The dependencies associated with a target are either other targets or files themselves. If they're files, then the target commands will only be executed if any of the dependent files have changed since the last time the command was executed. If the dependency is another target, then that target's commands will be evaluated in the same way. A simple command might have no dependencies if you want it to execute all the time. For example, "clean" might look like this: clean:
rm -f *.o core
On the other hand, if you have a command to compile a program, you probably want to make the compilation depend on the source files to compile. This might result in a makefile that looks like this: CC = gcc
FILES = in_one.c in_two.c
OUT_EXE = out_executable
build: $(FILES)
$(CC) -o $(OUT_EXE) $(FILES)
Now when you type "make build" if the dependencies in_one.c and in_two.c are older than the object files created, then make will reply that there is "nothing to be done." Note that this can be problematic if you leave out a dependency! If this were an issue, one option would be to include a target to force a rebuild. This would depend on both the "clean" target and the build target (in that order). The above sample file could be amended to include this: CC = gcc
FILES = in_one.c in_two.c
OUT_EXE = out_executable
build: $(FILES)
$(CC) -o $(OUT_EXE) $(FILES)
clean:
rm -f *.o core
rebuild: clean build
Now when rebuild is the target, make will first execute the commands associated with clean and then those associated with build.
When Targets FailWhen a target is executed, it returns a status based on whether or not it was successful--if a target fails, then make will not execute any targets that depend on it. For instance, in the above example, if "clean" fails, then rebuild will not execute the "build" target. Unfortunately, this might happen if there is no core file to remove. Fortunately, this problem can be solved easily enough by including a minus sign in front of the command whose status should be ignored: clean:
-rm -f *.o core
The Default TargetTyping "make" alone should generally result in some kind of reasonable behavior. When you type "make" without specifying a target in the corresponding makefile, it will simply execute the first target in the makefile. Note that in the above example, the "build" target was placed above the "clean" target--this is more reasonable (and intuitive) behavior than removing the results of a build when the user types "make"!
Reading Someone Else's MakefileI hope that this document is enough to get you started using simple makefiles that help to automate chores or maintain someone else's work. The trick to understanding makefiles is simply to understand all of your compiler's flags--much (though not all) of the crypticness associated with makefiles is simply that they use macros that strip some of the context from an otherwise comprehensible compiler command. Your compiler's documentation can help enormously here. The second thing to remember is that when you invoke make, it will expand all of the macros for you--just by running make, it's very easy to see exactly what it will be doing. This can be tremendously helpful in figuring out a cryptic command.

21 Ways To Promote Your Website - Part Three by Neil Stafford

2007-04-26T10:31:00.000-07:00

In this last installment of the series, we'll take a look at the remaining seven ways you can promote your website.
Please note that the 21 ways we've looked at are by no means exhaustive and should be used to help you decide which way(s) you prefer and are comfortable using.
With that thought, let's move on to the final seven.
15) Reciprocal Links
This involves the swapping of links with other websites usually within your niche market; however, I've seen many reciprocal links on sites that aren't related.
Reciprocal link exchanges were originally used to build up your link popularity rating with the search engines, although over the last few years this has become less effective as Search Engine technology advances.
However, don't discount reciprocal links just yet.
On several of our sites, we still seek out high ranking and high traffic websites where we can both benefit from a reciprocal link exchange.
In this case, I'm not doing it for the benefit of search engine ranking but for the pure reason of traffic generation.
A link in a prominent place on a high traffic site will, by its very nature, generate traffic for you. And if you have your site set up correctly you should be able to capture the visitors name and email address.
16) Search Engine Listings or SEO
Let's get one thing straight - I am not a search engine expert by any stretch of the imagination. In fact I heard the best definition of SEO earlier last year when it was called...
"Search Engine Optimist"
However, I do understand the principles and do put in place strategies to take advantage of the natural search listings.
The easiest way is to add content to your website and link this from an index page or site map on your website.
I run many websites that are single sales letter types sites and many of them have a page rank of 3, 4 or 5.
However, behind these pages are several dozen content pages that are linked via an index page. By checking my site statistics I can see which pages are driving traffic and in many cases new sales.
When setting up a new sales letter site, I'll use PPC traffic to gauge how well it will perform and for the ones that do really well I'll spend the time adding content pages to sit behind the main site.
17) Classified Adverts
I'm not talking about classified adverts online but simple adverts in your niche market's magazines and publications.
This simple strategy has made us thousands in various niche markets and has even had the magazine editorial team contact us to see if we would like to contribute to the magazine itself.
In specialist magazines you can often place a classified ad for only a few pounds or dollars and know that it will be reaching your target audience.
The idea of these adverts is not to sell your product off the page but to drive the readers to your website and preferably a name capture page.
To do this, your advert must contain a benefit to the reader to put down the magazine, go online and type in your web address.
18) Your Own Business Stationary
If you operate in many different niche markets and are only selling digital products then this may not be ideal for you, however, if you have a small number of markets then at a minimum I'd have business cards printed with your web address on them.
In our main niche markets, we have business cards that have an offer and call to action on the back to encourage people to visit our sites.
We also have letterheads, and if we send out a physical product, we enclose an insert with the branding and an offer or another call to action for the customer to take.
19) Email Campaigns
If people are already on your email list this shouldn't be the end of your traffic driving process. By making sub lists of your main list you can then send targeted messages to drive your customer and prospects to new sales pages and offers.
20) Forums
You may already know my view of forums within the Internet Marketing arena.
However, forums in niche markets are still an ideal way to drive traffic to your website. However, PLEASE don't go and blatantly promote your site on the forums...there are rules to follow.
First of all, find the forums in your niche and spend a bit of time 'lurking' reading the posts and watching how they are answered.
After a short time, you'll get the feel of the board and if they allow any promotion of websites or if you can use a signature file at the bottom of your post.
Once you understand the rules start answering some of the questions on the board, and leave your URL and/or signature. file at the end.
My own view with non marketing forums is not to try and answer all the questions; answer only a few and answer them completely with very good advice or suggestions.
This will get you noticed more and build up credibility with the other people on the board.
21) Conference Calls
Conference calls are an ideal way to build up an email list quickly and are an excellent relationship-building tool as well.
You can either have a free to join call or have attendees pay a fee to join you. Either way I'd approach other 'players' within your market and ask them would they promote your call for you. With a paid call you can offer an affiliate deal.
The call should be on a specific topic and during the call you can make reference to several pages on your site or make a specific sales offer for attendees.
With a free call you can make the MP3 recording available afterwards encouraging your attendees to tell others about it. This will create a viral effect as the call gets passed around and in turn drive traffic back to your website.
I have an mp3 that I recorded more than 3 years ago that still drives traffic to one of my sites each and every week!
Summary
So there you have it, the conclusion of '21 Ways To Promote Your Website'. Which ones will you implement into your business?
Running a successful web business is simple, but not easy. If it was easy everyone would be doing it.
However, it is simple...
What could be simpler than having a product that people are actively looking for and letting them know where they can get it from?
About the Author
Neil Stafford is Editor and Publisher of the Internet Marketing Review the UK's longest running PRINTED Internet Marketing Newsletter. 'Test drive' the Newsletter for FREE - Visit this special web page for more information: http://www.InternetMarketingReview.com/sya

Advanced Makefile Tricks

2007-04-25T10:51:00.000-07:00

Special MacrosThere are some special macros that you can use when you want fine-grained control over behavior. These are macros whose values are set based on specifics of the target and its dependencies. All special macros begin with a dolllar sign and do not need to be surrounded by parentheses:
$@$@ is the name of the target. This allows you to easily write a generic action that can be used for multiple different targets that produce different output files. For example, the following two targets produce output files named client and server respectively. client: client.c
$(CC) client.c -o $@
server: server.c
$(CC) server.c -o $@
$?The $? macro stores the list of dependents more recent than the target (i.e., those that have changed since the last time make was invoked for the given target). We can use this to make the build commands from the above example even more general: client: client.c
$(CC) $? -o $@
server: server.c
$(CC) $? -o $@
$^$^ gives you all dependencies, regardless of whether they are more recent than the target. Duplicate names, however, will be removed. This might be useful if you produce transient output (such as displaying a result to the screen rather than saving it a a file). # print the source to the screen
viewsource: client.c server.c
less $^
$+$+ is like $^, but it keeps duplicates and gives you the entire list of dependencies in the order they appear. # print the source to the screen
viewsource: client.c server.c
less $+
$>If you only need the first dependency, then $> is for you. Using $> can be safer than relying on $^ when you have only a single dependency that needs to appear in the commands executed by the target. If you start by using $^ when you have a single dependency, if you then add a second, it may be problematic, whereas if you had used $> from the beginning, it will continue to work. (Of course, you may want to have all dependencies should up. Consider your needs carefully.)
Wildcard Matching in TargetsThe percent sign, %, can be used to perform wildcard matching to write more general targets; when a % appears in the dependencies list, it replaces the same string of text throughout the command in makefile target. If you wish to use the matched text in the target itself, use the special variable $*. For instance, the following example will let you type make to build an executable file with the given name: %.c:
gcc -o $* $*.c
For this particular type of example, there is actually an even simpler way of writing this target using implicit targets--read on!
Implicit TargetsThere are some actions that are nearly ubiqutious: for instance, you might have a collection of .c files that you may wish to execute the same command for. Ideally, the name of the file would be the target; using the implicit target ".c" you can specify a command to execute for any target that corresponds to the name of a .c file (minus the .c extension). .c:
$(CC) -o $@ $@.c
This rule says that for any target that corresponds to a .c file, make should compile it using the name of the implicit target as the output, and the name plus the .c extension as the file to compile. For example, % make test_executable
would run gcc -o test_executable test_executable.c
if test_executable did not have an explicit target associated with it.
Macro ModificationSince the point of using macros is to eliminate redundant text, it should come as no surprise that it is possible to transform macros from one type into another using various macro modifications.
Replacing TextIt is possible to create a new macro based on replacing part of an old macro. For instance, given a list of source files, called SRC, you might wish to generate the corresponding object files, stored in a macro called OBJ. To do so, you can specify that OBJ is equivalent to SRC, except with the .c extension replaced with a .o extension: OBJ = $(SRC:.c=.o)
Note that this is effectively saying that in the macro SRC, .c should be replaced with .o.

What is spyware?

2007-04-25T06:24:00.000-07:00

Spyware is a general term used to describe software that performs certain behaviors such as advertising, collecting personal information, or changing the configuration of your computer, generally without appropriately obtaining your consent first.
Spyware is often associated with software that displays advertisements (called adware) or software that tracks personal or sensitive information.
That does not mean all software that provides ads or tracks your online activities is bad. For example, you might sign up for a free music service, but you "pay" for the service by agreeing to receive targeted ads. If you understand the terms and agree to them, you may have decided that it is a fair tradeoff. You might also agree to let the company track your online activities to determine which ads to show you.
Other kinds of spyware make changes to your computer that can be annoying and can cause your computer slow down or crash.
These programs can change your Web browser's home page or search page, or add additional components to your browser you don't need or want. These programs also make it very difficult for you to change your settings back to the way you originally had them.
The key in all cases is whether or not you (or someone who uses your computer) understand what the software will do and have agreed to install the software on your computer.
There are a number of ways spyware or other unwanted software can get on your computer. A common trick is to covertly install the software during the installation of other software you want such as a music or video file sharing program.
Whenever you install something on your computer, make sure you carefully read all disclosures, including the license agreement and privacy statement. Sometimes the inclusion of unwanted software in a given software installation is documented, but it might appear at the end of a license agreement or privacy statement.

Determining the Size of a Class Object

2007-04-24T20:17:00.000-07:00

By Girish ShettyThere are many factors that decide the size of an object of a class in C++. These factors are:
-Size of all non-static data members
-Order of data members
-Byte alignment or byte padding
-Size of its immediate base class
-The existence of virtual function(s) (Dynamic polymorphism using virtual functions).
Compiler being used
-Mode of inheritance (virtual inheritance)
Size of all non-static data membersOnly non-static data members will be counted for calculating sizeof class/object. class A {
private:
float iMem1;
const int iMem2;
static int iMem3;
char iMem4;
};
For an object of class A, the size will be the size of float iMem1 + size of int iMem2 + size of char iMem3. Static members are really not part of the class object. They won't be included in object's layout. <2>Order of data members
The order in which one specifies data members also alters the size of the class. class C {
char c;
int int1;
int int2;
int i;
long l;
short s;
};
The size of this class is 24 bytes. Even though char c will consume only 1 byte, 4 bytes will be allocated for it, and the remaining 3 bytes will be wasted (holes). This is because the next member is an int, which takes 4 bytes. If we don't go to the next (4th) byte for storing this integer member, the memory access/modify cycle for this integer will be 2 read cycles. So the compiler will do this for us, unless we specify some byte padding/packing. If I re-write the above class in different order, keeping all my data members like below: class C {
int int1;
int int2;
int i;
long l;
short s;
char c;
};
Now the size of this class is 20 bytes. In this case, it is storing c, the char, in one of the slots in the hole in the extra four bytes.
Byte alignment or byte paddingAs mentioned above, if we specify 1 byte alignment, the size of the class above (class C) will be 19 in both cases.
Size of its immediate base classThe size of a class also includes size of its immediate base class. Lets take an example: Class B {
...
int iMem1;
int iMem2;
}
Class D: public B {
...
int iMem;
}
In this case, sizeof(D) is will also include the size of B. So it will be 12 bytes.
The existence of virtual function(s)Existence of virtual function(s) will add 4 bytes of virtual table pointer in the class, which will be added to size of class. Again, in this case, if the base class of the class already has virtual function(s) either directly or through its base class, then this additional virtual function won't add anything to the size of the class. Virtual table pointer will be common across the class hierarchy. That is class Base {
public:
...
virtual void SomeFunction(...);
private:
int iAMem
};
class Derived : public Base {
...
virtual void SomeOtherFunction(...);
private:
int iBMem
};
In the example above, sizeof(Base) will be 8 bytes--that is sizeof(int iAMem) + sizeof(vptr). sizeof(Derived) will be 12 bytes, that is sizeof(int iBMem) + sizeof(Derived). Notice that the existence of virtual functions in class Derived won't add anything more. Now Derived will set the vptr to its own virtual function table.
Compiler being usedIn some scenarios, the size of a class object can be compiler specific. Lets take one example: class BaseClass {
int a;
char c;
};
class DerivedClass : public BaseClass {
char d;
int i;
};
If compiled with the Microsoft C++ compiler, the size of DerivedClass is 16 bytes. If compiled with gcc (either c++ or g++), size of DerivedClass is 12 bytes. The reason for sizeof(DerivedClass) being 16 bytes in MC++ is that it starts each class with a 4 byte aligned address so that accessing the member of that class will be easy (again, the memory read/write cycle).
Mode of inheritance (virtual inheritance)In C++, sometimes we have to use virtual inheritance for some reasons. (One classic example is the implementation of final class in C++.) When we use virtual inheritance, there will be the overhead of 4 bytes for a virtual base class pointer in that class. class ABase{
int iMem;
};
class BBase : public virtual ABase {
int iMem;
};
class CBase : public virtual ABase {
int iMem;
};
class ABCDerived : public BBase, public CBase {
int iMem;
};
And if you check the size of these classes, it will be:
Size of ABase : 4
Size of BBase : 12
Size of CBase : 12
Size of ABCDerived : 24 Because BBase and CBase are dervied from ABase virtually, they will also have an virtual base pointer. So, 4 bytes will be added to the size of the class (BBase and CBase). That is sizeof ABase + size of int + sizeof Virtual Base pointer. Size of ABCDerived will be 24 (not 28 = sizeof (BBase + CBase + int member)) because it will maintain only one Virtual Base pointer (Same way of maintaining virtual table pointer).

Programming Style, Naming Conventions

2007-04-23T20:10:00.000-07:00

Good naming can make a huge difference in program readability. Names like proc1, proc2, and proc3 mean next-to-nothing, but even apparently decent names can be ambiguous. For instance, to name a function that takes two ranges and computes the amount of the first that lies within the second, names like computeRangeWithinRange might sound reasonable. Unfortunately, this name gives no information about the order of arguments to the function. Sometimes this won't be a problem because an intelligent IDE should help you determine the names of the arguments to the function, but it can be confusing when the code is printed, or when you try to quickly read through the code. A better name might be computeRangeWithinFirstRange, which at least gives a sense of the order of the arguments to the function.
General Naming ConventionsIt's usually best to choose a consistent set of naming convnetions for use throughout your code. Naming conventions usually govern things such as how you capitalize your variables, classes, and functions, whether you include a prefix for pointers, static data, or global data, and how you indicate that something is a private field of a class. There are a lot of common naming conventions for classes, functions and objects. Usually these are broken into several broad categories: c-style naming, camelCase, and CamelCase. C-style naming separates words in a name using underscores: this_is_an_identifer. There are two forms of camelCase: one that begins with a lowercase letter and then capitalizes the first letter of every ensuing word, and one that capitalizes the first letter of every single word. One popular convention is that leading capital letter CamelCase is used for the names of structs and classes, while normal camelCase is used for the names of functions and variables (although sometimes variables are written in c-style to make the visual separation between functions and variables more clear). It can be useful to use prefixes for certain types of data to remind you what they are: for instance, if you have a pointer, prefixing it with "p_" tells you that it's a pointer. If you see an assignment between a variable starting with "p_" and one that doesn't begin with "p_", then you immediately know that something fishy is going on. It can also be useful to use a prefix for global or static variables because each of these has a different behavior than a normal local variable. In the case of global variables, it is especially useful to use a prefix in order to prevent naming collisions with local variables (which can lead to confusion). Finally, a common convention is to prefix the private fields and methods of a class with an underscore: e.g., _private_data. This can make it easier to find out where to look in the body of a class for the declaration of a method, and it also helps keep straight what you should and should not do with a variable. For instance, a common rule is to avoid returning non-const references to fields of a class from functions that are more public than the field. For instance, if _age is a private field, then the public getAge function probably shouldn't return a non-const reference since doing so effectively grants write access to the field!
Hungarian NotationHungarian notation has commonly been associated with prefixing variables with information about their type--for instance, whether a variable is an integer or a double. This is usually not a useful thing to do because your IDE will tell you the type of a variable, and it can lead to bizarre and complicated looking names. The original idea behind Hungarian notation, however, was more general and useful: to create more abstract "types" that describe how the variable is used rather than how the variable is represented. This can be useful for keeping pointers and integers from intermixing, but it can also be a powerful technique for helping to separate concepts that are often used together, but that should not be mixed.
AbbrevationsAbbreviations are dangerous--vowels are useful and can speed up code reading. Resorting to abbreviations can be useful when the name itself is extremely long because names that are too long can be as hard to read as names that are too short. When possible, be consistent about using particular abbreviations, and restrict yourself to using only a small number of them. Common abbreviations include "itr" for "iterator" or "ptr" for pointer. Even names like i, j, and k are perfectly fine for loop counter variables (primarily because they are so common). Bad abbreviations include things like cmptRngFrmRng, which at the savings of only a few letters eliminates a great deal of readability. If you don't like typing long names, look into the auto-complete facilities of your text editor. You should rarely need to type out a full identifier. (In fact, you rarely want to do this: typos can be incredibly hard to spot.)

Writing for Readability

2007-04-22T20:10:00.000-07:00

There are a lot of ways to solve the same problem in C or C++। This is both good and bad; it is good because you have flexibility. It's also bad because you have flexibility--the flexibility to choose different solutions to the same problem when it shows up in different places. This is confusing because it obscures the underlying similarity between the problems.
Using FunctionsUnlike prose, where repeating the same word or phrase may seem redundant, in programming, it's perfectly fine to use the same construction over and over again. Of course, you may want to turn a repeated chunk of code into a function: this is even more readable because it gives the block of code a descriptive name. (At least you ought to make it descriptive!) You can also increase readability by using standard functions and data structures (such as the STL). Doing so avoids the confusion of someone who might ask, "why did you create a new function when you had a perfectly good one already available?" The problem is that people may assume that there's a reason for the new function and that it somehow differs from the standard version. Moreover, by using standard functions you help your reader understand the names of the arguments to the function. There's much less need to look at the function prototype to see what the arguments mean, or their order, or whether some arguments have default values.
Use Appropriate Language FeaturesThere are some obvious things to avoid: don't use a loop as though it were an if statement. Choose the right data type for your data: if you never need decimal places in a number, use an integer. If you mean for a value to be unsigned, used an unsigned number. When you want to indicate that a value should never change, use const to make it so. Try to avoid uncommon constructions unless you have good reason to use them; put another way, don't use a feature just because the feature exists. One rule of thumb is to avoid do-while loops unless you absolutely need one. People aren't generally as used to seeing them and, in theory, won't process them as well. I've never run into this problem myself, but think carefully about whether you actually need a do-while loop. Similarly, although the ternary operator is a great way of expressing some ideas, it can also be confusing for programmers who don't use it very often. A good rule of thumb is to use it only when necessary (for instance, in the initialization list of a constructor) and stick with the more standard if-else construction for everything else. Sure, it'll make your program four lines longer, but it'll make it that much easier for most people to read. There are some less obvious ways of using standard features. When you are looping, choose carefully between while, do-while, and for. For loops are best when you can fill in each part (initialization, conditional, and increment) with a fairly short expression. While loops are good for watching a sentinel variable whose value can be set in multiple places or whose value depends on some external event such as a network event. While loops are also better when the update step isn't really a direct "update" to the control variable--for instance, when reading lines from a text file, it might more sense to use a while loop than a for loop because the control depends on the result of the method call, not the value of the variable of interest: while (fgets(buf, sizeof(buf), fp) != NULL)
{
/* do stuff with buf */
}
It wouldn't make sense to write this sort of thing as a for loop. (Try it!)
Unpack Complex ExpressionsThere's no reason to put everything on a single line. If you have a complex calculation with multiple steps and levels of parentheses, it can be extremely helpful to go from a one-line calculation to one that uses temporary variables. This gives you two advantages; first, it makes it easier to follow the expression. Second, you can give a distinct name to each intermediate step, which can help the reader follow what is happening. Often, you'll want to reuse those intermediate calcuations anyway. In addition to mathematical calculations, this principle also applies to nested function calls. The fewer events that take place on a single line of code, the easier it is to follow exactly what's happening. Another advantage to unpacking an expression is that you can put more comments in-line to explain what's going on and why.
Avoid Magic NumbersMagic numbers are numbers that appear directly in the code without an obvious reason. For instance, what does the number 80 in the following expression mean? for( int i = 0; i < 80; ++i )
{
printf( "-" );
}
It might be the width of the screen, but it might also be the width of a map whose wall is being drawn. You just don't know. The best solution is to use macros, in C, or constants in C++. This gives you the chance to descriptively name your numbers. Doing so also makes it easier to spot the use of a particular number and differentiate between numbers with the same value that mean different things. Moreover, if you decide you need to change a value, you have a single point where you can make the change, rather than having to sift through your code.

Unicode: What You Can Do About It Today

2007-04-21T19:10:00.000-07:00

by Jeff BezansonIf you write an email in Russian and send it to somebody in Russia, it is depressingly unlikely that he or she will be able to read it. If you write software, the burden of this sad state of affairs rests on your shoulders.
Given modern hardware resources, it is unacceptable that we can't yet routinely communicate text in different scripts or containing technical symbols. Fortunately, we are getting there.
After reading a lot on the subject and incorporating Unicode compatibility into some of my software, I decided to prepare this quick and highly pragmatic guide to digital text in the 21st century (for C programmers, of course). I don't mind adding my voice to the numerous articles that already exist on this subject, since the world needs as many programmers as possible to pick up these skills as soon as possible.
I. Encoding textGiven the variety of human languages on this planet, text is a complex subject. Many are scared away from dealing with world scripts, because they think of the numerous related software problems in the area instead of focusing on what they can actually do with their code to help.
The first thing to know is that you do not have to worry about most problems with digital text. The most difficult work is handled below the application layer, in OSes, UI libraries, and the C library. To give you an idea of what goes on though, here is a summary of software problems surrounding text:
EncodingMapping characters to numbers. Many such mappings exist; once you know the encoding of a piece of text, you know what character is meant by a particular number. Unicode is one such mapping, and a popular one since it incorporates more characters than any other at this time.
DisplayOnce you know what character is meant, you have to find a font that has the character and render it. This task is much complicated by the need to display both left-to-right and right-to-left text, the existence of combining characters that modify previous characters and have zero width, the fact that some languages require wider character cells than others, and context-sensitive letterforms.
InputAn input method is a way to map keystrokes (most likely several keystrokes on a typical keyboard) to characters. Input is also complicated by bidirectional text.
Internationalization (i18n)This refers to the practice of translating a program into multiple languages, effectively by translating all of the program's strings.
LexicographyCode that processes text as more than just binary data might have to become a lot smarter. The problems of searching, sorting, and modifying letter case (upper/lower) vary per-language. If your application doesn't need to perform such tasks, consider yourself lucky. If you do need these operations, you can probably find a UI toolkit or i18n library that already implements them. If you are savvy with just the first issue (encoding), then OS-vendor-supplied input methods and display routines should magically work with your program. Whether you want to or are able to translate your software is another matter, and compared to proper handling of character encodings it is almost optional (corrupting data is worse than having an unintelligible UI).
The encoding I'll talk about is called Unicode. Unicode officially encodes 1,114,112 characters, from 0x000000 to 0x10FFFF. (The idea that Unicode is a 16-bit encoding is completely wrong.) For maximum compatibility, individual Unicode values are usually passed around as 32-bit integers (4 bytes per character), even though this is more than necessary. For convenience, the first 128 Unicode characters are the same as those in the familiar ASCII encoding.
The consensus is that storing four bytes per character is wasteful, so a variety of representations have sprung up for Unicode characters. The most interesting one for C programmers is called UTF-8. UTF-8 is a "multi-byte" encoding scheme, meaning that it requires a variable number of bytes to represent a single Unicode value. Given a so-called "UTF-8 sequence", you can convert it to a Unicode value that refers to a character.
UTF-8 has the property that all existing 7-bit ASCII strings are still valid. UTF-8 only affects the meaning of bytes greater than 127, which it uses to represent higher Unicode characters. A character might require 1, 2, 3, or 4 bytes of storage depending on its value; more bytes are needed as values get larger. To store the full range of possible 32-bit characters, UTF-8 would require a whopping 6 bytes. But again, Unicode only defines characters up to 0x10FFFF, so this should never happen in practice.
UTF-8 is a specific scheme for mapping a sequence of 1-4 bytes to a number from 0x000000 to 0x10FFFF: 00000000 -- 0000007F: 0xxxxxxx
00000080 -- 000007FF: 110xxxxx 10xxxxxx
00000800 -- 0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
00010000 -- 001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
The x's are bits to be extracted from the sequence and glued together to form the final number.
It is fair to say that UTF-8 is taking over the world. It is already used for filenames in Linux and is supported by all mainstream web browsers. This is not surprising considering its many nice properties:
It can represent all 1,114,112 Unicode characters.
Most C code that deals with strings on a byte-by-byte basis still works, since UTF-8 is fully compatible with 7-bit ASCII.
Characters usually require fewer than four bytes.
String sort order is preserved. In other words, sorting UTF-8 strings per-byte yields the same order as sorting them per-character by logical Unicode value.
A missing or corrupt byte in transmission can only affect a single character—you can always find the start of the sequence for the next character just by scanning a couple bytes.
There are no byte-order/endianness issues, since UTF-8 data is a byte stream. The only price to pay for all this is that there is no longer a one-to-one correspondence between bytes and characters in a string. Finding the nth character of a string requires iterating over the string from the beginning.
See What is UTF-8? for more information about UTF-8.
Side note: Some consider UTF-8 to be discriminatory, since it allows English text to be stored efficiently at one byte per character while other world scripts require two bytes or more. This is a troublesome point, but it should not get in the way of Unicode adoption. First of all, UTF-8 was not really designed to preferentially encode English text. It was designed to preserve compatibility with the large body of existing code that scans for special characters such as line breaks, spaces, NUL terminators, and so on. Furthermore, the encoding used internally by a program has little impact on the user as long as it is able to represent their data without loss. UTF-8 is a great boon, especially for C programming. Think of it this way: if it allows you to internationalize an application that would have been difficult to convert otherwise, it is much less discriminatory than the alternative.
II. The C libraryAll recent implementations of the standard C library have lots of functions for manipulating international strings. Before reading up on them, it helps to know some vocabulary:
"Multibyte character" or "multibyte string" refers to text in one of the many (possibly language-specific) encodings that exist throughout the world. A multibyte character does not necessarily require more than one byte to store; the term is merely intended to be broad enough to encompass encodings where this is the case. UTF-8 is in fact only one such encoding; the actual encoding of user input is determined by the user's current locale setting (selected as an option in a system dialog or stored as an environment variable in UNIX). Strings you get from the user will be in this encoding, and strings you pass to printf() are supposed to be as well. Strings within your program can of course be in any encoding you want, but you might have to convert them for proper display.
"Wide character" or "wide character string" refers to text where each character is the same size (usually a 32-bit integer) and simply represents a Unicode character value ("code point"). This format is a known common currency that allows you to get at character values if you want to. The wprintf() family is able to work with wide character format strings, and the "%ls" format specifier for normal printf() will print wide character strings (converting them to the correct locale-specific multibyte encoding on the way out).
The C library also provides functions like towupper() that can convert a wide character from any language to uppercase (if applicable). strftime() can format a date and time string appropriately for the current locale, and strcoll() can do international sorting. These and other functions that depend on locale must be initialized at the beginning of your program using #include
main()
{
char *locale;
locale = setlocale(LC_ALL, "");
...
}
You don't have to do anything with the locale string returned by setlocale(), but you can use it to query your user's locale settings (more on this later).
The C library pretty much assumes you will be using multibyte strings throughout your program (since that's what you get as input). Since multibyte strings are opaque, a lot of functions beginning with "mb" are provided to deal with them. Personally, I don't like not knowing what encoding my strings use. One concrete problem with the multibyte thing is file I/O— a given file could be in any encoding, independent of locale. When you write a file or send data over a network, keeping the multibyte encoding might be a bad idea. (Even if all software uses only the proper locale-independent C library functions, and all platforms support all encodings internally, there is still no single standard for communicating the encoding of a piece of text; email messages and HTML tags do it in various ways.) You also might be able to do more efficient processing, or avoid rewriting code, if you knew the encoding your strings used.
Your encoding options
You are free to choose a string encoding for internal use in your program. The choice pretty much boils down to either UTF-8, wide (4-byte) characters, or multibyte. Each has its advantages and disadvantages:
UTF-8
Pro: compatible with all existing strings and most existing code
Pro: takes less space
Pro: widely used as an interchange format (e.g. in XML)
Con: more complex processing, O(n) string indexing Wide characters
Pro: easy to process
Con: wastes space
Pro/Con: although you can use the syntax L"Hello, world."to easily include wide-character strings in C programs, the size of wide characters is not consistent across platforms (some incorrectly use 2-byte wide characters)
Con: should not be used for output, since spurious zero bytes and other low-ASCII characters with common meanings (such as '/' and '\n') will likely be sprinkled throughout the data. Multibyte
Pro: no conversions ever needed on input and output
Pro: built-in C library support
Pro: provides the widest possible internationalization, since in rare cases conversion between local encodings and Unicode does not work well
Con: strings are opaque
Con: perpetuates incompatibilities. For example, there are three major encodings for Russian. If one Russian sends data to another through your program, the recipient will not be able to read the message if his or her computer is configured for a different Russian encoding. But if your program always converts to UTF-8, the text is effectively normalized so that it will be widely legible (especially in the future) no matter what encoding it started in.
In this article I will advocate and give explicit instruction on using UTF-8 as an internal string encoding. Many Linux users already set their environment to a UTF-8 locale, in which case you won't even have to do any conversions. Otherwise you will have to convert multibyte to wide to UTF-8 on input, and back to multibyte on output. Nevertheless, UTF-8 has its advantages.
III. What to do right nowBelow I'll outline concrete steps any C programmer could take to bring his or her code up to date with respect to text encoding. I'll also be presenting a simple C library that provides the routines you need to manipulate UTF-8.
Here's your to-do list:
"char" no longer means characterI hereby recommend referring to character codes in C programs using a 32-bit unsigned integer type. Many platforms provide a "wchar_t" (wide character) type, but unfortunately it is to be avoided since some compilers allot it only 16 bits—not enough to represent Unicode. Wherever you need to pass around an individual character, change "char" to "unsigned int" or similar. The only remaining use for the "char" type is to mean "byte".
Get UTF-8-cleanTo take advantage of UTF-8, you'll have to treat bytes higher than 127 as perfectly ordinary characters. For example, say you have a routine that recognizes valid identifier names for a programming language. Your existing standard might be that identifiers begin with a letter: int valid_identifier_start(char ch)
{
return ((ch >= 'A' && ch <= 'Z') (ch >= 'a' && ch <= 'z'));
}
If you use UTF-8, you can extend this to allow letters from other languages as follows: int valid_identifier_start(char ch)
{
return ((ch >= 'A' && ch <= 'Z') (ch >= 'a' && ch <= 'z')
((unsigned char)ch >= 0xC0));
}
A UTF-8 sequence can only start with values 0xC0 or greater, so that's what I used for checking the start of an identifier. Within an identifier, you would also want to allow characters >= 0x80, which is the range of UTF-8 continuation bytes.
Most C string library routines still work with UTF-8, since they only scan for for terminating NUL characters. A notable exception is strchr(), which in this context is more aptly named "strbyte()". Since you will be passing character codes around as 32-bit integers, you need to replace this with a routine such as my u8_strchr() that can scan UTF-8 for a given character. The traditional strchr() returns a pointer to the location of the found character, and u8_strchr() follows suit. However, you might want to know the index of the found character, and since u8_strchr() has to scan through the string anyway, it keeps a count and returns a character index as well.
With the old strchr(), you could use pointer arithmetic to determine the character index. Now, any use of pointer arithmetic on strings is likely to be broken since characters are no longer bytes. You'll have to find and fix any code that assumes "(char*)b - (char*)a" is the number of characters between a and b (though it is still of course the number of bytes between a and b).
Interface with your environmentUsing UTF-8 as an internal encoding is now widespread among C programmers. However, the environment your program runs in will not necessarily be nice enough to feed you UTF-8, or expect UTF-8 output.
The functions mbstowcs() and wcstombs() convert from and to locale-specific encodings, respectively. "mbs" means multibyte string (i.e. the locale-specific string), and "wcs" means wide character string (universal 4-byte characters). Clearly, if you use wide characters internally, you are in luck here. If you use UTF-8, there is a chance that the user's locale will be set to UTF-8 and you won't have to do any conversion at all. To take advantage of that situation, you will have to specifically detect it (I'll provide a function for it). Otherwise, you will have to convert from multibyte to wide to UTF-8.
Version 1.6 (1.5.x while in development) of the FOX toolkit uses UTF-8 internally, giving your program a nice all-UTF-8-all-the-time environment. GTK2 and Qt also support UTF-8.
Modify APIs to discourage O(n^2) string processingThe idea of non-constant-time string indexing may worry you. But when you think about it, you rarely need to specifically access the nth character of a string. Algorithms almost never need to make requests like "Quick! Get me the 6th character of this piece of text!" Typically, if you're accessing characters you're iterating over the whole string or most of it. UTF-8 is simple enough to process that iterating over characters takes essentially the same time as iterating over bytes.
In your own code, you can use my u8_inc() and u8_dec() to move through strings. If you develop libraries or languages, be sure to expose some kind of inc() and dec() API so nobody has to move through a string by repeatedly requesting the nth character.
IV. Some UTF-8 routinesVarious libraries are available for internationalization and converting between different text encodings. However, I couldn't find a straightforward set of C routines providing the minimal support needed for using UTF-8 as an internal encoding (although this functionality is often embedded in large UI toolkits and such). I decided to create a small library that could be used to bring UTF-8 to arbitrary C programs.
This library is quite incomplete; you might want to look at related FSF offerings and libutf8. libutf8 provides the multibyte and wide character C library routines mentioned above, in case your C library doesn't have them.
Since performance is sometimes a concern with UTF-8, I made my routines as fast and lightweight as possible. They perform minimal error checking— in particular, they do not bother to determine whether a sequence is valid UTF-8, which can actually be a security problem. I justify this decision by reiterating that the intention of the library is to manipulate an internal encoding; you can enforce that all strings you store in memory be valid UTF-8, enabling the library to make that assumption. Routines for validating and converting from/to UTF-8 are available free from Unicode, Inc.
Note that my routines do not need to support the many encodings of the world—the C library can handle that. If the current locale is not UTF-8, you call mbstowcs() on user input to convert any encoding (whatever it is) to a wide character string, then use my u8_toutf8() to convert it to the UTF-8 your program is comfortable with. Here's an example input routine wrapping readline(): char *get_utf8_input()
{
char *line, *u8s;
unsigned int *wcs;
int len;
line = readline("");
if (locale_is_utf8) {
return line;
}
else {
len = mbstowcs(NULL, line, 0)+1;
wcs = malloc(len * sizeof(int));
mbstowcs(wcs, line, len);
u8s = malloc(len * sizeof(int));
u8_toutf8(u8s, len*sizeof(int), wcs, len);
free(line);
free(wcs);
return u8s;
}
The first call to mbstowcs() uses the special parameter value NULL to find the number of characters in the opaque multibyte string.
Anyway, on with the routines. They are divided into four groups:
Group 1: conversions /* is c the start of a utf8 sequence? */
#define isutf(c) (((c)&0xC0)!=0x80)
/* convert UTF-8 to UCS-4 (4-byte wide characters)
srcsz = source size in bytes, or -1 if 0-terminated
sz = dest size in # of wide characters
returns # characters converted */
int u8_toucs(unsigned int *dest, int sz, char *src, int srcsz);
/* convert UCS-4 to UTF-8
srcsz = number of source characters, or -1 if 0-terminated
sz = size of dest buffer in bytes
returns # characters converted */
int u8_toutf8(char *dest, int sz, unsigned int *src, int srcsz);
/* single character to UTF-8 */
int u8_wc_toutf8(char *dest, wchar_t ch);
Note that the library uses "unsigned int" as its wide character type.You can convert a known number of bytes, or a NUL-terminated string. The length of a UTF-8 string is often communicated as a byte count, since that's what really matters. Recall that you can usually treat a UTF-8 string like a normal C-string with N characters (where N is the number of bytes in the UTF-8 sequence), with the possibility that some characters are >127.
Group 2: moving through UTF-8 strings /* character number to byte offset */
int u8_offset(char *str, int charnum);
/* byte offset to character number */
int u8_charnum(char *s, int offset);
/* return next character, updating a byte-index variable */
unsigned int u8_nextchar(char *s, int *i);
/* move to next character */
void u8_inc(char *s, int *i);
/* move to previous character */
void u8_dec(char *s, int *i);
Group 3: unicode escape sequencesIn the absence of unicode input methods, unicode characters are often notated using special escape sequences beginning with \u or \U. \u expects up to four hexadecimal digits, and \U expects up to eight. With these routines your program can accept input and give output using such sequences if necessary. /* assuming src points to the character after a backslash, read an
escape sequence, storing the result in dest and returning the number of
input characters processed */
int u8_read_escape_sequence(char *src, unsigned int *dest);
/* given a wide character, convert it to an ASCII escape sequence stored in
buf, where buf is "sz" bytes. returns the number of characters output. */
int u8_escape_wchar(char *buf, int sz, unsigned int ch);
/* convert a string "src" containing escape sequences to UTF-8 */
int u8_unescape(char *buf, int sz, char *src);
/* convert UTF-8 "src" to ASCII with escape sequences.
if escape_quotes is nonzero, quote characters will be preceded by
backslashes as well. */
int u8_escape(char *buf, int sz, char *src, int escape_quotes);
/* utility predicates used by the above */
int octal_digit(char c);
int hex_digit(char c);
Group 4: replacements for standard functions /* return a pointer to the first occurrence of ch in s, or NULL if not
found. character index of found character returned in *charn. */
char *u8_strchr(char *s, unsigned int ch, int *charn);
/* same as the above, but searches a buffer of a given size instead of
a NUL-terminated string. */
char *u8_memchr(char *s, unsigned int ch, size_t sz, int *charn);
/* count the number of characters in a UTF-8 string */
int u8_strlen(char *s);
/* given the string returned by setlocale(), determine whether the current
locale speaks UTF-8 */
int u8_is_locale_utf8(char *locale);
/* these functions can print from UTF-8 strings. they make no assumptions
about locale; you can circumvent them if is_locale_utf8 */
int u8_vprintf(char *fmt, va_list ap);
int u8_printf(char *fmt, ...);

So you want to write a game?

2007-04-20T10:19:00.000-07:00

By Alex Hoffer What exactly do you need to know to write a game? Well you, have to know what makes a game fun, of course, but from a technical perspective, what is there to it?
The best way to learn how to write games is, alas, to get a solid grounding in the basics of computer science.
GraphicsThere is perhaps no single area of gaming in which players standards have risen more than in the field of graphics. While players in the 70s and 80s were accustomed to screens of text or 16-bit black-and-white graphics, the users of today demand Riven-quality, 3D graphics, complete with lighting effects, textures, and scale. Unfortunately, graphics are hard to do. They require math, at least on the level of multivariable calculus, and a great deal of time. But if you aren't quite a math wizard yet, don't despair; for more casual games, most people are willing to accept simple 2D sprites. Anyone who's ever been addicted to Tetris knows that while simple graphics may not cut it on the shelves any more, they're no barrier to a satisfying gaming experience. For more info on graphics programming, check out our tutorial on creating graphics with OpenGL and the 3D rotations series at the advanced tutorial section of the site.
SpeedIf youre writing a game--particularly an arcade-style game--speed is all-important. Hardware advances have to some extent made optimization less relevant, but for every advance in hardware, an advance in graphics is sure to come along to take up the slack. And even a more simple game can run less than lightning-fast if it's written in an interpreted language like Java. Learning how to speed things up requires a familiarity with data structures and algorithms. Choosing the right data structure to store your game data in can mean the difference between a pokey game and one that zips along. For information on efficient game programming, see AI Horizon's article on efficient chessboard representation or algorithmic efficiency and big-o notation.
StructureNo matter what kind of program you're writing, from an implementation of Space Invaders to a filing system for grandma's recipes, clear programming structure is vital when it comes to understanding your code when you come back to work on it after a break, or, even moreso, if you plan on working with a buddy who has to be able to understand what you wrote or use your functions. Good commenting and readable style are a must. Games are also well-suited to object-oriented programming, since the elements of your game world are often, well, objects, like a spaceship, a bullet, or an evil alien vessel. Choosing classes appropriately is key, and inheritance can often come in handy (for example, if your game has several different light sources, or monsters, or doors, that all share some basic properties.) For more tips on style, see how and why to comment, thinking about programming, and this series on programming style.

10 Tips To Effective Search Engine Optimization, Submission And Promotion

2007-04-17T03:04:00.000-07:00

-Make sure your website is tested for good load time, dead links and cross-browser compatibility. Netmechanic.com is a good website to do this.
-Optimize you web site pages by making sure your top keywords appear in your title, meta tags and content.
-Make sure you provide quality content that have something unique to offer and that have keywords or key phrases people might search to find your site.
-If you sell products, give something away free (The word "free" is one of the top most searched words on the internet).
-Build quality links to your site pages from other well ranked sites on your target search engine.
Make a list of your top keywords and key-phrases and track your listings/ranking in the top 10 search engines and analyze it periodically.
-Submit to top directories there are many directories out there that list websites in their related categories - Just find the top ranked ones and submit your pages under related sections.
-Make sure your web site looks attractive and easy to use with clear navigation and easy to read layout and fonts. This is especially useful for directories as manual approval is required for them.
-Keep up to date with the latest in SEO by reading through articles, forums and related guides - remember SEO requires a lot of time and patience. You have to keep working on it.
-Keep your website focussed to cater to your visitors needs - don't throw in a free-for-all links program or forum to just attract traffic - in the long run this will pay-off as you website will be recognized for what it is.

Convert Excel files to simple Wikimedia and HTML tables

2007-04-17T03:02:00.000-07:00

I recently installed a Wiki at work, but our users aren't exactly computer experts, and Wiki experts even less so. So I wanted to make a tool to allow them to upload an Excel file and have it spit out Wiki code for a table. I started in ASP, but just uploading a file and reading other form values at the same time was enough to make me tear my hair out. (Yes, I looked at the ASP upload posts here, but most of it was far too complicated for what I was doing)Since Wikimedia is in PHP anyway, I figured I'd see if someone had created an Excel reader in PHP, and lo & behold, I found the aptly-named PHP-ExcelReader on Sourceforge.net. It works quite well, most of the bugs have been fixed, and it's pretty easy to use.The first page has a simple form and instructions. It allows the user to select their file, the rows that contain a title, header rows, and the first data row. I also added some optional style selections, such as positioning (none/center/float left/float right), font/bg colors, cell padding, cell spacing, and border width. After clicking "Next," the Wikimedia table code is displayed, along with a rendition of the table itself (in HTML, of course). Note: if you decide to modify this to create HTML code and strip out the Wiki part, the positioning/floating is not included (for my purposes, the HTML table is only to allow the user to see roughly what it will look like by itself).So far, it handles vertically or horizontally merged cells; however if a cell is merged over multiple rows and columns, data starts disappearing. That is a problem I couldn't figure out within the time I alotted myself (I have plenty of REAL work to do ). I had some trouble displaying dates correctly, but I'm not sure if the problem was with PHP-ExcelReader, my server, or something in my code (don't think so). Also, if a column is used and later all cells emptied, it seems to think it's still a used cell, despite the lack of any data.It does NOT, however, use any style or formatting from the Excel file: just data. No bold/italics, no font size changes, no charts or images (of course), and it does not know how wide the columns are.So it is very simple and not feature-rich, but I thought others might find it somewhat useful, even if just as an example of how to use PHP-ExcelReader. I'd be interested to know if anyone finds it useful or notices any obvious bugs.The attached ZIP file contains three PHP files: index.php contains my code, while reader.php and oleread.inc are the files from PHP-ExcelReader (unmodified). In index.php there are two fields that may need to be edited for your use. $thisfile can be changed if you don't want your file called indes.php, and $dropdir needs to be writeable by your web server.The file I uploaded disappeared. Here is a link to the file from another post
__________________www.Rhymezilla.com

C++ and Java Syntax Differences Cheat Sheet

2007-04-16T20:22:00.000-07:00

main function
C++// free-floating function
int main( int argc, char* argv[])
{
printf( "Hello, world" );
}
Java// every function must be part of a class; the main function for a particular
// class file is invoked when java is run (so you can have one
// main function per class--useful for writing unit tests for a class)
class HelloWorld
{
public static void main(String args[])
{
System.out.println( "Hello, World" );
}
}
Compiling
C++ // compile as
g++ foo.cc -o outfile
// run with
./outfile

Java // compile classes in foo.java to .class
javac foo.java
// run by invoking static main method in
java

CommentsSame in both languages (// and /* */ both work)
Class declarationsAlmost the same, but Java does not require a semicolon
C++ class Bar {};

Java class Bar {}

Method declarationsSame, except that in Java, must always be part of a class, and may prefix with public/private/protected
Constructors and destructorsConstructor has same syntax in both (name of the class), Java has no exact equivalent of the destructor
Static member functions and variablesSame as method declarations, but Java provides static initialization blocks to initialize static variables (instead of putting a definition in a source code file): class Foo
{
static private int x;
// static initialization block
{ x = 5; }
}
Object declarations
C++ // on the stack
myClass x;
// or on the heap
myClass *x = new myClass;

Java // always allocated on the heap (also, always need parens for constructor)
myClass x = new myClass();

References vs. pointers
C++ // references are immutable, use pointers for more flexibility
int bar = 7, qux = 6;
int& foo = bar;

Java // references are mutuable and store addresses only to objects; there are
// no raw pointers
myClass x;
x.foo(); // error, x is a null ``pointer''
// note that you always use . to access a field

Inheritance
C++ class Foo : public Bar
{ ... };

Java class Foo extends Bar
{ ... }

Protection levels (abstraction barriers)
C++ public:
void foo();
void bar();

Java public void foo();
public void bar();

Virtual functions
C++ virtual int foo(); // or, non-virtually as simply int foo();

Java // functions are virtual by default; use final to prevent overriding
int foo(); // or, final int foo();

Abstract classes
C++ // just need to include a pure virtual function
class Bar { public: virtual void foo() = 0; };

Java // syntax allows you to be explicit!
abstract class Bar { public abstract void foo(); }
// or you might even want to specify an interface
interface Bar { public void foo(); }
// and later, have a class implement the interface:
class Chocolate implements Bar
{
public void foo() { /* do something */ }
}

Memory managementRoughly the same--new allocates, but no delete in Java since it has garbage collection.
NULL vs. null
C++ // initialize pointer to NULL
int *x = NULL;

Java // the compiler will catch the use of uninitialized references, but if you
// need to initialize a reference so it's known to be invalid, assign null
myClass x = null;

BooleansJava is a bit more verbose: you must write boolean instead of merely bool.
C++bool foo;
Javaboolean foo;
Const-ness
C++ const int x = 7;

Java final int x = 7;

Throw SpecFirst, Java enforce throw specs at compile time--you must document if your method can throw an exception
C++int foo() throw (IOException)
Javaint foo() throws IOException
Arrays
C++ int x[10];
// or
int *x = new x[10];
// use x, then reclaim memory
delete[] x;

Java int[] x = new int[10];
// use x, memory reclaimed by the garbage collector or returned to the
// system at the end of the program's lifetime

Collections and Iteration
C++Iterators are members of classes. The start of a range is .begin(), and the end is .end(). Advance using ++ operator, and access using *. vector myVec;
for ( vector::iterator itr = myVec.begin();
itr != myVec.end();
++itr )
{
cout << *itr;
}

JavaIterator is just an interface. The start of the range is .iterator, and you check to see if you're at the end with itr.hasNext(). You get the next element using itr.next() (a combination of using ++ and * in C++). ArrayList myArrayList = new ArrayList();
Iterator itr = myArrayList.iterator();
while ( itr.hasNext() )
{
System.out.println( itr.next() );
}
// or, in Java 5
ArrayList myArrayList = new ArrayList();
for( Object o : myArrayList ) {
System.out.println( o );
}

TemplatesThis is still being to be added. See http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf for a good introduction.

Understanding the Start of an Object's Lifetime

2007-04-16T01:10:00.000-07:00

In C++, whenever an object of a class is created, its constructor is called. But that's not all--its parent class constructor is called, as are the constructors for all objects that belong to the class. By default, the constructors invoked are the default ("no-argument") constructors. Moreover, all of these constructors are called before the class's own constructor is called.
For instance, take the following code: include
class Foo
{
public:
Foo() { std::cout << "Foo's constructor" << std::endl; }
};
class Bar : public Foo
{
public:
Bar() { std::cout << "Bar's constructor" << std::endl; }
};
int main()
{
// a lovely elephant ;)
Bar bar;
}
The object bar is constructed in two stages: first, the Foo constructor is invoked and then the Bar constructor is invoked. The output of the above program will be to indicate that Foo's constructor is called first, followed by Bar's constructor. Why do this? There are a few reasons. First, each class should need to initialize things that belong to it, not things that belong to other classes. So a child class should hand off the work of constructing the portion of it that belongs to the parent class. Second, the child class may depend on these fields when initializing its own fields; therefore, the constructor needs to be called before the child class's constructor runs. In addition, all of the objects that belong to the class should be initialized so that the constructor can use them if it needs to. But what if you have a parent class that needs to take arguments to its constructor? This is where initialization lists come into play. An initialization list immediately follows the constructor's signature, separated by a colon: class Foo : public parent_class
{
Foo() : parent_class( "arg" ) // sample initialization list
{
// you must include a body, even if it's merely empty
}
};
Note that to call a particular parent class constructor, you just need to use the name of the class (it's as though you're making a function call to the constructor). For instance, in our above example, if Foo's constructor took an integer as an argument, we could do this: include
class Foo
{
public:
Foo( int x )
{
std::cout << "Foo's constructor "
<< called with "
<< x
<< std::endl;
}
};
class Bar
{
public:
Bar() : Foo( 10 ) // construct the Foo part of Bar
{
std::cout << "Bar's constructor" << std::endl;
}
};
int main()
{
Bar stool;
}
Using Initialization Lists to Initialize FieldsIn addition to letting you pick which constructor of the parent class gets called, the initialization list also lets you specify which constructor gets called for the objects that are fields of the class. For instance, if you have a string inside your class: class Qux
{
public:
Qux() : _foo( "initialize foo to this!" ) { }
// This is nearly equivalent to
// Qux() { _foo = "initialize foo to this!"; }
// but without the extra call to construct an empty string
private:
std::string _foo;
};
Here, the constructor is invoked by giving the name of the object to be constructed rather than the name of the class (as in the case of using initialization lists to call the parent class's constructor). If you have multiple fields of a class, then the names of the objects being initialized should appear in the order they are declared in the class (and after any parent class constructor call): class Baz
{
public:
Baz() : _foo( "initialize foo first" ), _bar( "then bar" ) { }
private:
std::string _foo;
std::string _bar;
};
Initialization Lists and Scope IssuesIf you have a field of your class that is the same name as the argument to your constructor, then the initialization list "does the right thing." For instance, class Baz
{
public:
Bar( std::string foo ) : foo( foo ) { }
private:
std::string foo;
};
is roughly equivalent to class Baz
{
public:
Bar( std::string foo )
{
this->foo = foo;
}
private:
std::string foo;
};
That is, the compiler knows which foo belongs to the object, and which foo belongs to the function.
Initialization Lists and Primitive TypesIt turns out that initialization lists work to initialize both user-defined types (objects of classes) and primitive types (e.g., int). When the field is a primitive type, giving it an argument is equivalent to assignment. For instance, class Quux
{
public:
Quux() : _my_int( 5 ) // sets _my_int to 5
{ }
private:
int _my_int;
};
This behavior allows you to specify templates where the templated type can be either a class or a primitive type (otherwise, you would have to have different ways of handling initializing fields of the templated type for the case of classes and objects). template
class my_template
{
public:
// works as long as T has a copy constructor
my_template( T bar ) : _bar( bar ) { }
private:
T _bar;
};
Initialization Lists and Const FieldsUsing initialization lists to initialize fields is not always necessary (although it is probably more convenient than other approaches). But it is necessary for const fields. If you have a const field, then it can be initialized only once, so it must be initialized in the initialization list. class const_field
{
public:
const_field() : _constant( 1 ) { }
// this is an error: const_field() { _constant = 1; }
private:
const int _constant;
};
When Else do you Need Initialization Lists?
No Default ConstructorIf you have a field that has no default constructor (or a parent class with no default constructor), you must specify which constructor you wish to use.
ReferencesIf you have a field that is a reference, you also must initialize it in the initialization list; since references are immutable they can be initialized only once.
Initialization Lists and ExceptionsSince constructors can throw exceptions, it's possible that you might want to be able to handle exceptions that are thrown by constructors invoked as part of the initialization list. First, you should know that even if you catch the exception, it will get rethrown because it cannot be guaranteed that your object is in a valid state because one of its fields (or parts of its parent class) couldn't be initialized. That said, one reason you'd want to catch an exception here is that there's some kind of translation of error messages that needs to be done. The syntax for catching an exception in an initialization list is somewhat awkward: the 'try' goes right before the colon, and the catch goes after the body of the function: class Foo
{
Foo() try : _str( "text of string" )
{
}
catch ( ... )
{
std::cerr << "Couldn't create _str";
// now, the exception is rethrown as if we'd written
// "throw;" here
}
};
Initialization Lists: SummaryBefore the body of the constructor is run, all of the constructors for its parent class and then for its fields are invoked. By default, the no-argument constructors are invoked. Initialization lists allow you to choose which constructor is called and what arguments that constructor receives. If you have a reference or a const field, or if one of the classes used does not have a default constructor, you must use an initialization list.

Gotchas for a C programmer using C++

2007-04-11T19:54:00.000-07:00

Implicit Assignment from void*You cannot implicitly assign from a void* to any other type. For instance, the following is perfectly valid in C (in fact, it's arguably the preferable way of doing it in C) int *x = malloc(sizeof(int) * 10);
but it won't compile in C++. (Try it yourself!) The explanation from Bjarne Stroustrup himself is that this isn't type safe. What this means is that you can have a void* that points to anything at all, and if you then assign the address stored in that void* to another pointer of a different type, there isn't any warning at all about it. Consider the following: int an_int;
void *void_pointer = &an_int;
double *double_ptr = void_pointer;
*double_ptr = 5;
When you assign *double_ptr the value 5, it's writing 8 bytes of memory, but the integer variable an_int is only 4 bytes. Forcing a cast from a void pointer makes the programmer pay attention to these things.
Freeing arrays: new[] and delete[]In C, there's only one major memory allocation function: malloc. You use it to allocate both single elements and arrays: int *x = malloc( sizeof(int) );
int *x_array = malloc( sizeof(int) * 10 );
and you always release the memory in the same way: free( x );
free( x_array );
In C++, however, memory allocation for arrays is somewhat different than for single objects; you use the new[] operator, and you must match calls to new[] with calls to delete[] (rather than to delete). int *x = new int;
int *x_array = new int[10];
delete x;
delete[] x;
The short explanation is that when you have arrays of objects, delete[] with properly call the destructor for each element of the array, whereas delete will not.
You must declare functions before useAlthough most good C code will follow this convention, in C++ it is strictly enforced that all functions must be declared before they are used. This code is valid C, but it is not valid C++: #include
int main()
{
foo();
return 0;
}
int foo()
{
printf( "Hello world" );
}
Gotcha for a C++ programmer using C
Structs and EnumsYou have to include the struct keyword before the name of the struct type to declare a struct: In C++, you could do this struct a_struct
{
int x;
};
a_struct struct_instance;
and have a new instance of a_struct called struct_instance. In C, however, we have to include the struct keyword when declaring struct_instance: struct a_struct struct_instance;
In fact, a similar situation also holds for declaring enums: in C, you must include the keyword enum; in C++, you don't have to. As a side note, most C programmers get around this issue by using typedefs: typedef struct struct_name
{
/* variables */
} struct_name_t;
Now you can declare a struct with struct_name_t struct_name_t_instance;
But there is another gotcha for C++ programmers: you must still use the "struct struct_name" syntax to declare a struct member that is a a pointer to the struct. typedef struct struct_name
{
struct struct_name instance;
struct_name_t instance2; /* invalid! The typedef isn't defined yet */
} struct_name_t;
C++ has a much larger libraryC++ has a much larger library than C, and some things may be automatically linked in by C++ when they are not with C. For instance, if you're used to using g++ for math-heavy computations, then it may come as a shock that when you are using gcc to compile C, you need to explicitly include the math library for things like sin or even sqrt: % g++ foo.cc
or
% gcc foo.c -lm
No Boolean TypeC does not provide a native boolean type. You can simulate it using an enum, though: typedef enum {FALSE, TRUE} bool;
main Doesn't Provide return 0 AutomaticallyIn C++, you are free to leave off the statement 'return 0;' at the end of main; it will be provided automatically: int main()
{
print( "Hello, World" );
}
but in C, you must manually add it: int main()
{
print( "Hello, World" );
return 0;
}

Function Pointers

2007-04-10T21:10:00.000-07:00

Example Uses of Function Pointers
Functions as Arguments to Other FunctionsIf you were to write a sort routine, you might want to allow the function's caller to choose the order in which the data is sorted; some programmers might need to sort the data in ascending order, others might prefer descending order while still others may want something similar to but not quite like one of those choices. One way to let your user specify what to do is to provide a flag as an argument to the function, but this is inflexible; the sort function allows only a fixed set of comparison types (e.g., ascending and descending). A much nicer way of allowing the user to choose how to sort the data is simply to let the user pass in a function to the sort function. This function might take two pieces of data and perform a comparison on them. We'll look at the syntax for this in a bit.
Callback FunctionsAnother use for function pointers is setting up "listener" or "callback" functions that are invoked when a particular event happens. The function is called, and this notifies your code that something of interest has taken place. Why would you ever write code with callback functions? You often see it when writing code using someone's library. One example is when you're writing code for a a graphical user interface (GUI). Most of the time, the user will interact with a loop that allows the mouse pointer to move and that redraws the interface. Sometimes, however, the user will click on a button or enter text into a field. These operations are "events" that may require a response that your program needs to handle. How can your code know what's happening? Using Callback functions! The user's click should cause the interface to call a function that you wrote to handle the event. To get a sense for when you might do this, consider what might happen if you were using a GUI library that had a "create_button" function. It might take the location where a button should appear on the screen, the text of the button, and a function to call when the button is clicked. Assuming for the moment that C (and C++) had a generic "function pointer" type called function, this might look like this: void create_button( int x, int y, const char *text, function callback_func );
Whenever the button is clicked, callback_func will be invoked. Exactly what callback_func does depends on the button; this is why allowing the create_button function to take a function pointer is useful.
Function Pointer SyntaxThe syntax for declaring a function pointer might seem messy at first, but in most cases it's really quite straight-forward once you understand what's going on. Let's look at a simple example: void (*foo)(int);
In this example, foo is a pointer to a function taking one argument, an integer, and that returns void. It's as if you're declaring a function called "*foo", which takes an int and returns void; now, if *foo is a function, then foo must be a pointer to a function. (Similarly, a declaration like int *x can be read as *x is an int, so x must be a pointer to an int.) The key to writing the declaration for a function pointer is that you're just writing out the declaration of a function but with (*func_name) where you'd normally just put func_name.
Reading Function Pointer DeclarationsSometimes people get confused when more stars are thrown in: void *(*foo)(int *);
Here, the key is to read inside-out; notice that the innermost element of the expression is *foo, and that otherwise it looks like a normal function declaration. *foo should refer to a function that returns a void * and takes an int *. Consequently, foo is a pointer to just such a function.
Initializing Function PointersTo initialize a function pointer, you must give it the address of a function in your program. The syntax is like any other variable: #include
void my_int_func(int x)
{
printf( "%d\n", x );
}
int main()
{
void (*foo)(int);
/* the ampersand is actually optional */
foo = &my_int_func;
return 0;
}
(Note: all examples are written to be compatible with both C and C++.)
Using a Function PointerTo call the function pointed to by a function pointer, you treat the function pointer as though it were the name of the function you wish to call. The act of calling it performs the dereference; there's no need to do it yourself: #include
void my_int_func(int x)
{
printf( "%d\n", x );
}
int main()
{
void (*foo)(int);
foo = &my_int_func;
/* call my_int_func (note that you do not need to write (*foo)(2) ) */
foo( 2 );
/* but if you want to, you may */
(*foo)( 2 );
return 0;
}
Note that function pointer syntax is flexible; it can either look like most other uses of pointers, with & and *, or you may omit that part of syntax. This is similar to how arrays are treated, where a bare array decays to a pointer, but you may also prefix the array with & to request its address.
Function Pointers in the WildLet's go back to the sorting example where I suggested using a function pointer to write a generic sorting routine where the exact order could be specified by the programmer calling the sorting function. It turns out that the C function qsort does just that. From the Linux man pages, we have the following declaration for qsort (from stdlib.h): void qsort(void *base, size_t nmemb, size_t size,
int(*compar)(const void *, const void *));
Note the use of void*s to allow qsort to operate on any kind of data (in C++, you'd normally use templates for this task, but C++ also allows the use of void* pointers) because void* pointers can point to anything. Because we don't know the size of the individual elements in a void* array, we must give qsort the number of elements, nmemb, of the array to be sorted, base, in addition to the standard requirement of giving the length, size, of the input. But what we're really interested in is the compar argument to qsort: it's a function pointer that takes two void *s and returns an int. This allows anyone to specify how to sort the elements of the array base without having to write a specialized sorting algorithm. Note, also, that compar returns an int; the function pointed to should return -1 if the first argument is less than the second, 0 if they are equal, or 1 if the second is less than the first. For instance, to sort an array of numbers in ascending order, we could write code like this: #include
int int_sorter( const void *first_arg, const void *second_arg )
{
int first = *(int*)first_arg;
int second = *(int*)second_arg;
if ( first < second )
{
return -1;
}
else if ( first == second )
{
return 0;
}
else
{
return 1;
}
}
int main()
{
int array[10];
int i;
/* fill array */
for ( i = 0; i < 10; ++i )
{
array[ i ] = 10 - i;
}
qsort( array, 10 , sizeof( int ), int_sorter );
for ( i = 0; i < 10; ++i )
{
printf ( "%d\n" ,array[ i ] );
}
}
Often, typedefs
are used to make code using function pointers somewhat more readable.
-->
Using Polymorphism and Virtual Functions Instead of Function Pointers (C++)You can often avoid the need for explicit function pointers by using virtual functions. For instance, you could write a sorting routine that takes a pointer to a class that provides a virtual function called compare: class Sorter
{
public:
virtual int compare (const void *first, const void *second);
};
// cpp_qsort, a qsort using C++ features like virtual functions
void cpp_qsort(void *base, size_t nmemb, size_t size, Sorter *compar);
inside cpp_qsort, whenever a comparison is needed, compar->compare should be called. For classes that override this virtual function, the sort routine will get the new behavior of that function. For instance: class AscendSorter : public Sorter
{
virtual int compare (const void*, const void*)
{
int first = *(int*)first_arg;
int second = *(int*)second_arg;
if ( first < second )
{
return -1;
}
else if ( first == second )
{
return 0;
}
else
{
return 1;
}
}
};
and then you could pass in a pointer to an instance of the AscendSorter to cpp_qsort to sort integers in ascending order.
But Are You Really Not Using Function Pointers?Virtual functions are implemented behind the scenes using function pointers, so you really are using function pointers--it just happens that the compiler makes the work easier for you. Using polymorphism can be an appropriate strategy (for instance, it's used by Java), but it does lead to the overhead of having to create an object rather than simply pass in a function pointer.
Function Pointers Summary
Syntax
DeclaringDeclare a function pointer as though you were declaring a function, except with a name like *foo instead of just foo: void (*foo)(int);
InitializingYou can get the address of a function simply by naming it: void foo();
func_pointer = foo;
or by prefixing the name of the function with an ampersand: void foo();
func_pointer = &foo;
InvokingInvoke the function pointed to just as if you were calling a function. func_pointer( arg1, arg2 );
or you may optionally dereference the function pointer before calling the function it points to: (*func_pointer)( arg1, arg2 );
Benefits of Function Pointers
Function pointers provide a way of passing around instructions for how to do something
You can write flexible functions and libraries that allow the programmer to choose behavior by passing function pointers as arguments
This flexibility can also be achieved by using classes with virtual functions I am grateful to Alex Hoffer and Thomas Carriero for their comments on a draft of this article.

Safer, Cheaper, Smarter Software Buying

2007-04-09T19:21:00.000-07:00

As a buyer (and coder), I always want to save money, which is what drew me to Rent A Coder (RAC) in the first place. There’s a terrific opportunity to get top quality work here at rock bottom prices, something I find to be quite refreshing in today’s high cost technology market. Along with the deep discounts I’ve found here, by taking advantage of RAC’s “Safe Project Escrow” TM a prospective buyer just can’t lose! However, there are some potential mistakes that can be made by both first-time as well as veteran buyers that could come back to haunt you – I’d like to review these with you and offer some suggestions. Probably the most important concept to understand is that RAC does not ever charge a fee to buyers for their use of the service. Why is this so important? Mainly, to avoid misunderstandings with coders about who pays RAC’s project fee and the final project cost. When a coder signs on with RAC, they contractually agree to pay a percentage (10% - 15% or $3.00, whichever is higher) of the total project cost to RAC as a “Finder’s Fee”. Obviously this fee supports RAC’s ongoing operational and administrative costs and is based on the type of project that was posted. As far as I have been able to determine, this fee has never increased since RAC went into operation, which is by the way, a great deal for the coders. In other words, there are no set fees for any particular project – it’s entirely based on the bid amount you accept, and paid for by the coder who won the bid in exchange for them using RAC to find work, maintain profiles, manage an escrow account for them, etc. Unlike other freelancing sites where coders pay a monthly fee as well as a commission for bidding on projects, RAC only charges them a fee when they win a bid and complete the project! More importantly, since this is a blind bidding system, there is no way for the coder to mark up his or her bid to pass the “Finder’s Fee” back to you as the buyer. Any coder bidding on a given project has absolutely no way of knowing of what the “other guy” bid on your project so every coder has an incentive to keep their bid as low as possible. Given that, if a coder should ever indicate to you that he or she has to charge you “extra” for RAC projects, you should realize that this is something the coder is doing entirely on their own and that perhaps it’s time to look for a different coder to work with. Your First Project and Auction Types Whether you’re a first time or even a veteran RAC buyer, your first project is typically posted as either an Open Auction (where any coder can bid) or a Private Auction (where only those you invited can bid). At this point, let’s assume that it’s your first project and you’ve never worked with any RAC coder. After posting your project, you’ll receive bids from all over the world (and I’m certain they’ll be as diverse as the coders posting them.) Many coders will offer a variety of incentives for you to choose their bid over any other but you have to step cautiously here. To a coder bidding on Open or Private Auctions this means that they will be paying a 15% “Finder’s Fee” to RAC when the project has been completed. Because of this, a coder might occasionally suggest having you repost your project for him or her only as a One on One Project/Enhancement Auction (12.5% “Finder’s Fee”) or as a Bonus/Other Direct Payment (10% “Finder’s Fee”) – you should never do this because if caught, the coder is subject to strict penalties up to and possibly including being banned from Rent A Coder and all Exhedra sites. Why would that happen? RAC (quite legitimately) views this behavior as the coder attempting to “cheat” RAC out of it’s rightfully earned “Finder’s Fee” of 15%. Once a project has been posted as a particular auction type, you can’t repost it without first obtaining permission from an RAC Facilitator (facilitator@rentacoder.com). Among other things, this might mean you have to go back and find another coder to finish your project – all because you tried to help the coder save a few dollars! If you’re at all like me, your time and effort are probably worth a lot more than that. You’re much better off waiting until the project is completed and then paying the coder a bonus to make up the difference if they did an outstanding job for you. Even more importantly, if you send the coder a Bonus/Other Direct Payment before they have completed any work for you at all, you risk losing your entire project cost because this type of auction bypasses escrow and the coder’s account is credited immediately. Technically, the coder doesn’t have to deliver anything to you at all, which leaves little recourse for you if the coder disappears or reneges on the project. Lastly, always remember that coders are expressly forbidden from requiring advance payments from buyers for any reason. Coders are allowed to request “phased” payments, i.e.; 25% upon delivery of beta, etc., but only after delivering a commensurate portion of the work they bid on. Working with Coders Directly on Other Projects Now let’s assume that your first project went well (which is usually the case) and you’re thinking about your next one. You may be considering using the same coder, which can work out exceptionally well for both of you because by now you’re familiar with each other and probably have a pretty good working relationship. This is the time to go back to RAC and post your project as a One on One Project/Enhancement type of auction for your coder. This saves the coder 2.5% off the “Finder’s Fee” and is a discount to the coder for bringing repeat business back to RAC. You might be inclined to work directly with the coder at this point and bypass RAC altogether (sometimes at the coder’s suggestion), but in all honestly, I can’t emphasize enough just how bad of an idea I think this is! Aside from the fact that this is a clear violation of both the Custom Software Buyer and Seller Agreements and, since using RAC costs you as a buyer nothing, there’s simply no better reason to continue to use them given the buyer protection they have to offer you. The only person who really stands to benefit from bypassing RAC is the coder and the benefit is usually so small that you should ask yourself if it’s worth risking your time, money and effort on. For example, let’s say you have a project in the $100 range (let’s keep the math simple). If you posted a One on One Project/Enhancement for your coder, this means that they will pay a “Finder’s Fee” of $12.50 to RAC. But it also means that you can set a project deadline, have the cost of your project placed in escrow until you indicate it’s satisfactorily completed, and have someone to turn to (facilitator@rentacoder.com) in the event something goes wrong on the project. Additionally, your coder is also aware that you will most likely be rating his or her performance so they have plenty of incentive to do a great job. Using the same project described above, if you bypassed RAC and worked directly with the coder you’d have no recourse through RAC on this new project! If the coder does not deliver, then you’ve completely wasted your time. If you paid the coder for all or even a portion of the project cost up front and they don’t deliver, you’ve just lost your money as well, all because you wanted to save the coder $12.50! Is it worth it? Not to me – I’d rather send the coder a $15.00 bonus when the project is finished and at least know that RAC was there with me every step of the way through the project, protecting my investment. The best possible advice I can offer you is for you to put the onus on the coder to deliver a top-notch project, on time and the way you want it, and then use the Bonus/Direct Payment Auction type to make up for any difference. Always remember though that you are never obligated to pay anything more than the amount of the bid you selected. Lastly, as a very productive coder at RAC, I can say that I emphatically support the “Finder’s Fee” concept. Without it, I would not have had the pleasure of meeting and working with over one hundred clients on my RAC projects! More importantly, I’ve had well over a year’s experience watching RAC evolve into the comprehensive and premiere freelance site it is today and I can plainly see that every “Finder’s Fee” I’ve paid has been put to excellent use benefiting both buyers and coders alike! Good luck to all of you on your projects and thank you for choosing Rent a Coder!

PHP 101 (part 2): Calling All Operators

2007-04-09T01:28:00.000-07:00

Not What You Expected
In Part One of this series, I gave you a brief introduction to PHP, and how it fits into your Web application development environment. I also taught you the basics of PHP variables, and showed you how to add, multiply and concatenate them together.
Now that you know the basics, it's time to focus in on one of PHP's nicer features - its ability to automatically receive user input from a Web form and convert it into PHP variables. If you're used to writing Perl code to retrieve form values in your CGI scripts, PHP's simpler approach is going to make you weep with joy. So get that handkerchief out, and scroll on down.
Form...
Forms have always been one of quickest and easiest ways to add interactivity to your Web site. A form allows you to ask customers if they like your products, casual visitors for comments on your site, and pretty girls for their phone numbers. And PHP can simplify the task of processing the data generated from a Web-based form substantially, as this first example demonstrates. This example contains two scripts, one containing an HTML form (named form.htm) and the other containing the form processing logic (message.php). Here's form.htm:

The critical line in this page is the
As you probably already know, the "action" attribute of the

tag specifies the name of the server-side script (message.php in this case) that will process the information entered into the form. The "method" attribute specifies how the information will be passed.
...And Function
Now for the other half of the puzzle: the message.php script. This script reads the data submitted by the user and "does something with it". Here is message.php:
$input"; ?>
When you enter some data into form.htm (let's say "Boo"), and submit it, the form processor message.php will read it and display it to you ("You said: Boo"). Thus, whenever a form is submitted to a PHP script, all variable-value pairs within that form automatically become available for use within the script, through a special PHP container variable: $_POST. You can then access the value of the form variable by using its "name" inside the $_POST container, as I did in the script above.
Obviously, PHP also supports the GET method of form submission. All you need to do is change the "method" attribute to "get", and retrieve values from $_GET instead of $_POST. The $_GET and $_POST variables are actually a special type of PHP animal called an array, which I'll be teaching you about shortly. Don't worry too much about it at the moment, just make sure you're comfortable with retrieving simple values from a form with PHP, and then scroll on down to learn about some more operators that are useful in this context.
Operating With Extreme Caution
Thus far, the scripts we've discussed have been pretty dumb. All they've done is add numbers and strings, and read back to you the data you typed in yourself - not exactly overwhelming. In order to add some intelligence to your scripts, you need to know how to construct what geeks call a "conditional statement" - a statement which lets your script perform one of a series of possible actions based on the result of a comparison test. And since the basis of a conditional statement is comparison, you first need to know how to compare two variables and determine whether they're identical or different.
You've already seen some of PHP's arithmetic and string operators. However, the language also comes with operators designed specifically to compare two values: the so-called "comparison operators". Here's an example that demonstrates them in action:
"; // greater-than operator // returns true if left side is greater than right // returns false here $result = ($mean >$median); print "result is $result
"; // less-than-or-equal-to operator // returns true if left side is less than or equal to right // returns false here $result = ($median <= $mode); print "result is $result
"; // greater-than-or-equal-to operator // returns true if left side is greater than or equal to right // returns true here $result = ($median >= $mode); print "result is $result
"; // equality operator // returns true if left side is equal to right // returns true here $result = ($mean == $mode); print "result is $result
"; // not-equal-to operator // returns true if left side is not equal to right // returns false here $result = ($mean != $mode); print "result is $result
"; // inequality operator // returns true if left side is not equal to right // returns false here $result = ($mean <> $mode); print "result is $result"; ?>
The result of a comparison test is always Boolean: either true (1) or false (0 - which doesn't print anything). This makes comparison operators an indispensable part of your toolkit, as you can use them in combination with a conditional statement to send a script down any of its multiple action paths.
PHP 4.0 also introduced a new comparison operator, which allows you to test both for equality and type: the === operator. The following example demonstrates it:
"; /* returns false, since the variables are not of the same type even though they have the same value */ $result = ($str === $int); print "result is $result
"; /* returns true, since the variables are the same type and value */ $anotherInt = 10; $result = ($anotherInt === $int); print "result is $result"; ?>
Read more about PHP's comparison operators at http://www.php.net/manual/en/language.operators.comparison.php.
A Question of Logic
In addition to the comparison operators I used so liberally above, PHP also provides four logical operators, which are designed to group conditional expressions together. These four operators - logical AND, logical OR, logical XOR and logical NOT - are illustrated in the following example:
"; /* logical OR returns true if any condition is true */ // returns true $result = (($status == 1) ($role <= 2)); print "result is $result
"; /* logical NOT returns true if the condition is false and vice-versa */ // returns false $result = !($status == 1); print "result is $result
"; /* logical XOR returns true if either of two conditions are true, or returns false if both conditions are true */ // returns false $result = (($status == 1) xor ($auth == 1)); print "result is $result
"; ?>
Logical operators play an important role in building conditional statements, as they can be used to link together related conditions simply and elegantly. View more examples of how they can be used at http://www.php.net/manual/en/language.operators.logical.php.
Older But Not Wiser
Now that you've learnt all about comparison and logical operators, I can teach you about conditional statements. As noted earlier, a conditional statement allows you to test whether a specific condition is true or false, and perform different actions on the basis of the result. In PHP, the simplest form of conditional statement is the if() statement, which looks something like this:
if (condition) { do this! }
The argument to if()is a conditional expression, which evaluates to either true or false. If the statement evaluates to true, all PHP code within the curly braces is executed; if it does not, the code within the curly braces is skipped and the lines following the if() construct are executed.
Let me show you how the if() statement works by combining it with a form. In this example, the user is asked to enter his or her age.
Enter your age:

Depending on whether the entered age is above or below 21, a different message is displayed by the ageist.php script:
= 21) { echo 'Come on in, we have alcohol and music awaiting you!'; } if ($age <>
If Not This, Then What?
In addition to the if() statement, PHP also offers the if-else construct, used to define a block of code that gets executed when the conditional expression in the if() statement evaluates as false.
The if-else construct looks like this:
if (condition) { do this! } else { do this! }
This construct can be used to great effect in the last example: we can combine the two separate if()statements into a single if-else statement.
= 21) { echo 'Come on in, we have alcohol and music awaiting you!'; } else { echo "You're too young for this club, come back when you're a little older"; } ?>
Spreading Confusion
If the thought of confusing people who read your code makes you feel warm and tingly, you're going to love the ternary operator, represented by a question mark (?). This operator, which lets you make your conditional statements almost unintelligible, provides shortcut syntax for creating a single-statement if-else block. So, while you could do this:
10) { $msg = 'Blocking your account...'; } else { $msg = 'Welcome!'; } ?>
You could also do this, which is equivalent (and a lot more fun):
10 ? 'Blocking your account...' : 'Welcome!'; ?>
PHP also lets you "nest" conditional statements inside each other. For example, this is perfectly valid PHP code:

Another, more elegant way to write the above is with a series of logical operators:

The Daily Special
PHP also provides you with a way of handling multiple possibilities: the if-elseif-else construct. A typical if-elseif-else statement block would look like this:
if (first condition is true) { do this! } elseif (second condition is true) { do this! } elseif (third condition is true) { do this! } ... and so on ... else { do this! }
And here's an example that demonstrates how to use it:

Today's Special

As you can see, this is simply a form which allows you to pick a day of the week. The real work is done by the PHP script cooking.php:

Today's special is:

In this case, I've used the if-elseif-else control structure to assign a different menu special to each combination of days. Note that as soon as one of the if() branches within the block is found to be true, PHP will execute the corresponding code, skip the remaining if() statements in the block, and jump immediately to the lines following the entire if-elseif-else block.
And that's it for now. To view more examples of conditional statements in action, visit http://www.php.net/manual/en/language.control-structures.php. In Part Three, I'll be bringing you more control structures, more operators and more strange and wacky scripts - so make sure you don't miss it!
Copyright Melonfire, 2004 (http://www.melonfire.com/). All rights reserved.

PHP 101 (part 1): Down the Rabbit Hole

2007-04-09T01:22:00.000-07:00

The Only Acronym You'll Ever Need
If you're new to Web development, you could be forgiven for thinking that it consists of no more than a mass of acronyms, each one more indecipherable than the last. ASP, CGI, SOAP, XML, HTTP - the list seems never-ending, and the sheer volume of information on each of these can discourage the most avid programmer. But before you put on your running shoes and flee, there's a little secret you should know. To put together a cutting-edge Web site, chock full of all the latest bells and whistles, there's only one acronym you really need to know:
PHP
Now, while you have almost certainly heard of PHP, you may not be aware of just how powerful the language is, and how much it can do for you. Today, PHP has the enviable position of being the only open-source server-side scripting language that's both fun and easy to learn. This is not just advertising: recent surveys show that more than 16,000,000 Web sites use PHP as a server side scripting language, and the language also tops the list of most popular Apache modules.
Why, you ask? The short answer: it's powerful, it's easy to use, and it's free. Extremely robust and scalable, PHP can be used for the most demanding of applications, and delivers excellent performance even at high loads. Built-in database support means that you can begin creating data-driven applications immediately, XML support makes it suitable for the new generation of XML-enabled applications, and the extensible architecture makes it easy for developers to use it as a framework to build their own custom modules. Toss in a great manual, a knowledgeable developer community and a really low price (can you spell f-r-e-e?) and you've got the makings of a winner!
My goal in this series of tutorials is very simple: I'll be teaching you the basics of using PHP, and showing you why I think it's the best possible tool for Web application development today. I'll be making no assumptions about your level of knowledge, other than that you can understand basic HTML and have a sense of humor. And before you ask... Yes, this series covers both PHP 4 and PHP 5, with new PHP 5 features flagged for easy reference.
Let's get going!
The Right Environment
PHP is typically used in combination with a Web server like Apache. Requests for PHP scripts are received by the Web server, and are handled by the PHP interpreter. The results obtained after execution are returned to the Web server, which takes care of transmitting them to the client browser. Within the PHP script itself, the sky's the limit - your script can perform calculations, process user input, interact with a database, read and write files... Basically, anything you can do with a regular programming language, you can do inside your PHP scripts.
From the above, it is clear that in order to begin using PHP, you need to have a proper development environment set up.
This series will focus on using PHP with the Apache Web server on Linux, but you can just as easily use PHP with Apache on Windows, UNIX and Mac OS. Detailed instructions on how to set up this development environment on each platform are available in the online manual, at http://www.php.net/manual/en/installation.php - or you can just download a copy of PHP 5 from http://www.php.net/ and read the installation instructions.
Go do that now, and come back when you've successfully installed and tested PHP.
Start Me Up
There's one essential concept that you need to get your mind around before we proceed further. Unlike CGI scripts, which require you to write code to output HTML, PHP lets you embed PHP code in regular HTML pages, and execute the embedded PHP code when the page is requested.
These embedded PHP commands are enclosed within special start and end tags, like this:

Here's a simple example that demonstrates how PHP and HTML can be combined:
Agent: So who do you think you are, anyhow?

Not quite your traditional "Hello, World" program... but then again, I always thought tradition was over-rated.
Save the above script to a location under your Web server document root, with a ।php extension, and browse to it. You'll see something like this: Look at the HTML source:
Agent: So who do you think you are, anyhow?
Neo: I am Neo, but my people call me The One.
What just happened? When you requested the script above, Apache intercepted your request and handed it off to PHP. PHP then parsed the script, executing the code between the marks and replacing it with the output of the code run. The result was then handed back to the server and transmitted to the client. Since the output contained valid HTML, the browser was able to render it for display to the user.
A close look at the script will reveal the basic syntactical rules of PHP. Every PHP statement ends in a semi-colon. This convention is identical to that used in Perl, and omitting the semi-colon is one of the most common mistakes newbies make. That said, it is interesting to note that a semi-colon is not needed to terminate the last line of a PHP block. The PHP closing tag includes a semi-colon, therefore the following is perfectly valid PHP code:

It's also possible to add comments to your PHP code, as I've done in the example above. PHP supports both single-line and multi-line comment blocks:

Blank lines within the PHP tags are ignored by the parser. Everything outside the tags is also ignored by the parser, and returned as-is. Only the code between the tags is read and executed.
A Case of Identity
Variables are the bread and butter of every programming language... and PHP has them too. A variable can be thought of as a programming construct used to store both numeric and non-numeric data; the contents of a variable can be altered during program execution. Finally, variables can be compared with each other, and you - the programmer - can write code that performs specific actions on the basis of this comparison.
PHP supports a number of different variable types: integers, floating point numbers, strings and arrays. In many languages, it's essential to specify the variable type before using it: for example, a variable may need to be specified as type integer or type array. Give PHP credit for a little intelligence, though: it automagically determines variable type by the context in which it is being used!
Every variable has a name. In PHP, a variable name is preceded by a dollar ($) symbol and must begin with a letter or underscore, optionally followed by more letters, numbers and/or underscores. For example, $popeye, $one and $INCOME are all valid PHP variable names, while $123 and $48hrs are invalid.
Note that variable names in PHP are case sensitive, so $me is different from $Me or $ME.
Here's a simple example that demonstrates PHP's variables:
Agent: So who do you think you are, anyhow?
$name, the $rank. You can call me by my serial number, $serialNumber."; ?>
Here, the variables $name, $rank and $serialNumber are first defined with string and numeric values, and then substituted in the echo() function call. The echo() function, along with the print() function, is commonly used to print data to the standard output device (here, the browser). Notice that I've included HTML tags within the call to echo(), and those have been rendered by the browser in its output. You can do this too. Really.
An Equal Music
To assign a value to a variable, you use the assignment operator: the = symbol. This is used to assign a value (the right side of the equation) to a variable (the left side). The value being assigned need not always be fixed; it could also be another variable, an expression, or even an expression involving other variables, as below:

Interestingly, you can also perform more than one assignment at a time. Consider the following example, which assigns three variables the same value simultaneously:

Not My Type
Every language has different types of variable - and PHP is no exception. The language supports a wide variety of data types, including simple numeric, character, string and Boolean types, and more complex arrays and objects. Here's a quick list of the basic ones, with examples:
Boolean: The simplest variable type in PHP, a Boolean variable, simply specifies a true or false value.

Integer: An integer is a plain-vanilla whole number like 75, -95, 2000 or 1.

Floating-point: A floating-point number is typically a fractional number such as 12.5 or 3.141592653589. Floating point numbers may be specified using either decimal or scientific notation.

String: A string is a sequence of characters, like "hello" or "abracadabra". String values may be enclosed in either double quotes ("") or single quotes(''). (Quotation marks within the string itself can be "escaped" with a backslash (\) character.) String values enclosed in double quotes are automatically parsed for special characters and variable names; if these are found, they are replaced with the appropriate value. Here's an example:

To learn more about PHP's data types, visit http://www.php.net/manual/en/language.types.php.
Market Value
If variables are the building blocks of a programming language, operators are the glue that let you build something useful with them. You've already seen one example of an operator - the assignment operator -, which lets you assign a value to a variable. Since PHP believes in spoiling you, it also comes with operators for arithmetic, string, comparison and logical operations.
A good way to get familiar with operators is to use them to perform arithmetic operations on variables, as in the following example:

Quantity	Cost price	Current price	Absolute change in price	Percent change in price
				%

Looks complex? Don't be afraid - it's actually pretty simple. The meat of the script is at the top, where I've set up variables for the unit cost and the quantity. Next, I've performed a bunch of calculations using PHP's various mathematical operators, and stored the results of those calculations in different variables. The rest of the script is related to the display of the resulting calculations in a neat table.
If you'd like, you can even perform an arithmetic operation simultaneously with an assignment, by using the two operators together. The two code snippets below are equivalent:

If you don't believe me, try echoing them both.
Stringing Things Along
Why stop with numbers? PHP also allows you to add strings with the string concatenation operator, represented by a period (.). Take a look:
' $statement = $a.' '.$b.' '.$c.' '.$d.'
'; print $statement; // and this returns 'begin the games now!' $command = $c.' '.$a.' '.$b.' '.$d.'!'; print $command; ?>
As before, you can concatenate and assign simultaneously, as below:

To learn more about PHP's arithmetic and string operators, visit http://www.php.net/manual/en/language.operators.arithmetic.php and http://www.php.net/manual/en/language.operators.string.php.
That's about it for this tutorial. You now know all about the basic building blocks and glue of PHP - its variables and operators. In Part Two of this series, I'll be using these fundamental concepts to demonstrate PHP's powerful form processing capabilities.
Copyright Melonfire, 2004 (http://www.melonfire.com/). All rights reserved.

Introducing Windows Forms

2007-04-08T01:19:00.000-07:00

Designing Windows Application is simpler and less time consuming with Visual Basic 2005. A number of new facilities and enhancements have been made to assist the developer complete the project in time and with lesser number of errors. Windows Form is the cynosure of the Windows Application. Visual studio 2005 packs more features to the already enriched area of Windows Forms, both at design and run time. Among the several features that have been added some standout as prominent. The management of layout of the form is made easier by providing the snap lines that make it easy to align controls with other controls as the layout is formed. A new deployment technology called ClickOnce for forms is added.
Creating a Windows Application
Understanding Classes, Inheritance, and Namespaces
Using The System.Windows.Forms.Form class
Designing a Form using Windows Forms Designer
Exploring the Forms Designer generated code
Using the Application class
Using the MessageBox class
Setting and Adding Properties to a Windows Form
Using the Visual Designer to set Windows Form Properties
Setting Windows Forms Properties programatically
Adding new Property to a Windows Form
Using Visual Inheritance
Event Handling
Handling Events by attaching a delegate
Handling Events by overriding protected method of base class.
Building graphical interface elements
Understanding The Graphics Object
Understanding The Windows Forms Coordinate System
Drawing Text on a Form
Drawing Shapes
Working with images Building graphical interface elements by using the System.Drawing namespace
In this tutorial we will learn about Graphics Object, The Windows Forms Coordinate System, Drawing Text on a Form, Drawing Shapes and Working with इमागेस

Understanding The Graphics Object
Graphics handling in Visual Basic .NET is based on GDI+ (Graphics Device Interface). A graphics device interface allows you to display graphics on a screen or a printer without having to handle the details of a specific display device. All that you need to do is to make calls to methods supported by the GDI+ classes and those methods make the corresponding calls to individual device drivers as needed to handle the screen or printer.
To create a graphics object
Receive a reference to a graphics object as part of the System.Windows.Forms.PaintEventArgs in the System.Windows.Forms.Control.Paint event of a form or control. This is usually how you obtain a reference to a graphics object when creating painting code for a control.
-or- Call the System.Windows.Forms.Control.CreateGraphics method of a control or form to obtain a reference to a System.Drawing.Graphics object that represents the drawing surface of that control or form. Use this method if you want to draw on a form or control that already exists.
-or- Create a System.Drawing.Graphics object from any object that inherits from System.Drawing.Image. This approach is useful when you want to alter an already existing image.
Let quickly see an example:
Click here for the Sample Code
You can manage the state of the Graphic Object easily as can be seen in the following code fragment
Click here for the Sample Code
The above code generates the output as shown below:

Dynamic Pages

2007-04-07T09:09:00.000-07:00

So what about the dynamic pages? First of all, you start with a HTML page as your first template. If you are satisfied with the layout, just rename the file to .php instead of .html. You are now able to add PHP tags to the page. To keep your project clean and easy to maintain, you can collect all the things you need into one file and put it into functions. You can name this file for example "dynamic.inc.php"
include "dynamic.inc.php";
This will enable you to use the functions that you have defined in "dynamic.inc.php" within your HTML template file. The filename has two extensions, which is common in the Unix and Linux world. The "inc" stands for a file that should be included into another file and therefore will not run on its own. The "php" stands for the PHP script language. It will prevent that the code in the file will be displayed, when anybody accidentally enters this file name into the browser URL. This will protect your intellectual property because the code from a php file is never shown in the browser.
In the dynamic file, we define the following functions:
show_title() will show the header for the HTML File
show_content() will show the main content
show_navigation() will show the navigation
Each function can be called anywhere in the template file by using the PHP tags:

Each of these three lines is a valid PHP tag. The first one is commonly used but not supported by all providers. If not supported, you can use the second variation. The third one is something that is very similar to the JavaScript syntax and can be used as well. Because the first method is the shortest, it is very popular and will normally not cause any problems.
Your web pages would not be very dynamic, if you do not have more than one page. Therefore, we will provide the function calls with a parameter. A parameter is something you pass along to the function that you call. It is like telling the function more details on what it should do for you.
Parameters can also be passed with web pages. If you add a question mark after the URL, you can set one or more parameters here. We will use both types of parameters here to navigate between the pages.
Example:
You provide a set of news pages for every month. To call the news for April 2001 you can name the index page like this: "http://www.mydomain.com/index.php?id=april+2001". This will show up the page "index.php" in the browser and it will also pass a parameter "id" with the value "april+2001". The plus sign is a placeholder for a blank because using blanks in a URL can cause some confusion within the script. For that reason, blanks and other special characters are encoded in the URL with special chars like the plus sign. If the plus sign itself is being used in a URL, it is encoded as "%2B".
If your user does not know anything about parameters, he/she will call the page just by using "index.php". For that reason, you may need to set a default for the parameter. In PHP, each URL parameter will be translated into a PHP variable. So your "id" parameter will be available as "$id" within PHP. The function empty($id) will check if this parameter is still empty. If this is the case, the parameter has not been passed in the URL and a default will be set to $id. This default should be the home page and is therefore set to "Home".
And this is your complete template with the PHP tags:
Now you want to know how the functions would work? Okay, let's start with the show_title() function:
function show_title($id)
{
$fp = fopen(get_filename($id), "r");
if (!$fp) return;
$line = trim(fgets($fp, 255));
fclose($fp);
echo $line;
}
The very first line is the function definition of show_title(). It contains the name of the function and the name of the passed parameter. In this case, the name is identical with the name we used to call the function "$id", but this is not necessary when you call a function. You can name the parameters as you like, you only have to make sure that they are placed at the correct position, if a function needs more than one parameter.
The function is then using curly brackets to enclose the function code. Everything between the opening and closing bracket belongs to that function.
The first line in the function is a call to the fopen() function that is defined within PHP. This function will open a file that is to be read or written it on the web server. The first parameter for fopen() is the name of the file. Now we only know the ID-Parameter and we have to build a filename from that. This is done by another function get_filename() that will be explained later. A second parameter will tell fopen() if the file should be opened for reading or writing. We are using the character "r" which tells the function to read the file only.
The function fopen() will return a value (which is called "return value") that is just an ID-number of the opened file. The second line in our function will check if the returned ID-number is a valid file handle. If this is not the case (the exclamation mark indicates the logical operator "not") the function will return without doing anything else.
The next statement will get a line from the opened file with the PHP function fgets(). This function reads a single line from a text file up to a specified length. In this case, we limited the length to 255 characters, because we do not expect a header to be longer than that. The return value from fgets() is not assigned to a variable, it is passed to another function trim() instead. This will strip all leading and trailing white spaces including carriage return characters.
Next, the file will be closed to tell PHP that we don't need the file handle any longer within this function. This is not really necessary if you just want to read from a file but it will save resources on the server. If you forget to close the file, it will remain open until the script ends.
The echo command will then display the line from the file. For the header we only read the first line from the file because we want to put the header line as a separate line in each text file.
To get a valid file name from the ID variable, we use this function:
function get_filename($id)
{
$name = "file_$id.txt";
if (file_exists($name))
{
return $name;
} else {
return "error.txt";
}
}
This will compose a filename from the elements "file_" the ID and ".txt". Please note that the variable "$id" can be included in the string that is provided in double quotation marks. If you use single quotation marks, the expression "$id" would show up as it is and you would get a "file_$id.txt" as result. With double quotation marks the content of $id will be evaluated and put into the string. So if the content of $id is "Home" you will get "file_Home.txt" (please note: uppercase letters are relevant in filenames on webserves).
Then, the function will check if the file exists on the server. The PHP function file_exists() returns true if the file can be found otherwise the result is false. If the file exists, the function returns the composed filename, otherwise it will return "error.txt" which should be the default error text like this:
File not found

The selected file was not found

If the specified ID is not assigned to a valid file, it will just display this text instead of the normal content. To build your dynamic content, you just need to create several text files with the name "file_{topic}.txt" were {topic} can be anything that is valid for a filename. In this example, the ID will also be displayed in the navigation link, so you may want to use something descriptive.
For example: You want to provide news for April 2001 and you name your ID "april 2001", then you need to have a file with the name "file_april 2001.txt". It is okay to have blanks in the filename as long as the operating system on the web server allows that. As you have learned before, blanks will be replaced by the URL encoding with a plus sign. The content of this file "file_april 2001.txt" could look like this:
News in April 2001
These are the latest news for april 2001
please read on to check these news ...
The first line is used as the header, all other lines are shown in the content of your page. You can use all HTML tags within this text, it will be included as it is stored in the text file.
What about the navigation? You do not want to build your navigation links by hand, do you? So we have a function here to build it from the available files:
function show_navigation($id)
{
global $PHP_SELF, $SCRIPT_NAME;
if (trim($PHP_SELF) == "") $PHP_SELF = $SCRIPT_NAME;

$dir = opendir('.');
if (!$dir) return;
while ($file = readdir($dir))
{
if ( (ereg("^file_.*\.txt$", $file)) and (is_file($file)) )
{
$item = ereg_replace("^file_(.*)\.txt$", "\\1", $file);
echo ''.$item."\n";
if ($id == $item)
{
echo "<=="; } echo " \n"; } } } This function will browse the current directory and display all files that fit the pattern "file_*.txt". The pattern is tested with the PHP function ereg() where you can use a regular expression to test it against the given filename. Explaining regular expressions would be outside the scope of this article, just let me say that "^file_(.*)\.txt$" checks if the name starts with the string "file_" and ends with ".txt". If this is the case, another PHP function ereg_replace() removes everything from the filename except the ID that will be shown in the navigation link. For each filename, a link will be generated to call the script itself ($PHP_SELF contains the name of the actual script) and passes the ID as a parameter. So if you click on one of these links, it will call up the appropriate content. The last function to explain is this: function show_content($id) { $fp = fopen(get_filename($id), "r"); if (!$fp) return; $first = true; while (!feof($fp)) { if ($fp) { $line = fgets($fp, 1024); if ($first) { $first = false; } else { echo $line; } } } fclose($fp); } It is pretty much similar to show_header(), but it reads the whole file line by line until the end. To avoid showing the first line (that contains the header only) there is a variable $first, defined to check if a line has already been read from the file. If this is not the case, this line will not be displayed and $first will be set to false. Conclusion: As you can see, building dynamic web pages is not so difficult with PHP. If you don't understand each detail here, just try it out and learn as you go. Scripting languages like PHP are excellent to start programming because you will get results even with a one-liner. Recommended BooksProfessional PHP Programming - This Book describes all the necessary facts about PHP programming including hands-on examples like a little shop application.

Building Dynamic Web Pages With PHP

2007-04-07T09:06:00.000-07:00

By Marian Heddesheimer of Rent A Tutor Site
This article will explain how to build dynamic web pages with PHP. PHP is a very popular and easy to learn script language. Regardless if you are starting to build your website, or if you are already a pro, just read on to learn more about dynamic web pages and PHP.
Why dynamic web pages?
If you have ever created a web site, you already know that maintaining very many pages is really a lot of work. Even if you never need to change the layout of the pages, you want to present the most current information on it. Sometimes the links will change, or the web pages you have linked to will disappear on the Internet. Then you need to load your page again and make all the necessary changes.
These changes are easy to do if your whole website is very small. With 5-10 pages to maintain, you can do it by hand and page by page. With more than ten pages, it will be more difficult. If you want to have a date on each page, you must check if it is the correct one. Moreover, if you ever want to change something in the layout, you have to do this for all the pages.
So this is the big advantage of dynamic web pages: You just need a single template to start with your layout. All content within that template will be filled in dynamically from a script. If the layout has to be modified, there is no need to change every single page, you just modify the initial template and all pages will look alike.
Why PHP?
To build dynamic web pages, you can use other available techniques: Most providers offer server side includes (SSI) for your pages. This will enable you to build one template and fill in parts of the page from include files. The disadvantage with SSI is: If it comes to more complicated stuff, you want to have more power to decide what will be included in your page and what will not. For example, if you want to show a specific content only after a special date and time has passed, you will need some kind of script. With a script you can decide, that the new content will display only if the system date on the web server is set past Jan. 1st 2002 at midnight.
With scripts, you can almost do everything you like. Some kinds of scripts that are offered by the providers are available on the Internet. You can use CGI/Perl for your scripting. Almost every provider supports Perl on the web server. On the other hand, Perl is not so easy to learn and the scripts are not so easy to install. Nonetheless, there are many Perl scripts available for free or a minimal charge that you can use for your own website without knowing the language.
Another script language is ASP, but it is usually only provided on Windows web servers. In the meantime, there is also an implementation of ASP for Linux servers, but it is not yet very popular. Windows web servers are also not very popular, because they are prone to virus attacks so that even Gartner Group has recommended not to use the Internet Server from Microsoft.
A third language is Cold Fusion, but this is not very common and is not often offered by the providers.
So finally, there is PHP: A free script language, what means that it is available free of charges and free of license fees. It runs perfectly on free operating Systems like Linux and works fine with free web server software like Apache. This is one of the reasons, why most providers offer PHP as script language free with the web space.
PHP works fine with HTML: You just put some extra tags in your web page to indicate that it is not a standard HTML, but a PHP code. To tell the web server that the page may contain these special tags, you have to rename your page from "index.html" to "index.php" for example. The file extension .php indicates a PHP script that can also contain standard HTML code. Therefore, it is very easy to mix your existing HTML template with the new PHP script code.
What is PHP?
PHP was developed by Rasmus Lerdorf in 1994 (see details at http://www.phpbuilder.com/manual/intro-history.php). It originally was an interpreter that read one line by another and tried to interpret the written code line by line. Since PHP4, it was improved by the Zend Engine from www.zend.com so that the code is now precompiled. The main advantage is that PHP scripts will now run much faster and the programming is more convenient. Now it is possible to define your functions after using them, which was not doable in PHP3.
PHP was meant as Personal HomePage tool, and this is where the name came from. Later it was renamed to "PHP: Hypertext Preprocessor" which is a reflective acronym because the acronym word "PHP" is contained in the long name. It is meant to be a script language that is easy to use and easy to mix with existing HTML code. Unlike using CGI/perl, there is no need to supply a special directory on the web server like cgi-bin. In most cases, there is no need to change access rights on the files that contain PHP code. The only necessary change to the HTML file is to modify the file extension from .html to .php. Some providers offer the old version PHP3 along with the new PHP4 so you have to use sometimes .php4 or .php3 for your filenames. Nonetheless, the official extension is .php, so you may have to ask your provider if there is something special on your web space.
As mentioned before, PHP is completely free and open source. This means that even the source code for PHP itself is available on the Internet. It is written in C and can be modified when necessary. Many developers are still working on the code, releasing new versions from time to time.
How to Start?
Got excited about PHP yet? So you want to know where to start? The initial start is quite easy: You should first check out if PHP is available with your web space and which version it is. It is really easy to do this. Just create a simple text file that contains theses commands:

Save this file as "info.php" and upload it to your web space. Then call it in your favorite browser by entering the appropriate URL like "www.mydomain.com/info.php".
You will get a page with lots of information or you will just see your command in the browser. If you just see the single line, either your provider does not support PHP or they are using other file extensions. Then try to rename your file to "info.php4", "info.php3" or "info.phtml". These are the most common extensions used instead of the official .php extension.
If you got the whole PHP information page, you will see the version of PHP, all the settings and server variables that are available for PHP and within your own scripts. It is a good idea to print this information for later reference.
Before you can build dynamic web pages, you should acquire a basic understanding about the language. If you already know any programming language like C, C++, VisualBasic or Java, you may find it very easy to switch to PHP. The language is pretty much like C++ and Java so that you can migrate from these languages. But even if you just have some knowledge in VisualBasic, you know what a variable and a function is, so it is not difficult to learn PHP. If you don't know anything about programming, PHP is a great tool in order to learn your first programming language for web programming.
To build your first program, you can use a simple text editor, even if it is not very comfortable. If you write more than ten lines of code, you might want a more convenient tool that can show you the correct spelling of the keywords. This feature is also known as "syntax highlighting" and there are some tools available for free. A list of these editors is available at: http://www.itworks.demon.co.uk/phpeditors.htm.
Another list with editors for PHP can be found at: http://php.weblogs.com/editors.
The next step will be to learn the specific language and create a first project. A good reference is the official php web site at http://www.php.net. Another good source for information is http://www.phpbuilder.com, where you can find articles on common PHP solutions and a forum with solutions to various questions on PHP. You will also find a variety of tutorials on PHP and there are several newsgroups related to PHP programming. At least, there are some online classes available for PHP like the one that I offer at http://www.rent-a-tutor.com/courses/index.php.

VB.NET 2005 Training : The .NET Framework Architecture Part 1

2007-04-07T05:53:00.000-07:00

This is the first tutorial as part of the Visual Basic .NET 2005 Training. In this tutorials we will be learning about the basics of The .NET Framework Architecture, The .NET vision, Common Language Runtime (CLR), .NET Framework Class Library and Microsoft Intermediate Language (MSIL). It's very important to learn the basics before we actually start with the Programming.
The .NET Vision

The .NET framework is a software technology that is directed towards connecting information, people, systems and devices seamlessly. The high level of software integration that has been attempted through use of XML web services enables the creation of small, discrete, building block types of applications. These applications are connected to other applications over the Internet.
Central to the .NET framework architecture is the effort to provide support to for the next generation solutions. The direction of change is to ensure that software deployment and versioning conflicts are avoided or minimized in the .NET Framework. User defined codes are released from the confines of the local storage systems and can be stored anywhere on a network and executed from any point in the network. Performance problems associated with scripted and interpreted environments are removed. Codes can be safely executed and the developer experience is consistent across widely varying types of applications, such as Windows based applications and web based applications. The thrust of design is towards creating a standard communication facility that is standardized so that .NET codes can be integrated with other codes easily and seamlessly.
At the core of the .NET infrastructure is the Common Language Runtime (CLR) and the .NET Framework class library.
The runtime functions, like an agent, managing code at execution time. It provides core services such as memory management, thread management and ‘remoting’. It enforces strict type safety and ensures code accuracy. This makes for security and robustness and provides a platform for running managed code.
The .NET Framework provides several runtime hosts. It also supports the development of third-party runtime hosts. For example, ASP.NET hosts the runtime to provide a scalable, server-side environment for managed code. ASP.NET works directly with the runtime to enable ASP.NET applications and XML Web services.
The .NET Framework can be hosted by unmanaged components such as the Internet Explorer. These load the common language runtime into their processes and initiate the execution of managed code. This creates a software environment that can exploit both managed and unmanaged features. This makes for mobility of the code.
Common Language Runtime (CLR)
The common language runtime (CLR) is the foundation upon which developers construct various kinds of applications. The benefits of the CLR are many. It makes for a vastly simplified development. It enables a seamless integration of code written in different languages. It provides evidence-based security with code identity. The assembly based deployment eliminates the problems of DLL. The versioning of reusable components makes for ease of usage. The implementation inheritance feature enables the reuse of code. The automatic object lifetime management makes the application- development comfortable. The self descriptive nature of objects makes for ease of programming and debugging.

CLR includes both private and shared components. It provides for incremental download of code and caching; native platform interoperability and seamless integration with COM. It offers dynamic inspection capabilities, administration and configuration options. The developer is not required to know all the runtime supported infrastructure. The tools and frameworks are designed to expose a subset of the functionality in accordance with the kind of application being built.
The common language runtime is a virtual execution system that provides important services such as memory management, security and also has a Just-in-Time compiler (JIT) which converts the intermediate language (IL) into native code that can be executed by the physical machine. The infrastructure provides a machine independent environment for application execution.
VB.NET 2005 Free Training : The .NET Framework Architecture Part 2. In this tutorial of The .NET Framework Architecture Part 2 we will learn about Just-In-Time (JIT) compilation, Assemblies, native assemblies, Global Assembly Cache (GAC) and Comparison of VB.NET, C#, and J#.
Just-In-Time (JIT) compilation
As stated above, the Just in time compiler is a facility that is invoked by the CLR to convert the IL into machine code. The .NET framework assemblies (*.dll or *.exe) files cannot be executed by the target processor unless it is converted into native code. When the Assembly is loaded the method calls are invoked for compilation into native code. Since this is done just when the method needs to execute, it is called Just in time compilation. When the JIT is invoked for the first time there is an overhead or performance penalty, since the assembly is converted into its Native code or image using the Native Image Generator (Ngen.exe). All subsequent calls will load faster as the Native image alone is invoked thereafter from the Native image cache.
Significantly, the IL can coexist with the machine code in the application. This feature also enables the developer modify the code or add to the code even when the application is actively deployed. This functionality provided by JIT makes the .NET framework an efficient, agile and powerful means of application development.
Assemblies, native assemblies, and the Global Assembly Cache (GAC)
The primary unit of deployment is the assembly. The assembly is used by the .NET CLR as the smallest unit of deployment; version control; security; type grouping and code reuse. An assembly will consist of a manifest and one or more modules or files. It can be defined as a logical DLL that contains a manifest, type metadata, MSIL and resources. Assemblies can be application private or shared. Private assemblies are restricted to use in a single application whereas shared assemblies can be used across applications. Private applications also reside within the application folder while shared assemblies reside in the common area-- GAC(Global Assembly Cache). They must have a globally unique name.
The existence of the manifest within the assembly makes it self descriptive. It can be viewed by the IL Disassembler (Ildasm.exe) which is part of the .NET framework SDK.
The assembly is identified by the manifest. It defines security requirements, lists other interdependent assemblies and all the types and resources exposed by the assembly. Localized resources exposed by assemblies and targeted by the application contain a default culture (language, currency, date/time format etc).
The manifest contains several sections. Identity, Referenced Assemblies, file list and Custom Attributes are some of the important sections of the manifest. The Identity section as the name suggests, identifies the assembly. It contains a .assembly directive. The version directive specifies the version of the assembly, so that the CLR identifies the different versions of an application. The Identity section contains a strong name for shared assemblies and a public/private encryption key is used to distinguish between assemblies of the same name. The Identity section also optionally contains the Culture which defines the country and language of the assembly target. The .locale directive is used for this purpose and the Culture-Neutral assemblies can be used by any assembly. The Referenced Assemblies section of the manifest provides a reference to all the assemblies used in an application.
Comparison of VB.NET, C#, and J#

The .NET framework architecture has made the language of coding immaterial to the final output. All languages also have equal access to all development capabilities and revolve around the .NET classes. The language syntax, operations etc look similar in all the languages of this group. Moreover, code can be shared by all .NET languages and so a class made in C# or J# can be used in VB.NET and vice versa.
In this context choice of language is no longer significant. Finally, all languages are transformed by the compiler into Microsoft Intermediate language. It is the programmer’s familiarity with the language that makes it material whether he is coding in VB.NET or C# or J#. However, the option settings in the compiler will have to be set to the language of coding before the compiler is used.
The speed of performance of the compiler will also vary with the language being compiled. For instance C# compiles faster than VB.NET. Subject to the above observation, the features of the languages will be dicussed in the next tutorial.

How To Make Money Online With Top Paying Keywords

2007-04-06T22:10:00.000-07:00

Author: Uche Okoroha
The majority of people making successful income on the internet make a large part of it with Google Adsense. By learning the secrets to adsense and how to make up to $100 per click, you too can establish comfortable revenue through the internet.
Many have scoured the internet for fast and easy ways to make money online. Most of the time this search leads to one company – Google. There are immense amounts of money to be made through Google Adsense using top paying keywords. What are top paying keywords, you ask? Top paying keywords are those that will return anywhere from a couple of dollars to one hundred dollars PER CLICK! Using these keywords on your Adsense site will allow you to maximize your profits online. In the following, I will outline from beginning to end how to make money online with top paying keywords.Firstly, you are going to want a website. If you don't have a website, or don't have to money to purchase one – don't worry, you can still make money with top paying keywords by going to a blog site and registering for a free blog. My two favorite blog sites are wordpress.com and blogspot.com. These blog sites will help you make money online with top paying keywords by allowing you to post your content on their website for free. They will even give you your own unique web address on their server. For example – my wordpress username is 'onlinemarketingteam'. This means that the location of my blog would be onlinemarketingteam.wordpress.com – this is the url that others can use to visit your website.Once you have your blog, think of what you want the focus of the blog to be. Sticking with what you know and love will make it easier to make money with top paying keywords. You want to make sure you know plenty about the subject you are writing your blog about. When you know what your blog is going to be about, try to think of a couple of different topics of articles you can write that will help others out. At this stage you might want to do a little research online or at your local library to gather more information on your topic.Now, take the first topic you want to write your article about and think of what keywords you want to use. It is important that you always do a full keyword analysis to make sure that you optimize your articles with top paying keywords. Try to think of what words YOU would type into a search engine to find your own blog. Once you have this list, you can run it through software that will help you find top paying keywords for your topic.My favorite top paying keywords software is Keyword Elite. This software will recognize your topic, and give you the most profitable keywords to use on your website. Once you have these top paying keywords, pick one or two and use them in the articles you write. For example – if the topic of my blog was airplanes. I would type 'airplanes' into the software, and it would tell me that advertisers pay a lot of money for the term 'private jets' . I would then write an article using the top paying keywords to put on my blog.When I put Adsense ads on the blog it will go through and gain the general idea of the content. It will then display ads from advertisers paying for the term 'private jets'. Each time a visitor clicks on one of these ads, I would get payed several dollars. To increase your income you could do research on additional categories and find top paying keywords for those subjects. Then, repeat the process by writing a different blog on that subject and optimizing your content with those top paying keywords.

Microsoft Visual Studio

2007-04-05T09:47:00.000-07:00

Microsoft Visual Studio is Microsoft's flagship software development product for computer programmers. It centers on an integrated development environment which lets programmers create standalone applications, web sites, web applications, and web services that run on any platforms supported by Microsoft's .NET Framework (for all versions after 6). Supported platforms include Microsoft Windows servers and workstations, PocketPC, Smartphones, and World Wide Web browsers.
Visual Studio includes the following:
Visual Basic
Visual C++
Visual C#
Visual J#
Visual Web Developer
Some versions include a developer edition of Microsoft SQL Server.
In the past, the following products were included:
Visual InterDev, a web page development application used for modifying Active Server Pages as well as HTML and other web scripting files.
Visual J++, a Java development tool.
Visual FoxPro, an xBase programming language now allied to but independent from the Visual Studio platform.
Contents[hide]
1 History
1.1 Visual Studio 97
1.2 Visual Studio 6.0
1.3 Visual Studio .NET (2002)
1.4 Visual Studio .NET 2003
1.5 Visual Studio 2005
2 Visual Studio Tools for Applications
3 Future development
4 Extensibility
5 Deployment
6 See also
7 References
8 External links
//

[edit] History

[edit] Visual Studio 97
Microsoft first released Visual Studio in 1997, bundling together many of its programming tools for the first time. Visual Studio 97 was released in two editions, Professional and Enterprise. It included Visual Basic 5.0 and Visual C++ 5.0, primarily for Windows programming; Visual J++ 1.1 for Java and Windows programming; and Visual FoxPro 5.0 for xBase programming. It introduced Visual InterDev for creating dynamically generated web sites using Active Server Pages. A snapshot of the Microsoft Developer Network library was also included.
Visual Studio 97 was Microsoft's first attempt at using the same development environment for multiple languages. Visual C++, Visual J++, InterDev, and the MSDN Library all used one environment, called Developer Studio. Visual Basic and Visual FoxPro used separate environments.

[edit] Visual Studio 6.0
The next version, version 6.0, was released in 1998. The version numbers of all of its constituent parts also moved to 6.0, including Visual J++ which jumped from 1.1, and Visual InterDev which was at 1.0. This version was the basis of Microsoft's development system for the next four years, as Microsoft transitioned their development focus to the .NET Framework.
Visual Studio 6.0 was the last version to include Visual Basic as most of its programmers knew it; subsequent versions would include a quite different version of the language based on .NET. It was also the last version to include Visual J++, which included deeper ties to Windows and proprietary extensions to the Java language that were incompatible with Sun's version. This caused Sun to sue Microsoft. As part of the settlement, Microsoft would no longer sell programming tools that targeted the Java Virtual Machine.
Although Microsoft's long-term goal was to unify its tools under one environment, this version actually had one more environment than VS 97. Visual J++ and Visual InterDev broke away from the Visual C++ environment, while Visual Basic and Visual FoxPro maintained their separate tools.

Visual Basic .NET

2007-04-05T09:32:00.000-07:00

Visual Basic .NET (VB.NET) is an object-oriented computer language that can be viewed as an evolution of Microsoft's Visual Basic (VB) implemented on the Microsoft .NET framework. Its introduction has been controversial, as significant changes were made that broke backward compatibility with VB and caused a rift within the developer community.
The great majority of VB.NET developers use Visual Studio .NET as their integrated development environment (IDE). SharpDevelop provides an open-source alternative IDE.
Like all .NET languages, programs written in VB.NET require the .NET framework to execute.
Contents[hide]
1 Versions of Visual Basic .NET
1.1 Visual Basic .NET
1.2 Visual Basic .NET 2003
1.3 Visual Basic 2005
1.3.1 IsNot Patent
1.3.2 Visual Basic 2005 Express
2 Relation to Visual Basic
2.1 Comparative samples
2.2 Controversy
3 Cross-platform and open-source development
4 Hello World Example
5 See also
6 Notes
7 External links
7.1 Tutorials
//

[edit] Versions of Visual Basic .NET
As of November 2006 there are three versions of Visual Basic .NET.

[edit] Visual Basic .NET
The original Visual Basic .NET was released alongside Visual C# and ASP.NET in 2002. C# — widely touted as Microsoft's answer to Java — received the lion's share of media attention, while VB.NET (sometimes known as VB7) was not widely covered. As a result, few outside the Visual Basic community paid much attention to it.[citation needed]
Those who did try the first version found a powerful but very different language under the hood, with disadvantages in some areas, including a runtime that was ten times as large to package as the VB6 runtime and an increased memory footprint.[citation needed]

[edit] Visual Basic .NET 2003
Visual Basic .NET 2003 was released with version 1.1 of the .NET Framework. New features included support for the .NET Compact Framework and a better VB upgrade wizard. Improvements were also made to the performance and reliability of the .NET IDE (particularly the background compiler) and runtime.
In addition, Visual Basic .NET 2003 was also available in the Visual Studio .NET 2003 Academic Edition (VS03AE). VS03AE is distributed to a certain number of scholars from each country for free.

[edit] Visual Basic 2005
Visual Basic 2005 is the next iteration of Visual Basic .NET, Microsoft having decided to drop the .NET portion of the title.
For this release, Microsoft added many features, including:
Edit and Continue - probably the biggest "missing feature" from Visual Basic, allowing the modification of code and immediate resumption of execution
Design-time expression evaluation
The My pseudo-namespace (overview, details), which provides:
easy access to certain areas of the .NET Framework that otherwise require significant code to access
dynamically-generated classes (notably My.Forms)
Improvements to the VB-to-VB.NET converter [2]
The Using keyword, simplifying the use of objects that require the Dispose pattern to free resources
Just My Code, which hides boilerplate code written by the Visual Studio .NET IDE
Data Source binding, easing database client/server development
The above functions (particularly My) are intended to reinforce Visual Basic .NET's focus as a rapid application development platform and further differentiate it from C#.
Visual Basic 2005 introduced features meant to fill in the gaps between itself and other "more powerful" .NET languages, adding:
.NET 2.0 languages features such as:
generics [3]
Partial classes, a method of defining some parts of a class in one file and then adding more definitions later; particularly useful for integrating user code with auto-generated code
Nullable Types
XML comments that can be processed by tools like NDoc to produce "automatic" documentation
operator overloading [4]
Support for unsigned integer data types commonly used in other languages

[edit] IsNot Patent
One other feature of Visual Basic 2005 is the conversion of If Not X Is Y to If X IsNot Y which gained notoriety [5] when it was found to be the subject of a Microsoft patent application [6]।

Relation to Visual Basic
Whether Visual Basic .NET should be considered as just another version of Visual Basic or a completely different language is a topic of debate. This is not obvious, as once the methods that have been moved around and which can be automatically converted are accounted for, the basic syntax of the language has not seen many "breaking" changes, just additions to support new features like structured exception handling and short circuited expressions. One simple change that can be confusing to previous users is that of Integer and Long data types, which have each doubled in length; a 16-bit integer is known as a Short in VB.NET, while Integer and Long are 32 and 64 bits respectively. Similarly, the Windows Forms GUI editor is very similar in style and function to the Visual Basic form editor.
The things that have changed significantly are the semantics — from those of an object based programming language running on a deterministic, reference-counted engine based on COM to a fully object-oriented language backed by the .NET Framework, which consists of a combination of the Common Language Runtime (a virtual machine using generational garbage collection and a just-in-time compilation engine) and a far larger class library. The increased breadth of the latter is also a problem that VB developers have to deal with when coming to the language, although this is somewhat addressed by the My feature in Visual Studio 2005.
The changes have altered many underlying assumptions about the "right" thing to do with respect to performance and maintainability. Some functions and libraries no longer exist; others are available, but not as efficient as the "native" .NET alternatives. Even if they compile, most converted VB6 applications will require some level of refactoring to take full advantage of the new language. Extensive documentation is available to cover changes in the syntax, debugging applications, deployment and terminology.

[edit] Comparative samples
The following simple example demonstrates similarity in syntax between VB and VB.NET. Both examples pops a message box saying "Hello, World" with an OK button.
Classic VB example:Private Sub Command1_Click()
MsgBox "Hello, World"
End Sub
A VB.NET example:Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
MessageBox.Show("Hello, World")
End Sub
Note that all procedure calls must be made with parentheses in VB.NET, whereas these were only required for function calls (however in VB6 they could be used in procedure calls as well by using the Call keyword)
Also note that the names Command1 and Button1 are not obligatory. However, these are default names for a command button in VB6 and VB.NET respectively.
Actually, there is a function called MsgBox in the Microsoft.VisualBasic namespace, but the System.Windows.Forms.MessageBox class is a preferred way of displaying message boxes since it has more features and is less language-specific.
The following example demonstrates a difference between VB6 and VB.NET. Both examples unload the active window.
Classic VB Example:Private Sub cmdClose_Click()
Unload Me
End Sub
A VB.NET example:Private Sub btnClose_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnClose.Click
Me.Close()
End Sub
Note the 'cmd' prefix being replaced with the 'btn' prefix, conforming to the new convention previously mentioned.
Visual Basic 6 did not provide common operator shortcuts. The following are equivalent: VB6 Example:Private Sub Timer1_Timer()
Form1.Height = Form1.Height - 1
End Sub
VB.NET example:Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick
Me.Height -= 1
End Sub

[edit] Controversy
Many long-time Visual Basic programmers have complained [8] about Visual Basic .NET, because initial versions dropped a large number of language constructs and user interface features [9] that were available in VB6 (which is now no longer sold), and changed the semantics of those that remained; for example, in VB.NET parameters are (by default) passed by value, not by reference. Detractors refer pejoratively to VB.NET as Visual Fred or DOTNOT.[10] On March 8, 2005, a petition [11] was set up in response to Microsoft's refusal to extend its mainstream support [12] for VB6 at the end of that month.
VB.NET's supporters state that the new language is in most respects more powerful than the original, incorporating modern object oriented programming paradigms in a more natural, coherent and complete manner than was possible with earlier versions. Opponents tend not to disagree with this, instead taking the position that although VB6 has flaws in its object model, the cost in terms of redevelopment effort is too high for any benefits that might be gained by converting to VB.NET. Independent developers producing software for Internet distribution have also taken issue with the size of the runtime.[citation needed]
It is simpler to decompile languages that target Microsoft Intermediate Language, including VB.NET, compared to languages that compile to machine code. Tools like .NET Reflector can provide a close approximation to the original code due to the large amount of metadata provided in MSIL.
Microsoft supplies an automated VB6-to-VB.NET converter with Visual Studio .NET, which has improved over time, but it cannot convert all code, and almost all non-trivial programs will need some manual effort to compile. Most will need a significant level of refactoring to work optimally. Visual Basic programs that are mainly algorithmic in nature can be migrated with few difficulties; those that rely heavily on such features as database support, graphics, unmanaged operations or on implementation details are more troublesome.
However in 2005 ArtinSoft, the company that developed the VB6-to-VB.NET converter for Microsoft that comes with Visual Studio .NET, developed a migration tool called the ArtinSoft Visual Basic Upgrade Companion. This tool expands upon the migration wizard included in Visual Studio .NET by providing some automated code refactoring, such as type inference for late-bound variables—producing explicitly typed variables—and conversion to structured error handling, among many other tweaks that improve code quality.
Using artificial intelligence algorithms, it is possible for this new tool to recognize certain code patterns that can be reorganized into more structured versions, yielding a higher quality .NET code. For example, the tool is able to automatically recognize commonly used patterns of “On Error GoTo”, analyze them, and convert them to code blocks that use “Try Catch” instead of the legacy error handling model—in many cases with no human intervention.
In addition, the required runtime libraries for VB6 programs are provided with Windows 98 SE and above, while VB.NET programs require the installation of the significantly larger .NET Framework. The framework is included with Windows Vista, Windows XP Media Center Edition, Windows XP Tablet PC Edition and Windows Server 2003. For other supported operating systems such as Windows 2000 or Windows XP (Home or Professional Editions), it must be separately installed.
Microsoft's response to developer dissatisfaction has focused around making it easier to move new development and shift existing codebases from VB6 to VB.NET. Their latest offering is the VBRun website, which offers code samples and articles for:
completing common tasks in VB6, like creating a print preview
integrating VB6 and VB.NET solutions (dubbed VB Fusion)
converting VB6 code to VB.NET

[edit] Cross-platform and open-source development
The creation of open-source tools for VB.NET development have been slow compared to C#, although the Mono development platform provides an implementation of VB.NET-specific libraries and is working on a compiler, as well as the Windows Forms GUI library.[citation needed]

[edit] Hello World Example
The following is a very simple VB.Net program, a version of the classic "Hello world" example:Public Class ExampleClass

Public Shared Sub Main()
System.Console.WriteLine("Hello, world!")
End Sub
End Class
The effect is to write the text Hello, world! to the output console. Each line serves a specific purpose, as follows:Public Class ExampleClass
This is a class definition. It is public, meaning objects in other projects can freely use this class. All the information between this and the following End Class describes this class.Public Shared Sub Main()
This is the entry point where the program begins execution. It could be called from other code using the syntax ExampleClass.Main(). (The Public Shared portion is a subject for a slightly more advanced discussion.)System.Console.WriteLine("Hello, world!")
This line performs the actual task of writing the output. Console is a system object, representing a command-line console where a program can input and output text. The program calls the Console method WriteLine, which causes the string passed to it to be displayed on the console.

How to Build a Pinhole Camera?

2007-04-05T02:26:00.000-07:00

Author: Monty Lee
This article provides information about building your own pinhole camera. If you wan to find out more about pinhole camera and how to make them, then take a look at this article now.

Do You Want to Build Your Own Pinhole Camera? Read On…As you probably know, these days, there are all kinds of cameras designed for different purposes. From digital and photo cameras to hidden or tiny spy cameras. There’s one more type of cameras that has gained popularity over the long years. It is called – a pinhole camera.What is a Pinhole Camera?A pinhole cam is a simple camera without lens. It’s a small box or can with a tiny (usually 0.5mm or smaller) hole inside one end and a piece of photographic paper in the other. The image is build by light passing through the hole. Although in the early days, pinhole cams did not have very clear image quality, these days there are pinhole cameras come with micro lens and provide very good image quality.The first pinhole camera was built in the 19th century. It gained some popularity and that time. Although cameras have advanced in size and quality, the principles still remain the same.Therefore, nowadays there are many enthusiasts who still prefer to build a pinhole camera themselves. This might be fun for amateurish purposes, however, for more serious tasks such as secret surveillance, an already built pinhole cam is much better choice.How to Build a Pinhole Camera?If you still prefer to build a camera yourself, then here are the basic steps you should look at. First, you’ll need a cardboard with a tape hinge , which can be used as a shutter. Second, you’ll need to make a pinhole. Simply take a needle (small in diameter, about 0.5mm) and punch through a piece of tinfoil. Then tape that piece to the inside of the box through a larger hole.If you’d like to change the angle of the view, you might want to create a moving box. You can simply take a sliding film holder so that the distance between the film and the pinhole can be changed.If you’ll move a film closer to the pinhole, you’ll get a wider angle of view, but shorter exposure time. Moving a film further from the pinhole will result in longer exposure time, but the angle of view will be narrow.More Serious Use of Pinhole CamerasActually, pinhole cameras may be used not only for taking photographs. They may be used for video recording too. However, making such pinhole video camera yourself would be very difficult if you don’t know the technical side involved.However, you may order small pinhole cameras for surveillance at very reasonable prices these days. You may order it online for less that $100 as a matter of fact.Such pinhole cameras can be used to track nannies or your spouse for instance. You never know, what these people are doing in your house. If you trust them, then you (probably) have nothing to worry about. But if you’re suspicious, then there’s nothing better than buying a wireless pinhole camera and putting it inside some fluffy bunny or behind some books on a book shelve.
About Author
Dan Crane specializes in spy camera industry and provides information and guides to consumers about spy cameras and surveillance equipment. If you'd like to learn more about http://www.vedosoft.com/best-price-bullet.html color bullet cameras or http://www.vedosoft.com/pinhole-wireless.html wireless pinhole cameras, then browse Vedosoft website for more information at: www.vedosoft.com

Safe Surfing

2007-04-05T02:24:00.000-07:00

Author: Edward Olsen
Keep your PC protected from online threats

If you’re going to connect to the internet, you need to protect your computer, otherwise it’s like leaving your front door wide open with a big ‘Robbers Welcome’ doormat on your front step. You’ve probably heard all the terms – such as virus, hacker, firewall, spyware and a million more – but perhaps think that the anti-virus programme that came with the computer, or that your PC-savvy mate downloaded for you is enough to keep you safe, right? Wrong … First of all, you need a firewall. This is your first line of defence, making it extremely difficult for any hacker or malicious programme to get through. Nothing is 100% impenetrable, however, and an anti-virus programme that will always be on the lookout for anything nasty that manages to find its way in is essential. But there are things that manage to get onto your pc in the most unlikely of ways: it can be inadvertently added by you as you download music, screensavers or games onto your PC, or it can even be added by someone you know and trust, such as a suspicious spouse or your employer. This is Spyware and is a frightening breach of privacy which allows people or programmes to see what you’re doing, what sites you look at and even log your keystrokes so that they can reproduce everything you type, such as passwords and credit card details. The only way to truly guard against spyware is to have a dedicated programme that detects and removes it. So, you have your firewall and your anti-virus programme in place; surely an anti-spyware programme is just money down the drain? Unfortunately not: this will fill the cracks left by your other security programmes, and although it will not make your computer completely impenetrable (unfortunately the people writing these programmes are extremely good at what they do) it will be the equivalent of locking all your doors and windows and having an alarm system armed before you leave your house – someone could still get in if they really wanted to, but they’d probably rather go next door, where they’ve rather invitingly left a downstairs window open. People are now using their computers for a range of personal and business applications, the loss or infiltration of which could do them serious emotional and financial damage. Taking preventative measures to ensure your online security should be as natural as closing the door behind you when you go out, and there are affordable and easy to use programmes out there to help you do just that. For a full range of products to keep your computer safe, visit http://www.vaultlock.com Otherwise you might as well order that ‘Robbers Welcome’ mat now!

Programming to Enjoy: The Difficulty of Getting It Right

2007-04-04T02:58:00.000-07:00

I had just the right example: binary search. Seems simple enough, doesn't it? The basic algorithm for a binary search requires a sorted array for which random accesses are constant time (otherwise it doesn't make any sense not to perform a linear search). Given that the array is of size k, split the array in half -- test the middle element, originally k/2; if it's the value you're searching for, return the current index. Otherwise, if you have only one element in your subarray, return a sentinel indicating that you can't find the value. If that's not the case, if your search key is less than the middle element, perform the same operation on the elements from the start to k/2 - 1; if the middle element is less than your search key, perform the search on the subarray of k/2 + 1 to k. Every time you do this, you cut the size of the array to search in half -- so it takes O(log(k)) time, and about 10-15 lines of code. How many bugs can you possibly have? Back to the story. I'll call my friend Joe to protect his pride. "Joe, let's make a bet. If you can write a perfect binary search function in the next hour -- and include a working main function for easy testing -- I'll buy you lunch tomorrow. Otherwise, you by me lunch. The only stipulation is that you can't test your code. Of course, you can compile it to make sure there aren't any compiler bugs." Joe: "I won't need to compile it. I'll send you my untested, uncompiled code by 12:30." With that, we shook hands and I left him to work. 42 minutes later, I received his 50 line program, reproduced below (with a few minor modifications).
#include
int bin_search(int* array, int size, int value)
{
return bin_search(array, 0, size-1, value);
}
int bin_search(int* array, int start, int end, int value)
{
if (start==end)
{
if (array[start]==value) return start;
else return -1;
}
else if (start==end-1)
{
if (array[start]==value) return start;
else if (array[end]==value) return end;
else return -1;
}
// We know there is at least 1 element between start and end
int midInd=(start+end)/2;
int midVal=array[midInd];
if (midVal==value) return midInd;
else if (midVal>value) return bin_search(array,start,midVal-1,value);
else return bin_search(array,midVal+1,end,value);
}
using namespace std;
int main()
{
int size;
cin>>size;
int* array=new int[size];
for (int i=0; i{
cin>>array[i];
}
int value, result;
cin>>value;
result=bin_search(array,size,value);
if (result==-1) cout<<"Sorry, not found\n";
else cout<<"This is element #"<}
Before reading the rest of this article, look through the code and figure out whether or not it works; if it doesn't work, see how many bugs you can find. Next: Who Won the Bet, and Why
Related articles Learn more about search techniques Learn more about the various sorting algorithms

Debugging in Visual Studio: Avoid Stepping Into Common Functions

2007-04-02T19:29:00.000-07:00

If you do a lot of debugging (and who doesn't?), you've probably encountered many function calls that you'd really like to step into. Sometimes this is easy: you just hit F11 and waltz right in to the function you care about. Sometimes, however, this is not so easy. In particular, if the code makes function calls to produce arguments for the function: call_of_interest( new blah( "a", 1 ), my_vector.begin(), my_vector.end() );
Suddenly, stepping into the function is a huge hassle; first, you're going to need to step through all of the function calls that produce its arguments। How inconvenient; especially when you are absolutely certain that you don't need to--after all, how likely is it that calling my_vector.begin() or your specialized operator new have anything to do with how the function of interest works? Probably not a lot--and if they do, you'll almost certainly be able to tell that they're causing problems by looking at the arguments passed in the function once you've stepped into it.

Sure, you could just set a break point inside the function you're interested in and then hit F5 to continue. But doing that is tedious, especially if you're only interested in one invocation of that function or if you want to step into a lot of functions. In those cases, it's much nicer to simply avoid many of the common functions, such as library functions, that are often invoked to produce inputs for functions. Various versions of Visual C++ allow you different amounts of control over how you can skip stepping into certain functions, and none of the implementations of this feature are documented or offically supported by Microsoft. Please note that I cannot guarantee that this functionality will work for you any more than Microsoft will provide that guarantee. Some of the examples require editing the registry; make sure to keep a backup before proceeding!
Visual Studio 6In Visual Studio 6.0, you can edit the file autoexp.dat (which has several other useful features in different versions of Visual Studio), located in "%ProgramFiles%\Microsoft Visual Studio\Common\MSDev98\Bin". In autoexp.dat, different directives appear under different sections named with "[secname]". To avoid stepping into certain functions, simply add a section, [ExecutionControl], and place under it directives that match either a function name ("myMethod"), a class followed by a method name ("class::method"), or a class followed by a * to skip stepping into all methods of that class ("class::*"). You may need to qualify your classes with their namespaces. Here is an example demonstrating how to avoid stepping into operators; add to autoexp.dat and restart Visual Studio to reload the file: [ExecutionControl]
operator new=NoStepInto
or MyClass::operator==NoStepInto
Visual Studio 7The debuggers for Visual Studio 7.0 and later read their NoStepInto configuration information from within the registry. You should backup your registry before playing with it. To edit your registry, you'll need to use regedit (just click on Start, go to the run menu, and type in "regedit" and hit enter). The registry key you'll want to change is HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\7.0\NativeDE\StepOver
or HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\7.1\NativeDE\StepOver
if you're using Visual Studio 2003. You may need to create the keys Native DE its child StepOver. You can do so in RegEdit by navigating to the "VisualStudio\7.0" key and right-clicking and selecting "New->Key". Inside the StepOver key, you can create new string values that contain regular expressions to match against function names; you can also include a number for the priority of each expression. Using priority, you can set multiple expressions so that you step into a specific function for a class, but skip stepping into all others. For instance, you might have a string with the name and value 10 string\:\:append.*=StepInto
20 string\:\:.*=NoStepInto
In regular expression parlance, ".*" simply means "match any number of characters". For instance, the second expression matches any function in the string class. (Note that 10 is the name, and everything following it is the value to enter for that name.) Notice that you need to escape the colons because they have special meaning in Visual Studio regular expressions. Similarly, if you wish to match against templates, you need to escape the open and close brackets: 10 .*\<.*\>=StepInto
Which should always step into any template function.
Visual Studio 8Visual Studio 8 has the same basic functionality as Visual Studio 7 with a few improvements. In addition, you should be aware that the key you must modify is now: HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\8.0\NativeDE\StepOver
You'll need an account with Admin privileges to set this up. In addition to the ability to match regular expressions provided in Visual Studio 7, a few new escape sequences have been added to the regular expressions you can use, including "\funct" to match the name of a function, "\scope" to match a scope (e.g., std::my_namespace::etc::so::forth), and "\oper", which matches any operator. Note that when you use these escape sequences, you must indicate the end of the escape sequence with a colon. So you might write "\scope:" followed by the rest of the expression to match. For instance, you could avoid stepping into any overloaded operators by using the expression \scope:operator\oper:=NoStepInto
which might be useful if you are using a lot of classes with simple operators whose behaviors you can trust to be correct.

Application Development

2007-04-01T21:41:00.001-07:00

Our application development services cover the concept-to-market needs of the product and include product conceptualization, design, development, testing, and support. Our offshore product development center can serve as an offshore extension of your product engineering setup in a seamless and low-risk manner.
This division works on the concept of Lab-on-Hire (LoH), where a team of engineers is dedicated to your project depending on its requirements. This team works with you through the Product Life Cycle to make application enhancements, do testing, and issue releases for each version of the product.
Benefits for this kind of a setup include:
Reduced time to market
Global engineering workforce to ensure 24x7 product development cycle
Full implementation of digital technologies in the product development phase
Increased profitability by reduced product development cost As part of the Product Development and Support we provide the following services to our clients:
Product Design and Conceptualization
Development
Testing
Release
Support Services
During each of these phases your lab at Website Toolbox will act like a virtual extension of your onsite development team. Both of the teams will work in close coordination for each version release.
Application development services can be provided for virtually any programming language on any operating system.

Solving Cool Problems with Genetic Algorithms

2007-04-01T01:30:00.000-07:00

Genetic algorithms are useful for solving problems having solutions representable as strings (hence the name Genetic Algorithm - the programming model is based on DNA). In terms of practical value, genetic algorithms are useful for solving problems in which the solutions are difficult to find by following a specific algorithm designed to solve the problem (using genetic algorithms in place of predesigned algorithms such as Djikstra's algorithm for path finding just wouldn't make sense). It functions as a sort of systematized brute force approach. Problems genetic algorithms are valuable for solving include scheduling problems, constraint satisfaction problems, and other problems that require searching a large number of possibilities. Genetic algorithms can be applied to protein folding or even tuning Linux kernel performance।
A simpler example just to get the point across is finding a five digit number that acts as the best solution to an expression; for example, if you wish to find the number that makes the expression x^2+2x-11 equal to 0, you could of course use brute force to solve the equation, but a genetic algorithm can also be used, and if you have a very complex expression, it may be of great value to use a genetic algorithm, especially when one considers the time saved over brute force. In a sense, all genetic algorithm problems boil down to solving complex expressions or sets of expressions, as all problems are representable in that fashion. Genetic algorithms work from the same basis as evolutionary theory. A genetic algorithm has several components: a pool of solutions, a method of evaluating the effectiveness of each solution, a breeding function that combines the best solutions into new solutions, and a mutation function. The pool of solutions do not compete for resources; rather, each solution is tested by an evaluation function (called the "fitness" function), which then gives it a ranking based on its effectiveness at solving the problem compared to the other solutions. The best solution strings are the ones that are ranked highest (that are the most "fit"); the breeding function takes two of the better performing solutions and combines them together into a new solution. The breeding function should repeat the process of randomly selecting two solutions and breeding them; the better performing functions should be given the higher percentage chance of being selected. The breeding function generally works by taking slices of each solution and splicing them together into a new one. Solutions are often represented as strings, so generally, a breeding function will take fragments of random lengths from each string and concatenate them together to form a new string. Each fragment should be placed into the location in the new string that corresponds to its location in the old string. For example, if a string fragment is from positions 5 to 8 in the first string being bred, it should be placed into positions 5 through 8 in the new child solution. After the strings have been bred, and the set of potential solutions has been refilled, it is important to have the mutation function. The mutation function is important because it introduces an element of randomness that allows variation in the solution sets, which otherwise would stagnate and have no advantage over a hand-crafted solution. Mutations may diminish the strength of some solutions, but in general it will increase the overall value of the solution set; by including a very small mutation rate, you introduce new traits that might never have otherwise existed within the pool. This allows you to explore a larger group of possibilities and avoid stagnation. In fact, many other AI techniques forgo the idea of breeding solutions and work simply by making small "mutations" or changes to a potential solution to a problem. Genetic algorithms can do some amazing things and solve very complex problems. Nevertheless, this techniques will require having way of evaluating possible solutions -- this is one of the most difficult problems with genetic algorithms. The second challenge is finding a good way to represent solutions to the problem as strings. Once these are sorted out, a genetic algorithm may be a good approach to your problem.

Debugging Strategies, Tips, and Gotchas

2007-04-01T01:07:00.000-07:00

Use the Right ToolsIt should go without saying that you should always be using the best tools available; if you're hunting a segmentation fault, you want use a debugger. Anything less than that is unnecessary pain. If you're dealing with bizarre memory issues (or hard-to-diagnose segfaults), use Valgrind on Linux or Purify for Windows.
Debug the ProblemMy first instinct when debugging is to ask, "is my code too complicated?" Sometimes we'll all come up with a solution to a problem only to realize that the solution is really hard to get working. So hard, in fact, that it might be easier to solve the original problem in another way. When I see someone struggling to debug a complex mass of code, my first thought is to ask whether there's a cleaner solution. Often, once you've written bad code, you have a much better idea of what the good code should look like. Remember that just because you've written it doesn't mean you should keep it! The trick is always to decide if you're trying to solve the original problem or to solve a particular choice of solution. If it's the solution, then it's possible that your problems don't stem from the problem at all--maybe you're over-thinking the problem or trying a wrong-headed approach. For instance, I recently needed to parse a file and import some of the data into an access database to prototype an analysis tool. My first instinct was to write a Ruby script that interfaced directly with Access and inserted all of the data into the database using SQL queries. As I looked at the support for doing this in Ruby, I quickly realized that my "solution" to the problem was going to take a lot longer than the problem should have taken. I reversed course, wrote a script that just output a comma-separated value file, and had my data fully imported in about an hour.
An Aside on Bad CodePeople are often reluctant to throw out bad code that they've written and re-write it. One reason is that code that's written feels like completed work, and throwing it out feels like going backward. But when you're debugging, rewriting the code can seem more appealing because you're probably saving yourself time spent debugging by spending a bit more time coding. The trick is to avoid throwing out the baby with the bath water--remove the bad code, don't start the whole program over again (unless it's rotten to the core). Rewrite only the parts that really need it. Your second draft will probably be both cleaner and less buggy than the first, and you may avoid issues like having to go back later and rewrite the code just so that you can figure out how it was supposed to work. On the other hand, when you're absolutely sure that code that looks horrible is the right code to use, you'll want to explain your rationale in a comment so someone (or you) doesn't come back later and hack it apart.
Minimize Potential Problems by Avoiding Copy-Paste SyndromeNothing is more frustrating than to realize that you're debugging the same problem multiple times. Whenever you copy and paste large chunks of code, you leave yourself open to the unknown demons inhabiting that code. If you haven't debugged it yet, odds are that you're going to have to. And if you forgot that you copied that code somewhere else, you're probably going to be debugging the same code more than once. (There are other reasons to avoid copy-paste syndrome; even worse than debugging the same code twice is finding the bug in only one piece of copy-pasted code.) The best way to avoid copy-paste syndrome is to use functions to encapsulate as much of your repeat code as possible. Some things can't easily be avoided in C++; you're going to write a lot of for loops no matter what you're doing, so you can't abstract away the whole looping process. But if you have the same loop body in multiple places, that might be a sign that it should be pulled into a separate function. As a bonus, this makes other future changes to your code easier and allows you to reuse the function without having to find a chunk of code to copy.
When to Copy CodeAlthough copying code is usually dangerous, there are times when it may be the best choice. For instance, if you need to make small, irregular tweaks to a chunk of code, but the bulk of it needs to remain the same, then copying, pasting, and careful editing might make sense. By copying the code, you avoid the chance that you introduce new bugs by mistyping the code. It should go without saying that you should have carefully debugged the code you plan to copy before you do so! (But I said it, and I'm not even paid by the word.) The second reason to copy code is when you have long variable names and a bad text editor. The best solution is generally to get a better text editor with keyword completion.
Make Big Problems Found Late Small Problems Found Early
Testing EarlyOne advantage of pulling out code and putting it into functions is that you can then separately test those functions. This means that you can sometimes avoid debugging big problems caused by simple bugs in the original functions. Nothing is more frustrating than writing perfectly correct code given how you thought a function (or a class) worked, only to find out that it doesn't work that way. This kind of unit testing requires some discipline and a good sense of what can go wrong with your code. Another advantage of early testing--especially if you write some or all of your tests up-front, before the code--is that you'll pay more attention to the specific interface to your class. If you can't test error handling because you're using an assert instead of an exception or error code, that might be an indication that you should be using some form of error reporting rather than asserts. (Of course, this won't always be the case--there are times when you just want to verify that your asserts work correctly.) Beyond error-reporting, writing tests is the first time you can test your code's interface, which is often as valuable as testing that the code works. If the interface to your class is clunky, or your functions have impossible-to-understand, let alone remember, argument lists, it might be time to rethink what you're doing before you write the underlying code.
Compiler WarningsMany potential bugs can be caught by your compiler. Some such errors include using uninitialized variables, accidentally replacing a check for equality with an assignment in a conditional, or, in C++, errors related to mixing types such as pointers and ints. Since this has been covered before, I suggest checking out the article why you should pay attention to compiler warnings.
Printf LiesBecause I/O is usually buffered by the operating system, using printfs in your debugging process is risky. When possible, use a debugger to figure out what lines of code are the problem rather than narrowing in on the issue with code littered by printfs and cout. (And beware the stray printf that slips in during debugging and, ahem, slips into the final version.)
Flush OutputNevertheless, there are times when you actually need to keep track of some state in a log file--perhaps you simply have too much data that you need to collect, and you need the data from program start-up to the moment the bug occurs. To ensure you collect all of the data, be sure to flush it: you can use fflush in C, or output an endl in C++. fflush takes the FILE pointer you are writing into; for instance, to flush stderr, you would write fflush( stderr);
Check Your Helper FunctionsThis should be obvious, but it's easy to forget in the heat of the moment: always verify that your helper functions work, especially when seemingly simple code is failing. When possible, isolate each helper function and test it individually, then test each of its helper functions. There's nothing more frustrating than realizing that your original logic was right, but your assumption about a helper function was wrong.
When Cause Doesn't Immediately Lead to EffectEven if a helper function doesn't seem to be the immediate source of a problem, its side effects may cause latent problems. For instance, if you have a helper function that can return NULL and you pass its output into a library function dealing with C-strings, you may see the immediate cause as dereferencing a NULL pointer in strcat, but the real cause was the buggy function you wrote earlier (or the fact that you didn't check for NULL after calling it).
Remember That Code May Be Used in More Than One PlaceAnother problem that can come up when debugging is that you discover the problem appears to be the result of a particular function call, set a break point inside that function, and then discover that there are hundreds of calls to the same function throughout the code. Or worse, you don't notice this until wasting hours of time trying to figure out what's going on or thinking that the reason for the problem is that the function is being called incorrectly. (When, in fact, it's being called correctly but with different arguments than the point at which the bug occurred.) The most obvious solution is to check the call stack after hitting a break point or to set the breakpoint right before the call that is actually the problem. Unfortunately, this doesn't always help if the same call works thousands of times but fails on the 1001st call. Potential solutions include counting the number of calls to a function and then stepping through that many breakpoints set inside the function, or using a static variable as a counter.

Answers.com Releases Free AnswerTips Tool for Websites and Blogs

2007-03-30T10:39:00.000-07:00

HTMLPrimer.comThursday, February 22, 2007; 07:32 AM
Answers Corporation, creator of Answers.com, began offering its latest webmaster tool, AnswerTips, to websites and blogs. AnswerTips allow sites to provide visitors with instant access to Answers.com's comprehensive information on four million topics, without having them leave the site or blog.
AnswerTips are a unique site feature and provide instant background information when a site's visitor double-clicks a word on an "AnswerTips-enabled" site. Activate an AnswerTip, and without leaving the page, a small information bubble opens, providing definitions, explanations, biographies, historical background and countless other types of relevant information. Unlike other offerings, the AnswerTip provides content on the spot, rather than a number of related search links to follow.
The free content in an AnswerTip comes from Answers.com's extensive database of information consisting of four million topics that are licensed from over 120 authoritative reference publications and other resources.
"It's about immediate gratification for anyone reading your blog," said Gil Reich, Vice President of Product Management for Answers Corporation. "Readers get the information they want while remaining engaged in reading your content. Fewer distractions create a better experience on a website, and they save the writer time providing background information on subjects and terminology that his or her audience might be unfamiliar with."
The technology behind AnswerTips yields a more productive user experience than a simple dictionary site or program. The tool has the ability to crack acronyms, quote stock prices and retrieve biographical information on everyone from rock musicians to political figures. Using patented technology, AnswerTips scans the text surrounding a word to retrieve the most appropriate information. For instance, it can differentiate between 'Paris Hilton' and 'plaster of Paris' when only the word "Paris" is double-clicked.
Currently, AnswerTips technology has been implemented on Answers.com, WikiAnswers (wiki.answers.com) and CBSNews.com, and was beta tested on a few select blogs and websites, including:
A VC (http://avc.blogs.com/a_vc/2007/02/this_blog_is_an.html) CleverClogs (http://www.cleverclogs.org/2006/12/instant_onsite_.html)
California Polytechnic State University Library ( http://www.library.calpoly.edu)
Write Technology (http://www.writetech.net/2007/02/answer_tips.html)
In addition to being available directly from Answers.com at: (http://www.answers.com/main/answertip_landing.jsp)
AnswerTips are also available within the widget gallery of TypePad at: http://www.sixapart.com/typepad/widgets/publishing-tools/answertips.html.
Other free tools from Answers.com include 1-Click AnswersTM (Windows, Mac OS X), which enables AnswerTips within all of your desktop applications, and the Firefox extension (Windows, Mac OS X and Linux). For more about Answers.com webmaster tools, visit http://www.answers.com/main/webmasters.jsp.
About Answers Corporation
Answers Corporation (NASDAQ: ANSW) operates the award-winning Answers.com(TM) information portal, delivering comprehensive content on four million topics spanning health, finance, entertainment, business and more. Content includes over 120 licensed titles from leading publishers such as Houghton Mifflin Riverdeep Group PLC, Barron's, Encyclopedia Britannica, All Media Guide and others; original articles written by Answers.com's editorial team; community-contributed articles from Wikipedia; and user-generated questions & answers from Answers.com's industry-leading WikiAnswersTM (wiki.answers.com). Founded in 1999 by CEO Bob Rosenschein, Answers.com can be launched directly from within Internet Explorer 7, Firefox and Opera browsers, and its service is integrated into sites like Amazon.com's A9.com, The New York Public Libraries' homeworkNYC.org, The New York Times, CBSNews.com and others. Answers.com is also available for mobile devices at mobile.answers.com. For investment information, visit ir.answers.com.

Big Business Web Design Disasters

2007-03-29T06:03:00.001-07:00

When you think of the world's most successful businesses, what names come to mind? Most likely, consumer-oriented giants such as Coca-Cola, McDonald's, Sheraton, Disney, IBM, and General Electric. Not only have they spent billions on advertising to buy their way into your head. They offer convenient products and services that have made them a part of your life.But when you think of the most successful web sites, what names come to mind? Names like Google, Yahoo! Amazon, AOL, Kazaa (for better or worse), and Hotmail.The late-1990s mantra about the web being a disruptive technology that would destroy traditional companies may have been overstated. But a decade and a half into the web's existence, it is clear that the world's leading corporations have been sidelined on the web.The biggest shopping site is not walmart.com but amazon.com. The biggest map site is not randmcnally.com but mapquest.com.Established companies have usually only been able to buy their way into this market through acquisitions (as with Microsoft's purchase of Hotmail, which it used as a base for creating MSN).Why, with few exceptions, were the world's most successful web sites not launched by the world's most successful corporations?Many Big Name Companies' Web Sites a Vast Waste of Time for VisitorsThe McDonald's web site talks about food, but has no real menu. The Coca-Cola USA web site has no clear ingredients list or nutritional information, no recipes for floats or mixed drinks, no company history, and nothing else useful to people who like Coke. All that information has been inexplicably located on the "company" page, which on every other web site is used for investor relations. The Johnson and Johnson web site has useful information if you can access it—when the author attempted to open it, it crashed two different web browsers (Internet Explorer and Mozilla) before finally yielding (to the Opera browser).Many big-name companies' web sites offer lessons in what not to do in web design. The biggest lesson by far is not to sacrifice usability in an attempt to look cool, and never forget why your users came to your site in the first place. McDonald's may be the world's largest restaurant chain, but it didn't get that way because of its web site.Why Big-Budget Websites Are More Often Bombs than BlockbustersThe web sites of many successful corporations (both B2C and B2B) are like big-budget Hollywood movies that spend millions on stars and special effects, and a quarter of a percent of the budget on the script. Worse, the special effects of blockbuster web sites are far more annoying than impressive.Special Effect that Bombs Number 1: Flash!When web sites don't offer any content—any useful information to read—what do they put up there instead? Spinning Coke bottles. Chicken McNuggets and French fries that zoom out toward you when you position your cursor over them. Changing pictures of generic-looking office buildings and men in suits (on the web site of real estate giant CB Richard Ellis—but that essentially describes the generic look of many corporate web sites).Of course, Flash can be used as a way to present content—words, both printed and recorded, and pictures that actually illustrate something. But more often, it is used to impress. And most often, it ends up annoying. Who wants to spend the better part of a minute waiting for a rotation of generic pictures of smiling models?Special Effect that Bombs Number 2: Splash ScreensYou type in duracell.com expecting information on batteries—which you will find, if you have the patience not to hit the “back” button while the site shows a picture of a battery revolving painfully slowly.On http://www.mcdonalds.com you're met with pictures of happy children playing with Ronald McDonald and a menu to select what country you're from.Johnson's and Johnson's web site shows a logo before automatically redirecting you to the main page—that is if it doesn't crash your browser first (which happened when the author tried to access the page on May 2, 2004 ).Another way big consumer corporations' web sites from Schick to Mercedes-Benz to Thomas Cooke waste your time with splash pages is by making you choose what country you're visiting from. This could have been detected automatically, or at least, useful worldwide content could have been placed on the homepage, with an option to choose a country prominently displayed.Splash pages are the internet equivalent of making patrons wait in line out front before letting them inside. Unless a site belongs to a night club or a professional services firm with too much business, keeping people outside can't be a good idea.Special Effect that Bombs Number 3: Overbuilt or Badly Built “Dynamic” FunctionalityEvery web surfer has a story about a shopping cart that malfunctioned just when they were about to click “purchase” on something they really wanted. Or a detailed form that lost all the information after the “submit” button was pressed.Sometimes, malfunctioning dynamic content can distort the way an entire site presents itself. If the dynamic content is so complex that it presents problems for many users, it is unlikely the dynamic content is worth it. When I visited disney.com in May 2004, my first greeting was a message that your computer is sufficiently up-to-date (or not) to handle the site.In short, you may want your small or medium-sized business to get as big as Coca Cola or Disney, but you'll never get there if your website looks like theirs do.

The Power OF HTML Email Advertising And When To Use Text Email

2007-03-29T06:01:00.000-07:00

The issue of HTML email versus text email usually raises heated debate amongst those involved in email advertising. For some people, feelings about HTML-formatted email have changed over time. However there are a number of issues that one should take into consideration before making a decision either for or against sending HTML email in their advertising campaign.
It may show to be successful way of advertising, but then on the other hand it could be a pain to the ones on the receiving end. To start with, not everybody has the ability to receive HTML Email, which is a very important factor for anybody involved in email advertising to take note of. It is estimated that over 30 per cent of email users are not able to receive HTML Email. HTML may show up unreadable or in non-standard fonts, clashing colours, badly formatted images and sometimes there is no quick or easy way to adjust appearance to be read.
However it is also a fact that this figure is reducing by the day. Still there is no denying the fact that HTML email will always get twice the response rate that text email would usually get, according to Email Marketing research. It is easy to see why this is so. With HTML email, full color graphics and even moving images and graphics can easily be created. These are usually much more attractive and can be powerful in drawing attention to a message.
Also, according to research, it’s mentioned that text just can't do some of the things that HTML email marketing can, such as the ability to embed links into the email form itself. Yet despite this powerful statistic in support of HTML email, it is also true to say that most times, email users expect most of the HTML email messages they have received to be spam. Many notorious spammers have actually perfected the art of creating flashy HTML graphics to sell whatever it is they are trying to sell in their intrusive and illegal way. There are plenty of other reasons to favor plain text over HTML, such as band width waste and security exploits, but what it really comes down to is that like all other forms of information junk, there is more effort put into the font styling, rather than the actual email content.
Choosing the right Marketing Company is often one of the biggest reasons a campaign fails or succeeds. It is also significant to note that there are some very successful marketers who use nothing else but text email in all their campaigns. They place all their focus on powerful words and directing people to their web sites and blog sites, where color and full HTML can be fully utilized to elaborate further on their advertising messages. The obvious advantage they enjoy is the fact that they do not need to worry about some recipients having turned off all HTML in incoming email messages, which many people often do to deal with the rising volumes of spam.

Complete Website Solutions: Tips For Choosing A Web Solutions Provider

2007-03-28T19:05:00.000-07:00

by Cogniter Technologies

Your website is intrinsic to your business, whether you're running an online store looking to attract local customers through the web or any business in between. Your web solutions provider should be a good partner and a strong source of support for your online needs. Check out these tips for businessman who are either looking for their first provider or are looking to switch to a provider that better suits their business. Who you choose will have a big impact on your and your customer's web experience.1. You shouldn't have to be a technology virtuoso to get your business's website up and running. Look for a web solutions provider that offers a variety of template option to help get your site online. Templates should be easy to use and customizable. A wizard interface that walks you through the template is a great way for users who are new to building websites to get comfortable and get a professional-looking website up quickly. A provider that has experience with small businesses will understand your needs and be able to guide you through the process. 2. It's not just about having a place to park your website. Look beyond the basics to see what extras a provider offers. Your website solution provider must provide you basic web services like application development, web marketing, design great business logos & business portals or we can say B2B sites. Search Engine Optimization is another helpful feature to look for. Finally, look for a web solutions provider that can give you statistics tools. Those can help you monitor your website's performance and find out information like where your visitors are coming from and at what times your site is busiest. 3. Your business is growing, and your web solutions provider needs to be able to grow with you. Your website might start out as a basic informational site, but you could decide you want to sell your products online or want to offer more advanced services to your customers. Check out what packages and services a provider offers. You should be able to move up to more sophisticated packages as your business needs increase. Look for e-commerce services and more advanced e-mail services that can handle your customer and employee growth as needed. 4. Make sure you find a web solutions provider that knows how important reliability is when it comes to dealing with your customers. Uptime, the amount of time your website is up and running and viewable online, is a great measure of reliability. Don't settle for anything less than 99.9 percent uptime. Also, ask what your potential provider does to protect your website data. Regular data backups are an absolute necessity. 5. In an online world of bits and bytes, its still people who make things happen. Customer service should be a top priority for a web solutions provider. Whether you're just looking for more information on product offerings or have a question about your site, find a provider that has actual people there to help. Cogniter Technologies goes beyond e-mail support to offer free 24/7 phone support that connects its customers to a real, live and understanding customer service consultant. Having over 4 years of experience in providing internet services and solutions and having completed hundreds of projects in different domains Cogniter Technologies has built a large database of knowledge that enables us to deliver the “right” solutions that address the needs of clients. Businessman can't afford to wait hours on hold or days for an e-mail response. When it comes to your business, you need to be able to handle your web solutions on your own schedule.You are just one step beyond to see your online business growth, go to www.cogniter.com & see your business in growing shape. Sponsored by Cogniter Technologies Inc, Chandigarh, India

Advantages of using tableless CSS | XHTML Web Design Techniques

2007-03-28T18:57:00.000-07:00

by Tim Warren

Tables used to be the “in” thing when it came to designing web sites. As with many other things though, new techniques and methods standards are bound to emerge with time. When once tables were seen in most web pages, some experts now suggest that tables should be thrown out of the window.
In simple words, tableless web design is basically a method whereby page layout control is achieved without the use of HTML tables. Instead, text and other elements on a page are arranged using CSS (Cascading Style Sheets). This language is the brainchild of the W3C (World Wide Web Consortium). It was designed in such a way as to improve web accessibility as well as to make use of HTML for semantic purposes rather than presentational purposes.
One thing that has been making the headlines in the past year or so is the term SEO (Search Engine Optimization) techniques. With search engines such as Google and Yahoo making big waves in the information sector, web designers are scrambling to get on their good side. The one main goal of a web designer is to get his site on the top pages for search results. How is this achieved? By making one’s site search engine friendly.
Search engines make use of various techniques to index all existing web sites. Based on these various techniques, they assign a page rank to the web site. The higher the page rank, the more chances it will be high up in the search engine results. The higher up the site is in ranking, the more chances that people will visit the site. That means good news for the web site. That is where semantics and HTML come in.
So how about tables? Web designers who favor tables assert that they make the design process easier and less time consuming. More so, they assert that tables are more compatible with various web browsers. On the other hand, proponents of tableless formats assert that tables do not adhere to web standards and web accessibility.
Over the years, people have been trying to come up with web standards that are based on logic and that would make it easier for everyone involved to access web sites. Text readers, bots, mobile devices, and other elements were all taken into consideration. As such, the tableless format has come into popular use.
Why should you follow this standard? Here are a few reasons as to why you should go tableless:
• The current W3C standards dictate the use of tableless design. • Practically all browsers in use today support CSS for controlling layouts. As such, your site will be compatible with most any browser. • It is easier to make global changes to the layout with the use of CSS. That is, if the coding is properly done, of course. • Web site accessibility for people with special needs is done more easily with the proper implementation of content into XHTML documents. In this case, CSS is used only for the layout and style. • Unnecessary code is eliminated with the use of XHTML and CSS, making for a sleeker and more manageable code. • Tableless formats make it easier for search engines to index a web site.
Though tableless formats are being widely used for page layout control, it does not necessarily mean that tables are not being used anymore. They are merely not optimal for presentation purposes.

Security Enhancements and Fixes in PHP 5.2.1 and PHP 4.4.5:

2007-03-28T00:39:00.000-07:00

Fixed possible safe_mode & open_basedir bypasses inside the session extension.
Fixed unserialize() abuse on 64 bit systems with certain input strings.
Fixed possible overflows and stack corruptions in the session extension.
Fixed an underflow inside the internal sapi_header_op() function.
Fixed non-validated resource destruction inside the shmop extension.
Fixed a possible overflow in the str_replace() function.
Fixed possible clobbering of super-globals in several code paths.
Fixed a possible information disclosure inside the wddx extension.
Fixed a possible string format vulnerability in *print() functions on 64 bit systems.
Fixed a possible buffer overflow inside ibase_{delete,add,modify}_user() functions.
Fixed a string format vulnerability inside the odbc_result_all() function.
Security Enhancements and Fixes in PHP 5.2.1 only:
Prevent search engines from indexing the phpinfo() page.
Fixed a number of input processing bugs inside the filter extension.
Fixed allocation bugs caused by attempts to allocate negative values in some code paths.
Fixed possible stack/buffer overflows inside zip, imap & sqlite extensions.
Fixed several possible buffer overflows inside the stream filters.
Memory limit is now enabled by default.
Added internal heap protection.
Extended filter extension support for $_SERVER in CGI and apache2 SAPIs.
Security Enhancements and Fixes in PHP 4.4.5 only:
Fixed possible overflows inside zip & imap extensions.
Fixed a possible buffer overflow inside mail() function on Windows.
Unbundled the ovrimos extension.
The majority of the security vulnerabilities discovered and resolved can in most cases be only abused by local users and cannot be triggered remotely. However, some of the above issues can be triggered remotely in certain situations, or exploited by malicious local users on shared hosting setups utilizing PHP as an Apache module. Therefore, we strongly advise all users of PHP, regardless of the version to upgrade to the 5.2.1 or 4.4.5 releases as soon as possible.
For users upgrading to PHP 5.2 from PHP 5.0 and PHP 5.1, an upgrade guide is available here, detailing the changes between those releases and PHP 5.2.1.
Update: Feb 14th; Added release information for PHP 4.4.5.
Update: Feb 12th; The Windows install package had problems with upgrading from previous PHP versions. That has now been fixed and new file posted in the download section.

Open Source Organizations and Affiliations

2007-03-27T10:38:00.000-07:00

Google is proud to take part in the following technical and advocacy organizations:
The Eclipse Foundation
Eclipse is an open source community whose projects are focused on providing a vendor-neutral open development platform and application frameworks for building software. The Eclipse Foundation is a not-for-profit corporation formed to advance the creation, evolution, promotion, and support of the Eclipse Platform and to cultivate both an open source community and an ecosystem of complementary products, capabilities, and services.
The Free Software Foundation
The Free Software Foundation (FSF), established in 1985, is dedicated to promoting computer users' rights to use, study, copy, modify, and redistribute computer programs. The FSF promotes the development and use of Free Software, particularly the GNU operating system, used widely in its GNU/Linux variant. The FSF also helps to spread awareness of the ethical and political issues surrounding freedom in the use of software.
The Java Community Process
Since its introduction in 1998 as the open, participative process to develop and revise the Java technology specifications, reference implementations, and test suites, the Java Community Process (JCP) program has fostered the evolution of the Java platform in cooperation with the international Java developer community.
The Mozilla Foundation
Established in July, 2003, with start-up funds from the Netscape division of AOL, the Mozilla Foundation exists to provide organizational, legal, and financial support for the Mozilla open-source software project. The Foundation has been incorporated as a California not-for-profit corporation to ensure that the Mozilla project continues to exist beyond the participation of individual volunteers, to enable contributions of intellectual property and funds and to provide a vehicle for limiting legal exposure while participating in open-source software projects.
OASIS
OASIS (Organization for the Advancement of Structured Information Standards) is a not-for-profit, international consortium that drives the development, convergence, and adoption of e-business standards. The consortium produces more Web services standards than any other organization, along with standards for security, e-business, and standardization efforts in the public sector and for application-specific markets.
ODF Alliance
The ODF alliance works globally to educate policymakers, IT administrators, and the public on the benefits and opportunities of the OpenDocument Format, to help ensure that government information, records, and documents are fully and natively accessible across platforms and applications, even as technologies change.
OSDL
OSDL - home to Linus Torvalds, the creator of Linux - is dedicated to accelerating the growth and adoption of Linux in the enterprise. Founded in 2000 and supported by a global consortium of IT industry leaders, OSDL is a non-profit organization that provides state-of the-art computing and test facilities in the United States and Japan available to developers around the world. OSDL's founding members were IBM, HP, CA, Intel, and NEC.
Python Software Foundation
The Python Software Foundation (PSF) is a non-profit membership organization devoted to advancing open source technology related to the Python programming language. It qualifies under the US Internal Revenue Code as a tax-exempt 501(c)(3) scientific and educational public charity, and conducts its business according to the rules for such organizations.

3. Criterios de Selección

2007-03-26T19:51:00.000-07:00

En el capítulo anterior se vio la forma de recuperar los registros de las tablas, las formas empleadas devolvían todos los registros de la mencionada tabla. A lo largo de este capítulo se estudiarán las posibilidades de filtrar los registros con el fin de recuperar solamente aquellos que cumplan una condiciones preestablecidas.
Antes de comenzar el desarrollo de este capítulo hay que recalcar tres detalles de vital importancia. El primero de ellos es que cada vez que se desee establecer una condición referida a un campo de texto la condición de búsqueda debe ir encerrada entre comillas simples; la segunda es que no se posible establecer condiciones de búsqueda en los campos memo y; la tercera y última hace referencia a las fechas. Las fechas se deben escribir siempre en formato mm-dd-aa en donde mm representa el mes, dd el día y aa el año, hay que prestar atención a los separadores -no sirve la separación habitual de la barra (/), hay que utilizar el guión (-) y además la fecha debe ir encerrada entre almohadillas (#). Por ejemplo si deseamos referirnos al día 3 de Septiembre de 1995 deberemos hacerlo de la siguente forma; #09-03-95# ó #9-3-95#.
3.1 Operadores Lógicos
Los operadores lógicos soportados por SQL son: AND, OR, XOR, Eqv, Imp, Is y Not. A excepción de los dos últimos todos poseen la siguiente sintaxis:
operador
En donde expresión1 y expresión2 son las condiciones a evaluar, el resultado de la operación varía en función del operador lógico. La tabla adjunta muestra los diferentes posibles resultados:

Operador

Resultado
Verdad
AND
Falso
Falso
Verdad
AND
Verdad
Verdad
Falso
AND
Verdad
Falso
Falso
AND
Falso
Falso
Verdad
OR
Falso
Verdad
Verdad
OR
Verdad
Verdad
Falso
OR
Verdad
Verdad
Falso
OR
Falso
Falso
Verdad
XOR
Verdad
Falso
Verdad
XOR
Falso
Verdad
Falso
XOR
Verdad
Verdad
Falso
XOR
Falso
Falso
Verdad
Eqv
Verdad
Verdad
Verdad
Eqv
Falso
Falso
Falso
Eqv
Verdad
Falso
Falso
Eqv
Falso
Verdad
Verdad
Imp
Verdad
Verdad
Verdad
Imp
Falso
Falso
Verdad
Imp
Null
Null
Falso
Imp
Verdad
Verdad
Falso
Imp
Falso
Verdad
Falso
Imp
Null
Verdad
Null
Imp
Verdad
Verdad
Null
Imp
Falso
Null
Null
Imp
Null
Null
Si a cualquiera de las anteriores condiciones le anteponemos el operador NOT el resultado de la operación será el contrario al devuelto sin el operador NOT.
El último operador denominado Is se emplea para comparar dos variables de tipo objeto Is . este operador devuelve verdad si los dos objetos son iguales
SELECT * FROM Empleados WHERE Edad > 25 AND Edad <> 25 AND Edad < sueldo =" 100;" estado =" 'Soltero';"> 100 AND Sueldo < 500) OR (Provincia = 'Madrid' AND Estado = 'Casado');
3.2 Intervalos de Valores
Para indicar que deseamos recuperar los registros según el intervalo de valores de un campo emplearemos el operador Between cuya sintaxis es:
campo [Not] Between valor1 And valor2 (la condición Not es opcional)
En este caso la consulta devolvería los registros que contengan en "campo" un valor incluido en el intervalo valor1, valor2 (ambos inclusive). Si anteponemos la condición Not devolverá aquellos valores no incluidos en el intervalo.
SELECT * FROM Pedidos WHERE CodPostal Between 28000 And 28999; (Devuelve los pedidos realizados en la provincia de Madrid)
SELECT IIf(CodPostal Between 28000 And 28999, 'Provincial', 'Nacional') FROM Editores; (Devuelve el valor 'Provincial' si el código postal se encuentra en el intervalo, 'Nacional' en caso contrario)
3.3 El Operador Like
Se utiliza para comparar una expresión de cadena con un modelo en una expresión SQL. Su sintaxis es:
expresión Like modelo
En donde expresión es una cadena modelo o campo contra el que se compara expresión. Se puede utilizar el operador Like para encontrar valores en los campos que coincidan con el modelo especificado. Por modelo puede especificar un valor completo (Ana María), o se pueden utilizar caracteres comodín como los reconocidos por el sistema operativo para encontrar un rango de valores (Like An*).
El operador Like se puede utilizar en una expresión para comparar un valor de un campo con una expresión de cadena. Por ejemplo, si introduce Like C* en una consulta SQL, la consulta devuelve todos los valores de campo que comiencen por la letra C. En una consulta con parámetros, puede hacer que el usuario escriba el modelo que se va a utilizar.
El ejemplo siguiente devuelve los datos que comienzan con la letra P seguido de cualquier letra entre A y F y de tres dígitos:
Like 'P[A-F]###'
Este ejemplo devuelve los campos cuyo contenido empiece con una letra de la A a la D seguidas de cualquier cadena.
Like '[A-D]*'
En la tabla siguiente se muestra cómo utilizar el operador Like para comprobar expresiones con diferentes modelos.
Tipo de coincidencia
Modelo Planteado
Coincide
No coincide
Varios caracteres
'a*a'
'aa', 'aBa', 'aBBBa'
'aBC'
Carácter especial
'a[*]a'
'a*a'
'aaa'
Varios caracteres
'ab*'
'abcdefg', 'abc'
'cab', 'aab'
Un solo carácter
'a?a'
'aaa', 'a3a', 'aBa'
'aBBBa'
Un solo dígito
'a#a'
'a0a', 'a1a', 'a2a'
'aaa', 'a10a'
Rango de caracteres
'[a-z]'
'f', 'p', 'j'
'2', '&'
Fuera de un rango
'[!a-z]'
'9', '&', '%'
'b', 'a'
Distinto de un dígito
'[!0-9]'
'A', 'a', '&', '~'
'0', '1', '9'
Combinada
'a[!b-m]#'
'An9', 'az0', 'a99'
'abc', 'aj0'

3.4 El Operador In
Este operador devuelve aquellos registros cuyo campo indicado coincide con alguno de los en una lista. Su sintaxis es:
expresión [Not] In(valor1, valor2, . . .)
SELECT * FROM Pedidos WHERE Provincia In ('Madrid', 'Barcelona', 'Sevilla');
3.5 La cláusula WHERE La cláusula WHERE puede usarse para determinar qué registros de las tablas enumeradas en la cláusula FROM aparecerán en los resultados de la instrucción SELECT. Depués de escribir esta cláusula se deben especificar las condiciones expuestas en los partados 3.1 y 3.2. Si no se emplea esta cláusula, la consulta devolverá todas las filas de la tabla. WHERE es opcional, pero cuando aparece debe ir a continuación de FROM.
SELECT Apellidos, Salario FROM Empleados WHERE Salario > 21000;
SELECT Id_Producto, Existencias FROM Productos WHERE Existencias <= Nuevo_Pedido;
SELECT * FROM Pedidos WHERE Fecha_Envio = #5/10/94#;
SELECT Apellidos, Nombre FROM Empleados WHERE Apellidos = 'King';
SELECT Apellidos, Nombre FROM Empleados WHERE Apellidos Like 'S*';
SELECT Apellidos, Salario FROM Empleados WHERE Salario Between 200 And 300;
SELECT Apellidos, Salario FROM Empl WHERE Apellidos Between 'Lon' And 'Tol';
SELECT Id_Pedido, Fecha_Pedido FROM Pedidos WHERE Fecha_Pedido Between #1-1-94# And #30-6-94#;
SELECT Apellidos, Nombre, Ciudad FROM Empleados WHERE Ciudad In ('Sevilla', 'Los Angeles', 'Barcelona');

4. Agrupamiento de Registros
4.1 GROUP BY
Combina los registros con valores idénticos, en la lista de campos especificados, en un único registro. Para cada registro se crea un valor sumario si se incluye una función SQL agregada, como por ejemplo Sum o Count, en la instrucción SELECT. Su sintaxis es:
SELECT campos FROM tabla WHERE criterio GROUP BY campos del grupo
GROUP BY es opcional. Los valores de resumen se omiten si no existe una función SQL agregada en la instrucción SELECT. Los valores Null en los campos GROUP BY se agrupan y no se omiten. No obstante, los valores Null no se evalúan en ninguna de las funciones SQL agregadas.
Se utiliza la cláusula WHERE para excluir aquellas filas que no desea agrupar, y la cláusula HAVING para filtrar los registros una vez agrupados.
A menos que contenga un dato Memo u Objeto OLE , un campo de la lista de campos GROUP BY puede referirse a cualquier campo de las tablas que aparecen en la cláusula FROM, incluso si el campo no esta incluido en la instrucción SELECT, siempre y cuando la instrucción SELECT incluya al menos una función SQL agregada.
Todos los campos de la lista de campos de SELECT deben o bien incluirse en la cláusula GROUP BY o como argumentos de una función SQL agregada.
SELECT Id_Familia, Sum(Stock) FROM Productos GROUP BY Id_Familia;
Una vez que GROUP BY ha combinado los registros, HAVING muestra cualquier registro agrupado por la cláusula GROUP BY que satisfaga las condiciones de la cláusula HAVING.
HAVING es similar a WHERE, determina qué registros se seleccionan. Una vez que los registros se han agrupado utilizando GROUP BY, HAVING determina cuales de ellos se van a mostrar.
SELECT Id_Familia Sum(Stock) FROM Productos GROUP BY Id_Familia HAVING Sum(Stock) > 100 AND NombreProducto Like BOS*;
4.2 AVG
Calcula la media aritmética de un conjunto de valores contenidos en un campo especificado de una consulta. Su sintaxis es la siguiente
Avg(expr)
En donde expr representa el campo que contiene los datos numéricos para los que se desea calcular la media o una expresión que realiza un cálculo utilizando los datos de dicho campo. La media calculada por Avg es la media aritmética (la suma de los valores dividido por el número de valores). La función Avg no incluye ningún campo Null en el cálculo.
SELECT Avg(Gastos) AS Promedio FROM Pedidos WHERE Gastos > 100;
4.3 Count
Calcula el número de registros devueltos por una consulta. Su sintaxis es la siguiente
Count(expr)
En donde expr contiene el nombre del campo que desea contar. Los operandos de expr pueden incluir el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario pero no otras de las funciones agregadas de SQL). Puede contar cualquier tipo de datos incluso texto.
Aunque expr puede realizar un cálculo sobre un campo, Count simplemente cuenta el número de registros sin tener en cuenta qué valores se almacenan en los registros. La función Count no cuenta los registros que tienen campos null a menos que expr sea el carácter comodín asterisco (*). Si utiliza un asterisco, Count calcula el número total de registros, incluyendo aquellos que contienen campos null. Count(*) es considerablemente más rápida que Count(Campo). No se debe poner el asterisco entre dobles comillas ('*').
SELECT Count(*) AS Total FROM Pedidos;
Si expr identifica a múltiples campos, la función Count cuenta un registro sólo si al menos uno de los campos no es Null. Si todos los campos especificados son Null, no se cuenta el registro. Hay que separar los nombres de los campos con ampersand (&).
SELECT Count(FechaEnvío & Transporte) AS Total FROM Pedidos;
4.4 Max, Min
Devuelven el mínimo o el máximo de un conjunto de valores contenidos en un campo especifico de una consulta. Su sintaxis es:
Min(expr) Max(expr)
En donde expr es el campo sobre el que se desea realizar el cálculo. Expr pueden incluir el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario pero no otras de las funciones agregadas de SQL).
SELECT Min(Gastos) AS ElMin FROM Pedidos WHERE Pais = 'España'; SELECT Max(Gastos) AS ElMax FROM Pedidos WHERE Pais = 'España';
4.5 StDev, StDevP
Devuelve estimaciones de la desviación estándar para la población (el total de los registros de la tabla) o una muestra de la población representada (muestra aleatoria) . Su sintaxis es:
StDev(expr) StDevP(expr)
En donde expr representa el nombre del campo que contiene los datos que desean evaluarse o una expresión que realiza un cálculo utilizando los datos de dichos campos. Los operandos de expr pueden incluir el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario pero no otras de las funciones agregadas de SQL)
StDevP evalúa una población, y StDev evalúa una muestra de la población. Si la consulta contiene menos de dos registros (o ningún registro para StDevP), estas funciones devuelven un valor Null (el cual indica que la desviación estándar no puede calcularse).
SELECT StDev(Gastos) AS Desviacion FROM Pedidos WHERE Pais = 'España'; SELECT StDevP(Gastos) AS Desviacion FROM Pedidos WHERE Pais= 'España';
4.6 Sum
Devuelve la suma del conjunto de valores contenido en un campo especifico de una consulta. Su sintaxis es:
Sum(expr)
En donde expr respresenta el nombre del campo que contiene los datos que desean sumarse o una expresión que realiza un cálculo utilizando los datos de dichos campos. Los operandos de expr pueden incluir el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario pero no otras de las funciones agregadas de SQL).
SELECT Sum(PrecioUnidad * Cantidad) AS Total FROM DetallePedido;
4.7 Var, VarP Devuelve una estimación de la varianza de una población (sobre el total de los registros) o una muestra de la población (muestra aleatoria de registros) sobre los valores de un campo. Su sintaxis es:
Var(expr) VarP(expr)
VarP evalúa una población, y Var evalúa una muestra de la población. Expr el nombre del campo que contiene los datos que desean evaluarse o una expresión que realiza un cálculo utilizando los datos de dichos campos. Los operandos de expr pueden incluir el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario pero no otras de las funciones agregadas de SQL)
Si la consulta contiene menos de dos registros, Var y VarP devuelven Null (esto indica que la varianza no puede calcularse). Puede utilizar Var y VarP en una expresión de consulta o en una Instrucción SQL.
SELECT Var(Gastos) AS Varianza FROM Pedidos WHERE Pais = 'España'; SELECT VarP(Gastos) AS Varianza FROM Pedidos WHERE Pais = 'España';

Tutorial de SQL

2007-03-26T19:47:00.000-07:00

1.- INTRODUCCION
El lenguaje de consulta estructurado (SQL) es un lenguaje de base de datos normalizado, utilizado por el motor de base de datos de Microsoft Jet. SQL se utiliza para crear objetos QueryDef, como el argumento de origen del método OpenRecordSet y como la propiedad RecordSource del control de datos. También se puede utilizar con el método Execute para crear y manipular directamente las bases de datos Jet y crear consultas SQL de paso a través para manipular bases de datos remotas cliente - servidor.
1.1. Componentes del SQL
El lenguaje SQL está compuesto por comandos, cláusulas, operadores y funciones de agregado. Estos elementos se combinan en las instrucciones para crear, actualizar y manipular las bases de datos.
1.2 Comandos
Existen dos tipos de comandos SQL:
los DLL que permiten crear y definir nuevas bases de datos, campos e índices.
los DML que permiten generar consultas para ordenar, filtrar y extraer datos de la base de datos.

Comandos DLL
Comando
Descripción
CREATE
Utilizado para crear nuevas tablas, campos e índices
DROP
Empleado para eliminar tablas e índices
ALTER
Utilizado para modificar las tablas agregando campos o cambiando la definición de los campos.

Comandos DML
Comando
Descripción
SELECT
Utilizado para consultar registros de la base de datos que satisfagan un criterio determinado
INSERT
Utilizado para cargar lotes de datos en la base de datos en una única operación.
UPDATE
Utilizado para modificar los valores de los campos y registros especificados
DELETE
Utilizado para eliminar registros de una tabla de una base de datos
1.3 Cláusulas
Las cláusulas son condiciones de modificación utilizadas para definir los datos que desea seleccionar o manipular.
Cláusula
Descripción
FROM
Utilizada para especificar la tabla de la cual se van a seleccionar los registros
WHERE
Utilizada para especificar las condiciones que deben reunir los registros que se van a seleccionar
GROUP BY
Utilizada para separar los registros seleccionados en grupos específicos
HAVING
Utilizada para expresar la condición que debe satisfacer cada grupo
ORDER BY
Utilizada para ordenar los registros seleccionados de acuerdo con un orden específico
1.4 Operadores Lógicos
Operador
Uso
AND
Es el "y" lógico. Evalua dos condiciones y devuelve un valor de verdad sólo si ambas son ciertas.
OR
Es el "o" lógico. Evalúa dos condiciones y devuelve un valor de verdar si alguna de las dos es cierta.
NOT
Negación lógica. Devuelve el valor contrario de la expresión.
1.5 Operadores de Comparación
Operador
Uso
<
Menor que
>
Mayor que
<>
Distinto de
<=
Menor ó Igual que
>=
Mayor ó Igual que
=
Igual que
BETWEEN
Utilizado para especificar un intervalo de valores.
LIKE
Utilizado en la comparación de un modelo
In
Utilizado para especificar registros de una base de datos
1.6 Funciones de Agregado
Las funciones de agregado se usan dentro de una cláusula SELECT en grupos de registros para devolver un único valor que se aplica a un grupo de registros.
Función
Descripción
AVG
Utilizada para calcular el promedio de los valores de un campo determinado
COUNT
Utilizada para devolver el número de registros de la selección
SUM
Utilizada para devolver la suma de todos los valores de un campo determinado
MAX
Utilizada para devolver el valor más alto de un campo especificado
MIN
Utilizada para devolver el valor más bajo de un campo especificado

2. Consultas de Selección
Las consultas de selección se utilizan para indicar al motor de datos que devuelva información de las bases de datos, esta información es devuelta en forma de conjunto de registros que se pueden almacenar en un objeto recordset. Este conjunto de registros es modificable.
2.1 Consultas básicas
La sintaxis básica de una consulta de selección es la siguiente:
SELECT Campos FROM Tabla;
En donde campos es la lista de campos que se deseen recuperar y tabla es el origen de los mismos, por ejemplo:
SELECT Nombre, Telefono FROM Clientes;
Esta consulta devuelve un recordset con el campo nombre y teléfono de la tabla clientes.
2.2 Ordenar los registros
Adicionalmente se puede especificar el orden en que se desean recuperar los registros de las tablas mediante la claúsula ORDER BY Lista de Campos. En donde Lista de campos representa los campos a ordenar. Ejemplo:
SELECT CodigoPostal, Nombre, Telefono FROM Clientes ORDER BY Nombre;
Esta consulta devuelve los campos CodigoPostal, Nombre, Telefono de la tabla Clientes ordenados por el campo Nombre.
Se pueden ordenar los registros por mas de un campo, como por ejemplo:
SELECT CodigoPostal, Nombre, Telefono FROM Clientes ORDER BY CodigoPostal, Nombre;
Incluso se puede especificar el orden de los registros: ascendente mediante la claúsula (ASC -se toma este valor por defecto) ó descendente (DESC)
SELECT CodigoPostal, Nombre, Telefono FROM Clientes ORDER BY CodigoPostal DESC , Nombre ASC;
2.3 Consultas con Predicado
El predicado se incluye entre la claúsula y el primer nombre del campo a recuperar, los posibles predicados son:
Predicado
Descripción
ALL
Devuelve todos los campos de la tabla
TOP
Devuelve un determinado número de registros de la tabla
DISTINCT
Omite los registros cuyos campos seleccionados coincidan totalmente
DISTINCTROW
Omite los registros duplicados basandose en la totalidad del registro y no sólo en los campos seleccionados.
ALL
Si no se incluye ninguno de los predicados se asume ALL. El Motor de base de datos selecciona todos los registros que cumplen las condiciones de la instrucción SQL. No se conveniente abusar de este predicado ya que obligamos al motor de la base de datos a analizar la estructura de la tabla para averiguar los campos que contiene, es mucho más rápido indicar el listado de campos deseados.
SELECT ALL FROM Empleados; SELECT * FROM Empleados; TOP
Devuelve un cierto número de registros que entran entre al principio o al final de un rango especificado por una cláusula ORDER BY. Supongamos que queremos recuperar los nombres de los 25 primeros estudiantes del curso 1994:
SELECT TOP 25 Nombre, Apellido FROM Estudiantes ORDER BY Nota DESC;
Si no se incluye la cláusula ORDER BY, la consulta devolverá un conjunto arbitrario de 25 registros de la tabla Estudiantes .El predicado TOP no elige entre valores iguales. En el ejemplo anterior, si la nota media número 25 y la 26 son iguales, la consulta devolverá 26 registros. Se puede utilizar la palabra reservada PERCENT para devolver un cierto porcentaje de registros que caen al principio o al final de un rango especificado por la cláusula ORDER BY. Supongamos que en lugar de los 25 primeros estudiantes deseamos el 10 por ciento del curso:
SELECT TOP 10 PERCENT Nombre, Apellido FROM Estudiantes ORDER BY Nota DESC;
El valor que va a continuación de TOP debe ser un Integer sin signo.TOP no afecta a la posible actualización de la consulta.
DISTINCT
Omite los registros que contienen datos duplicados en los campos seleccionados. Para que los valores de cada campo listado en la instrucción SELECT se incluyan en la consulta deben ser únicos.
Por ejemplo, varios empleados listados en la tabla Empleados pueden tener el mismo apellido. Si dos registros contienen López en el campo Apellido, la siguiente instrucción SQL devuelve un único registro:
SELECT DISTINCT Apellido FROM Empleados;
Con otras palabras el predicado DISTINCT devuelve aquellos registros cuyos campos indicados en la cláusula SELECT posean un contenido diferente. El resultado de una consulta que utiliza DISTINCT no es actualizable y no refleja los cambios subsiguientes realizados por otros usuarios.
DISTINCTROW
Devuelve los registros diferentes de una tabla; a diferencia del predicado anterior que sólo se fijaba en el contenido de los campos seleccionados, éste lo hace en el contenido del registro completo independientemente de los campo indicados en la cláusula SELECT.
SELECT DISTINCTROW Apellido FROM Empleados;
Si la tabla empleados contiene dos registros: Antonio López y Marta López el ejemplo del predicado DISTINCT devuleve un único registro con el valor López en el campo Apellido ya que busca no duplicados en dicho campo. Este último ejemplo devuelve dos registros con el valor López en el apellido ya que se buscan no duplicados en el registro completo. 2.4 Alias
En determinadas circunstancias es necesario asignar un nombre a alguna columna determinada de un conjunto devuelto, otras veces por simple capricho o por otras circunstancias. Para resolver todas ellas tenemos la palabra reservada AS que se encarga de asignar el nombre que deseamos a la columna deseada. Tomado como referencia el ejemplo anterior podemos hacer que la columna devuelta por la consulta, en lugar de llamarse apellido (igual que el campo devuelto) se llame Empleado. En este caso procederíamos de la siguiente forma:
SELECT DISTINCTROW Apellido AS Empleado FROM Empleados;
2.5 Recuperar Información de una base de Datos Externa
Para concluir este capítulo se debe hacer referencia a la recuperación de registros de bases de datos externa. Es ocasiones es necesario la recuperación de información que se encuentra contenida en una tabla que no se encuentra en la base de datos que ejecutará la consulta o que en ese momento no se encuentra abierta, esta situación la podemos salvar con la palabra reservada IN de la siguiente forma:
SELECT DISTINCTROW Apellido AS Empleado FROM Empleados IN 'c:\databases\gestion.mdb';
En donde c:\databases\gestion.mdb es la base de datos que contiene la tabla Empleados.

Tutorial ASP Secuencias de comandos asp

2007-03-26T19:31:00.000-07:00

Agregar secuencias de comandos
Como vimos anteriormente, una pagina ASP mezcla en el mismo archivo secuencias de comandos con código HTML standard. Las secuencias de comandos asp se distinguen del resto del texto del archivo mediante delimitadores (un delimitador es un carácter o secuencia de caracteres que marca el principio o final de una unidad).
En el caso de HTML , dichos delimitadores son los símbolos "<" y ">" que enmarcan las etiquetas Html. ASP utiliza los delimitadores
""
para enmarcar las secuencias de comandos.
Veamos esto con un ejemplo sencillo:

Hola, bienvenido a mi página, estamos a :

La función NOW() de VBScript devuelve la fecha y hora actuales.Cuando el servidor Web procese la pagina nos devolverá el siguiente resultado al explorador:

Hola, bienvenido a mi página, estamos a : 4/1/2000 14:25:55 PM

Como vemos, el cliente, no recibe el código asp, recibe el resultado de la ejecución de dicho código.
Dentro de los delimitadores ASP se puede incluir cualquier instrucción, expresión, procedimiento u operador válido para el lenguaje de programación que estemos usando. Un ejemplo de esto seria una página que nos mostraría:
Buenos días
si la ejecutamos antes de las 12:00 o:
Buenas Tardes
si la ejecutamos después de esta hora, el código seria el siguiente:

Buenos días

Buenas Tardes

Establecer el lenguaje de la aplicación
ASP viene de forma nativa con dos motores de secuencia de comandos Microsoft Visual Basic Scriptig Edition (VBScript) y Microsoft JScript. Puede instalar y utilizar motores de otros lenguajes como REXX y Perl.
Para establecer el lenguaje principal de secuencia de comandos en todas las páginas de una aplicación, establezca la propiedad Lenguaje ASP predeterminado en la ficha Opciones de la Aplicación en el Administrador de Servicios Internet.
Para establecer el lenguaje principal de secuencia de comandos en una única página, hay que agregar la directiva al principio del archivo .asp. La sintaxis de esta directiva es la siguiente:

donde Lenguaje_secuencia_comandos es el lenguaje principal de secuencia de comandos que va a establecer en esa página concreta. El valor de la página invalida el valor global de todas las páginas de la aplicación.
Todos los ejemplos de estas páginas están escritos en VBScript

Comentarios en VBScript
VBScript acepta comentarios marcados con apóstrofes. Estos comentarios se eliminan al procesarse la secuencia de comandos y no se envían al explorador.
'Esta linea y las siguientes son comentarios.
'La función ImprimirTabla imprime los elementos de una matriz.
Call ImprimirTabla (mimatriz( ))
No puede incluir comentarios en expresiones de resultados. Por ejemplo, la primera línea que sigue funciona, pero la segunda no, porque empieza con

Distinguir entre mayúsculas y minúsculas
VBScript no distingue entre mayúsculas y minúsculas।
Tipos de datos en VBScript
Vbscript solo tiene un tipo de datos llamado Variant.
El tipo Variant es una clase especial de datos que puede contener diferentes tipos de información, se comporta como un número cuando se utiliza en un contexto numérico, y como una cadena de caracteres cuando se usa en un contexto de cadena, no obstante podemos forzar a que los números se comporten como cadenas poniéndolos entre comillas (" ").
Aunque solo existe un tipo de datos, podemos hacer distinciones mas precisas acerca de la naturaleza de la información a través de los Subtipos incluidos en el tipo Variant, además vbscript pone a nuestra disposición funciones para convertir los datos de un tipo a otro.
Subtipo
Descripción
Valor de Vartype
Empty
Variable sin inicializar
0
Null
Variable intencionadamente vacia
1
Boolean
Dos valores posibles True o False
11
Byte
Entero entre 0 y 255
17
Integer
Entero entre -32.768 y 32.768
2
Currency
Numero entre -922.337.203.685.477,5808 y 922.337.203.685.477,5807
6
Long
Numero entre -2.147.483.648 y 2.147.483.647
3
Single
Numero de precisión simple
4
Double
Numero de doble precisión
5
Date
Fecha entre 1-1-100 y 31-12-9999
7
String
Cadena de longitud variable hasta 2.000.000.000 de caracteres.
8
Object
Contiene un Objeto
9
Error
Contiene un numero de error
10
Conversión de Tipos
Todas la funciones de conversión de tipos tienen la misma sintaxis:
Funcion(expresión), siendo expresión el dato que se desea convertir.
Cbool
Convierte una expresión a tipo Boolean
Cbyte
Convierte una expresión a tipo Byte
Clnt
Convierte una expresión a tipo Integer
Clng
Convierte una expresión a tipo Long
Csng
Convierte una expresión a tipo Single
Cdbl
Convierte una expresión a tipo Double
Ccur
Convierte una expresión a tipo Curency
Cdate
Convierte una expresión a tipo Date
Cstr
Convierte una expresión a tipo String

Tambien podemos podemos conocer el subtipo de una variable mediante la función Vartype(variable) que nos devuelve el valor referenciado en la tercera columna de la tabla 1
Variables en VBScript
Vbscript no necesita la declaración explicita de variables, pero es conveniente su declaración para evitar errores (se puede forzar la declaración de variables incluyendo la sentencia al principio de la pagina .asp).
Para declarar una variable se utiliza la instrucción DIM. PUBLIC o PRIVATE. Por ejemplo:

Tutorial ASP

2007-03-26T19:21:00.000-07:00

Páginas Active Server
Páginas Active Server (ASP, Active Server Pages) es un entorno para crear y ejecutar aplicaciones dinámicas e interactivas en la Web.Se puede combinar páginas HTML, secuencias de comandos y componentes ActiveX para crear paginas y aplicaciones Web interactivas.
El modelo de Páginas ASP
Las páginas ASP comienzan a ejecutarse cuando un usuario solicita un archivo .asp al servidor Web a través del explorador. El servidor web llama a ASP, que lee el archivo solicitado, ejecuta las secuencias de comandos que encuentre y envía los resultados al explorador del cliente.
Puesto que las secuencias de comandos se ejecutan en el servidor, y NO en el cliente, es el servidor el que hace todo el trabajo necesario para generar las paginas que se envían al explorador. Las secuencias de comandos quedan ocultas a los usuarios, estos solo reciben el resultado de la ejecución en formato HTML.
Desaparece por tanto el problema de si el cliente puede o no ejecutar sentencias de comandos, el servidor Web solo envía el resultado en código HTML standard interpretable por cualquier explorador.
Crear Páginas ASP
Los archivos .asp son archivos de texto normales, no es necesario ningún editor especial para crearlos, puede usarse cualquier editor que genere código ascii.Un archivo .asp puede contener texto, código HTML, código ASP o cualquier combinación de estos. Si no contiene código ASP se comporta como un archivo .html normal.
(Nota: todos los archivos .asp requieren una parte de proceso por el servidor, por lo cual no es conveniente convertir a .asp los archivos que no contengan código)
Internet Information Server
Introducción
Instalación de protocolo TCP/IP
Seguridad del sitio Web

1.-Introducción
IIS es el software estándar que soporta comunicaciones Internet en Windows NT .
No es el único, ni proporciona todos los servicios posibles; sin embargo su importancia es enorme al haberse convertido en uno de los más extendidos; haciendo fuerte competencia a los servidores basados en plataformas UNIX.
El auge viene de la mano de la fuerte penetración de Windows NT, complementándose muy adecuadamente con este desde le punto de vista comercial y técnico.
Proporciona unas buenas prestaciones en equipos con muy diferentes prestaciones de hardware.
Es especialmente ventajoso en su utilización en redes Intranet debido a la compatibilidad y posibilidades de uso conjunto con los productos de la familia Microsoft (Word, access, odbc, etc.)
Todo indica que el conjunto NT-IIS-Explorer será utilizado de forma creciente para la publicación de datos en Intranet/Internet.
Los servicios básicos que nos proporciona IIS4 son WWW, FTP, Correo y NEWS.
La instalación de IIS es sobre NT Server 4.0, aunque se puede instalar sobre Workstation o Windows 95-98 la versión PWS 4 con la consiguiente perdida de prestaciones.
Workstation puede servir muy adecuadamente como banco de pruebas y aprendizaje.
Una de las principales ventajas de IIS4 es el soporte nativo de páginas ASP (también se soportan en IIS3 mediante la actualización pertinente).
Para publicar en Intranet necesitamos:
Tarjeta adaptadora de red
Un servidor DNS o WINS si deseamos usar nombres en vez de direcciones IP numéricas.
Para publicar en Internet necesitamos:
Una tarjeta de comunicaciones
Una conexión a Internet
Una dirección IP registrada en un DNS
Todo esto nos lo proporciona los Proveedores de Servicios Internet (ISP), junto con la dirección IP de gateway de su servidor, a través del cual se realizaran los encaminamientos de la información.

2.-Instalación del protocolo TCP/IP
Se configura a través de la ventana Red en el Panel de Control de Windows, en esta ventana configuramos los servicios, protocolos, adaptadores y enlaces.
En la pestaña Protocolos seleccionamos TCP/IP, si no aparece, lo añadiremos con el botón Agregar.
Una vez escogido pulsamos Propiedades para configurarlo.
Pestaña Dirección IP:
Configuramos por cada tarjeta:
Adaptador (Tipo de tarjeta)
Dirección IP
Mascara de subred
Gateway
Pestaña Dirección DNS:
Nombre de Host + Dominio (identificación de la maquina que estamos configurando)
Orden de búsqueda del servicio Dns
Orden de búsqueda de sufijo de dominio (opcional)
Todos estos parámetros nos los proporciona nuestro proveedor ISP.

3.-Mecanismos de seguridad
La seguridad de un sitio Web es especialmente importante, debido a la necesidad de garantizar su utilización por usuarios remotos.
IIS 4.o utiliza la seguridad de Windows NT y en algunos casos la amplia.
Se recomienda el uso del sistema de archivos NTFS de NT por su mayor seguridad.
Windows NT basa su seguridad en el sistema de usuarios y contraseñas, el uso adecuado de estas contribuye a mantener el equipo seguro.
La mayor parte de las peticiones de paginas Web son realizadas por clientes anónimos, en este caso, el servidor web se encarga de suplantar al usuario real mediante el uso de la cuenta del usuario anónimo.
Mecanismo de seguridad en una petición:
Comprobación de la dirección IP del cliente por IIS.
Comprobación de usuario y contraseña.
Comprobación de los permisos de acceso a archivos establecidos en el sistema NTFS.
Si cualquiera de estas comprobaciones es errónea, la petición no tendrá éxito.
Administración de la cuenta de usuario anónimo.
Cuando se instala IIS se crea automáticamente en NT el usuario anónimo con el nombre IUSR_Nombre del equipo y con la misma contraseña aleatoria que en IIS y el derecho de Inicio de Sesión en Local.
Conviene revisar los derechos de los grupos que tienen los grupos Todos e Invitados a los que pertenece el usuario anónimo.
Para que el usuario anónimo funcione correctamente debemos activar Permitir Anónimos en las propiedades del servicio Web.
Autenticación
Si se desea, se puede restringir la utilización de los servicios Web de tal forma que únicamente los clientes que proporcionan un nombre de usuario y una contraseña válidos puedan acceder a las paginas solicitadas.
En IIS existen 2 formas de autenticación:
Autenticación Básica: El usuario y la clave se transmiten sin cifrar
Autentificación Desafío/Respuesta de Windows NT: El usuario y la clave se transmiten cifrados; el usuario debe de estar dado de alta en el dominio de la maquina que ejecuta IIS y tener derechos de Acceso al equipo desde la red. Es muy adecuado en redes Intranet; precisa un cliente Internet Explorer en versión 2 como mínimo.
Generalmente se permiten simultáneamente Anónimos y mecanismos de autenticación, en este caso en primer lugar se usa el usuario Anónimo y si se produce un error por falta de permisos de acceso a un recurso, el cliente recibe una ventana de dialogo solicitándole las credenciales.

Establecimiento de permisos en los directorios y ficheros de un sitio Web (aspectos Básicos)
De forma genérica un sitio Web reside en
Un directorio particular
Los subdirectorios que parten del particular
Los directorios virtuales
Cada uno de los elementos anteriores, en caso de existir, deberá poseer los suficientes permisos para que el sitio Web funcione correctamente, pero con las restricciones adecuadas para que el equipo este seguro.
Una buena metodología consiste en agrupar los ficheros según su naturaleza y de forma jerárquica; de manera que tengamos separadas distintas aplicaciones en distintos directorios, con sus documentos en subdirectorios.
La asignación general de permisos sigue la siguiente estructura:
Programas CGI, ISAPI, etc
Permiso de Ejecución
Páginas ASP
Permisos de Lectura y Ejecución
Documentos estáticos HTML, Imágenes, etc
Permiso de Lectura
Bases de datos, ficheros auxiliares, etc.
Permisos de Lectura y Escritura.
Se debe tener en cuenta que desde IIS se pueden establecer permisos de Lectura y Ejecución, y desde NT cualquier permiso implementado en NTFS. En caso de discrepancia se toma la opción más restrictiva.

The .NET Framework Architecture Part 2

2007-03-26T00:27:00.000-07:00

Just-In-Time (JIT) compilation
As stated above, the Just in time compiler is a facility that is invoked by the CLR to convert the IL into machine code. The .NET framework assemblies (*.dll or *.exe) files cannot be executed by the target processor unless it is converted into native code. When the Assembly is loaded the method calls are invoked for compilation into native code. Since this is done just when the method needs to execute, it is called Just in time compilation. When the JIT is invoked for the first time there is an overhead or performance penalty, since the assembly is converted into its Native code or image using the Native Image Generator (Ngen.exe). All subsequent calls will load faster as the Native image alone is invoked thereafter from the Native image cache.
Significantly, the IL can coexist with the machine code in the application. This feature also enables the developer modify the code or add to the code even when the application is actively deployed. This functionality provided by JIT makes the .NET framework an efficient, agile and powerful means of application development.
Assemblies, native assemblies, and the Global Assembly Cache (GAC)
The primary unit of deployment is the assembly. The assembly is used by the .NET CLR as the smallest unit of deployment; version control; security; type grouping and code reuse. An assembly will consist of a manifest and one or more modules or files. It can be defined as a logical DLL that contains a manifest, type metadata, MSIL and resources. Assemblies can be application private or shared. Private assemblies are restricted to use in a single application whereas shared assemblies can be used across applications. Private applications also reside within the application folder while shared assemblies reside in the common area-- GAC(Global Assembly Cache). They must have a globally unique name.
The existence of the manifest within the assembly makes it self descriptive. It can be viewed by the IL Disassembler (Ildasm.exe) which is part of the .NET framework SDK.
The assembly is identified by the manifest. It defines security requirements, lists other interdependent assemblies and all the types and resources exposed by the assembly. Localized resources exposed by assemblies and targeted by the application contain a default culture (language, currency, date/time format etc).
The manifest contains several sections. Identity, Referenced Assemblies, file list and Custom Attributes are some of the important sections of the manifest. The Identity section as the name suggests, identifies the assembly. It contains a .assembly directive. The version directive specifies the version of the assembly, so that the CLR identifies the different versions of an application. The Identity section contains a strong name for shared assemblies and a public/private encryption key is used to distinguish between assemblies of the same name. The Identity section also optionally contains the Culture which defines the country and language of the assembly target. The .locale directive is used for this purpose and the Culture-Neutral assemblies can be used by any assembly. The Referenced Assemblies section of the manifest provides a reference to all the assemblies used in an application.
Comparison of VB.NET, C#, and J#

The .NET framework architecture has made the language of coding immaterial to the final output. All languages also have equal access to all development capabilities and revolve around the .NET classes. The language syntax, operations etc look similar in all the languages of this group. Moreover, code can be shared by all .NET languages and so a class made in C# or J# can be used in VB.NET and vice versa.
In this context choice of language is no longer significant. Finally, all languages are transformed by the compiler into Microsoft Intermediate language. It is the programmer’s familiarity with the language that makes it material whether he is coding in VB.NET or C# or J#. However, the option settings in the compiler will have to be set to the language of coding before the compiler is used.
The speed of performance of the compiler will also vary with the language being compiled. For instance C# compiles faster than VB.NET. Subject to the above observation, the features of the languages will be dicussed in the next tutorial.