W3C home > Mailing lists > Public > www-rdf-interest@w3.org > March 2001

RE: Again: Anonymous Resources

From: Lee Jonas <lee.jonas@cakehouse.co.uk>
Date: Fri, 9 Mar 2001 15:29:28 -0000
Message-ID: <51ED29F31E20D411AAFD00105A4CD7A770BC@zingiber.cakehouse.co.uk>
To: "'Aaron Swartz'" <aswartz@swartzfam.com>, "'Stefan Kokkelink'" <skokkeli@mathematik.uni-osnabrueck.de>, RDF interest group <www-rdf-interest@w3.org>


Aaron Swartz [mailto:aswartz@swartzfam.com] wrote:
>
>Lee Jonas <lee.jonas@cakehouse.co.uk> wrote:
>
>> IMHO *anonymous* means "without a name".
>
>Yes, but the question is when. Newborn animals often don't have a name, but
>we often give them one. Does that mean they're all anonymous? Anonymous
>resources could also be seen as the naming of something without a name.

No, anonymous resources are resources without a name.  You describe
anonymous resources with RDF syntax constructs (e.g. rdf:Description) but
those constructs are entirely separate to the underlying resource they
describe.

In the example above, a newborn animal is an entity (a "resource" in RDF
terms) - it simply exists - yet it does not have any artificial identifier
(a name, or a "URI-reference" in RDF terms) until you assign it one.  I.e.
it is anonymous then you give it a name and it is no longer anonymous.  Does
the nature of that animal change once you have given it a name?  Certainly
not.

To reiterate: assigning an artificial identifier to an entity does not
change the entity's nature, it just provides the assigner with a convient
mechanism for referring to it.  URI-references are artificial identifiers to
entities such as people, objects, html documents, xml documents, other web
resources, etc (note: Uniform Resource *Identifier*).  Equally, they do not
impact on the fundamental nature of these entities.

>> If that is the behaviour you want, you would have to specify a "name"
(i.e.
>> URI) and it would no longer be anonymous.  Hence I believe that the mere
act
>> of describing anonymous resources does _not_ give them a name.
>
>But there is a subtle difference here: whether something has a name which
>others can use (i.e. so my documents can go in and talk about anonymous
>resources in your document), which I don't believe exists; and whether
>something has a name which can be used internally (i.e. by the RDF
>processor) and thus be returned by the parser as a resource with a URI.
>
>The second question is how they are returned? As a generated fragid, like
>SiRPAC does? As a large, unique, random number in some special namespace?
>With a property that states they are anonymous? Etc.
>
>Let's be careful about the destinction,
>
>-- 
>[ Aaron Swartz | me@aaronsw.com | http://www.aaronsw.com ]

Yes, but this is a shortcoming of the RDF syntax - see Stefan's argument for
using a 'rdf:anonymous_ID' attribute.  Is this in the issue list?

I think it is important to distinguish between the RDF model and its
serialisation into XML (i.e. RDF syntax).  Given that you may not wish to
refer to a resource outside of its immediate scope at the model level, an
application shouldn't have to name it.

However, any parser/writer must represent a potentially converging and/or
cyclic RDF graph in XML.  Due to XML's inherantly hierarchical nature it
means the parser may have to link some nodes in the XML element tree to
others with RDF syntax level identifiers and references - hence Stefan's
rdf:anonymous_ID.

The value of any such identifier should be opaque and its scope should be
the XML document in hand.  This would mean that a parser is free to invent
whatever id-generation scheme it chooses.  Any other parser encountering
such an attribute knows it to be merely syntactic with a scope limited to
the XML document currently being parsed.  It reconstitutes the RDF model
level graph from the RDF syntax as triples (which also need the syntax ids
to refer to the same anonymous resources in different triples).  The
application should be free to discard the syntax level IDs.  However, the
parser needs to communicate to the application somehow that a resource is
actually anonymous.  David Megginson's RDF Filter takes this step.  It would
be good if the mechanism for doing this was part of some common RDF parser
API, which allows an application to remain parser independent - e.g.
following RDF Filter's lead, or inventing some special URN protocol such as
'urn:rdfanon:...'.

This practise would have two main advantages:
1) Applications only deal with syntax level ids during
serialisation/reconstitution of RDF model graphs.

2) Parsers interoperate through XML documents only.  There does not need to
be a globally unique ID generation mechanism implemented by all applications
/ parsers, indeed it doesn't even need to be the same id generation scheme
at all - generated syntax level IDs are merely opaque tokens that are unique
within the scope of that document (i.e. XML attributes of type ID).

Reserialisation of a graph could even result in a parser using its own
syntax level id generation scheme, effectively transforming an XML
document's syntax id values from one parser's scheme to another.  It should
be able to do this as these ids are not part of the RDF model, and they are
valid only within the scope of the XML document in hand.  Hence there would
be no net effect to the RDF model serialised.

Regards

Lee
Received on Friday, 9 March 2001 10:30:53 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:51:48 GMT