Jon Udell has written a good summary of a lot of the recent discussion about XML, RDF and namespaces in his post today on Symbol grounding and extensible aggregators. I have been trying to keep up with a number of these discussions, as they are very relevant to the iCite net.

Whatever structure is used to represent information—whether it is a node of information, or a list or a tree or a graph of node relationships, processing that information requires some querying of that structure. And, forming the query and working with the query results means either knowing something about that structure or being able to figure something about it.

XML and RDF both do certain things consistently which provide a structural pattern that can be understood by parsers. For example, opening tags and closing tags in XML provide a pattern that you won't expect to find in a plain text file.

I think what can be said about RDF over XML is that the RDF structure provides a pattern that is more consistent to figure out, in terms of its general logical meaning. RDF/XML is, in the general case, a richer structural pattern than XML.

But, in a practical application like reading a RSS-type feed, generally the feed reader is looking for particular things. For example, every RSS-type reader I have ever seen looks for things like posts, post titles, post timestamps, etc. In other words, these RSS-type readers aren't trying to figure much, if anything out, about the information based on its structure.

This "knowing things ahead of time" context, I think, frames some of the reaction towards RDF and assumption that XML is quite sufficient for RSS-type feeds. From this perspective, namespaces just allow one to add other things to look for that aren't the core things already being looked for.

What I think is an interesting issue, and what I think Jon is getting at in his post, is how does an information reader know to look for new types of information and then know what to do with what it finds?

With the iCite net, I have a particular application through which I am building an experiment with this. In the iCite net, each iCite's attribute set (domain schema and domain operators) is published as an iCite, and can be subscribed to (used) by other iCites.

As I mentioned in my recent post about Are RSS and Atom/N/Echo/Pie formats suffering too tightly coupled MVC?, iCites look to expose information models and controllers the way web pages expose the views.

What is interesting about web pages, as an example, is that each new page can totally change the user interface. A button concept can go from being a grey box to being a picture of Marc Canter in Kindergarden.

Similarly, I am interested in exploring applications where the "browser" can support data structure and operational changes with each new "page". Web pages already do this, but within a relatively limited range of data structure and operational possibilities. At least, I think with the iCite net, that range can be extended.

I think both XML and RDF proponents have imagined this kind of browser-application that is hip to model, view and controller extensibility. And, I may be incorrect in this assumption, but I think the RDF focus is more on model extensibility (e.g., RDF databases) and the XML focus is more on controller extensibility (e.g., web services) and view extensibility (e.g., XSLT and CSS).

In my own focus, I basically just think what would be interesting would be, the way every web user can create and post a blog post or web page and link to others, if they could also create a schema / namespace / data structure and web service and link (interoperate / aggregate) those with others.

I think, like blogging, there are fun and natural ways to do this.