Blindsiding and forward thinking

Recovered from the Wayback Machine.

When Sam Ruby invited me into an IRC chat last week to talk about creating a compliant RDF/XML syntax for Pie/Echo/Atom, I wasn’t aware that there was an agenda behind this effort. It wasn’t until Sam published the full model at his weblog and discussed how RDF needs to meet XML half way and that there needs to be changes to the RDF/XML syntax for it to be more ‘palatable’, that I became aware that there was a lot of behind the scenes conversations occurring about RDF/XML and Pie/Echo/Atom.

I was disappointed in this effort, not the least of which is that all it did last week is start up the usual anti-RDF crowd; the same crowd who give very little in the nature of specifics about exactly what they dislike. (Sam did give three specifics, and all three were comprehensively addressed in his comments.)

Being an RDF and RDF/XML supporter among anti-RDF crowd feels like being in the middle of a bobbing head factory after an earthquake.

I though the issue was over and done with, though, and I was turning my attention to trying to repair the damage to RDF/XML, when I read with suprise today, this article by Mark Pilgrim at I discovered it when I went to Mark’s site and saw Everything considered harmful.

If I was disappointed in last week’s debacle, I was wasn’t made happier that O’Reilly and published Mark’s article when they declined my suggestion of an article discussing some of the politics surrounding RDF/XML — a suggestion I made over a month ago. And that my own effort last week was, frankly, used against what I support — without me being given fair time for defense except in this weblog. Thank goodness for weblogs, I suppose.

In case you’re not a techie and are curious as to what the technical term for all of this is, it’s called ‘being blindsided’.

Mark discusses four issues of RDF: model, syntax, semantic web, and tools. He stated that people may be communicating at cross-purposes because they’re talking about different issues when they talk about ‘RDF’. Some may like the model, but not the syntax. Others may like the tools, but think the semantic web is a pipedream.

I can agree with Mark’s assessment of the four issues. His opinion about using RDF for Pie/Echo/Atom is: the model forced the people to examine specific aspects of the syntax, which is good; the syntax sucks; the tools that work with the syntax are good (he mentions a Python one, of course, RDFLib); while the semantic web is a pipedream.

I can’t disagree with Mark’s opinion — it is his opinion. But I can disagree with his arguments.

Unfortunately, the example used to demonstrate how difficult the RDF/XML syntax was one created under a specific requirement — create a full, proper, formal syntax using all nuances of the RDF/XML syntax. Because of this, it effectively brings in the most complex aspects of RDF/XML, rather than keeping the model simpler, and more digestible by the XML folks. I wrote an email to Sam Ruby afterwards and said the model could be made simpler, more practical.

Returning to Mark Pilgrim’s article, he said that because the syntax is too complicated for the XML people to manually read and write, this makes RDF/XML untenable for Pie/Echo/Atom. He further states that we RDF/XML supporters can use XSLT to transform the syntax easily, and that when we have RDF support installed, we also have XSLT support installed.

Mark is in error.

First of all, an important objective of RDF/XML is dissemination of data. It’s not the processing it’s the data that’s critical; the more data is organized into RDF/XML, better yet full OWL, the more data is directly accessible by automated tools and bots from machines other than where the XML resides. In addition, data formatted as RDF/XML can be merged automatically, without having any prior knowledge of the vocabulary — another critical factor.

If a person who has the Pie/Echo/Atom syndication feed does not run an XSLT transform on the data to create RDF/XML versions of the data, the web bots then will need to do this, and this makes most data gathering techniques prohibitive.

The power behind RDF/XML is to have people generate data files that can be accessed by RDF tools, as Technorati is doing with our FOAF RDF/XML files at this very moment. Most webloggers I know don’t have RDF or XSLT capability or experience. They don’t have XML capability or experience, either, if it comes to that.

Second, what makes Mark think that people who work with RDF/XML are familiar with XSLT or have this installed automatically with our ‘tools’? I’ve worked with RDF/XML in six different programming languages, but I don’t work with XSLT — I think XSLT is the ugliest damn thing in the world to work with. I don’t have XSLT support installed.

Now, tools can be modified to add support to generate the RDF/XML format explicitly. I can create an MT template to do this, and I’m sure other tools can also do this. This helps RDF/XML users, but unfortunately, this doesn’t help Pie/Echo/Atom, or the Pie/Echo/Atom syndication users.

With Pie/Echo/Atom being vanilla XML, it becomes extremely difficult to add in new extendsion to the data. These have to become basically Pie/Echo/Atom extensions, which means they are single-purpose only, and there isn’t necessarily common agreement about what these extensions mean — the group has to work through each. Secondly, there is no automated way to add support for existing RDF/XML vocabularies that are getting widespread support, such as FOAF and others that are most likely going to be hitting the streets shortly. What has to happen is that transforms need to be made with FOAF and other RDF/XML vocabularies to XML, added into Pie/Echo/Atom, and then transformed back to RDF/XML.

Now, exactly what about this is ‘easier’?

In addition, I can access an RDF/XML file using a web bot or any kind of application, can pull out the statements, can store them, can query them all without making one change to code to add the new vocabulary. Not one change in code. The same ease of extensibility does not apply to vanilla XML. Period.

I asked a question, and no one at Pie/Echo/Atom answered it: Can you use regular XML tools on a Pie/Echo/Atom RDF/XML feed? Without transforms? If the answer is yes, then which format is the more exclusionary?

Regardless, I am disappointed at how this whole thing played out. I thought the RDF/XML community acted with integrity, first supporting the notion that Pie/Echo/Atom would not be RDF/XML and we would have to use transforms (though we knew this would cause problems later for Pie/Echo/Atom and others); secondly, when the issue was brought up again, supporting, in good faith, the creation of the proper RDF/XML model with hopes of further discussion, only to have our effort and our hopes tossed aside.

As for the semantic web — as Kendall Clark stated today, with the candidate release of OWL, we’re on our way. We were only waiting on the specs to get to recommendation state because there was too much flux previously. Now, we have a stable platform in which to work. In some ways, I’m glad we don’t have to worry about Pie/Echo/Atom and it can go its little deadend alley approach of being ‘pure’ XML, because we all have other things to do.

As for the semantic web, and being a dreamer — guilty as charged. I can see the ’semantic web’ in my mind, and it’s so real to me, I can reach out and touch it. If this is a pipedream, then leave the room, because I’m going to smoke it. And I’m going to help make it real.

I could use so many examples from history of dreamers who made things work in the face of those who said they couldn’t be done — proving that the sun doesn’t circle the earth, that we can fly, that we can walk on the moon and hopefully soon, on Mars. That time and light are effected by gravity and actually be able to demonstrate it. To discover a planet in another solar system. That we can talk to someone in England directly on the phone. That some day, we’d be able to sit at a computer, reading this.

That something like a transparent food could be created in all flavors, none of them natural. So put that on your scales, and see if you don’t get jello.


One other thing that I thought of after I wrote this article originally. Mark mentioned that through the process of creating the RDF/XML syntax, the RDF model generated questions about the order and the nature of two sets of data — the entries and the contributors. He thought this was a very helpful exercise.

However, Mark neglected to mention how it was the nature of RDF/XML semantically flavored syntax that drove this out. He also neglected to mention how vanilla XML was going to be used to enforce these set membership rules. So, how does one enforce or at a minimum document collection or container semantics using plain vanilla XML?

Print Friendly, PDF & Email