I've just read DaveWiner's article, and I think it's disgraceful that he hasn't even mentioned RSS 1.0
RSS is an acronym out of control. My limited understanding of the situation is that Dave Winer simply refuses to acknowledge the RDF origins and subsequent 'fork' of the RSS standard. The RDF compliant version of RSS (which originally stood for RDF Site Summary) is RSS 1.0 and this is adopted by people like W3C, OASIS and the O'Reilly Network (web site related to the O'Reilly publishers).
The significant point about RSS 1.0 is that it allows the users to take baby steps in the world of RDF .. the basis of the semantic web. By using RSS 1.0 your not only marking up your news for syndication .. you're also joining the semantic web (as defined by w3c's path ) http://www.w3.org/DesignIssues/Semantic.html )
THIS is the real competition that Atom needs to be 'worried' about, NOT Dave Winer.
The reason for this 'rant' is that I've just spent the last couple of months defining a syndication standard for UK local authorities (see and http://www.esd-toolkit.org/laws/) and) we all agreed to adopt RSS 1.0 because it had the 'healthier' prospect as a standard compared to RSS 2.0 (and that Atom was too new to be adopting at this stage.)
I find it bizzare that Dave Winer doesn't even mention the very popular RSS 1.0 'fork' in a piece that was otherwise recognising the value of 'working together'
Strictly speaking RSS 1.0 is NOT the origin of RSS. The precursor of RSS was invented by Netscape, and Winer modified it, in co-ordination with Netscape, to produce RSS 0.91 and then 0.92 which became a de-facto standard. Some people then tried to graft RDF on to it, to make RSS 1.0. However the standard didn't particularly take off. If you think RSS 1.0 is "very popular" show me a comparison count of RSS 0.92, RSS 1.0 and RSS 2.0 feeds in the world.
The point is that the "let's define things properly" camp has essentially abandoned RSS 1.0 in favor of Atom, and the "bottom-up" camp was never there. So where does the healthiness of RSS 1.0 come from? I dunno, maybe things look different in local authorities but I'll bet on the market to win this.
Naturally, I think RDF is pointless because the SemanticWeb is dead in the water ;-) I tried to at least understand RDF last year when I was very excited about FOAF but I gave up after three days of trying to read tutorials which hadn't been updated since 1998. (The question I foundered on was : how do I represent a boolean value in RDF? Do I make something which references the ultimate URI of "truth"? Can I just set have a tag who's text content is "true" or can I allow the existence or non-existence of a tag to indicate that something is true or present or not. )
Now, I freely admit to being lazy and stupid, but it's precisely because, statistically more people are like me than smart and hard-working, that I can't see how everyone's going to switch to RDF or SemanticWeb. (Except maybe after the tools are automated and it essentially becomes a big-corp. thing that casual hackers don't have the resources to get involved in.)
When I read criticisms of the difficulty of RDF and NameSpaces, they resonate very strongly with my experience. But maybe we need some kind reason why these are, in principle, more difficult. After all it's only a couple of extra lines of code. Why is this so much harder?
I think the key is this : RDF namespaces force you to think more globally.
That's not controversial. That's the point of RDF. To make you mark things up in a form which (in theory) will eventually be widely understood and which allows inferences to be made.
But the problem is with the force bit. A lot of the time you don't want to think globally. You have an immediete problem (how to make this information available to that program); and really you :
- don't have the time,
- don't have enough knowledge, and
- don't need
to think about the place of your data in the wider ontology.
My point is that, as a developer, you really need the freedom to make a suitable decision about the scope of your thinking.
RSS 0.9X and 2.0 are designed for immediate communication between existing programs. If you need other formats you can roll your own XML or RSS variant. RSS 1.0 is designed, as you rightly point out, to be a gateway drug, to constrain you into doing a little bit of that unwanted global thinking.
Forcing developers to do things which aren't relevant to them usually means several things :
- They'll do it badly :
** They'll put vague, over-general tags around things because they don't know the more useful and specific tags they should use instead.
** They'll use off-the-shelf ontologies like the DublinCore which are not necessarily very relevant to the data.
They'll fake** it by putting nonsensical information in, just to make it past the syntax checking. (eg. make people put a date field in when they don't need or have access to the date, and they'll probably fill it with a dummy date string.
- You'll steal time from the things they actually do need to do to
- You'll demotivate them (who likes to do irrelevant work?)
I said the SemanticWeb was dead in the water because I think ClayShirky's criticism nails it very thoroughly. (Read the piece linked from the SemanticWeb page.) RDF is a political ideology. It starts from the idea that it would be good for people to do more mark-up (true) and infers that the way to make this happen is to design formats that coerce them into doing more mark-up. What will happen instead is that people will choose to use formats that are less coercive.
Also Shirky's point about confusing what's hard and what's easy is definitely true for RSS. The times when the extra thinking of RDF isn't a problem, are times when it solves trivial problems. Certainly I'd be interested in any actual application which used RSS 1.0 because it needs to, ie. does something useful with RDF that couldn't have been done with some variant of RSS 2.0.
Now, I mentioned that things might look different from a local-government perspective. That's clearly true, because government is the ultimate top-down control system where one lot of people make decisions and tell other people what to do. So, clearly, a committee in local government can mandate the use of these formats. However, this works fine until you reach the boundary of the hierarchical organization, when it needs to communicate with the outside world. At this point you'll bump into other people who made the decision to work differently.
But let's see. I'm open to be proven wrong if RSS 1.0 really does start to outpace RSS 2.0 and 0.92.
Q : Phil, I can't help noticing that the implication of your argument here ... against the global NameSpace in RDF is incompatible with what you say in CodeIsNotATree / SemanticsOfProgrammingEnvironments,. There you think that module-names should negotiate at a global scale for the rights to unique IDs in a global name-space, rather than forcing people to think in terms of hierarchies. Now you say that people want to think in terms only of their local name-space without considering the global picture.
A : Erm ... yes, let me think about that a bit.
Phil ... couple of points ... including some pedantry :)
1) Origins of RSS:
When I talked of "RDF Site Summary" as the origin of RSS I was refering to a history of RSS described in the O'Reilly book about RSS, in which they state "The first draft of the RSS format, as designed by Dan Libby, was a fully RDF-based data model, .....". Admittedly this was soon compromised so that even RSS 0.9 was not true RDF, but hey the 'R' in RSS originally stood for RDF.
RSS 1.0 was then a move to bring RSS back to being fully RDF compliant.
2) Market uptake
A recent survey put market uptake of the relative formats as around 30% RSS 1.0, 26% RSS 2.0 and 38% RSS 0.91. We would not have gone with RSS 1.0 if it wasn't already a serious contender in terms of market uptake.
One of the joys of namespaces is PRECISELY that you can think locally whilst acting globally. By using a global prefix to the local namespace you can use any term you wish to use locally with full confidence that it will NEVER clash with a term used by someone with a different global prefix.
RDF can be expressed in very simple ways within XML (now that RDF/XML has been well defined). This was not always true, and probably held up the uptake of RDF by many years.
RSS 1.0 is a simple format .... it's just that 'Really Simple Syndication' is winning the spin war on this point. Indeed, you don't need to think about RDF when using RSS 1.0 for simple headline syndication .. it's just a simple XML format with some clear rules on how to use it.
The fact that RSS 1.0 happens to be in RDF format is a bonus that can be exploited later.
Both RSS 2.0 and RSS 1.0 are extensible through the use of defining elements in a new namespace. Currently the RSS 2.0 page about modules lists 9 modules. The RSS 1.0 pages list 23 modules !!
6) Still early days for RDF
Yes ... I agree that RDF is building for a future that hasn't yet fully happened. But:
- there is no more need for 'force' within the RDF world than within the XML world in general.
- the expression of 'truth' values is no more difficult in RDF than in XML
- RDF is precisely NOT about top down control ... it allows for bottom up just fine
... and finally, the best description I have heard to explain the importance of RDF over straight XML is as follows:
- XML = tree structures
- RDF = graph structures
RDF/XML is slowly turning the web into a network of locally produced, interconnected, typed, directional graphs. That's so much more useful than plain old XML.
... and admittedly I have just recently been bitten by this bug .. and I'm still on a high ;)
Thanks, this is useful. And could sort out some of my confusion.
1) I'll grant you. I didn't know this.
: update : according to this ( - http://www.cadenhead.org/workbench/entry/2005/01/08#2431 - which is by a known Winer supporter) RSS from Netscape was certainly RDF though with some possible inspiration by a non-RSS format from Winer
2) Ditto. Are the trends also in RSS 1.0's direction?
3) I still see it as making you think more about the global.
If I understand correctly, the difference is between :
- 1) using a <name> tag, and
- 2) doing 1) AND specifying in the header that <name> is an example of <globalUri:name>
I grant that 2) is pretty minimal, but it still seems to require an extra step. If, for example, I don't have the appropriate globalUri for name off by heart, I still have to go and look it up. Equally, when I parse a document, I can't rely on <name> having a meaning defined by convention. I have to check it against the header, in case a perverse source has mapped it onto <globalUri:date>. Also, what am I meant to do if an RSS file has erroneously mapped <name> onto <globalUri:date> but then used it as if it contains name?
4) Well, it's simple, but it still looks like RSS 1.0 has an extra-level of indirection. While it isn't clear what that extra indirection is ever going to buy us down the line.
The only scenario I can imagine where RSS 1.0 scores over RSS 2.0 is if you have a generic RDF processor which sucks in an RSS 1.0 feed, knowing nothing about RSS and syndication, but somehow uses an external service to identify that these tags are mapped onto globally defined things that are typically used in syndication feeds, and from this guesses what it should do with this feed. But seriously, can you imagine an application which doesn't understand syndication or the purpose of RSS, but does anything meaningful based on looking up the meaning of <name> etc?
(Bit like counting sheep by counting legs and dividing by 4, you don't understand the concept of "syndication" but infer it from your understanding of "name"?)
Isn't it really the case that so much implicit context is needed that, in practice, anyone consuming an RSS feed is going to use a dedicated RSS reader? And if you have a dedicated RSS reader then it could work equally well with 1.0 or 2.0?
(Maybe TypeKit does something like I'm satirizing here?)
5) Good point in RSS 1.0 favour. Presumably because 1.0 can use generic RDF modules rather than ones specifically crafted for RSS?
6) The problem with building for a future which hasn't happened is that most of the time you're building for a future which never happens. It's Wiki:BigUpFrontDesign written especially big.
If you know how to represent boolean values in RDF, please tell me. I really can't figure it out from the documentation. :-(
Graph vs. Tree is clearly something I can sign up to : See HypertextVsHierarchy. OTOH graphs are basically what you get by linking things. So, as far as I can see, the only thing you need to make links between XML documents is XLink.
Anyway, you've convinced me I need to have another look at RSS 1.0, and maybe RDF. Cheers. :-)