XML Reference Guide

There is a perception in XML-land that RDF, or the Resource Description Framework, is somehow "complex" or "difficult to understand". This perception has been so strong that it has actually led to resistance to technologies that make use of it, such as the Semantic Web or RSS 1.0. It doesn't have to be that way.

Let's start at the beginning. RDF doesn't actually describe anything. There, I've said it. Just as XML isn't actually a language, but rather a system of rules for creating a new language -- documents must be well-formed, elements must be nested properly, and so on -- RDF is quite literally a framework for describing resources.

So what's a resource? A resource can be just about anything, but at this point it's usually something accessible via a URL, such as a web page or a graphic. (RDF isn't limited to these types of resources, but to keep it simple we'll limit this discussion to them for now.

Then what are we describing? We're describing properties of that resource. For example, we might make the following assertions:

The Vanguard Science Fiction Report has a creator of Nicholas Chase
XML Primer Plus has an ISBN of 0672324229
The InformIT Reference Guide has an image of 
                http://www.informit.com/images-psts/topic_icons/xml_e.gif

Now, those might sound a little awkward from a grammatical point of view, but that's how we phrase an assertion:

<resource> has a <property> of <literal value>

(You might also look at it as

Subject predicate object

You can take that triple and express it as a Resource Graph:

One requirement is that the resource that's being described -- in this case, The Vanguard Science Fiction Report -- has to be specified via a Uniform Resource Identifier (URI). The most common type of URI is a URL, or Uniform Resource Locator, so we can change the graph to show that, as in:

From here, that's pretty clear to a human reading it. Or is it? The term "creator" has lots of different meanings. We could mean the person who wrote the content, or the person who authored the web page, or even God, for that matter. So it would help if we could refer to a specific definition, such as "An entity primarily responsible for making the content of the resource."

Now, as it happens, there is such a defintion that we can reference. The Dublin Core Metadata Initiative (from Dublin Ohio, not Ireland) has created a set of definitions, such as creator, subject, type, and contributor. We could specify that we mean the Dublin Core creator property by including it's full identifier:

At this point the assertion is fairly unambiguous. We know what resource we're describing, and we're clear on exactly the property we're setting. Some might argue that the actual value, "Nicholas Chase," is still ambiguous, and you could, by rights, specify a URI that represents me, but the Dublin Core definition of "creator" recommends that you use a human readable name here. See, we're standardizing things already, and we haven't even put this into XML yet!

Speaking of which, let's do that. What we want to do is create an XML structure that defines the resource that we're describing and provides an unabiguous way of describing it. We'll start with an overall structure:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <rdf:Description rdf:about="http://www.vanguardreport.com/">

  </rdf:Description>
</rdf:RDF>

Here we've simply specified that we're describing a resource, and the resource the descriptions are about is http://www.vanguardreport.com. We'll add the actual descriptions in a moment, but before we move on, let's take a good, hard look at what we've got here.

Specifically, note the use of namespaces. If you've only got a passing familiarity with namespaces, you may not have made the connection that the rdf: in rdf:RDF is actually just the alias. It's not the actual namespace. The actual namespace is http://www.w3.org/1999/02/22-rdf-syntax-ns#. This means that the element

rdf:RDF

is actually

http://www.w3.org/1999/02/22-rdf-syntax-ns#RDF

What this means for us is that we can use namespace information to easily specify not only a property, but the full URI for a property, as in:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:dc="http://purl.org/dc/elements/1.1/">
  <rdf:Description rdf:about="http://www.vanguardreport.com/">
    <dc:title>The Vanguard Science Fiction Report</dc:title> 
    <dc:creator>Nicholas Chase</dc:creator>
  </rdf:Description>
</rdf:RDF>

By creating the Dublin Core namespace, with an alias of dc:, we've quickly specified the http://purl.org/dc/elements/1.1/creator and http://purl.org/dc/elements/1.1/title properties.

In some cases, the value of the property isn't a literal value, but a separate resource. For example, we can create a RSS 1.0 feed that includes RDF information:

(Note to the observant: Yes, the URL's have been shortened for display purposes.)

<?xml version="1.0" encoding="utf-8"?> 
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
  xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
  xmlns="http://purl.org/rss/1.0/"> 

  <channel rdf:about="http://www.informit.com/isapi/topics/guide_rss.xml">
    <title>InformIT :: XML Reference Guide</title>
    <link>http://www.informit.com/</link>
    <description>The latest weblog and content updates for the InformIT XML 
                 Reference Guide</description>
    <sy:updatePeriod>hourly</sy:updatePeriod>
    <sy:updateFrequency>6</sy:updateFrequency>
    <sy:updateBase>2003-01-01T12:00+00:00</sy:updateBase>

    <image rdf:resource="http://www.informit.com/images-psts/topic_icons/xml_e.gif" />

    <items>
      <rdf:Seq>
        <rdf:li rdf:resource=
           "http://www.informit.com/weblog/showComments.asp?weblog_id={367F6DB57E04}" />
        <rdf:li rdf:resource=
           "http://www.informit.com/weblog/showComments.asp?weblog_id={878C86686856}" />
      </rdf:Seq>
    </items>

  </channel>

  <image rdf:about="http://www.informit.com/images-psts/topic_icons/xml_e.gif">
    <title>InformIT XML Reference Guide</title>
    <url>http://http://www.informit.com/images-psts/topic_icons/xml_e.gif</url>
    <link>http://www.informit.com/</link>
  </image>

  <item rdf:about=
      "http://www.informit.com/weblog/showComments.asp?weblog_id={367F6DB57E04}">
    <title>Blog :: Netscape is dead; Long live Mozilla</title> 
    <link>http://www.informit.com/weblog/showComments.asp?weblog_id={367F6DB57E04}</link>
    <description>When Netscape released its browser as open-source, it was the Mozilla project 
      that took up the ...</description>
  </item> 

  <item rdf:about=
      "http://www.informit.com/weblog/showComments.asp?weblog_id={878C86686856}">
    <title>Blog :: RSS 2.0 transferred to neutral party</title>
    <link>http://www.informit.com/weblog/showComments.asp?weblog_id={878C86686856}</link>
    <description>Part of the RSS controversy has centered around the perception 
       that RSS 2.0 was somehow ...</description>
  </item>

</rdf:RDF>

We've got a few things going on in this file, so let's take them one at a time. First of all, just because there's no prefix for the RSS namespace (http://purl.org/rss/1.0/) doesn't mean that it doesn't define a set of properties. For example, the image element describes the http://purl.org/rss/1.0/image property of the http://www.informit.com/isapi/topics/guide_rss.xml resource. Second, it just so happens that the value of the image property isn't the string http://www.informit.com/images-psts/topic_icons/xml_e.gif, but rather the resource at that location.

(If the value were the string, it would have been written as:

<image>http://www.informit.com/images-psts/topic_icons/xml_e.gif</image>)

Finally, we're getting a brief glimpse of some of the structure that RDF can provide with the items element. The value of the items property is actually a sequence of resources. The Resource Description Framework defines a number of structures to assist in situations like this.

Overall, we couldn't even begin to cover all of what RDF has to offer in this short piece, but it all boils down to this: RDF creates a way to specify metadata, or data about data, by specifying a resource, the property, and the value of the property. Other organizations can then take this framework and define properties that everyone can agree on so that both people and automated systems can make sense of your information.