During my professional career I have become accustomed to the development tools that make the engineer’s job much easier. On the other hand I’ve come to the realization that little time and attention is being spent on optimization and proper use of those tools. While there is plenty of information out there on framework comparisons, guides, APIs, and the like very few products seem to adopt the best practices and the tier two functionality slips through the cracks of the Q&A process. This is usually the case with logging.
Log4J is the status quo when it comes to logging in Java. With the expanded mainstream popularity the framework which has been branched in C++ (Log4cxx) ,  C#/.NET (Log4Net) and even PHP (Log4php) has made it easy to add logging to multi tier applications. The advantage of having a very granular approach with different log levels (DEBUG, INFO, ERROR, etc.) and the Logger package inheritance make it a flexible tool. Without getting into details on the configuration and how to get started I want to spend time on the proper Logger initialization and use for exception handling.

Log4J Logger

As described in the Logger API we can get our Logger initialized inside the class in one of several ways the most common of which are:

- using the Class object

Logger log = Logger.getLogger(getClass());

- using a string

Logger log = Logger.getLogger(getClass().getName());

or

Logger log = Logger.getLogger("com.java.foo.MyClass");

Once we have a logger instance we can easily log messages with different threshold:

Foo foo = new Foo();
log.info("Created object foo: " + foo.toString());

or

if(log.isDebugEnabled())
{
	//do something
	log.debug("Result: " + foo.getResult());
}

Exception handling

It gets more interesting when we get to exception handling. In the regular try catch scenario we usually deal with some exception where we want to collect some output about what happened and where. A lot of times developers are tempted to use exception.getMessage() which is often empty or yet worse call exception.printStackTrace() which actually prints to the standard output rather than our log file. In order to successfully print the exception message and the stack trace we can add the exception to the logger output by doing this instead:

try
{
	computeInterestRates();
}
catch(Exception e)
{
	//something went wrong - log an error
	log.error("Error during RateCalc: ", e);
}

Conclusion

It is easy to get lost in requirements and miss on some of the essential product functionality. The proper use of logging helps reduce and eliminate defects in the lifecycle of the software and be a life saver in the long run. Make sure that you properly handle all logging. Keep in mind that the overuse of logging has a detrimental effect on performance so use it sparingly. For more information see the Log4j Official Documentation.

Caused by: java.lang.LinkageError: loader constraints violated when linking javax/activation/DataHandler class

Translation: This is typically caused to be thrown when two different classloaders load different versions of the same class (different signatures). The underlying cause is essentially including two versions of the same class in your CLASSPATH. Most often the underlying reason is including a JAR file as a dependency in your WAR or EAR which is already included as part of your Servlet Container (my development container happens to be JBoss) or your JVM.
A quick search on findjar.com established that my problem is caused by activation.jar which happens to be included both in my project and the JBoss lib. A quick way to verify this is to extract the EAR or WAR file and have a look for the jar question. In my case I was able to find it in both WEB-INF/lib and JBOSS/lib. A quick fix or a proof of the solution is simply removing one of the instances. For me removing the jar from the EAR proved to be the solution.
Since I like automation when it comes to dependency management I am using Maven to alleviate all the hassles of the manual equivalent. That means that I need to trace which of my build modules includes the jar in question. This is done by building the Maven dependency tree:

mvn dependency:tree

or tunnel the output to a text file which you can examine in your favorite editor (recommended)

mvn dependency:tree > tree.txt

Here it’s worth noting that the dependency feature parameter “outputFile” is not working at the time of writing due to a known bug. After building and searching the tree I can easily identify all the references: javax.xml.bind and javax.xml.ws
Now in order to fix the problem all I need to do is provide the exclusion to both dependencies in my pom.xml:

<exclusions>
<exclusion>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
</exclusion>
</exclusions>

Now my dependency looks like this:

<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.0.3</version>
<exclusions>
<exclusion>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
</exclusion>
</exclusions>
</dependency>

Before I run a full build it’s best to verify that there are no more references of activation.jar in my tree by creating the dependency tree again. With that out of the way I am ready to build and deploy my EAR to test the solution. For more on maven dependency mechanism and managing exclusions please refer to the Maven documentation.

To help clearly define and put the focus of it’s customization effort Google renamed the ‘Personalized Home’ page to iGoogle. Along with that came some new features which were along the lines of the rest of the Web 2.0 world: personalization with the portal feel while being able to aggregate all Google features like web, images, mail, calendar, maps, news and more. The concept of taking full advantage of localization, syndication, collaboration and bringing more web to the user by having gadgets really took off and has proven to be the fastest growing company product for 2006.

One thing that really stands out about the platform is that it has almost no learning curve and it allows the user to define the boundaries within which it will be used. A user is easily able to use the service without even signing up with an account (using cookies) but if you want to take personalization to the next level you can sign up and use it on multiple computers, customize it even more and bring social networking in the picture. Adding the ability to collaborate (discuss stocks or share documents for examle) and get updates about your friends’ photo album or new widgets that they have added is like taking all the applications you use, putting them on the web and running a cross layer of social networking to form something bigger than the sum of its parts.

The widgets concept is great and while it still has some rough edges it definitely provides a great start for organizing a dashboard with customizable layout and content spread on optionally multiple tabs. The rich library of existing widgets will satisfy almost any taste and even for the pickiest users there is an opportunity to create their own widgets by using the Widget Maker feature which provides a nice widget API (more on that in my next post). While talking about customization I can’t help mentioning the themes which offer the extra touch of personality. Unless you are one of these boring people like me you might want to pick one of the many themes which nicely change the default white frame and add the extra touch of personality without taking away from the content. As a new addition Google has even gone a step further including the so called Artist Themes which represent the artwork of world class artist.

In conclusion iGoogle introduces a new way of looking at web + search and re-defines customization with features like location-based personalized search. This direction will be very important for Search 2.0 as it reaches more and more mobile devices. On the other hand a lot is left to be desired in improving the functionality of widgets: creating anything different than the boring RSS or a poorly styled functionally handicapped widget.

While DVD was great while it lasted and marked one of the greatest successes in the history of consumer electronics it was clear that its days were numbered. The standard definition that DVD had to offer was not enough to satisfy the likes of Hollywood. With technology racing at an unimaginable rate and HD video and audio reaching living rooms around the world the world for the next generation high definition format was started. That is a round 2 for Sony and the long forgotten Betamax Vs. Video Home System (or VHS as we all know it) for standard domination. The last time around Sony’s Betamax lost the battle despite being technologically superior. Better quality had recording time as a trade-off. The majority of consumers did not want to commit to a standard and movies were offered for both. Unlike this time the battle continued much longer and finally VHS’s dominant market share, higher recording capacity, and lower media costs forces Sony to pull out. Well, apparently the folks at Sony have learned a few lessons. Although Blue Ray still has a higher cost and the early momentum that HD DVD generated this time we have a much more competitive product. Starting with much higher capacity [50Gb for a dual layer compared to 30Gb for Toshiba's HD DVD] Blue Ray seems technologically superior. This time Sony took a different approach and overcame the somewhat established HD DVD lead by spending most time and applying pressure to the movie studios themselves. The tight competition forced studios to offer movies in one format or the other but not both. Same was valid for manufacturer support where Blue Ray had better success. All the success could also be partially credited to region coded support and better digital right management and copy protection. At the end it came down to Warner Brothers followed by Wal Mart who joined Sony and agreed to offer movies exclusively in Blue Ray. While those two add just one more to the count they represent 80% and 32% respectively of the market share in their industry which makes the decisions huge. Toshiba knew that was a big sway on Blue Ray’s direction – it was more than they could handle. Disappointing signs from investors forced the giant to discontinue the efforts to revive the initial momentum and under such pressures Toshiba made a press release announcing the end of the Blue Ray Vs. HD DVD war. Although Sony was ready for a long battle it can now claim the victory.

The score is not 1:1 and the question “Is <insert movie> coming to Blu-ray?” in section 4.3 of the Blue Ray FAQ much easier to answer. Lesson learned for Sony – what goes around comes around.

After a couple of days researching what exactly Google Apps has to offer and countless hours of searching for feedback from people with first hand experience on the matter I decided to bite the bullet and pull the plug on my good ‘ol mail server. My main motivation was the fact that i can try it for free and even continue using it for free as long as my domain met certain criteria. On top of that Google provided me with scheduling and collaboration tools using a one-size-fits-all approch. At that point I had heard enough and was ready to get my hands dirty with Google Apps or at least as dirty as a keyboard, mouse and 2 hours of my free time will allow. But before I continue sharing my adventure I wanted to share some of the pros and cons of using Google Apps.

Pros:

Most apparently you get a nice, production grade Gmail email service with a 99.9% uptime promise, backups, security, spam filters, web inteface people are familiar with.

Cost. The cost of the implementation and the ROI is very low (50$ per user per account per user – that excludes aliases and lists) for the Premier edition and FREE for the Standard version. Compared to other combinations requiring some combination of software + hardware + support you get the most bang for your buck.

Ease of use. Needless to say nowadays it’s hard to find a person not familiar with Google’s Gmail and their slick and easy to use web interface. This makes the transition for any institution a breeze and the time spent in user training limited.

Ease of administration …administration? What’s that? No, but honestly adding users is a breeze as well as user aliases and list administration. Of course there is always more to be expected especially when it comes to granularity and the concept of groups but it is my belief that there is already somebody in cube scetching and coding that implementation.

Premium Edition FREE. If you satisfy certain requirements you can use Google Apps Premier absolutely free. Those include registered non-profits and educational institutions.

Built-in Security – Google uses secure connections and data redundancy. Through the use of protocols such as SSL and TLS you can make sure your data is protected. In certain situations this extra security can pose a problem with existing applications which make use of SMTP but don’t provide secure connection but there are possible workaronds.

Physical security – your data is stored on a server in a data center with top of the line protection from any natural events from floods and fire to earthquakes.

Calendar functionality by itself is a great feature which again most people use and are familiar with the interface from their personal accounts. The integration under the same umbrella comes handy and the Premier edition includes goodies like room and resource scheduling.

Great collaboration tools like document sharing, simultaneous editing, web publishing and chat. It’s hard to express in words the time savings and convenience when you see a combination of these tools in action – whether you have 20 people editing the same document or just want to send a message to somebody you have everything you need.

A free replacement for an Office suite. Although Google Docs was not created as a perfect replacement of applications like Microsoft Office in mind it provides most of the features most users are likely to use. Except the fact that Google really missed the memo on a presentation replacement application their solution focuses on collaboration, central data storage, and 24/7 availability.

More of the bonus features include: API, Single Sign-On solution, super easy email migration, support for email gateway

Cons:

Control. Well, of course by committing you have less control in the decision making process but you can try and then always switch to another solution

You get what you pay for. If you don’t have the Premier edition free support is to no avail. That means that you will have to spend time researching when problems arise and most likely end up paying when there is nothing you can do about the problems

Maturity. Be mindful that Google Apps is a project in progress and is not very mature. That means that it is incomplete and lacks certain functionality which you might expect.

Support …or the lack thereof is one important thing to mention. See, even if you use the premium edition and pay all the fees you can only get so much. Getting to talk to a real person is off limits and all the automated phone service refers you is help and forum URLs. Your only chance to get some personal attention is to use the ticketing system submit form and prey that your issue gets looked at pretty soon. Make sure you bookmark this page https://mail.google.com/support/bin/request.py?contact_type=bugs&ctx=bugflow_register08 as it will be your only point of contact with the Gods of Email.

Executables. Watch out for executable files – Google will not let them in even if you try to trick it by archiving it. Although sending executables through email is not a good practice as well as coaching your users to open executable extensions this can be a little annoying.

CSS. Not that this is exactly a very big deal for most people and they might as well never notice it but Gmail’s web interface will strip headers and almost all CSS from an email sent as HTML. For udnerstandable reasons they don’t want layout hiccups but some users can find that a bit inconvenient.

Privacy is a major concern for any organization especially when it has to do with sensitive company data and intellectual property.

Regulatory compliance. Before I continue any further let me just say that if your organization requires regulatory compliance of any sort which is often the case with certain branches of government, healthcare, and the financial industry you can automatically forget about it – Google Apps does not comply with the storage, transfer, filtering, privacy and disaster recovery requirements for those sectors.

Ads. When using the web interface you might have to see a couple of advertisements. Unfortunately the free edition does not have the option to turn them off but after all there is no such thing as free lunch.

SMTP limit. If you really read the fineprint you will know …or you will find out later that Google’s SMTP service has a restriction to send only up to 500 emails per day for a particular account. While this is enough for the average Joe in your office it might pose a risk if you are using any automated email services and notification in your organization. Again the workaround is using a separate SMTP server as an email proxy.

To get everything started we’ll prepare a web form in pure XHTML which submits the content entered by the user via POST submit to our script which will assemble the message and send it. Our script will utilize the PHP mail function so you will have that functionality enabled on your server in order to send email messages. In PHP this configuration is done in php.ini in a section called [mail function]. I am not going to get into great details but in short there will be three settings : SMTP, sendmail_from, and sendmail_path that you will have to configure. If you are configuring a Windows machine you would want to set the SMTP section to your outgoing SMTP server whereas UNIX and Linux users will have to set sendmail_path to make use of the sendmail program unless you don’t have sendmail installed or will prefer use SMTP anyway. In either case sendmail_from will refer to the email address that will appear as the default in the from section.

Getting Started:

In order to make it easier for the user to create messages from scratch we’ll provide an XHTML form with the following fields: email (that will be the sender’s email), subject, text content, and html content. Alternatively you can provide a field for the recipient(s) email but for spam purposes our public form will not utilize that. You can easily refactor it and provide that functionality by adding a single field.

<input name="email" size="20" type="text" />
<input name="subject" size="20" type="text" />
<textarea cols="40" rows="10" name="messageplain"></textarea>
<textarea cols=40 rows=10 name="messagehtml"></textarea>

Here is the full XHTML page with the form. Please ignore the plain styling – you can easily override the CSS and create some fancy styling. I will strongly suggest if doing that to get everything working first.
As you can see our form element uses the POST method and submits to the next part of our discussion: the mail.php document containing our message assembly and submission code
<form action="mail.php" method="POST">

Now let’s look closer at what happens behind the scenes and how our message gets processed. To be able to successfully accomplish our goal we need to examine the anatomy of an email message. An email consists of three components:

• the envelope – includes routing information for your message and is used by the MTA to transfer your email over the network. Typically you don’t need to be concerned with the envelope as it is not visible by the user.
• the headers – the headers are the most intererting part of an email containing processing information. Some are mandatory: Date From, To, (or BCC) while others are optional: Subject, Cc, Reply-To, Received, Message-Id.
• the message body – this is the section with the actual content of your email message. The body is separated from the headers by a single blank line.

First we need to create our mail headers correctly. Let’s look at an example of what our headers need to look like:

From: <admin@nedkoko.com>
To: <recipient@domain.com>
MIME-Version: 1.0
Content-Type: multipart/alternative; boundary=”fU3W4Vzr4G3D54f3″

Keep in mind that this is a simplified version of the headers but it works great for the purposes of our demonstration. Note that for content type “multipart/mixed” is used to send messages with different Content-Type sections (usually attachments) but for our purposes we want to use “multipart/alternative” which signifies different (“alternative”) versions of the same content.
Ok, now that we know what our headers need to look like we can start our form processing by extracting the content from our submission:

$email = $_POST['email'];
$to = 'nedko1@yahoo.com';
$subject = $_POST['subject'];
$messageplain = $_POST['messageplain'];
$messagehtml = $_POST['messagehtml'];

Now that we have our form content we need to create our boundary for separating the different parts of the message. A good way to do that is to use some kind of hashing which will guarantee uniqueness and will be different for each message. For that purpose i decided to use and MD5 hash algorithm applied on the current timestamp. That will satisfy our requirements and provide a 128bit value we can use for separation.
$mime_boundary = "----=_NextPart_X[".md5(time())."]";.
Let’s proceed next with creating a nice little header based on what we have so far:

$headers = "From: <admin@nedkoko.com>\r\n".
"To: <".$to."> \r\n".
"MIME-Version: 1.0\r\n" .
"Content-Type: multipart/alternative; ".
"boundary=\"".$mime_boundary."\"\r\n";

As you notice the “boundary” is not a separate header as it’s not separated on a new line as the specs require. That is because it is considered as a part of the “Content-Type”. It’s time to pay more attention to our actual message which will follow our headers separated by a blank line. Since we have multiple sections of our message body we will start each section with “–” followed by the boundary, followed by the content type and encoding. As we have two sections: text and HTML versions we start with the text:

“–”.$mime_boundary.”\r\n”.
“Content-Type: text/plain; charset=\”utf-8\”\r\n”.
“Content-Transfer-Encoding: quoted-printable\r\n\r\n”.
$messageplain.”\r\n\r\n”.

Then we do the same with the HTML version. Again we provide “–” with the boundary, content type and then the encoding:

"--".$mime_boundary."\r\n".
"Content-Type: text/html; charset=\"utf-8\"\r\n".
"Content-Transfer-Encoding: 8bit\r\n\r\n".
$messagehtml."\r\n\r\n".

Looks like we are finished with both versions of the message so now we have to wrap it up and specify that this is the end of our body content:

"--".$mime_boundary."--\r\n";

Note that the end is demarcated by “–” both in front and after the boundary, making if different from separator between different parts of the body. Finally, we can apply some basic form validation (optional but recommended) and call the mail function to process our mail request. It is important to mention that the mail function can be invoked with @ in order to suppress any errors it generates. Even better it returns a boolean value specifying if the message was successfully sent so we can then include some extra logic to provide feedback to the user.

if (mail($to,$subject,$message, $headers))
{
echo "<h4>Your message was sent successfully. </h4>";
}

Mission accomplished! Here you can download a zip of the full mail.php as well as see the full working version in action here. Hope this quick introduction has shed more light into email message formats and specifics of MIME.

I cannot quite recall the first time I sent an email except that for all I know it was a long time ago and that it’s only intent was to notify its recipient that I had actually embraced the cyberspace. It was a time when having an email address was a privilege, not a right and 1200bps modems where top of the line. In today’s world I would be quite astonished if somebody told me they don’t have an email. In fact I will be even more surprised if they told me that they have an email which they don’t use on a daily basis to conduct personal and business activities but merely for the purpose of having one.

Today as email becomes more popular than traditional mail we send plain text emails, HTML emails and even rich media emails containing Flash. While the good old plaint text emails were easily readable they were ugly to say the least and not quite well organized as far as data presentation is concenred. With all the advantages that HTML layout and presantation brings to the table come some caveats: even if we assume that all your recepients will be able to see the content (if they have HTML enabled) we can’t be quite sure how it will look on different mail clients due to a number of reasons. The solution: Multipart emails.

What is the Multipart MIME?

The Multipart mime content is just another fancy term for providing more than one version of your email. In reality MIME stands for Multipurpose Internet Mail Extensions and was created as a standard to extend the existing one and provide support for [you guessed it] among other things support for multipart message body, non-text attachment and non-ASCII (e.g. UTF8) character encondings. The way multipart content works is by specifying a boundary in the “Content-type:” header of your email. The boundary is used to separate the different content types and looks something like this:

Content-type: multipart/mixed; boundary="fU3W4Vzr4G3D54f3"

There are no rules as of the content of the boundary but as it must not occur in any of the parts of your message content is usually a randomly generated sequence of numbers, letters or combination of both in order to guarantee uniqueness and differentiate from any possible dictionary words. So as you start your message each data type section is separated by “–” followed by the boundary sequence and the content type + encoding. After the last section “–” followed by the boundary followed by “–” is used to delimit the end of the message. Here is an example of a complete message:

MIME-version: 1.0
Content-type: multipart/mixed; boundary="fU3W4Vzr4G3D54f3"

This is a multi-part message in MIME format.
--fU3W4Vzr4G3D54f3

Content-type: text/plain; charset="utf-8"
Content-Transfer-Encoding: quoted-printable
This is the body of the message.
--fU3W4Vzr4G3D54f3

Content-type: text/html; charset="utf-8"
Content-Transfer-Encoding: 8bit

<html>
  <head><title>A HTML email</title></head>
  <body>This is the body of the message.</body>
</html>

--fU3W4Vzr4G3D54f3--

Note that for demonstration purposes we’ve oversimplified the HTML. In a real environment you would want to be as explicit as possible and provide a doctype for your HTML document as well as follow the guidelines as much as possible to ensure uniform rendering across engines.

Some useful tips

So far so good! Now that we are familiar with how the multiheader MIME emails can help you ensure that your message will reach its intended audience we need to spend some time and pay attention to some specifics of formatting.

• Keep it simple – concentrate on your content rather than sophisticated presentation. Focus on your message! As far has the HTML is concerned – don’t get too fancy and code a very simple, old school webpage.
• I can’t stress enough how important HTML formatting is but I want to reiterate that you need to be very careful and make sure to create valid, well formatted HTML. To ensure the quality of your code and the proper rendering I will suggest that you use a professional tool like Dreamweaver of Frontpage or an online validator as the one from the W3C. Of course in addition to that I will suggest testing the rendering in different browsers and email clients to avoid surprises.
• Along the same lines you will need to set an online version of the HTML document and include a link with the URL in the beginning of both the plaintext and HTML versions. This will ensure that your recipient can open the message in a browser if there are any rendering problems, the content is blocked by a spam engine or if the plaintext version is just not good enough. This comes quite useful as usually the purpose of your message is to get the recipient to visit the website and start some sort of interaction.
• Use tricks like capitalizing the headlines and spacing or underlining for distinguishable headlines and section separation. This can be very helpful for plaintext emails as they can often be hard to read.
• As usually spam blockers often prevent some of the images from displaying be careful and don’t overuse images for messages. For all images provide good ‘alt’ attribute description for the content of the image in the cases when they are not shown.
• Webmail based services are more than likely going to slightly modify your code so be prepared to have tags like DOCTYPE, BODY, and HEAD to be stripped. That’s expected as understandably those elements have the chance to interfere with their site.
• Avoid sophisticated designs requiring high width as a lot of the client email preview windows will be just a few hundred pixels wide.
• Don’t rely on heavy use of CSS styles as almost 90% of the time they will get stripped. That’s especially true for services like Hotmail, Yahoo Mail, and Gmail as your CSS has a chance to override their own styles.
• Tables are your friend. Really! Use TABLE tags to position the content within your web page. Go back to basics and rely on what’s proven and working across different rendering engines.
• Work with a carefully selected vocabulary. That’s especially true for words you include in the title as they are very likely to stand out when examined by the spam filters.
• Keep your message short. Remember that multiplart MIME emails technically double the length of your email so while they work great for relatively short emails
• Test, Test, Test – That’s really the safest way to make sure that there won’t be surprises. Apart from not accomplishing your goal you are running the risk to loose credibility with your audience.

NEXT: see an example on how to create a multipart MIME email web form in PHP (…coming soon)

Resources:

Mime
Sending both HTML and plain text emails
RFC2045, RFC2046, RFC2047, RFC4288, RFC4289, RFC2077

The Space Shuttle is used by the US government for human spaceflight missions and is designed with the goal to carry astronaut and load such as satellites and modules to the International Space Station. It was first launched on April 12, 1981 and is still in use to present day. Originally six shuttles were built but as the Enterprise was not designed for flight only five were deemed spaceworthy. As Challenger and Columbia were destroyed in takeoff and reentry disasters only 3 currently remain: Discovery, Atlantis and Endeavour. More information about the space shuttle and it’s structure you can find here.

Apart from being just a vehicle the shuttle program is a medium in establishing world peace and cooperation.Long gone are the days when space was considered solely expressions of patriotism and competition in the arms race in the Cold War. The shuttle is the main vehicle for transporting modules and equipment from and to the space station. Today the International Space Station (ISS) is the biggest space laboratory known to man and hosts technology and personnel from all over the world. And with STS 120 a new record is set – for the first time in history of space exploration two women are in charge of two spacecrafts at the same time as Pamela Melroy is calling the shots on Discovery and ISS commander Peggy Whitson.

But as high tech as it is some of the design and technology used for the original construction is aged and obsolete and therefore often compared to an old car. Due to safety concerns and a way to provide a honorable retreat for the shuttle NASA has decided to move on. Unfortunately the time and resources needed to maintain and keep up to date with technology are overwhelming and the point was reached to where it’s not worth it. While NASA has announced the retiring of the Shuttle program in 2010 which will be replaced by 2014 by Orion a new age in space exploration is marked. Partly with pride and honor and partly with sadness humanity gets ready for a shift. Not simply a shift of technology but a shift of evolution and creativity of mankind. To honor those who believed, those who dedicated their life and those who lost it I would consider attending a space shuttle launch as one of my top 10 on the TO DO list.

Style and Design – be attractive

This is the start of any successful and even decent blog. In order to attract visitors and eventually regular readers you will need to start with the basics – the building blocks. Regardless of whether you have a custom solution or a hosted blog somewhere it is really important early on in the game to start with clean, organized, and well styled blog which is easy to read. This first step will improve the usability and will help boost your credibility as a content provider. To read more on usability visit Jacob Nielsen’s website. Furthermore you can use one of the thousands of ready templates available online or create your own.

Content – it’s all about what you have to offer

In order to best serve your visitors you need to provide the right content. One way is to target specific audience by providing specialized information. That will be your niche and most of your readers will be return visitors interested in that topic. Another approach will be to provide original content or opinions on something widely publicized. When providing content make sure you are not ‘borrowing’ somebody else’s thought and ideas. Here is a list of the 12 DOs and DON’Ts with regards to copyright.

Know your audience – the customer is king

In order to be a successful blogger you will need to possess qualities like dedication, passion and endurance. Remember that blogging is not a sprint but a marathon and only the fittest survive. Therefore getting familiar with your traffic is your responsibility. Start by using some of the available tools to obtain data and measure key statistics about the people visiting your blog. Who are your visitors? Where do they come from? How do they find your content? What do they read and how long? How many repeating visitors you have? Answering questions like these can be crucial to being successful. A simple example will be knowing how many people are subscribed to your RSS feeds. In order to obtain traffic data use one of the numerous tools like Google Analytics, Feed Burner or your web server stats (here is a tool for Apache)

Arm Yourself – use all the tools at your convenience

Use the tools that will help you improve your site and make it easily accessible. For a starter you can make your blog URLs more user and search engine friendly by using permalinks. This makes your pages easier to remember, bookmark, and find by search engine. Here is a short permalinks guide for WordPress. Another great think that you can use to your advantage is to provide RSS feeds of your blog. This can be done either independently or linked through Feed Burner for advanced capabilities and tracking purposes. For added value or “bonus points” so to say it will be nice to include podcasts and/or videos to your blog. And if you still have not had enough you can include to your blog the rest of the bells and whistles out there – featured article plugins, social bookmarking tools like links to del.icio.us, Digg etc. You can also take the initiative and post your blog on any of those sites and even more (BlogsOfTheDay, Technorati and others).

In Conclusion…

In conclusion I want to re-iterate by saying that i can’t possibly stress enough how important following the rules above is to your final success. As simple as those basic directions might seem they are very often ignored or followed wrong. Remember: create a welcoming blog, be original and creative, don’t steal other people’s content, get to know your audience, use all the tools that can possibly help you attract more readers. Make sure you keep the two-way communication with your readers by providing feedback to their comments and repsonding to emails. Feels free to add more to the topic by posting comments below. Happy Blogging!