Re: QName URI Scheme Re-Visited, Revised, and Revealing

"Sean B. Palmer" wrote:
> 
> [Snipping uri@w3.org]
> 
> > Uhhh... so even if the NS spec says X and Y are different,
> > RDF can do whatever it likes with them, including saying
> > X = Y [...]
> 
> Of course it doesn't say that two names are equivalent; it simply uses the
> QNames to form URI references.

This seems to be a fundamental point that you and Patrick are
approaching from different directions.

If I may muddy the waters further (hopefully not... 8-):

+++

Patrick seems to be saying that two distinct QNames can map to the same
URI. This loses the distinction between the two resources, and we will
end up with triples about a single resource, where the original data in
XML were about two different resources/entities/things.  The whole point
of namespaces in XML is to qualify tag names which are likely to be used
by more than one source, so two different QNames refer to different tags
(which may or may not, in reality, refer to the same actual entity in
the world).

Sean seems to be saying that this is irrelevant, because anyone using
RDF knows that QNames are treated in this way and wouldn't use XML such
that the confusion would ever arise; and perhaps even that XML encodings
of RDF in which this problem would occur are abusing RDF and are
invalid. In other words, QNames in RDF are just a shorthand for the URI
and have no significance. [* but see below]

+++

So, this is all fine if you only use plain XML, where QNames matter, and
all fine if you only use RDF, where URIs matter.
The remaining question is whether we are causing ourselves problems when
we are in both camps, e.g. trying to convert plain XML 'legacy'
documents into RDF.

For example, lets say we are processing XML files in various schemas
into one common format; it is possible, although unlikely, that we will
have QNames from different sources that happen to map to the same URI.
This is not a problem until we try to convert our old data into new RDF,
where we discover (or maybe we don't !) that the URIs clash.

So in summary, we cannot use the standard QName->URI mapping where the
original data were not intended for RDF consumption; we would have to
create some new namespaces for our RDF to avoid ambiguity, and convert
the data using our new namespaces. This may or may not be seen as a
significant problem.

Apologies in advance if I have misrepresented any views.

Regards,

David Allsopp
QinetiQ
UK

[*] However, I think there may still be a separate problem if people
choose RDF namespaces without a terminal '#', as we can still get
unintentional URI clashes on rare occasions, if people choose very
similar namespaces:
http://foo.com/discovery + ack
http://foo.com/discover + yack

In addition, if such data is parsed and the re-serialised, the original
namespace cannot be recovered; the URI is preserved of course. This
would not be a problem if the problem of clashes was eliminated, but I
think the two are bound together because the addition of '#' separators
to avoid clashes also allows namespace recovery.

-- 
/d{def}def/u{dup}d[0 -185 u 0 300 u]concat/q 5e-3 d/m{mul}d/z{A u m B u
m}d/r{rlineto}d/X -2 q 1{d/Y -2 q 2{d/A 0 d/B 0 d 64 -1 1{/f exch d/B
A/A z sub X add d B 2 m m Y add d z add 4 gt{exit}if/f 64 d}for f 64 div
setgray X Y moveto 0 q neg u 0 0 q u 0 r r r r fill/Y}for/X}for showpage

Received on Thursday, 23 August 2001 07:32:24 UTC