As a professional SEO I know how important links are to achieving rankings from Google. As such, I know the temptation to find a link in any place you can in order to achieve your desired SEO results. For some people, this means trying to build links through blog commenting. For others it means using automated software to build a massive quantity of blog comments with the hopes that some of them will give their webpage authority in Google’s eyes.

Because of this, a couple years ago, Google rolled-out the nofollow tag. When you add this parameter to your link, you are telling Google that you are not vouching for the site at the receiving end of the link. Although some say the nofollowed link still passes value, most agree they nolonger do.

This created a demand for dofollow blogs- blogs that do not automatically add the nofollow attribute to links- so the blog comments can pass authority to a website they are linking to. This created a demand for websites that list dofollow blogs. Some developers even created WordPress plugins (since it is one of the most popular blogging platforms) that specifically offers blog commenters dofollow links, such as Link Love or CommentLuv.

Of course, the goldmine for any SEO doing blog comments for links is an auto-approve, dofollow blog. This not only gives the authority for the link but bypasses the pesky and slow process of manual approval.

All this is done in the hopes of building some links, to pass authority to a website, with the hopes of improving the receiving site’s rankings in Google. The blog commenting for link building is a risky SEO tactic, but many still do it- whether manually or using specialized blog commenting software.

Since so many people still think this is valuable enough to keep doing, I’m going to make this blog post a repository for blog comments. I will approve every blog comment for this post- whether automated or manually submitted. Some of them will be funny. Some will be sad. All will be an interesting look into the measures some SEOs will take to improve their rankings.

Update: I think this post attracted a swarm of spambots- which have overwhelmed me with hundreds of comments. I understand that I was asking for it but nothing I did seemed to solve this problem. Then I installed the GrowMap Anti-Spambot Plugin. It was solved almost immediately!

Help me out with a couple comments (or even a Re-Tweet) and you might just get a little reward!

I used the b2evolution program for over 5 years now but recently migrated over to WordPress.

If you would like to make this same migration, I would like to offer my experience as services to you. As a professional SEO I can offer further assistance to take your b2evolution website to the next level.

Pay for these services can be negotiated on a case-by-case basis. Payments can be accepted by snail mail or online through PayPal.

I am investigating the benefits of connecting this blog to technorati.com. I’ll keep you informed if I think this is worth the time.

WK4VB2YRRCGX

The big announcement Wednesday about Google integrating Twitter updates into its search results has made me wonder how this might affect natural search. It all depends on how they include Twitter in the results.

Clearly this is an attempt to make its results more time-relevant. Lots of electrons have been used to describe what Google did when Michael Jackson died- so many people searched for news that Google thought it was a malware attack and started blocking anyone searching for “Michael Jackson”. Meanwhile Twitter, who had recently added a search box to their homepage, emerged as a real-time search engine by keeping everyone informed with the latest information. Google has to integrate Twitter into its search results or it will not be useful or relevant in times like these.

As a matter of fact (and irony) a search of “Michael Jackson” in Google can give us a glimpse into how Google might include Twitter updates into its search results. Now your page might vary but here’s how my search looked:

The Google page started with a section of news stories, had a couple natural results, then included some videos and pictures, more natural results and finally a section for blogs and books about Michael Jackson.

Interestingly (has Google learned from their mistake?) the News results lead this query. News results do not always lead a search result. Whatever criteria Google uses to determine where the news results appear on a page could also be used to include Twitter updates.

In the same way Google has included pictures, videos, blogs and books in the middle of the natural search results. The point here is: Google could put a section of Twitter updates anywhere on the page it desires.

Between these categorical results are some naturally ranked pages. They fulfill all the conventional criteria to get ranked- keyword matched url (michaeljackson.com) and authority domains (wikipedia). Theoretically Google could rank a particular Twitter update as if it were a page in itself but this could be easily abused.

How ever Google includes Twitter results, it is clear that companies interested in ranking should also be interested in having a keyword presence on Twitter. Although the potential for abuse is clear, there will still be a legitimate interest in keeping your company relevant. Tweets that include keyword phrases that you want to rank for as well as SEO friendly re-directions will be very important.

No matter how Google integrates Twitter updates into its search results, if you are concerned with appearing in search results, you should sponsor FeedTwit.

I heard something about another search engine integrating Twitter updates into their results too. If you want to find out about that, Google it.

Can you think of any other ways Google might integrate Twitter updates into its search results? Please share them, below.

I am a huge college basketball fan so naturally this is my favorite time of the year. This is probably because I went to the University of Kansas- a school who’s only coach with a losing record is James Naismith. My love of all things Jayhawk Basketball makes it hard to fill out my brackets in any objective way- somehow I always end up with Kansas winning the championship. That means I only predicted the national champion once since I was in Junior High School (the last time the Jayhawks won the National Championship).

This year I had to come up with a better method for filling out my brackets. Everyone has their own method- from considering RPI to team mascots- but I wanted to do something different. This year I used Googlefight to pick the winner. As I did, I learned a little about keywords and SEO.

Basically Googlefight compares two terms and determines a winner based upon the number of results that term comes up in a search. So, when I put in “North Carolina” vs. “Radford” naturally North Carolina came up with more results and thereby won. My theory was, the more people talking about a team the more likely that team would win. This would consider all important factors in an objective way- if a smaller school had a lot of buzz around it, it could trump another school, for example.

There came a problem when I got to some terms. Some were so broad they prevailed over others that the picks were rather silly. For example, “American” vs. “Villanova” resulted in American winning (actually, they almost did). Another problem cam up when I entered proper names for schools that never use them- everyone calls “Connecticut”, “UConn” for example. I knew I had to be more specific.

Since I was really wanting to measure discussion around a school’s basketball team I decided to narrow my focus (lengthen my keyword tail) to include “basketball” after the name of the school. I was afraid that using abbreviations for team names wouldn’t be accurate enough so I used the formal name of the school, excluding terms like “universtiy.” This resulted in preferring schools named on geographies rather than private schools because “Texas basketball” would consider any basketball related ideas within Texas. I think this was good (we will see) because schools recruit in their geography so if there is a lot of interest in basketball in that state, that school tended to win.

Some of the results were interesting. For instance, when I entered my beloved Jayhawks against my Dad’s alma mater- NDSU, the Jayhawks merely edged by. That’s exactly how the game felt! At the same time, no matter how I entered “American Univeristy” it always kept winning. This is because this term is so broad- and had I not made an exception to my method here, American would have won the tournament.

As of right now (Saturday afternoon) my method has picked 23 out of 33 games correctly and predicted some surprising upsets: Siena, Arizona, Cleveland State, Dayton, Texas A&M, Maryland, and Michigan.

Follow me on @dizzySEO to see how my brackets conclude. I will use the hash: #marchmadness.

This is a javascript program that will help its user track their progress as they read through the Bible in one year.

Features (preview or use):

• Multiple Reading Plans.
• Hints and suggestions on reading the Bible.
• Links to the www.biblegateway.com to read your favorite translation or listen to the chapter on audio.
• Multiple user interface.
• Helps if you get behind.

How to use:

• Download the yearly_bible.zip file and unzip it.
• Upload to your website OR use on your home computer. NOTE: the hyperlink Bible passages will call www.biblegateway.com, so be careful if you have dial-up.
• The “today.html” file is where you begin.

Previously, when I have written posts about RSS feeds, I have written them for non-programmers. After programming RSS feeds for a couple months now- primarily thanks to other people who have kindly posted their code on the web- I feel I owe the web and need to return the favor.

One day I sat down to do some programming when I discovered that one of my automated programs was throwing errors. For days it had been misbehaving (and in a way that I didn’t notice). Since my web host had enabled Apache Error Logs- probably because I kept blaming them for problems I had created- there was one error log that was a couple megabytes large (the errors were occurring every five minutes over a couple-day period).

One day- when I am a PHP whiz and stop forgetting to add semi-colons at the end of lines or start treating objects as they are supposed to be treated- I won’t have to worry about such things. Until then I needed a way to tell me something was going wrong that was independent of the program itself (because, in this case, it appeared to be functioning normally).

I consider myself a RSS evangelist so it was time to start preaching to myself- his seemed to be a good use of an RSS feed. Using the power of PHP I knew I could parse the error log and produce a RSS feed that would broadcast my errors to the world- or at least to me.

Step 1: Parse the Apache Error Log
I first had to read the log file. The file is composed of any number of error messages in a standard format. For example (file names and directories have been changed to protect the innocent code):

[23-Mar-2009 22:04:09] PHP Parse error: syntax error, unexpected T_ECHO in /home/davidzim/public_html/your_mama/error.php on line 8

All I had to do to get at each item was to read the file contents into an array:

$lines= file("error_log");

And iterate through the array with a foreach loop:

foreach($lines as $line) {


You will notice the date is always in brackets and exactly 20 characters long. It was easy to strip this out of the line

$date= substr($line, 1, 20);


The rest of the line- the error message itself- could then be read:

$desc= substr($line, 23); // adding two spaces for the brackets and one for the space


Now I have a date for each error and the error itself. All that came next was to format this into a RSS feed

Step 2: Creating a RSS Feed with PHP
This is where things seem a little more hairy but really they are pretty simple.

A RSS feed is simply an XML formatted file following a specific format. I like the RSS 2.0 Specification. There are certain elements that are required and others that might be helpful to add.

The basic information every feed needs is a <title>, a <link> (home page for the link), and a <description>. Another helpful element is the <lastBuildDate>. These nodes are all children of the <channel> node which is a child of the <rss> root.

I have found that it is easy to create an RSS feed in PHP if you use the DomDocument objects available in PHP 5. All you have to do is create a DomDocument object (in XML 1.0):

$doc= new DomDocument('1.0');

and then begin to add children to that node. Like I mentioned the root node of this XML document is <rss>. You must create the element and append it (as a child) to the document:

// create root node
$root = $doc->createElement('rss');
$doc->appendChild($root);

Since we are working with RSS 2.0, we need to add an attribute to that node stating the version is “2.0″:

$version = $doc->createAttribute('version');
$root->appendChild($version);
$text= $doc->createTextNode('2.0');
$version->appendChild($text);

Although technically each RSS feed can have any number of channels, I have never seen a feed with more than one <channel>. It is a child of the <rss> root:

$channel= $doc->createElement('channel');
$root->appendChild($channel);

Next the <channel> node gets its children. Its children start with information about that feed as a whole- a <title>, <description> and a <link>. A <lastBuildDate> can be useful as well:

// nodes of channel
$info= $doc->createElement('title');
$channel->appendChild($info);
$text= $doc->createTextNode('Error log for '.$url);
$info->appendChild($text);
$info= $doc->createElement('link');
$channel->appendChild($info);
$text= $doc->createTextNode($url.'error_log');
$info->appendChild($text);
$info= $doc->createElement('description');
$channel->appendChild($info);
$text= $doc->createTextNode("This is the apache error log for $url");
$info->appendChild($text);
$info= $doc->createElement('lastBuildDate');
$channel->appendChild($info);
$text= $doc->createTextNode(Date('r')); // now;
$info->appendChild($text);

In this above code I reference a variable called $url. I could have simply hard-coded the URL into this document, but instead I wanted this script to be dropped into any directory and report on the error log of that directory. To do this I just had to access the SERVER variable at the beginning of the script:

$url= 'http://'.$_SERVER['HTTP_HOST'];
$url.= substr($_SERVER['REQUEST_URI'], 0, strrpos($_SERVER['REQUEST_URI'],'/')+1);

Next comes the items for the feed. Naturally I want each item to be a line from the error log. This is where we iterate through the error log (as in step 1) and read the lines of the error log into items. Each item is a child of <channel>:

$item = $doc->createElement('item');
$channel->appendChild($item);

And each <item> has children of its own. According to the RSS 2.0 specification, the only thing that is required is either a <title> or <description>. Commonly feed items contain both. They usually have a <date> for the item.

Since it’s good practice to have both a title and description, we can’t just read the non-date information off the line, but a little more parsing is required to make two different elements. I noticed that there is a basic error description that follows the date on each line of the error log. This basic error description is followed by a colon and two spaces. That phrase will become my <title>. For the description I decided to simply take the entire line of data. I convert the date into a usable format (with my favorite PHP function: strtotime()) and add these nodes to the <item> node using a foreach loop:

// title is the phrase after the date and before the colon and two spaces
$child = $doc->createElement('title');
$item->appendChild($child);
$first_colon= strpos($line, ": ", 23);
$title= substr($line, 23, $first_colon-23);
$value = $doc->createTextNode($title);
$child->appendChild($value);
// the description is the entire contents of one line from the error log
$child = $doc->createElement('description');
$item->appendChild($child);
$value = $doc->createTextNode($line);
$child->appendChild($value);
// the pubDate is printed between the two brackets and always 20 characters long
$child = $doc->createElement('pubDate');
$item->appendChild($child);
$date= substr($line, 1, 20);
$value = $doc->createTextNode(date('r', strtotime($date)));
$child->appendChild($value);

One important note: RSS feeds publish items from the most recent to the oldest items. The error log adds new items to the end of the file. Before we read the items into the feed, we need to reverse the order of the items in the array. We can simply use the array_reverse() function, when we read the file into an array at the beginning of this script:

$lines= array_reverse(file("error_log"));


Finally, we write out the nodes of the DomDocument and we have a working RSS feed publishing our error log:

echo $doc->saveXML();


Apache Error Log RSS Feed in PHP (script in its entirety)


/* Script by David Zimmerman

$child = $doc->createElement('pubDate');
$item->appendChild($child);
$date= substr($line, 1, 20);
$value = $doc->createTextNode(date('r', strtotime($date)));
$child->appendChild($value);
}
echo $doc->saveXML();
?>


There’s a lot going on here, which is why I have to use the Feed Validator to make sure everything is running smoothly.

You could always improve this script. You could add caching so that every time this script is called by a feed reader, it doesn’t have to read your file again. You could add a <guid> child to the <item> node to designate each item as unique (something the Feed Validator recommends). You could also add a “no error” item every so often to reassure you that the feed is still working and there are no errors in that directory.

What makes this really cool is in how you could receive this feed. You could send the feed to your cell phone as text messages (although beware you could get a message every five minutes if the same problem I had happens to you) or simply through your favorite blog reader. There are many different ways you can receive a RSS feed.

One thing I don’t know about is security. Am I giving out intelligence to hackers by telling them I have error logs enabled? Am I making it worse by giving them a RSS feed to my error logs? (Notice I don’t tell you where to find my error log feed as an example) If you know about such things, I would appreciate your comments.

Did I overlook anything? Am I unclear or just wrong in any of my descriptions? Do you see a way this script can be improved? Then leave a comment below.

If this script is useful to you, subscribe to my RSS feed and you might find more helpful posts like this one.