Jeni's Musings

Those of you who have been following this blog will know that I’ve been thinking recently about how to handle uncertainty related to RDF triples (specifically in the context of a genealogical web app). Certainty isn’t the only kind of metadata-about-triples that you’d want to keep in an app like this. We need to know things like:

• who made the statement
• when the statement was made
• what evidence that led to the statement being made
• licensing information about the reuse of the statement
• (if we go with the rating idea) what ratings the statement has been given
• (if we allow editing of statements) what changes have been made to the statement over time

and so on. In short, all the metadata that you’d want to associate with resources you’d also want to associate with statements.

Another question to answer:

I’ve been reading about RDF, and I’m not sure in what situations it is more appropriate to use RDF over straight XML. I usually see RDF expressed as XML, but sometimes I see it written as language-independent functions (or methods).

Part of me is wondering if RDF is more appropriate for this project. What might the benefits be? And if it is, how difficult it would be to refactor it.

I’ve been thinking a bit recently about how to deal with certainty in our Genealogical Web 2.0 application. We’ve come round to using an RDF model to represent what the Gentech data model calls “assertions”; assertions such as “Charles Darwin was a passenger on the Beagle Voyage” are represented as an RDF Statement in which (a resource representing) “Charles Darwin” is the subject, (a resource representing) “Beagle Voyage” is the object, and “was a passenger on” is the predicate/property.

As I’ve mentioned before, I’ve been a RDF sceptic for a long time. Perhaps it’s precisely because of my knowledge engineering background: in my experience, the field is about equal parts academic optimism, sales-related exaggeration and plain old information management. In other (un-minced) words, unrealistic aims with unproven technologies that are sold as being much cleverer (and more innovative) than they are. It’s not just RDF, I should say, but the whole Semantic Web pitch (typified for me by the idea of halting global terrorism using the power of Topic Maps) that seemed ludicrous to me.

Time moves on, and I might be changing my mind.

I think RDFa has a lot of things going for it. I’ve been a big Semantic Web sceptic for a long time, but getting semantic information embedded into web pages is cool, and RDFa is that much more rigorous than microformats. Sure, it’s a bit more complicated too, but I’m not afraid of namespaces!

The problem is that I’m supposed to be assessing the introduction of RDFa into a biggish, important, real-world website. It’s a website where every change has to go through a Process. There are project managers, development managers, product managers. There are functional specifications, technical specifications, and rollout documents. There are unit tests, peer reviews and user acceptance tests. The database is huge; the HTML is pre-generated.

Having avoided RDF like the veritable plague for years, I have been forced to look at it properly for my latest “put RDFa on our web pages” project. So the other day I came across this weirdness surrounding “QNames” in Turtle, SPARQL and RDFa (and so on)…

As we all know, RDF is about making statements about resources, and resources are identified by URI. And the predicates/properties that you use to make statements about resources are also identified by URI. So I can say things like (in Turtle syntax):

<http://www.lmnl.org/wiki/Creole>
  <http://purl.org/dc/elements/1.1/creator>
    [<http://xmlns.com/foaf/0.1/weblog>
     <http://www.jenitennison.com/blog>] .

and it means that the creator (as defined by Dublin Core) of the page <http://www.lmnl.org/wiki/Creole> is someone whose weblog (as defined by FOAF) is <http://www.jenitennison.com/blog/>.