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

!RE: What to do about namespace derived URI refs... (long)

From: <Patrick.Stickler@nokia.com>
Date: Fri, 8 Jun 2001 18:35:03 +0300
Message-ID: <6D1A8E7871B9D211B3B00008C7490AA507958766@treis03nok>
To: sean@mysterylights.com, Patrick.Stickler@nokia.com
Cc: www-rdf-interest@w3.org


> -----Original Message-----
> From: ext Sean B. Palmer [mailto:sean@mysterylights.com]
> Sent: 08 June, 2001 17:17
> To: Patrick.Stickler@nokia.com
> Cc: www-rdf-interest@w3.org
> Subject: Re: What to do about namespace derived URI refs... (long)
> 
> 
> > The fact that existing RDF applications using tricks of adding
> > punctuation to the ends of namespace URIs and specifically
> > defining that the identity of names within that namespace follow
> > the syntax derived by straight concatenation does *NOT*
> > demonstrate that the current practice "works" for all anticipated
> > SW applications.
> 
> Hmm... I guess that you have a totally different vision of the
> "anticipated SW applications" from the rest of us. You still haven't
> explained why, raher than how, we'd want to be able to grok, for
> example, XML Schema in RDF. I mean, what's the point?

I mean, if I wish to use XML Schema to provide for strong data typing
of literals, including enumerations of controlled token value sets for
properties (e.g. ISO language codes, etc.) then I need to be able
to map from that serialization to the URIs needed/used by my RDF
based KR system.

Not only is there no way to (in the Schema without custom programming)
define that the value of <foo:language>en</foo:language> is actually
the ISO defined language "English" rather than the RDF Literal 'en'
but also there is no reliable mapping from the qualified name "foo:language"
to the full URI representing the property 'language' within the namespace
associated with the prefix 'foo' as discussed at length these past few
days.

If the W3C's vision of the SW is based on the concerted capabilities of
XML+XML Namespaces+XML Schema+RDF+RDF Schema(+DAML), then all of these
technologies should provide a single, consistent, unified mechanism
for identifiers. I just can't get from 

   <foo:language xmlns:foo="name:partax:(foo(properties))">

to  "name:partax:(foo(properties(language)))"

with XML and RDF.

I should *not* have to program these mappings! To do so is asking
for an exponential demand in interface glue between every disparate
system and ever disparate ontology and every URI scheme! Knowledge
should be able to travel around the SW using XML serialization and
go to/from triples without *any* special knowledge about URI schemes
and ontologies. 

There are two suggestions on the table that hold promise to solve
this problem absolutely:

1. There can be a single URN scheme for namespaces (and the name
sets defined within them) which all namespace names must conform
to and which must be used for all vocabularies on the SW.

This is unlikely to be possible due to the cooperative/chaotic
nature of the internet. Just too hard to get people to agree
and conform.

2. Rework the specs so that irregardless of the MIME content
type of whatever a namespace URI might dereference to, a fixed
syntax will be used for deriving full URIs from QNames and
namespaces, and that same, single scheme will ensure consistency
of all references to/from XML serializations.

[Thanks to Lee Jonas for that suggestion -- *great* idea]

I would suggest a refinement of the "fixed syntax" approach to
one of a "fixed formula", such as something like the following:

If the namespace name ends in an alphanumeric character, suffix
the local name with an intermediate '#'.

   e.g.  "urn:foo:bar" + "bas" -> "urn:foo:bar#bas"
         "http://foo.com/bar" + "bas" -> "http://foo.com/bar#bas"

If the namespace name ends in a right bracketing pair character,
insert the local name preceeding the final namespace name character
and surrounded to like left and right bracketing characters.

   e.g. "urn:foo:(bar)" + "bas" -> "urn:foo:(bar(bas))"
        "urn:foo:[bar]" + "bas" -> "urn:foo:[bar[bas]]"
        "urn:foo:{bar}" + "bas" -> "urn:foo:{bar{bas}}"
        "urn:foo:<bar>" + "bas" -> "urn:foo:<bar<bas>>"

Otherwise, concatenate the namespace name and local name with
no intermediate punctuation.

   e.g. "urn:foo:bar/" + "bas" -> "urn:foo:bar/bas"
        "http://foo.com/bar/" + "bas" -> "http://foo.com/bar/bas"

Such a formula/algorithm would apply *only* to URIs of abstract
names within an abstract namespace and are *not* required to 
correspond to e.g. URI refs into the structure of a given schema,
even if the namespace URI might dereference to such a schema
(which it shouldn't, since a URI should define a single resource,
and thus it shouldn't serve both as the identity of an abstract
namespace *and* a schema instance defining properties of that
namespace, right?)

There is also the issue of cases where the formula might create
URIs that violate the defined syntax of the URI scheme in question.

OK, tear it apart ;-)

Cheers,

[And have a nice weekend... the day's long over in Finland and 
I'm heading home...]

Patrick
Received on Friday, 8 June 2001 11:35:38 GMT

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