What Is RSS

RSS is a format for syndicating news and the content of news-like
sites, including major news sites like Wired, news-oriented community
sites like Slashdot, and personal weblogs. But it's not just for
news. Pretty much anything that can be broken down into discrete items
can be syndicated via RSS: the "recent changes" page of a wiki, a
changelog of CVS checkins, even the revision history of a book. Once
information about each item is in RSS format, an RSS-aware program can
check the feed for changes and react to the changes in an appropriate
way.

RSS-aware programs called news aggregators are popular in the
weblogging community. Many weblogs make content available in RSS. A
news aggregator can help you keep up with all your favorite weblogs by
checking their RSS feeds and displaying new items from each of
them.

A brief history

But coders beware. The name "RSS" is an umbrella term for a format
that spans several different versions of at least two different (but
parallel) formats. The original RSS, version 0.90, was designed by
Netscape as a format for building portals of headlines to mainstream
news sites. It was deemed overly complex for its goals; a simpler
version, 0.91, was proposed and subsequently dropped when Netscape
lost interest in the portal-making business. But 0.91 was picked up
by another vendor, UserLand Software, which intended to use it as the
basis of its weblogging products and other web-based writing
software.

In the meantime, a third, non-commercial group split off and
designed a new format based on what they perceived as the original
guiding principles of RSS 0.90 (before it got simplified into 0.91).
This format, which is based on RDF, is called RSS 1.0. But UserLand
was not involved in designing this new format, and, as an advocate of
simplifying 0.90, it was not happy when RSS 1.0 was announced.
Instead of accepting RSS 1.0, UserLand continued to evolve the 0.9x
branch, through versions 0.92, 0.93, 0.94, and finally 2.0.

What a mess.

So which one do I use?

That's 7 -- count 'em, 7! -- different formats, all called "RSS".
As a coder of RSS-aware programs, you'll need to be liberal enough to
handle all the variations. But as a content producer who wants to
make your content available via syndication, which format should you
choose?

RSS versions and recommendations

Version

Owner

Pros

Status

Recommendation

0.90

Netscape

Obsoleted by 1.0

Don't use

0.91

UserLand

Drop dead simple

Officially obsoleted by 2.0, but still quite popular

Use for basic syndication. Easy migration path to 2.0 if you need more flexibility

0.92, 0.93, 0.94

UserLand

Allows richer metadata than 0.91

Obsoleted by 2.0

Use 2.0 instead

1.0

RSS-DEV Working Group

RDF-based, extensibility via modules, not controlled by a single vendor

Stable core, active module development

Use for RDF-based applications or if you need advanced RDF-specific modules

2.0

UserLand

Extensibility via modules, easy migration path from 0.9x branch

Stable core, active module development

Use for general-purpose, metadata-rich syndication

What does RSS look like?

Imagine you want to write a program that reads RSS feeds, so that
you can publish headlines on your site, build your own portal or
homegrown news aggregator, or whatever. What does an RSS feed look
like? That depends on which version of RSS you're talking about.
Here's a sample RSS 0.91 feed (adapted from
XML.com's RSS feed):

<rss version="0.91">
<channel>
<title>XML.com</title>
<link>http://www.xml.com/</link>
<description>XML.com features a rich mix of information
and services for the XML community.</description>
<language>en-us</language>
<item>
<title>Normalizing XML, Part 2</title>
<link>http://www.xml.com/pub/a/2002/12/04/normalizing.html</link>
<description>In this second and final
look at applying relational normalization techniques to W3C XML Schema data modeling,
Will Provost discusses when not to normalize, the scope of uniqueness and the
fourth and fifth normal forms.</description>
</item>
<item>
<title>The .NET Schema Object Model</title>
<link>http://www.xml.com/pub/a/2002/12/04/som.html</link>
<description>Priya Lakshminarayanan describes
in detail the use of the .NET Schema Object Model for programmatic manipulation
of W3C XML Schemas.</description>
</item>
<item>
<title>SVG's Past and Promising Future</title>
<link>http://www.xml.com/pub/a/2002/12/04/svg.html</link>
<description>In this month's SVG column,
Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.</description>
</item>
</channel>
</rss>

Simple, right? A feed comprises a channel, which has a title,
link, description, and (optional) language, followed by a series of
items, each of which have a title, link, and description.

Quite a bit more verbose. People familiar with RDF will recognize
this as an XML serialization of an RDF document; the rest of the world
will at least recognize that we're syndicating essentially the same
information. In fact, we're including a bit more information:
item-level authors and publishing dates, which RSS 0.91 does not
support.