Re: [RSS-DEV] A note on namespaces
- On Sat, 7 Sep 2002, Dan Brickley wrote:
>I think it's more about perspective than control -- or perhaps about
> The debate about namespaces in RSS is a debate about control. Two years
> ago, there was a big fight about RSS, control and namespaces. This WG was
> created by those of us who wanted to decentralise control of RSS, so that
> the dull common core (channel/item/title/link etc.) was managed separately
> from the creation of descriptive markup that could add valuable detail to
> RSS feeds. We chose RDF as our architecture for making decentralised use
> of the XML namespaces mechanism, building on RSS's origins with Netscape
> and MCF. The main objection to this approach came from Dave Winer, who
> argued strongly against namespaces (and RDF) on the grounds of
> simplicity, preferring a centralised model of format control with a
> slowly evolving set of RSS tags from a single authoritative source.
the way control of semantics is managed. And I think this is an
important debate, because it is a central question in the whole
semantic web approach.
Dave's approach (my interpretation) is that it's better to create
a simple direct vocabulary for writing syndication messages --
something that is easy for a person to understand by reading a
message, with only basic understanding of XML. It's then easy for
relatively non-technical people to build RSS feeds (or process ones
they receive), using their intuition of the message semantics
as a guide.
Rationale: this is what worked well with HTML, so let's
keep doing this until the model breaks. Then, the obvious
next step is to use namespaces as the simplest possible XML way
of adding non-standard components into RSS.
I'd call this the 'human-centric' model, since the focus is on
making the markup as simple as possible for people to read and
understand. On the other hand, this means the receiver's
processing tools end up being complicated (and messy), as they
have to allow for all the idiosyncracies of 'semantically
different' feeds using a bunch of 'cobbled' together adapters
(one for each sufficiently different RSS feed). Still,
you can usually figure it out by looking at a message or
The RDF-centric approach starts by assuming that the preceding
approach is insufficient in the long run: as syndicated feeds get
more complicated (that is, they contain lots of complex
extensions/modules, local customizations, etc.), then 'cobbling'
breaks down, and you need a formal semantic framework (RDF) to
stabilize the whole thing and make machine-to-machine exchange
and processing (more) reliable.
Basically, the idea is that syndication management gets harder and
harder as you get more and more 'weird' RSS feeds ... And you can
fix this by ensuring the messages are themselves more semantically
I'd call this the 'semantic-centric' approach, since it focuses on
ensuring semantically-parseable messages. The catch is that the
approach is much more rigorous -- statements must be 'correct'
and meaningful RDF, and you need tigher control over the semantics
of interchange. This it's harder for small developers or
individuals to follow this approach because ... well ... RDF
is harder than simple ol' XML.
My take: if the goal is to make RSS easy to use _by hand_ by users
or run-of-the mill developers, then Dave's approach makes the
most sense. On the other hand, if the goal is to use RSS as a
machine-to-machine exchange syntax, with well-defined APIs (some
sort of Web services interface) with little or no human intervention,
then the RDF-way makes most sense.
And, it woudl seem, the goal is both -- as it is with the whole
semantic web question. No wonder this debate keeps coming back
again and again and again ....