Norm et al.
> At a recent telcon, Stuart Williams and I agreed to publish our one
> page summary of section 2 of the architecture document this week. ...
>
> http://www.w3.org/2001/tag/doc/identify.html
>
I congratulate you on your noble effort. It seems to me that this is an
effort to clarify, perhaps supercede RFC 2396, and perhaps such an effort
should be submitted as an RFC at some point but that detail is not
important.
Regarding fragment identifiers and what they identify:
http://www.w3.org/2001/tag/doc/identify.html#d0e230
It certainly can be argued that the _intention_ of fragment identifiers was
to identify parts of documents returned as resource representations. On the
other hand there are a few W3C sanctioned practices which are problematic
for this viewpoint. Indeed there is a widespread view that a URIreference
itself can be said to indentify (in RDF terms) a "resource" itself, or as
DAML describes a "Thing" which is not neccessarily a fragment of an
rfc2396:resource representation, rather an entity in of its own self.
In a recent Internet Draft
http://ietf.org/internet-drafts/draft-borden-frag-00.txt I attempt to define
what a URIreference identifies as a "sub-resource" but the intention is not
that a fragment identifier necessarily identify part of a resource, rather a
"node" or a daml:Thing.
As is noted:
[[
Specifications such as XML Namespaces [4] and RDF [16] use URI
references as opaque names. Such usage does not depend on resolution of
the URI.
]]
One might have argued that an XML Namespace name ought be a URI not a URI
_reference_ but this is the case and this practice is well established. If a
fragment identifier identifies _part of_ a resource representation, what
explains the fact that an XML Namespace name is a URI reference? What part
of a resource might a namespace be?
Similarly the RDF practice is to treat URIreferences as opaque names or
terms in the RDF domain of discourse. In such case, a fragment identifier
does not necessarily reference a part of a particular resource
represenation.
When you say
[[
This means that in general, it's not possible to determine what a fragment
identifier means without retreiving the resource into which it points.
]]
I am not sure how to interpret this. Certainly in RDF or DAML (now OWL) one
defines what a URI reference 'means' based on its description, or the class
to which it belongs. There is not generally a need to dereference a URI.
The next point:
[[
A URI that consists of only a fragment identifier (i.e, one that begins with
a " # ") always points into the document that contains the URI, irrespective
of the effective base URI.
]]
I disagree. Again, particularly with RDF applications that do not
necessarily maintain the concept of a "current document", a bare fragment
identifier might be converted into an absolute URI + frag id, via the base
URI. Indeed RFC 2396 explicitly licences such use when appropriate.
To quote the appropriate passage:
[[
4.2. Same-document References
A URI reference that does not contain a URI is a reference to the
current document. In other words, an empty URI reference within a
document is interpreted as a reference to the start of that document,
and a reference containing only a fragment identifier is a reference
to the identified fragment of that document. Traversal of such a
reference should not result in an additional retrieval action.
However, if the URI reference occurs in a context that is always
intended to result in a new request, as in the case of HTML's FORM
element, then an empty URI reference represents the base URI of the
current document and should be replaced by that URI when transformed
into a request.
]]
Read 'however' ...
Clearly (sic) however, this language ought be clarified. However, such
clarification should represent the needs of applications that do not tend to
resolve URIs such as RDF + OWL. In such cases, it is greatly preferable to
compose a URIreference from the fragment identifier and base URI.
Similarly when converting from XLink to RDF, particularly for simple XLinks,
one needs a mechanism to specify the starting URIreference of such a link,
and the base URI is an effective way to derive such a URIreference. Taken
outside its containing document, a bare fragment identifier is, well,
useless. IMHO it should be treated similarly to a relative URI.
Jonathan