The Resource Description Framework (RDF) concerns the representation of MetaData about web resources. RDF has a standardised representation in XML, RDF/XML, that is often equated with RDF itself.

Under the RD Framework, all meta-data is constructed as statements, consisting of:

For instance, the meta-data "the Wiki page on the ResourceDescriptionFramework was modified on April 2, 2004" would be represented by the statement <the Wiki page on the ResourceDescriptionFramework, was modified on, 2 April 2004>. The subject is the Wiki page, the predicate "was modified on", and the object the date.

Since we are working with web resources, subject and predicate are always a UniformResourceIdentifier (URI). The object can also be a URI, or it can be plain text, or some other format like a date. A common set of predicates used for simple RDF is the DublinCore URIs.

The Resource Description Framework also states that any statement can be given a URI, and statements made about it. I could for instance record the authority that made a particular statement, and I could attach to the URI of that authority statements about what statements it has made. For example, <Chris Purcell, stated, <Cambridge University, is, fantastic>>; <<Cambridge University, is, fantastic>, was stated by, Chris Purcell>.

The Resource Description Framework allows you to express web-based metadata using XML (RDF/XML). This includes sitemaps, content ratings, stream channel definitions, digital library collections, and distributed authoring. [1] [2]

As a an example, consider the Meatballl RichSiteSummary (RSS) [3]:

    <item rdf:about="">
        <description>reply to sunir</description>
            <rdf:Description wiki:host="" link="">

Compare this to a feed that uses less RDF stuff:

    <item rdf:about=";id=RecentChanges;revision=2">

Compare this to the old non-RDF using RSS:

     <title>Clash im Internet?</title>

Note how RDF is crud to parse, but it can represent "richer" information. Take the dc:contributor field as an example. In the non-RDF feed, the element content is all there is. It is a string, but we know nothing else about it. When rendering such a feed on a web page, the simplest thing is to just print it.

The RDF feed, however, tells us more about dc:contributor, such as a link to more information about the contributor. The value is in a separate element, and there even is an attribute from the wiki namespace telling us what host the contributor used.

When using this feed to produce a web page, for example, the problem is much harder. Even with an XML parser, you will have to include all sorts of logic to actually find the correct element content or attribute value containing the name of the contributor in the document object model (DOM). The richness of the information attracts many developers to RDF. At the same time, the hideous complexity also turns many developers off. After all, if all you want to do is encode the information so that it can be represented in web pages, RDF might be too costly for its benefits.

See also

Further reading


I like the page, and it's a lot more PlainTalk than most descriptions of RDF. But, I want to make it even more so. :)

I'd also like to explain things like:

  • Why triples? Why not, say, quadruples, or doubles?
  • What's all this about RDF representing "graphs?" How does it represent a graph? Why is that important?
  • What will this do for us, that we couldn't do before?

I know the answers to some of these, and I have notions of answers to the rest. But it'd be great to have clear answers to all of these.

I've already read MurrayAltheim's notes on the page about TopicMaps, and I'd like to rework that as well.

Okay, in order then. Why triples? Because a lot of common statements one wants to make are triples: subject, verb, object. The translation is clean.

Why not quadruples? Because a quadruple can be synthesised by creating a "quadruple" node and making four triples from it to the four things the quadruple is linking. While it's easy to label the three parts of a triple (subject, object, type), what would you label the four parts of a quadruple? If you synthesise it as I just described, you can use the predicates of those four triples as labels. Suppose I'm making a quadruple describing a job offer:

 <job offer, employer, my dad>
 <job offer, employee, me>
 <job offer, offer, ten bob>
 <job offer, date, Tuesday>

Why not doubles? The whole point is to be able to give meaning (a predicate) to the triples. While you could synthesise triples with doubles, clearly that's far too much hassle.

Why does RDF represent graphs? In graph notation: each triple is a directed, coloured edge between two vertices. The direction is subject->object, the "colour" is the predicate. Any directed, coloured graph can be turned into RDF by assigning each vertex and each colour a URI, and doing the obvious. (That may not be transparent, sorry.)

What will this do for us, that we couldn't do before? There are several things linked together. Firstly, we have a standard (RDF) for representing arbitrary graphs, and a standard format (RDF/XML) for storing them for use by any other graph parser. Since RDF uses URIs, that makes it ideal for describing web-based stuff; since the file format is XML, that makes it ideal for transfer on the web. Anything that "understands" RDF can be taught new types of information (new predicates) with less hassle, since it can already store that information without structural changes; since RDF is graph theory, and anything can be represented, that means one never needs to alter the interface between your program and its storage again.

TopicMaps cover the same ground, and have similar benefits. I'm planning on researching the comparisons, so will post more then.

I appreciate your answers. I just think we can do better. :)

I think there's a deeper reason for using triples.

Saying, "It's because it's how we talk" leaves me sort of wondering. "Why does it matter how we talk?" and "What's so magical about triples?"

So I want to think a little further into this.

Consider: "A.x->B" and "A.y->C"

We could express it as:

  • Relations: x → AxB, y → AyC
  • Links: A → AxB, AxB → B, and A → AyC, AyC → C

But it happens that we want to talk about the types of relationships between things often. Since graphs have nodes, and connectors between nodes, it is very convenient to collapse the above into just:

  • A.x → B, and A.y → C

What I think we want to do is ground this in what we know: We divide the world into things, and the relationships between things. This model is made to represent the world. I do believe I remember reading a ton of Taoist and Buddhist text on the inter-relatedness of all things.

Okay. So, this makes sense: Modeling the world as things and relationships between things, we use triples because we want to refer to two things (2) and the relationship between them (1). 2+1 being 3, we have tripples.

Next question: What do you mean when we say that nodes and verticies have URIs? Do you mean URLs, or do you really mean URLs + URNs? (URNs being something we very rarely use. The best I've seen is ISBN numbers.)

If you wanted to say "Lion Kimbro's has a home page," I understand that you might say: "Lion Kimbro – has – a daughter." But then: What would you link Lion Kimbro to? (My blog? My address book? Some other page of mine?) What would you link "a daughter" to? A wikipedia entry? A wiktionary entry? And what about "has"- what would you link that to? "Filial relationship, in existance?"

That's one part that always confuses me.


I mean URIs, I believe. One can happily talk about ISBNs with RDF.

To talk about Lion Kimbro, one would pick some arbitrary URI that didn't mean anything else. We don't want to reuse it for a page describing Lion Kimbro that also has properties, because then we might start talking about Lion's creator, and that's not a meta-element intended for theological use :)

Beyond that, well, that's getting into ontologies, and that's strongly debated regardless of the use of RDF to frame it. RDF just picks a URI, and lets us people argue whether the URI means "filial relationship, in existance", or "possesses". Machines, after all, don't care.

Actually, Topic Maps don't cover the same ground. Apart from using a graph structure (which a lot of things have, such as the Web), there are more differences than similarities. This is a common misconception I tried to make clear in a much longer explanation on the TopicMap page.

As for triples, it's both how we talk and simply how logicians have historically tried to represent knowledge, such as predicate logic (developed by the German philosopher Gottlob Frege in 1879), where statements of logic were first mapped to natural language, e.g.,

    Every dog is a mammal.
    For every x, if x is-a dog, then x is-a mammal. 

The statement above could be written as a triple (is-a,dog,mammal) or (dog,mammal,is-a) – the order doesn't matter so long as it's understood – assigning "mammal" to "dog" using the "is-a" relation. While logical language may seem awkward, it is at least precise.

In RDF, pretty much everything is a URI. It's even more than at first glance, in that many of the short strings in RDF are subsitutes for URIs, e.g., in RSS "dc" is really a stand-in for "". So if you want to state something about "Lion Kimbro" you create a URI. You create URIs for the subjects, objects, and predicates necessary to form the statements you want to make. One of the problems with RDF is that there's no way to establish whether a statement about a URI is a statement about the web resource the URI resolves to, or about what the web resource represents. Does your home page represent you? How can you create a URI to represent you? Even Tim Berners-Lee's Scientific American article makes this mistake, conflating a person and their web page. These are thorny issues that bring up big ugly words like reification, and many thousands of hours and emails have been spent arguing about these sorts of things within the W3C. So if you're confused, you're at least in good company… – MurrayAltheim

To answer Lion's 3rd question (what does this do for me that I couldn't do before), although I'm just learning this stuff myself and my answer may therefore be wrong:

Two things.

Reason 1. Consider these three ways of saying the same thing with XML-ish syntax:

 <rdf:RDF xmlns:rdf="">
  <rdf:Description rdf:about="">
    <dc:author rdf:resource=""/>


<link href="" rel="alternate"  type="text/html"/>
<author><name>Stefano Mazzocchi</name>


  <meta name="dc:author" value="Stefano Mazzocchi"/>

Sure, we could transform these all into some standard normal form. But the point is this. XML is built for treating these as hierarchially structured data objects. When you address information in these objects, you address it like "What is, where>href = ''?" or "what is head.meta->value, where head.meta->name = 'dc:author'"?

RDF is built on triplets. When you address information, you address it like "What is the dc:author of the URI"?

And isn't that what we really meant anyway?

(see also

Reason 2.

RDF provides a principaled way to specify meta information (meta-meta information?).

  • You can make statements about statements, like "The dc:author of page is Stefano Mazzocchi. The dc:author of the previous statement is Bayle Shanks.".
  • With RDFSchema, you can say things about terms in the language itself, for instance you can describe what you mean by "dc:creator" like this:

  rdf:type       rdf:Property ;
  rdfs:label     "Creator"@en-US ;
  rdfs:comment   "An entity primarily responsible for making the content of the resource."@en-US ;
  dc:description "Examples of a Creator include a person, an organisation, or a service. "@en-US ;
  rdfs:isDefinedBy\240<> ;
  dct:issued     "1999-07-02" ;
  dct:modified   "2002-10-04" ;
  dc:type        dcp:element ;
  dct:hasVersion dch:creator-004 .
  • With OWL, you can specify relations between terms in the language. For example, you could formally say something like "'atom:author' is equivalent to 'dc:author'." Or you could say "worksWith is a symmetric property. fatherOf is not a symmetric propery". This allows you to build automated inference engines that automatically figure out how to transform one form of data representation (say, Atom) into another form (say, RSS), just by specifying the relations between the terms in each of those languages.

See also Mazzocchi's article part I.

But… I think you can automatically translate XML such as

<link href="" rel="alternate"  type="text/html"/>
<author><name>Stefano Mazzocchi</name>

to RDF if you bother to write a (schema?) for the XML. So maybe it's just as easy to use standardized XML when you can, and translate to RDF as needed.

Here's where I am at, as far as RDF and the Semantic Web goes-

I have come to believe:

  • RDF & the semantic web have little to do with web pages. Most semantic web descriptions talk about annotating web pages. I think this is good, in that it explains the semantic web to people in a way they are comfortable with. But I think it's bad, because it misleads techies who want to understand what the fuss is about.
  • In fact, the semantic web is about networked data. I believe it should be explained to techies in those terms.
  • The graph is the most generic data structure there is. All structured data can be well represented in terms of a graph. There is no structure of interconnected data that cannot be represented as a graph. (In trees, children cannot link to their grandparents or cousins.) This is because graphs represent "things, and the relationships between things," most abstractly.
  • Triples are used because they are a minimalist representation of graphs. That philosophers or other people happen to talk in terms of triples is a convenience- not a first principle, not a founding thought, not an origin.
  • Identifying nodes by URIs was a simple mistake. It'll be useful for a while, but when people start making large data stores, they will ignore the URI identifiers. They'll ignore them, because there will be overlap problems. Data meant to describe a web page will overlap data intended to describe a person.
  • Instead of using URI's to link up data, we'll link up by sewing together along standard unique marks. In OWL, these unique marks are called identified with an "inverse functional property." So, for instance, if you are linking to your friend Bayle Shanks, you would say, "The person named Bayle Shanks with such-and-such e-mail." When the data for Bayle Shanks comes in, you don't look for a URI- you check that his name and e-mail match.
  • The semantic web is terribly exciting.

I want to add- I highly recommend the ESW wiki. I want everyone that learns about the semantic web to use the ESW wiki, and WikiAsYouLearn. If there's something you wonder about, or are unclear about, please- leave a note on the ESW wiki. We can build up our collective and individual understandings there.

If you want to play over there; Please send me an e-mail. If there's no one to interact with you, I will- I'm terribly interested in seeing that resource grow, and I enjoy learning semantic web stuff, and teaching what I learn. I've written a bunch of pages over there already. Check out formal systems language! Pictures! I pictures.

I'm increasingly of the opinion that the "simple mistake" is not identifying nodes by URIs, but in thinking those URIs have any relation to "web pages". A couple of posts on www-rdf-interest, which you'll find at PeriPeri:ResourceDescriptionFramework+URIs, are highly pertinent.

Take the following statement:

    CW:ResourceDescriptionFramework dc:author "Bob Jones"

Does this mean that the ResourceDescriptionFramework page has "Bob Jones" as author? Or that "Bob Jones" was an author of what the URI describes (RDF)?

What if the page has multiple representations? Depending on the exact HTTP GET headers, you might get an RDF file back – or French. Which of these representations did "Bob Jones" author?

What if the page is rewritten? How do we refer to the old version of the page?

The best solution (as far as I can see) is to forget entirely about whatever web page(s) you might get by dereferencing the URI. In RDF, a URI is opaque. If you want to use it to refer to the resource located at a given URI, you add statements to that effect. That way, we can also annotate what HTTP headers were involved, and when the GET was sent.

    CW:ResourceDescriptionFramework resultOfDereferencing "&CW;ResourceDescriptionFramework"

EditNearLinks: UniformResourceIdentifier RichSiteSummary


The same page elsewhere: