Internet Alchemy

I’ll be in the Bay Area for the Web 2.0 conference for a few days next week, arriving Tuesday night. I’ll be with Paul Miller who recently joined Talis. Please feel free to drop me a line or skype me if you’d like to get together to talk about silkworm, web services, semantic webs, or just shoot the breeze.

I’ve added a few more blogs to Planet Web 2.0. These are onese I’ve been particularly enjoying over the past few weeks:

• Dion Hinchcliffe - some new and interesting viewpoints including a different visualisation of Web 2.0
• John Musser - APIs, APIs, APIs. The new mantra of Web 2.0?
• Dan Grossman - a VC’s perspective on Web 2.0
• Bill Scott - thoughtful and thought-provoking writing on AJAX, rich data wen other Web 2. 0 goodness.

I’ve also added Richard’s ZDNet blog too. I meant to add it weeks ago but things have been hectic!

As part of the ongoing experiment with adding tagging to this site, I’ve enabled RSS feeds for individual tags, e.g. web20 or tagging. I still think that tagging has value but it’s not a panacea.

My goal in this posting, prompted by some email discussions on constrained profiles of RDF/XML, is to take three simple triples and see how many ways there were of serialising them as RDF/XML. I chose not to consider order of the elements to be significant - I may be mean but I’m not without a heart.

The triples I chose were trivial. In prose they are: “there is something that is a person, with a name of Eve and a homepage of http://example.org/~eve”. In Turtle/NTriples/N3:

_:eve rdf:type foaf:Person .
_:eve foaf:name "Eve" .
_:eve foaf:homepage <http://example.org/~eve>.

When I started this posting I thought I could squeeze out seven RDF/XML serializations of the same three triples, so I had a clever name for the post all worked out. When I actually came to serialize the triples I came up with sixteen variations! It rather spoilt the joke but it sort of hammers home the point I’m trying to make.

Here’s a challenge for a talented XPather: write an XPath that selects the homepage of the person with name “Eve”. It must work with all sixteen of these serialisations.

Remember, all of these XML documents parse to the same three triples above. My maths is too rusty to work out how many serialisations there are of 4, 5, 6 or more triples let alone the few hundred that comprise my FOAF file.

Face 1:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <foaf:Person>
    <foaf:name>Eve</foaf:name>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </foaf:Person>
</rdf:RDF>

Face 2:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
    <foaf:name>Eve</foaf:name>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 3:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <foaf:Person foaf:name=“Eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </foaf:Person>
</rdf:RDF>

Face 4:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description foaf:name=“Eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 5:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <foaf:Person rdf:nodeID=“eve”>
    <foaf:name>Eve</foaf:name>
  </foaf:Person>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 6:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <foaf:Person rdf:nodeID=“eve” foaf:name=“Eve” />
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 7:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
    <foaf:name>Eve</foaf:name>
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 8:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve” foaf:name=“Eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 9:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:name>Eve</foaf:name>
  </rdf:Description>
  <foaf:Person rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </foaf:Person>
</rdf:RDF>

Face 10:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:name>Eve</foaf:name>
  </rdf:Description>
  <foaf:Person rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </foaf:Person>
</rdf:RDF>

Face 11:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:name>Eve</foaf:name>
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 12:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve” foaf:name=“Eve” />
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 13:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:name>Eve</foaf:name>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 14:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve” foaf:name=“Eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
</rdf:RDF>

Face 15:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:name>Eve</foaf:name>
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
  </rdf:Description>
</rdf:RDF>

Face 16:

<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” 
         xmlns:foaf=“http://xmlns.com/foaf/0.1/”>
  <rdf:Description rdf:nodeID=“eve” foaf:name=“Eve” />
  <rdf:Description rdf:nodeID=“eve”>
    <foaf:homepage rdf:resource=“http://example.org/~eve”/>
  </rdf:Description>
  <rdf:Description rdf:nodeID=“eve”>
    <rdf:type rdf:resource=“http://xmlns.com/foaf/0.1/Person” />
  </rdf:Description>
</rdf:RDF>

If we rely on HTTP we will melt the Internet.

Don Box

I have to admit to a terrible addiction of hoarding old computer parts. I’m in the middle of a three way room swap - my office is becoming Kier’s bedroom, Freya is moving into his vacated bedroom and now her old bedroom, the smallest in the house, is now the office. It’s a tricky maneuver and up until this weekend we had a quantum superposition of bedroom states. I collapsed one part of that at the weekend and now there is no office detritus in Kier’s s new bedroom. There’s nothing else either yet, but that has to wait until next weekend.

Having far less space means I have to do the unthinkable and throw some stuff out! I’m resigned to the fact that my PC building days are over - I’m exclusively a laptop user now. Here’s the roll call of some of the victims:

• A Western Digital Caviar 1210 hard disk dated 2 November 1993 with a capacity of 212.6 MB - I believe this came from the first PC I ever fully owned.
• An internal ZIP drive from 1997 plus half a dozen ZIP disks.
• A truly ancient IBM external floppy drive with proprietary thinkpad connector
• An internal DDS2 DAT drive plus a dozen tapes with unknown contents (obsolete in the face of writeable DVDs)
• An ultra-slim CD drive that came out of a Compaq server and so has a proprietary interface
• A floppy drive missing the disk eject button
• A trackball that never worked with any of my vaios
• Several mice
• A Hewlett Packard Deskjet Portable circa 1996 - single sheet feed
• An external tricom modem designed for laptops (when was the last time I had a laptop without a built-in modem?)
• Dozens of random cables…

The following items go into Kier’s hands to help feed his insatiable appetite for all things electronic:

• Two IBM Fast/Wide SCSI cards
• An Intel Celeron 500
• A Tyan Tiger motherboard

Fascinating paper on the underlying architecture of the eDonkey network

eMule is a popular file sharing application which is based on the eDonkey protocol. This report describes the network behavior of eMule and explains the basic terminology that is needed to understand the protocol. The report also gives a full specification of the eMule network protocol including an appendix which provides the message formats.

I experienced something of a system shock at the DC2005 conference today. I sat in on the Architecture Working Group meeting and as events unfolded I suddenly realised that, without a radical change, I could well be witnessing the beginning of the end of the RDF project.

We were discussing the progress of the Dublin Core RDF task force and there were a number of agenda items under discussion. We didn’t get past the first item though - it was so hairy and ugly that no-one could agree on the right approach. The essence of the problem is best illustrated by the dc:creator term. The current definition says An entity primarily responsible for making the content of the resource.. The associated comments states Typically, the name of a Creator should be used to indicate the entity and this is exactly the most common usage. Most people, most of the time use a person’s name as the value of this term. That’s the natural mode if you write it in an HTML meta tag and it’s the way tens or hundreds of thousands of records have been written over the past six years. Here’s that model:

Of course, us RDFers, with our penchant for precision and accuracy take issue with the notion of using a string to denote an “entity”. Is it an entity or the name of an entity. Most of us prefer to add some structure to dc:creator, perhaps using a foaf:Person as the value. It lets us make more assertions about the creator entity. Here’s a picture of that model:

The problem, if it isn’t immediately obvious, is that in RDF and RDFS it’s impossible to specify that a property can have a literal value but not a resource or vice versa. When I ask “what is the email address of the creator of this resource?” what should the (non-OWL) query engine return when the value of creator is a literal? It isn’t a new issue, and is discussed in-depth on the FOAF wiki.

There are several proposals for dealing with this. The one that seemed to get the most support was to recommend the latter approach and make the first illegal. That means making hundreds of thousands of documents invalid. A second approach was to endorse current practice and change the semantics of the dc:creator term to explictly mean the name of the creator and invent a new term (e.g. creatingEntity) to represent the structured approach.

Danbri referred us to work he had done after the last DC meeting in 2004 on a SPARQL query to convert between the two forms. Discussion then moved onto special case processing for particular properties, along the lines of “if you see a dc:creator property with a literal value then you should insert a blank node and hang the literal off of that”. Note that I’m paraphrasing, no-one actually said this but it was the intent.

That’s when my crisis struck. I was sitting at the world’s foremost metadata conference in a room full of people who cared deeply about the quality of metadata and we were discussing scraping data from descriptions! Scraping metadata from Dublin Core! I had to go check the dictionary entry for oxymoron just in case that sentence was there! If professional cataloguers are having these kinds of problems with RDF then we are fucked.

It says to me that the looseness of the model is introducing far too much complexity as evidenced by the difficulties being experienced by the Dublin Core community and the W3C HTML working group. A simpler RDF could take a lot of this pain away and hit a sweet spot of simplicity versus expressivity.

Where can complexity be removed?

The graph is fundamental and I think the base triple model - the simplest construct that could possibly make a graph - is right. But there are too many types of nodes: URIs, blanks, literals, literals with language, datatyped literals, XML literals. What if there were only two: literals and URIs? The rest are a distraction. URIs are cheap and to be honest I’ve never understood why referring to me with a URI like http://purl.org/NET/iand/foaf#ian is frowned on, especially in light of the httpRange-14 decision.

What if it were possible to define two types of properties: those that had literal values and those that had URI values? Wouldn’t that make mappings from HTML and Dublin Core simpler and easier to validate?

What if we jilted the ugly sisters of rdf:Bag, rdf:Alt and rdf:Seq and took reification out back and shot it? How many tears would be shed?

What if we junked classes, domains and ranges? Would anyone notice? The key concept in RDF is the relationship, the property.

The result would be a subset of RDF, RDF-lite perhaps. All instances of RDF-lite would be valid RDF-full but the converse couldn’t be true. Sparql would still work and so, I suspect, would the OWL machinery despite the omission of classes. RDF diffs would be trivial without blank nodes allowing efficient synchronisation of triple stores. Signing of triples would also be possible without requiring the hoops of canonicalisation to be jumped through.

Maybe it’s necessary to take a few steps back to find the true path to the summit.

So, I’m here at the Dublin Core conference. Hotel has free wi-fi, which coupled with Skype lets me chat to the kids before they go to bed without having to pay through the nose. The conference itself has wi-fi too but only port 80 seems to be open which means no email, webmail, skype, IRC or MSN. Blogging works though!

P.S. leave a message on this entry if you want to meet up.

I’m going to be at the Dublin Core 2005 conference in Madrid all next week. If anyone wants to meet up for a chat, food or beer (or all three) email me at iand@internetalchemy.org or give me a call on +44 (0)7966 473239. See you there!