Looking for a way to attract more attention to your website? Offer a fresh face and new content on a regular basis and you'll find people will check back to see what's new and you'll have a tool to measure what attracts and what doesn't. Here's how to do it.

Your website homepage is your front door through which online browsers come to visit your business. Static, never-changing content is no more interesting to a returning visitor than a book they have already read. To keep your audience captivated and coming back you need to make your home on the web inviting and interesting.

Present a Dynamic Home Page

One way that you can present changing home page content is to design ten to twelve unique pages with different content and then rotate them every month. Take a couple of weeks to design different ideas and images. Create page promotions that include a message that is timeless or that has a seasonal or timely announcement such as "Holiday Specials." When you consider different features for your home page and when it should be placed you're forced to look closely at at your marketing strategy over a one year period. This will save you a lot of time since you then won't have to think about your content through the year. It also allows you to plan your offers and gather the necessary content.

A web developer can put your home pages on a rotating script or use an automatic timer. You can then rotate your home pages to highlight a new tip every month or to promote a featured product. The home page of your website is much like the front cover of a magazine. People want to see a home page that has different photos and content at least every month, preferably every week. You won't want all of the content of your website to be featured on the page as this will overwhelm your website visitors. So choose one or two features to highlight each month. The rest of your website content should be well organized within the rest of the pages of your site. When you're ready to update your home page you simply grab content from your internal pages. This way you're not having to create new content. You're just reorganizing your existing content so that it feels new to your visitors.

Don't Change Your Home Page Too Often:

Even though you want your website to be new and dynamic you also don't want to change it too often. People take comfort from their favorite websites and want them to be familiar. If you change your home page too often or too much you may create confusion or give people the feel that someone else has taken over your site. You could also compromise your positioning in search engines. So maintain some consistency.

When you make changes to graphics or content it shouldn't make a major change to the way your website looks and feels. Regular visitors should be able to find the same information that they've always found on your home page and in the same place. As a rule, the headers and navigation tools on your page shouldn't ever change without a complete redesign and announcing that to your visitors. Change content and images with other content and images while maintaining the sites original functionality. Home pages that are consistent lend a feeling of comfort to users. If your customers learn to expect consistency they'll also learn to rely on your quality customer service. If you're a small online business, gaining your customer's trust is your most important step to success.

The Benefits of a Flexible Home Page

A flexible home page lets you test your off line marketing efforts. Before you spend money on a magazine or newspaper ad you can test it out on your website. You'll be able to see how people react to the ad. It will let you determine which featured products attract the most interest. You can also determine which graphics generate the most attraction. Web analytics software (Google Analytics is great and free to use) can provide you with this type of information. It will help you obtain marketing data that is detailed and precise. You can see which graphics people have clicked on as well as what web page they were on just before they left your website.

Once you've mastered the technique of updating your home page, while at the same time keeping the core content the same, you'll be well on your way to recognizing the benefits of a flexible home page.

Servers are systems which are used to manage computer networks. They are able to perform all kinds of activities and they could be dedicated to a particular job. For instance, a file server stores the files which contain data and information that belong to a certain network. An example of this would be Microsoft's Exchange Server, which is dedicated to handle business mails as well as other types of business communication. Another example would be multiprocessor servers that handle several tasks simultaneously such as managing mailboxes, storing data and other tasks.

Servers have been basically created to be able to have better management of data. They make the whole process of information management faster and safer. However, there are also other applications for servers. These would include the provision of access to the Internet. A lot of people make use of a server, which has been provided by a company, which manages the availability of web connectivity and other services for them. This actually makes it a lot cheaper and easier to use so that we can stay connected online.

Servers are also useful to manage official communication. Since virtually all offices today are running on LAN servers, companies are able to connect and manage all their computers centrally and conveniently. It also serves as a cheaper, simpler and safer method to keep everything well managed.

Servers also permit remote access. If an individual has to access a computer in the main office and he or she is traveling, that individual can access the information that he or she needs from that computer using a computer at the current location which is also connected to the same server where the other one is connected to.

Don't be fooled by seeming simplicity. A lot of developers get comfortable with a certain way of designing a database for their web applications that they miss out on techniques they should rather employ to make things run faster and more efficiently. A lot of developers don't bear in mnd that the small site they are creating now might grow into something incredibly large and complex, and the database they designed has become bloated and doesn't scale well to meet the demands of the increased traffic.

This article hopes to provide web developers with a few techniques to help make their database and queries faster and more efficient.

1. Avoid Character Types

When you are designing a database, it is so easy to set all data types to the VARCHAR type as it can then contain any data you want; numbers or text. But character data is amongst the most inefficient data type you can get. If a field is only going to contain numbers, then make it one of the appropriate types (INT, DOUBLE, etc).

Also, wherever possible in your web development code, try to use numeric data types as opposed to characters. One of the most common things a script has to store are flags like whether someone answered yes or no to a question, etc. You could of course store it as 'Y' or 'N' but why not store it as 0 and 1?

The reason this makes a difference is when you have a database, for example, with over 500 000 entries, and are running a SELECT on that field, comparisons are processed a lot faster for numeric data types than character types. Also, if you need to return data to the calling script, numeric data is less memory intensive than character data. In addition, your web development language (PHP, ASP, etc) would also be able to process and perform functions on numeric data better than character data.

I am not trying to convince you never to use character data types. Sometimes it is a necessity, but if you can find ways to reduce the amount of character data processed by your SQL database, the better your server will cope.

2. Normalization

Normalizing a database is really quite a complex process. It is a process that describes a way to design a database structure to avoid repetition of data in your database and can lead to significant performance benefits if employed correctly. However, the entire process of normalisation is a bit beyond the scope of this article as it can fill books on its own, but any developer designing a database should seriously consider becoming knowledgable about normalisation and employing it in their own designs.

For a good tutorial on this process: http://www.keithjbrown.co.uk/vworks/mysql/mysql_p7.php

3. DateTime vs Timestamp fields

This actually relates to 1. a bit. The big difference to bear in mind here is that a field of type DATETIME is actually stored as a series of characters. A field of type TIMESTAMP is actually stored as an integer. So therefore, a more efficient way of storing dates is using the timestamp method. The timestamp has its drawbacks however. For one, you cannot store a date early than 1 January, 1970. Also, timestamps in your script will need recalculating to get to the character format. Because of this recalculation, it may not be better to store as timestamp. It really is a case of testing which format works better for your needs.

4. Use LIMIT where possible

In your queries, if you are doing a SELECT to a database and you only expect a certain number of results, using the LIMIT statement can speed your query up incredibly.

For example, if you have a table of users and you need to run a query to search for one users record, you can use a query like:

SELECT user_name FROM users WHERE user_id = 453;

This query is perfectly valid and will return the right result. But you also know there will only be ONE result. The query above will search the database, find what you want, but then still continue searching after that. It would run a lot faster if you could tell the query that once it has found what you are looking for to stop searching. LIMIT can do this, as this query shows:

SELECT user_name FROM users WHERE user_id = 453 LIMIT 1;

Imagine this scenario. You have a table called logins, that records every login from a user. It currently contains over 2 000 000 records, and you want to find the first time a user logged in. Now bear in mind that because this table inserts data over time, it is already sorted for by date. You could do the following query:

SELECT MIN(login_date) FROM logins WHERE user_id = 4876;

This will return the record you want, but SQL will now have to get all dates for that user, sort them and then return the lowest value to you. Our table is already date sorted simply because of the way it records data for us. So using LIMIT can be more effective:

SELECT login_date FROM logins WHERE user_id = 4876 LIMIT 1;

Because it is sorted, the first one will always be a users first login.

5. Avoid using LIKE

If you have tried to employ 1. above, then hopefully you will be in a scenario where you do not need to use LIKE all that much. LIKE is one of the most inefficient ways of searching a table. LIKE performs a text comparison search in a field and with no wildcards is as efficient as a direct comparison; i.e. WHERE name = 'Jane' is equivalent to WHERE name LIKE 'Jane'. It is when you start introducing the wildcard characters like '%' that things get really hairy.

If you do have to use LIKE, then at least try and make efficient use of the wildcards. These are '_' (underscore) and '%'. Let me explain all this with a real world example.

In a project I was involved in, we had a SQL database storing logs generated automatically from a mail server. Unfortunately, the mail server pretty much just dumped a very long string of text data into a field that contained the data we wanted. A script had to be written to find all logs that referred to a login by a user into the POP server. The only way we could do this was to search every record for a string in the msg field that had the text "User logged in" in it. The first query developed was something like this:

SELECT msg FROM logs WHERE msg LIKE '%User logged in%';

This query took on average of about 35 minutes to process. Obviously not an ideal situation. The way the LIKE worked here was that it had to parse through every single portion of each and every record in the msg field looking for text that matched "User logged in" anywhere in the text. We were able to determine eventually that the text "User logged in" occured at the end of that text in the msg field and so we altered the query:

SELECT msg FROM logs WHERE msg LIKE '%User logged in';

The '%' at the end was removed as we do not want to worry about text after because there is none. The query now only compares text to our string in the msg field at the end of the field and no longer parses through the entire piece of text stored in msg. The query now ran in under 2 minutes. (This was actually still too long, but how we optimised from there is a little beyond the scope of this article.)

Hopefully with all these elements put into practice on your next web development project, you can have a database that runs quickly, efficiently, uses as little resources as possible and wont grind to a halt when the load suddenly increases.