Google Reader provides you with a nifty tool to help you do this. With the “Share” feature of Google Reader, you can easily syndicate a list of articles that you recently read and found interesting.

Get a Google Account: Start Reading

If you don’t use Google Reader – or another feed reader – start using one. Until you use RSS feeds on a daily basis, you’ll never know how wonderful they are, and you’ll never know how much your readers may come to rely on them.

Once I decide I like a site, I generally read it through Google Reader. If an article is interesting, I’ll click through to the site and comment on it. Other than that, I rarely go back to the site. Without the RSS reader, I’d probably never return to the site at all.

An RSS reader is a great way to collect relevant readings into one location – so you can sit there with your cup of coffee and read all of the new stuff out in the blogosphere. You can then decide what is important enough to comment on (on someone else’s blog) or respond to (on your own blog).

Share Items – Creating Your Own Feed

With Google Reader, there is a cool “Share” feature. At the bottom of the article you are reading, there’s a list of options – “Add Star,” “Share,” “E-mail,” and “Mark as Read.”

By choosing the “Share” option you are adding that article to a publicly viewable list. That list also generates its own RSS feed – which makes it easy for you to syndicate the feed on your own site. By doing so, you provide your readers with a list of articles that you recently read and found interesting.

It’s a more targeted and stable than a standard RSS feed that just shows every headline from a given website – which will hopefully make it more useful for your readers.

Grab the Widget, Style Yourself

This feed is available in a standard rss xml file. You could use SimpleXML to parse the feed and display the information yourself. Or, you could use the ready-made widget that Google provides.

The Google widget uses Javascript to access the information while your page is loading. This potentially stops your page from hanging if the Google server is not responding – the rest of the page can load while the RSS feed is updated. You can find this widget by clicking on the “Your shared items” link in Google Reader and clicking on the “put a clip of your shared items” link.

The only problem is that the pre-designed styles don’t offer you a lot of options for making the list blend in with your site’s theme. My suggestion would be to select “None,” for the color scheme. You may also want to leave the title blank, and add your own title to the feed.

If you do this, the feed will be generated with the following HTML. Note: This example uses the “Show item sources” option.

<div id="readerpublishermodule0" class="reader-publisher-module">
  <ul>
    <li>
      <a class="i" title="Good for Hunters, Bad for Druids" href="http://4thehorde.wordpress.com/2008/04/25/good-for-hunters-bad-for-druids/">Good for Hunters, Bad for Druids</a>
      <div class="s">from <a href="http://4thehorde.wordpress.com">For the Horde</a></div>
    </li>
    <li>
      <a class="i" title="Bornakk: Druids Not to be &quot;Big Green Blobs&quot;" href="http://feeds.feedburner.com/%7Er/Resto4Life/%7E3/279629927/">Bornakk: Druids Not to be "Big Green Blobs"</a>
      <div class="s">from <a href="http://www.resto4life.com">Resto4Life</a></div>
    </li>
  </ul>
  <div class="f"><a href="http://www.google.com/reader/shared/user/18391951200330501918/state/com.google/broadcast">Read more...</a></div>
</div>

By taking a look at this example HTML, you can easily style the widget yourself.

The entire thing is contained in a div with class “reader-publisher-module.” Each headline is contained within its own “li.” If you use the option to display the source of the article, it’s in a div with class “s” inside the list item.

My one gripe with Google Reader is I can’t create multiple shared lists. For example, I’ve divided blogs I read into ones related to web development and ones related to World of Warcraft. I’d love to be able to create a shared article list for each topic, so that I can syndicate each one on a different website.

If you want to see this in action, check out my World of Warcraft blog, Rolling Horde. It’s on the right hand side, in the middle column, underneath the recent articles.

There are a few things you need to keep in mind while writing an XML document, or else the RSS reader will not be able to understand it. It’s better to think of writing XML as writing code than text, because there are some strict syntax rules you need to adhere to.

Balance Opening and Closing Tags

One strict syntax rule of XML is that opening and closing tags must be balanced. For every opening tag, there must be a closing tag.

<item>
  <description>
</item>
 
<item>
  <description></description>
</item>

In this example, the first item element is invalid – because description has no closing tag. The second example is valid, because description is closed. You could also use a self-closing tag if description doesn’t contain a value.

<item>
  <description />
</item>

With a simple feed, it can be easy enough to keep tags balanced. However, it’s a good idea to look into using an XML parser like SimpleXML to build the feed. This ensures that the tags are balanced and that the XML is well-formed.

Ampersands Are Not Allowed

The lovely ampersand – & – is not allowed to appear in an XML document without being escaped (&).

If a browser or feed reader encounters an ampersand that isn’t escaped and that isn’t being used to form a valid entity, the application will simply stop reading. You might overlook this possible problem if your URLs use query strings – and thus have ampersands inside them.

The solution is to escape all of the URLs and data that is going into your feed. The reader will convert & back into & so that your links work correctly. PHP offers a function to help you do that.

$escapedText = htmlentities($unescapedText);

Pass all of the text that needs to be escaped (like your URLs) through the htmlentities function, and your problems will be solved. Incidentally, this will also escape > and < characters.

No Non-Breaking Spaces!

The final tip deals with invalid entities, like  . As mentioned before, ampersands are a strict no-no. They can be used to form entity codes, but they cannot be used by themselves.

If you attempt to create an entity that the XML processor doesn’t recognize, it won’t read it as an entity – it will read it as an ampersand with some text following. For example, &bob; would be read by an XML processor as an ampersand and the word “bob;”.

It would then promptly stop processing your feed.

One common way for this to break your feed is the non-breaking space character –  . These often serve no purpose in the document, but you might get them littered around your source code if you use a WYSIWYG editor.

You could get rid of these by filtering your output through a function that does a str_replace of   with ‘ ‘.

If the non-breaking space character serves a purpose in your document, you can preserve it for the browser but make the XML processor ignore it. This is where CDATA comes in.

<description><![CDATA[This is a description with content that
<strong>shouldn't</strong> be interpeted
by the &nbsp; XML processor.]]></description>

When you wrap text inside that tag – <![CDATA[ and ]]> – you tell the processor to ignore the text and spit it out as is. This can help your non-breaking space character make it to the user. You may also want to use this if your descriptions and content include HTML tags.

Browse the Spec

These are a couple of tips to help you address some of the more common things that will break your XML documents.

However, there are many other minor errors you can come across. The only way to learn about them and solve them is through two things – research and trial and error.

You may want to take some time to browse the XML specification as well as read forums for problems that other people have. Then, test things out and find out what doesn’t work.

This article will look at how to build a basic feed of data – for our purposes, we’ll consider random quotes. It will also illustrate how to use SimpleXML to build the feed for us.

The RSS 2.0 Standard

RSS feeds, like XML in general, have specific standards. In order to be use-able across platforms, it is imperative that standard syntax and naming patterns are used. If you’re unfamiliar with the RSS 2.0 standard, you should look through a copy here.

Before we get to building the feed, let’s identify what tags we’re going to use.

The entire feed is wrapped in an <rss> tag. Within that element is a <channel> element.

The <channel> element has a number of optional child elements. The basic ones we’ll want to include are – <title>, <description>, <link>, and <pubDate>.

The actual data (our random quotes) is wrapped in <item> elements. These also have a bunch of optional parameters. We’ll be using the basics – <title;>, <description>, and <pubDate>. Notice that there’s no link – because we’re feeding simple data, not articles!

Creating the SimpleXML Object

In order to create the SimpleXML object, you need to feed it some kind of XML string. Normally this would be a completed file or string – like an existing feed.

Since we’re building the feed with SimpleXML, we don’t have a lot to start with. We can give it a very basic string to create the object – an opening and closing rss element.

$xml = new SimpleXMLElement('<rss version="2.0"></rss>');

Adding Child Elements

The addChild() method of SimpleXML allows us to add child elements to existing elements. In addition to adding a child element, the method returns a reference to the new child – allowing us to manipulate it in turn.

The first child we’ll need to create is the channel element.

$channel = $xml->addChild('channel');

That creates the channel element and stores a reference to it in $channel. We can then use the $channel variable to add more children – the information defining the channel element itself.

$channel->addChild('title', 'Test Feed');
$channel->addChild('link', 'http://www.earn-web-cash.com');
$channel->addChild('description', 'This is a feed testing how to build an RSS feed in SimpleXML');
$channel->addChild('pubDate', date("D, d M Y H:i:s T"));

You may want to include other optional parameters that are included in the specification. Just add another $channel->addChild() call with the parameter’s name and its value.

Creating the Random Quote Items

At this point, we just need to add our item elements and we’re done. To do that, we’ll loop through an array of data, create an item element, and add the appropriate children to it.

Let’s assume that I retrieved information from a database table with three columns – title, description, and pubDate.

while ($row = mysql_fetch_array($result)) {
  $newItem = $channel->addChild('item');
  $newItem->addChild('title', $row['title']);
  $newItem->addChild('description', $row['description']);
  $newItem->addChild('pubDate', date("D, d M Y H:i:s T", $row['pubDate']));
}

Again, you can add extra data to your feed by adding extra child elements.

Outputting the Feed

Now that the entire feed is stored in the $xml variable, we just need to output it.

In doing this, we’ll do two things. We need to define the content-type as xhtml/xml. Then we use the asXML() method to print the information in an xml string.

header('Content-Type: application/xhtml+xml');
echo $xml->asXML();

You could alternatively save this to an xml file. There are two ways to do this – either file_put_contents the output from asXML() or pass a filename as the parameter for asXML().

file_put_contents($filename, $xml->asXML());
//  or ...
$xml->asXML($filename);

Start Feeding

With this basic script, you can serve up any kind of information as an RSS feed. This makes it easy for people to read it in their RSS readers or even access the information on the cell phones.

There are plenty of types of data you could use this for – quotes, jokes, question of the day, trivia, tip of the day, etc. By publishing tiny bits of data on a daily basis, you keep your users coming back for more – but you don’t need to publish full size articles every day.

In case you ran into trouble putting the script together, here’s the entire source code with an array of data built into it.

$items = array();
$items[] = array('title' => 'Mark Twain on Profanity', 'description' => 'Under certain circumstances, profanity provides a relief denied even to prayer.');
$items[] = array('title' => 'Woody Allen on People', 'description' => 'It seemed the world was divided into good and bad people. The good ones slept better... while the bad ones seemed to enjoy the waking hours much more.');
$items[] = array('title' => 'Will Rogers on Vets', 'description' => 'The best doctor in the world is the veterinarian. He can\'t ask his patients what is the matter - he\'s got to just know.');
 
//  Create the root element - RSS
$xml = new SimpleXMLElement('<rss version="2.0"></rss>');
 
//  Create the channel element, a child of RSS
$channel = $xml->addChild('channel');
 
//  Add random channel information
$channel->addChild('title', 'Random Quotes');
$channel->addChild('link', 'http://www.earn-web-cash.com');
$channel->addChild('description', 'This is a feed of random, interesting quotes.');
$channel->addChild('pubDate', date("D, d M Y H:i:s T"));
 
//  Loop through and create item elements
foreach ($items as $item) {
  $newItem = $channel->addChild('item');
  $newItem->addChild('title', $item['title']);
  $newItem->addChild('description', $item['description']);
}
 
//  Output
header('Content-Type: application/xhtml+xml');
echo $xml->asXML();

As others have pointed out, this can be counter-productive. People don’t like to read articles that have just one Digg – they seem unpopular.

So here’s a solution: use the Conditional “Digg This” WordPress Plugin to only show the Digg Badge for articles that have a certain number of Diggs.

Why Shouldn’t You Show the Digg Badge on Every Article?

It’s easy enough to plaster the Digg Badge in your template or use a plug-in to add it to every post. Most of your posts aren’t going to be popular though. You’ll get at most one or two Diggs… nothing to write home about.

When a user opens your article, he or she might be impressed by “100 Diggs.” He or she definitely won’t be impressed by “1 Digg.” That’s a hint that your article wasn’t anything special – so why should the reader keep going?

Using the Plugin to Only Show the Badge on Popular Articles

The Conditional Digg This plug-in was designed to address this issue.

All you need to do is download the source code, upload it to your plugins directory, unpack the tar.gz, and click “Activate.” You don’t need to modify any settings or insert anything into your template. It’s all automated.

How Does It Work?

The basic concept behind the plugin is this:

• Load a story in your WordPress Blog
• Check the Digg API to see how many diggs the article has
• If the article has 10 or more diggs, show the badge…
• Otherwise, leave it alone.

Originally, I coded the plug-in to use a php function to access the API and check the number of Diggs each article had as it loaded. This worked perfectly – but it took a while. Sometimes, the API is slow to respond. If the API took 8 seconds to spit back a response, that meant your page would take 8 extra seconds to load up.

Even if the API was responding quickly, this was a problem for the front page and category pages. At best, the API takes about .25 to .5 seconds to respond – and with 10-15 checks on a page… you’re still waiting a good long time for the page to load.

Load First, Check the API Later

The solution I came up with was to use some nifty AJAX to perform the API checking behind the scenes.

The plug-in creates an AJAX request for each article. It sends information to a php script which accesses the Digg API behind the scenes. The page loads up instantly and AJAX will quietly do its thing. When the response is ready, it’ll change the page to include the Digg This badge if necessary.

So, the next time you want to display a “Digg This” badge on your article, think about how many diggs your article has already. Or, use the Conditional “Digg This” WordPress Plugin to automatically add a badge to your popular articles.

There is a ton of cool stuff you can do with this. Basically, you send a request to the Digg server and it sends back whatever kind of information you want – category names, recent diggs, recent stories, archived stories, etc. You can read through the API to see everything you can do.

For now, we’ll focus on one nifty little trick – grabbing a random story from a given topic.

Digg API Basics: How It Works

Before we can build our script, we need to know the basics of how the Digg API works.

Your script sends an HTTP GET request to the Digg server. This has three major parts. If this is valid, the server sends you a response in one of several designated formats. You can then parse it into use-able information and display it on your site.

The basic parts of the request are…

• Base Digg URL: http://services.digg.com
• An Endpoint: i.e. /stories/topic/programming – this determines the type of information you’re getting back
• A query string: i.e. ?count=5&offset=20

For this tutorial, we’ll be working with the “Programming” topic because, well, it works with my site. You can look at the list of topics on the API page and tailor this to your needs.

Therefore the URL we’ll be accessing is: http://services.digg.com/stories/topic/programming

What Goes In the Query String

To go along with this, we’re going to have to build a query string. There are a few required elements (appkey, type) and some optional ones that we’ll also use (count, offset).

“appkey” is basically an ID tag associated with your application. Digg uses this for statistical purposes. You can set this equal to the URI of your website.

“type” describes the type of response you’ll get. There are four response types, of which two are applicable for use in a PHP script. We’re going to focus on the XML response and use SimpleXML to parse the information. Therefore type should be set to ‘xml.’

“count” tells the server how many stories we want to fetch. “offset” tells the server how many stories to skip before it starts fetching them. The “offset” is going to allow us to fetch a random story.

Building the Query String

So how do we build the query string? First, we need to turn each of our values into a parameter in the format key=value. The value must also be url encoded. Here’s how we do that in php.

$appkey = 'http://www.earn-web-cash.com';
$appkeyParam = 'appkey=' . urlencode($appkey);

We can then string together all these variables with ampersands (&) in between. We then place a ? in the beginning of the query string, attach it to our URL, and we’re good to go.

I wrote a short function I use to automatically build the query string from an array of values. I create an empty array, store the value with a key equal to its parameter name, and then pass it through the function. The function returns the full query string for me to use.

// Example array:
//    $params['appkey'] = 'http://www.earn-web-cash.com';
//    $params['type'] = 'xml';
 
function buildQuery ($args) {
  $query = '?';
  foreach ($args as $key => $val) {
    if ($query != '?') {
      $query .= '&';
    }
 
    $query .= $key . '=' . urlencode($val);
  }
  return $query;
}

One other minor task we need to do is set up a “user_agent” for PHP. The Digg server wants to know who’s accessing it, so you need to define a “user_agent” value for your instance of PHP with the ini_set command. You can call your application whatever you want, but it usually follows the format – Name/Version.

ini_set('user_agent', 'RandomDiggStory/1.0');

Firing Off the Request and Getting a Response

We should now be able to send our request, get a response, and use some information.

To get a random story, we’re actually going to have to send two requests. The first is going to allow us to find out how many stories exist in the topic. The second will actually fetch a random story.

To find out how many stories exist in the topic, we’re going to create our request with the following information. The appkey doesn’t matter, the type will be xml, the count will be 0, and the offset doesn’t matter.

Once we build the entire url with the query string, we open that location with simplexml_load_file – and the response will automatically be placed in a SimpleXML object for us.

$params = array();
 
$params['appkey'] = 'http://www.earn-web-cash.com';
$params['type'] = 'xml';
$params['count'] = 0;  //  We don't need an offset for this one
 
$query = buildQuery($params);
$url = 'http://services.digg.com/stories/topic/programming';
$reqUrl = $url . $query;
 
$xml = simplexml_load_file($reqUrl);
$total = (int) $xml['total'];  // Need to typecast, or it'll be an object
 
echo $xml->asXML();  // Look at the source code to see what you fetched

The last line (echo $xml->asXML()) isn’t necessary – it’s just to give you an idea of the information you just fetched. It isn’t a whole lot – but we didn’t ask for a whole lot.

The piece of information we wanted was the total number of stories in our topic. That’s the ‘total’ attribute of the ‘stories’ element. We fetched it with $xml['total'] and stored it in the $total variable.

Last Step: Fetching the Random Story

With this information in hand, we can craft a new request and get our random story. You can copy and paste the same information we used before, but make these changes to the $params array.

$params['count'] = 1; // We want one story
$params['offset'] = rand(0, $total);

By generating a random value for offset between 0 and the maximum, we’re effectively choosing one random story from the available list.

Now run the script again. At the end, $xml should have one random story stored in it. The story information is stored in the story child element, and we can access some of the information like this.

echo $xml->story['link']; // the URL
echo $xml->story['submit_date']; // timestamp when it was submitted
echo $xml->story->title;
echo $xml->story->description;

If you browse through the source code of the xml you outputted, you’ll find all of the essential information about the story. Now you can format it nicely and add it to your website.

In case you ran into trouble along the way, here’s the complete source code of the script. You’ll need to go in and change the topic to your desired topic and set your own appkey, but otherwise it should be all set to go.

His parser wasn’t working – because all of the information was stored in attributes instead of child elements. What’s the difference between the two? And how can we fix it?

Use SimpleXML.

Difference Between a Child and an Attribute

For starters, let’s take a look at a sample XML file. This will help illustrate the difference between a child element and an attribute, and it will give us something to work with later on.

<?xml version="1.0" encoding="UTF-8"?>
 
<library>
  <book lang="en">
    <author>John Steinback</author>
    <title>Of Mice and Men</title>
  </book>
 
  <book lang="en">
    <author>F. Scott Fitzgerald</author>
    <title>The Great Gatsby</title>
  </book>  
</library>

This simple XML file is a “library.” It contains a list of books – each of which has an author, a title, and a “lang” attribute.

In this example, “book” is an element. It is a child element of library – which means it is an element created inside the open library element. You could also refer to the library element as the parent of all the book elements.

To create a child element, you simply create a set of tags within a larger set of tags. The book is a child of library, while the author is a child of book. We could create more children for “Author” – like age, sex, and hair color.

By contrast, “lang” is an attribute. It is defined inside the opening tag of an element. By declaring lang="en" we are saying that the book has the attribute of being written in English.

It is simply another (perhaps more annoying) way to store information in an XML file. Most basic XML parsers look for tags and content – but the attribute is neither. It’s contained inside a tag, so it needs to be handled specially.

Thankfully, SimpleXML is designed to help us do just that.

Loading the File in SimpleXML

I saved the xml file above in “xmltest.xml.” In my php script, I can load it into a SimpleXML object with this function call.

$xml = simplexml_load_file('xmltest.xml');

This creates a SimpleXML object which is a tree of connected objects. The root object represents the “library” element. It then has an array of children called “book,” and each “book” element has two children element of its own.

Using the SimpleXML object structure, we can access some pieces of our XML document like this.

var_dump($xml->book[0]); //  All of the info in Book 1
echo $xml->book[0]->author; // First book, John Steinbeck
echo $xml->book[1]->title; // Second book, The Great Gatsby

Accessing the Lang Attribute in the Object Tree

The initial question now resurfaces – how do we access an attribute, like the ‘lang’ attribute?

All of the elements are nicely arranged in a tree. The parent element has a child element, which has a child element, so on and so forth. We can easily access these as related objects like we did above.

The attributes are exploded into an array and attached to the element that they define. So, for example, we defined a ‘lang’ attribute for our book element. Therefore, the value of lang will reside in an array attached to that specific book element.

We can access it like this.

echo $xml->book[0]['lang']; // en

To find an attribute of an object with SimpleXML, you navigate to the element in question and then access an array indexed by the names of the attributes. In this case, our attribute was named ‘lang’ so we use ‘lang’ as a key in the array to get the value.

For simplicity’s sake, it is usually better to define all of your XML data as child elements. This allows you to easily expand data types in the future, and you won’t have to mix methods for accessing the data.

However, if you’re working with someone else’s XML file, you may need to look up attributes. Now you know how.

Or, take a look at my photography studio’s website. Along with photography, we offer a handful of design and printing services, mostly for models, actors, and fashion designers. Our newest offering is the design and printing of modeling/acting comp cards, which start at $60 for a set.

Most blogging platforms come with built-in support for RSS feeds. Why? It’s a great way for users to keep up to date on your new content. Instead of loading up a dozen favorite sites, they can look at one feed reader and then decide what to pursue further.

So what if you don’t use a blogging platform or CMS that creates a feed for you? You can create one yourself in PHP. It’s pretty simple.

Elements of an RSS 2.0 Feed

There are pretty strict standards about RSS feeds – intended to make it easier for readers to parse and display the information. Before we dive into building a feed, we should look at what it should contain. You can read the full spec at feedvalidator.

An RSS 2.0 Feed is a special type of XML file. The first things you’ll need in your file is an xml declaration, and an opening/closing RSS tag. Like this.

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  //  Feed elements here
</rss>

Inside the opening rss tag, you can also include any namespaces that you’ll be using. That’s a bit more than we need to worry about at the moment, though.

Inside the rss tag, you need to create a channel tag. This holds all of the individual articles as well as some basic information about the feed. You’re required to create a title, link, and description tag. You can add a lot of optional tags, of which the lastBuildDate tag would be most useful.

A basic channel declaration would look something like this.

<channel>
   <title>My Wonderful Blog</title>
   <link>http://mydomain.com</link>
   <description>This is a feed of the latest articles at My Wonderful Blog.</title>
   <lastBuildDate>Thu, 14 Feb 2008 10:57:05 GMT</lastBuildDate>
 
   //  Include individual articles here
</channel>

Finally, you can include the individual articles inside of this channel tag. Each article is represented by an item tag and a series of optional tags. Some good tags to use for a basic feed would be title, link, description, and pubDate. Like this…

   <item>
      <title>My Latest Article</title>
      <link>http://mydomain.com/latestarticle.php</link>
      <description>This is the latest cool article at my wonderful blog.</description>
      <pubDate>Thu, 14 Feb 2008 10:57:05 GMT</pubDate>
   </item>

Using PHP to Create the RSS Feed

Now that we know what goes in to an RSS feed, we can worry about how to create one.

There are several approaches we can take here. We could have PHP dynamically output an RSS feed every time the file is accessed. We could create a SimpleXML object and write it to a file each time a new article is added. Or we could simply create a string and write it to an xml file.

We’ll take the third approach. This means we need to do three things.

• Fetch the data from the database
• Build the xml formatted string
• Write the xml data to a file

Fetch the Data from the Database

This will vary depending on the database type you’re using and how it’s set up. If you’ve gotten this far in creating a dynamic, PHP-driven site, I’m sure you can figure out how to fetch information for your own database.

For the purpose of this tutorial, we’ll fetch information from a mySQL database. The database will hold the title, link, description, and pubDate of each article.

$query = "SELECT title, link, description, pubDate FROM
   articles LIMIT 10";
$result = mysql_query($query);

Note: I only retrieved the last 10 entries. There is no strict limit to the number of entries an RSS 2.0 feed can have, but it’s polite to leave it small. If they want to read every article, they’ll come to your site.

Building the XML Formatted String

Now, we need to create a blank string, format it like an XML file, loop through the mySQL result array, and insert the data into the XML file.

First, we’ll add the xml declaration, the rss tag, the channel tag, and the channel info. Then we can loop through the result set and create one item tag for each article.

$xmlString = '<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
   <title>My Wonderful Blog</title>
   <link>http://mydomain.com/</link>
   <description>Latest articles at My Wonderful Blog.</description>
   <lastBuildDate>' . date("D, d M Y H:i:s e") . '</lastBuildDate>
 
';
 
while ($row = mysql_fetch_array($result)) {
$xmlString .= '   <item>
      <title>' . $row['title'] . '</title>
      <link>' . $row['link'] . '</link>
      <description>' . $row['description'] . '</description>
      <pubDate>' . date("D, d M Y H:i:s e", $row['pubDate'] . '</pubDate>
   </item>
';
}
 
$xmlString .= '</channel>
</rss>';

Most of that should be self-explanatory. Where I added a newline before ending the string, I was simply adding white space to make the source code more readable. This isn’t necessary – but I like neat, readable source code.

$xmlString is being created in the beginning. Then, the additional strings are appended to it with the .= operator.

The one important thing to note here is date("D, d M Y H:i:s e"). This is PHP’s function to create a formatted date. The characters inside the string determine how the timestamp is formatted.

This format is the standard required by RSS 2.0 feeds. You could simply copy and paste this string to format your dates. “D, d M Y” creates something like “Thu, 14 Feb 2008.” “H:i:s” creates the time as “18:23:30.” “e” is a representation of the timezone – which should be GMT.

Write the String to an XML File

Finally, we need to write this string to an xml file. For simplicity’s sake, we’ll call this “feed.xml” and place it in the same directory as our script.

You could use a few functions to do the file-writing. In this case, file_put_contents would be simplest – all we need to do is dump the contents of the string into a file and overwrite any previous contents.

$filename = "feed.xml";
file_put_contents($filename, $xmlString);

Now you just need to incorporate this into your existing site. You could make this a standalone script and access it every time you add new content to your site.

Or, if you’re using some kind of home-brewed CMS, you could wrap this in a function and call it right after you save the content of a new article.

Besides creating a custom feed for your own website, there are some other uses for this. You could use it to create a feed of articles from diverse sources around the internet.

If you write at a variety of sites – like Helium, Associated Content, and Xomba – you can use this to create a unified feed. Or, you could create a feed of only select articles from one of those sources. You could also create a feed of simple data – not articles – like quotes, jokes, tips, etc.

Or, you could use RSS for what’s intended for – content syndication. With Simple XML, it’s a piece of cake to use an RSS feed to add a list of links to relevant articles on your page.

What Are RSS Feeds and XML Files?

Hopefully you know what an XML file and an RSS feed is. If not, here’s the quick and dirty explanation.

An XML file is a special way to store information. All of the information is wrapped in tags – kind of like HTML. However, instead of using this to format the output, this is used to tell the reader what the information means.

So, for example, a <link> tag would probably describe a link.

XML was created to allow information to be easily ported between platforms and systems. An RSS feed is a special type of XML file to help reach that goal. Most websites (including almost all blogs), publish an RSS feed that is simply an XML file containing the latest few entries on the website.

An RSS feed also has a standard structure – which is why we can easily build a script that can parse any valid RSS feed and add the links to your site.

Getting Started with Simple XML

Before SimpleXML, you had to build your own XML parser to work with PHP and XML files. This was possible, but it meant a lot of overhead – so it wasn’t a good idea for small projects.

With SimpleXML, you can load any XML file into PHP as a specially structured object. The object’s structure mirrors the XML file. So, if there’s a <item> tag, it creates an object with name “item.” It then creates children objects of every tag inside that item tag.

To load an XML file into a SimpleXML object, you simply use this function call. Run this entire script to see what the SimpleXML object looks like after it’s loaded.

$filename = "http://www.dzone.com/links/feed/frontpage/rss.xml";
//  That's the DZone RSS Feed
 
$feed = simplexml_load_file($filename);
var_dump($feed);

What’s In an RSS Feed, and How Do We Use It?

If you ran that script, you should see the guts of an RSS feed. I’d suggest you view the source code of the output page, since it’ll be formatted nicely for you.

Like I mentioned before, RSS feeds have a standard structure so that apps can predictably interact with them. This is the basic structure you should see inside the DZone RSS feed.

//  Some random stuff up top
<channel>  // This parent tag holds all the page information
  <item>  //  There's one item per page listed in the feed
    <title> ... </title>
    <link> ... </link>
    <description> ... </description>
    <pubDate> ... </pubDate>
  </item>
  //  You could have a lot more <item> tags here
</channel>

All of this information is nicely placed in our SimpleXML object for us to manipulate.

The entire channel (all of the children tags inside the channel tag) is stored in the ‘channel’ object, which is a child of the larger ‘feed’ object that we created earlier ($feed).

You can access the channel like this.

var_dump ($feed->channel);

If there were multiple channels, then ‘channel’ wouldn’t be a single object – it would be an array of objects. This is the case with the ‘item’ tags. There are a lot of items, so they are stored in an array – which is a child object of the ‘channel.’

You can access the items like this.

var_dump ($feed->channel->item[n]);

Finally, the individual item holds most of the information we want. It has children named ‘pubDate,’ ‘title,’ and ‘link’ (along with a few other optional parameters).

echo $feed->channel->item[0]->title;
echo $feed->channel->item[0]->link;
echo $feed->channel->item[0]->pubDate;

So How Is This Useful to Us?

As you may have noticed, each item consists of the information you need to make a link back to it. The item consists of a title, a URL, a pubDate, and a description. You could use any combination of these that you feel is useful – but here’s an example of how to create a link to an article.

echo '<a href="' . $feed->channel->item[0]->link . '">' .
  $feed->channel->item[0]->title . '</a>';

And that’s all there is to it. You could spruce it up by adding a date underneath the link. Or you could add a short excerpt of the description.

What If I Want to Include All of the Links?

I suppose adding one link is kind of silly. With a loop, we can easily iterate through the item[] array and output a link for every item in the RSS feed.

For good measure, we’ll also format it nicely in an unordered list. From there, you can add some styling and it’ll fit right into the sidebar of your page.

//  Load the XML file into a Simple XML object
$filename = "http://www.dzone.com/links/feed/frontpage/rss.xml";
$feed = simplexml_load_file($filename);
 
//  Iterate through the list and create the ul
echo "<ul>";
foreach ($feed->channel->item as $item) {
  echo "<li><a href='" . $item->link . "'>" .
    $item->title . "</a></li>";
}
echo "</ul>";

There ya have it. A semantically structured list, built from a remote RSS feed. All in a couple lines of code.

You could of course separate this out into a function, and then pass a filename (and perhaps a limiting # of items to print) to your function. The function would return a string with the html list, or output it directly (depending on your preference).

Word of Caution: Remember that you don’t own content just because it is published in an RSS feed. The author still does.

I would assume that it’s fair game and free of copyright issues to print links to the original author’s site. However, some authors publish their entire articles in their RSS feeds. Do not re-publish the entire article. That is copyright infringement, it is illegal, and you can get in a lot of trouble. Not to mention it’s highly unethical.

With that in mind, happy syndicating!