+1 I completely agree with Bob again.
Though my preference of course would be to put RDF in the content.
RDF has structures for ordered lists. It probably has vocabularies
for songs.
It has vocabulary to specify the author of a work, etc... And with
foaf you
could also specify which of the artists was your friend. In short you
can
mix the different RDF vocabularies out there in well understood ways.
For those of you new to RDF but au fait with Java, I have just
written up a blog
that should help explain exactly why RDF is so powerful:
http://blogs.sun.com/roller/page/bblfish?
entry=java_annotations_the_semantic_web
In short: RDF can be mapped directly onto Java Beans. Just as Beans
can be plugged
together, so RDF markup can be plugged together. Welcome to the world
of OO xml.
Henry Story
On 30 Aug 2005, at 07:49, Bob Wyman wrote:
I’m sorry, but I can’t go on without complaining. Microsoft has
proposed extensions which turn RSS V2.0 feeds into lists and we’ve
got folk who are proposing much the same for Atom (i.e. stateful,
incremental or partitioned feeds)… I think they are wrong. Feeds
aren’t lists and Lists aren’t feeds. It seems to me that if you
want a “Top 10” list, then you should simply create an entry that
provides your Top 10. Then, insert that entry in your feed so that
the rest of us can read it. If you update the list, then just
replace the entry in your feed. If you create a new list (Top 34?)
then insert that in the feed along with the “Top10” list.
What is the problem? Why don’t folk see that lists are the stuff of
entries – not feeds? Remember, “It’s about the entries, Stupid…”
I think the reason we’ve got this pull to turn feeds into Lists is
simply because we don’t have a commonly accepted “list” schema. So,
the idea is to repurpose what we’ve got. Folk are too scared or
tired to try to get a new thing defined and through the process, so
they figure that they will just overload the definition of
something that already exists. I think that’s wrong. If we want
“Lists” then we should define lists and not muck about with Atom.
If everyone is too tired to do the job properly and define a real
list as a well defined schema for something that can be the payload
of a content element, then why not just use OPML as the list format?
What is a search engine or a matching engine supposed to return as
a result if it find a match for a user query in an entry that comes
from a list-feed? Should it return the entire feed or should it
return just the entry/item that contained the stuff in the users’
query? What should an aggregating intermediary like PubSub do when
it finds a match in an element of a list-feed? Is there some way to
return an entire feed without building a feed of feeds? Given that
no existing aggregator supports feeds as entries, how can an
intermediary aggregator/filter return something the client will
understand?
You might say that the search/matching engine should only present
the matching entry in its results. But, if you do that what happens
is that you lose the important semantic data that comes from
knowing the position the matched entry had in the original list-
feed. There is no way to preserve that order-dependence information
without private extensions at present.
I’m sorry but I simply can’t see that it makes sense to encourage
folk to break important rules of Atom by redefining feeds to be
lists. If we want “lists” we should define what they look like and
put them in entries. Keep your hands off the feeds. Feeds aren’t
lists – they are feeds.
bob wyman
