--- In rss-dev@y..., Dan Brickley <daniel.brickley@b...> wrote:
>
> On Sat, 7 Sep 2002, p2psmoke wrote:
>
> > --- In rss-dev@y..., Chris Croome <chris@w...> wrote:
> > > Hi
> > >
> > > On Sat 07-Sep-2002 at 05:36:16PM -0000, p2psmoke wrote:
> > > >
> > > > Still, you'll get pushback, would need to have specific,
tangible
> > > > reason for having container (i.e. necessary for backwards
> > > > compatibility).
> > >
> > > The reason for the container (the Items element) is to enable
the
> > > item's to be ordered from a RDF point of view.
> > >
> > > Chris
> >
> > Chris, I know where you're coming from and I've tested this one in
> > public and it just don't fly. The response is "Well, we all know
the
> > order of the items".
>
> Shelley,
>
> Chris is right. An RDF parser (such as the one in Mozilla /
Netscape 7,
> HP's Jena, Redland's Raptor, Adobe's XMP library, etc) has well
understood
> behavior. It takes an RDF/XML document as input, and returns an
unordered
> set of triples as output. Just as the relational database model
tells us
> that the order of the rows in our RDBMS databases is not
meaningful, the
> RDF spec tells us that the triples constituting an RDF graph are not
> meaningfully ordered.
>
> This has two interesting consequencees:
>
> * RDF parsers can confidently throw away a *lot* of information,
since
> the use of RDF/XML syntax indicates which aspects of the XML
formatting
> are incidental and don't carry meaning.
>
> This is great news for aggregators of Web data, and saves much
more
> space than (for example) the false economy of eliding the DC
namespace
> into the RSS one to save on some occurances of 'dc:'.
>
> * Applications layered on top of generic RDF parsing, query,
storage
> tools will need to use constructs that are visible in the RDF
graph,
> if they do care about ordered lists. RDF'99 had Bag/Seq/Alt; RDF
Core's
> recent work augments this with a different idiom for lists.
>
> This means that if we want ordering in RSS documents to carry
meaning,
> and if we don't want to have to write special case parsers 'cos
we're
> otherwise happy using generic RDF parsers, that we can't treat
> document ordering as meaninful without using RDF's container
syntax.
> Which was, as I took it, Chris's point.
>
>
> "Well, we all know the order of the items" may be true of human
readers,
> and even of special-case parsers they write. But it isn't true of
generic
> RDF parsers; they won't pass through any ordering information
unless it is
> made explicit. The RDBMS/SQL analogy is the best explanation I've
found
> for this. RDF is data-centric not document-centric, and so makes
> preservation of document order the exception rather than the rule.
You
> have to explicitly opt-in to have ordering information survive in
the RDF
> world. That's the cost associated with the benefit of knowing
> automatically when it is OK to throw away information about the
order in
> which XML elements were written. For aggregators of mixed-namespace
RSS,
> that's a big benefit, since it makes it possible to do lots of
useful
> processing on content found in unfamiliar namespace extensions.
Without
> this convention, an aggregator would have to keep track of a lot
more
> information...
>
> Dan
>

Dan, I hear you and I'm with you. But one of the issues that will
probably exist with many uses of RDF in the future is that people
will focus on their own specific needs rather than looking at the
bigger picture.

Using the container to provide sequencing for RDF parsers right out
of the box. That's cool, and I've used this with the applications
you've mentioned.

But the people who write the RSS tools don't care other than the fact
that creating an RSS document is made more complex with the existing
use of a container. And people out there want to read and manually
write these documents and the container confuses them.

Using the RDBMS/SQL example, ordering is not part of the
infrastructure of the tables, its part of the querying process.
RDBMS, just like with RDF, is concerned about the collection of data
for an entity, how to identify the entity, and how to relate
entities, all within fairly rigid guidelines that prevent variations
away from some small group of mathematically proven rules. No more,
no less. Ordering is processing, and isn't part of the model, it
occurs through SQL as in "select a, b, c from tablea order by a". A
direct analogy in RDF would be to not have the container, but to
order based on one of the properties, such as a date.

What might be a better thing, don't you all think, is to have a non-
optional date field. And then let the aggregators display however
they want based on this date.

Shelley

>
> --
> mailto:danbri@w...
> http://www.w3.org/People/DanBri/