Subject: RE: PaceExtensibilityAndVersioning

From: "David Orchard" <[email-masked]>
Date: Mon, 19 Jul 2004 16:05:49 -0700

Ken,

Could elaborate a bit more?  I'm a little confused about who's being targetted with what extensions.  In your possibility #1, where is the extension?  

I think you are asking 2 separate questions: 
1) Do we want a mustUnderstand at the element level to be a fault of the feed or the element?  
2) Do we want to be able to target particulare nodes(intermediaries) with a mustUnderstand, ie an intermediary and the target node mustUnderstand a particular extension?

I don't know whether an intermediary should be targetable with an extension.  I've always found intermediaries very confusing.  Does this happen in Atom?

Is the particular problem you are worried about that a feed aggregator might not understand an extension but the receiving nodes might, and so an entry is marked with mU but the feed doesn't get it?  FWIW, this is exactly why SOAP has the "role" attribute, so that particular nodes can be targetted with information and mU.

I think I'm hearing that there are really 3 scenarios for end nodes:
- unknown element extension is optional and is ignored
- unknown element extension is required for entire feed and faults entire feed if extension is unknown.
- unknown element extension is required for element and faults (ignores?) element if extension is unknown.

Which seems like a question about scope of the faulting if unknown.  Perhaps unknownExtensionFaultScope="atom:element" in the element extension?  So it can pick out high up the ancestry the mU applies?

Dave

> -----Original Message-----
> From: [email-masked]
> [mailto:[email-masked]]On Behalf Of Ken MacLeod
> Sent: Monday, July 19, 2004 1:31 PM
> To: Atom Syntax
> Subject: Re: PaceExtensibilityAndVersioning
> 
> 
> 
> "David Orchard" <[email-masked]> writes:
> 
> > http://www.intertwingly.net/wiki/pie/PaceExtensibilityAndVersioning
> 
> +1
> 
> One thing I'm trying to think of is how we could model mustUnderstand
> causing the faulting of individual entries, rather than an entire
> feed.
> 
> Possibility #1:
> 
>     Restrict faulting to identified "top-level" elements.  If an
>     extension should fault at both the feed level and at the element
>     level, a mustUnderstand attribute must appear in both.  The
>     corresponding feed-level mustUnderstand element may just be a
>     placeholder for that purpose.
> 
> Possibility #2:
> 
>     Instead of true/false, we use feed/entry/none (default: none).
> 
>     Pass-through intermediaries could then pass-through entries marked
>     with mustUnderstand="entry", but not entries marked with
>     mustUnderstand="feed", since the intermediary itself must
>     understand the effect on the feed from the one entry to be able to
>     pass it on alone.
> 
>     Feed-level extensions would be always be feed/none.
> 
>     This possibility has the drawback in that it doesn't scale well to
>     other top-level elements, that may in turn be cross-referenced to
>     other top-level elements.
> 
> Possibility #3:
> 
>     Do nothing.  If the intermediary doesn't understand, it faults its
>     source feed and doesn't pass on any entries.  If the intermediary
>     does understand the scope of the extension element, and chooses to
>     pass on an entry with mustUnderstand="true", it understands that
>     downstream clients may fault the entire feed based on that entry.
> 
>   -- Ken
> 
>

---

From: Ken MacLeod <[email-masked]>
Date: 19 Jul 2004 18:41:50 -0500

"David Orchard" <[email-masked]> writes:

> Could elaborate a bit more?  I'm a little confused about who's being
> targetted with what extensions.  In your possibility #1, where is
> the extension?

A producer publishes a feed which contains entries where some contain
elements with mustUnderstand="true".  An intermediary (like Feedster
or PubSub) reads the feed and selects entries to redistribute in a new
feed.  The client reads the feed from the intermediary.

The mU extension is in the entry and ''The meaning of
"understanding"'' is that it only applies to the entry.

> 1) Do we want a mustUnderstand at the element level to be a fault of

This is the more important question.  Can we optionally restrict
faulting to the atom:entry element level.

> 2) Do we want to be able to target particulare nodes(intermediaries)
> with a mustUnderstand, ie an intermediary and the target node
> mustUnderstand a particular extension?

This question can be deferred until (1) is addressed.

> I don't know whether an intermediary should be targetable with an
> extension.  I've always found intermediaries very confusing.  Does
> this happen in Atom?

Yes.  Copying of individual entries from feeds or other sources is
picking up.  Sites like Feedster and PubSub are doing this on a big
scale, and TrackBack and remote comments are be doing it on a small
scale.

> Is the particular problem you are worried about that a feed
> aggregator might not understand an extension but the receiving nodes
> might, and so an entry is marked with mU but the feed doesn't get
> it?  FWIW, this is exactly why SOAP has the "role" attribute, so
> that particular nodes can be targetted with information and mU.

No, I'm not worried so much about the role as I am worried that
atom:entry elements are considered first-class resources in their own
right, even when grouped together within a feed, so the scope question
below is what applies:

> - unknown element extension is required for element and faults
>   (ignores?) element if extension is unknown.
> 
> Which seems like a question about scope of the faulting if unknown.
> Perhaps unknownExtensionFaultScope="atom:element" in the element
> extension?  So it can pick out high up the ancestry the mU applies?

Yes, that'd work.

  -- Ken