Loading ...
Sorry, an error occurred while loading the content.

Re: [RSS-DEV] A note on namespaces

Expand Messages
  • Ian Graham
    ... I think it s more about perspective than control -- or perhaps about the way control of semantics is managed. And I think this is an important debate,
    Message 1 of 2 , Sep 8, 2002
      On Sat, 7 Sep 2002, Dan Brickley wrote:

      > 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.

      I think it's more about perspective than control -- or perhaps about
      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
      two ...

      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 ....

    Your message has been successfully submitted and would be delivered to recipients shortly.