[
Lists Home |
Date Index |
Thread Index
]
I have said, it is always dereferenceable, meaning, the syntax
alone is not enough to know what it means given that it is a
URI and a URL (it's overloaded).
Only the authority assigning meaning or identity
to it knows, so you have to ask the cat or trust the cat. One
can always put the URzed into the address box and the system will
go looking for a hypermedia dispenser to ask. Only a learned
convention teaches one to trust the cat. In practical ways,
there is no difference between the URL and URI. It's all word
games and to figure it out, one must know which word games
the cat is playing today. The recourse to talking about
these strings as URIs is just a way of overloading it so
that "resources", the term, can itself become abstract,
and representations become the physical bits if any.
sign -> signifier -> signified -> referents
That is the classic semiotic classifier chain.
What Tim is saying AFAICT is that a namespace name is:
1. A name. A sign.
2. A string. A signifier
3. Signified. You choose but don't tell.
4. Referents. Many choose. This is a natural
consequence of the fact that there can be many
representations. URIs don't identify one thing;
they identify one node for inquiry.
The messiness in this is that the idea that dereferencing
is not necessary for disambiguation. A namespace is
suppose to be the name; not an annotation to a name. The
user sees the local part of the name and considers that
the name. He is surprised to discover that without the
namespace value, the URI, he may be missing some part of
the intent because the dereferencing is optional. For
predictable behavior (name or reference to further disambiguating
information), that is unreliable. One has to inquire to
discover if inquiry yields further results (click the URI).
So again, we are back to asking the cat.
AFAICT, and I am not an RDF expert, the URI identifies a
resource uniquely. What does RDF represent? A concept?
Is a concept a unique resource? I think that is messy.
All identity gets one is an assignment of uniqueness to
an object/entity/thing/whatever. The problem of making
a URI equal a "word" is that words are neither unique
nor interpretable out of context. Identification is
not classification. You don't fire on acquisition of
a target. You track and then fire when context provides
enough information to classify friend or foe; or you take
the risk and if you error, you get back an error message.
Depending on the system, that can mean as little as
mutting "awsh*t" or a lengthy investigation with letters
of regret.
len
-----Original Message-----
From: Mike Brown [mailto:mike@skew.org]
Tim Bray wrote:
> I think if I ever decided to edit this thing again, I would include
> something along the lines of Amy's language, that namespace names are
> strings which follow the syntactic rules for URI references, and that
> making them dereferencable may be a good and useful practice but MUST
> not be necessary for the base use case of disambiguation. -Tim
Bullard, Claude L (Len) wrote:
> I like that.
Remember when I said
> I can see how using a URI for its syntax and not its semantics
> undermines interoperability. But I don't see how URLs fix that.
and Simon, championing URLs for namespace identifiers over URIs, replied
> URLs don't fix much except that you can get an answer of some kind.
> Whether that answer helps you or not is a different question. The
> notion of URIs takes away the "give me an answer" and leaves us with a
> pile of characters and few rules for determining even as simple a thing
> as "are these the same identifier?", never mind "do these identify the
> same resource?".
...? If you recall, your contribution was a rhyme about a dead/alive cat,
so it's difficult to ascertain what your position actually was, but
I thought we were at least in agreement on the idea that it was
harmful to use a URI for its syntax and not its semantics. But now you
don't seem to mind.
Right now, a namespace identifier is
- a string,
- a URI,
- treated as just as string, not a URI.
while Tim & Amy's suggestion is to say a namespace identifier is
- a string,
- indistinguishable from a URI, but it *is not* a URI,
- treated as just a string, not a URI, since it is not a URI.
So I must ask, how is that you now believe that it is OK for a namespace
identifier to look like a URL, but not be dereferencable? How is this
not in violation of the principle of least surprise? You seem to now be
at odds with your earlier position, as well as with Simon's position.
Lastly, I shudder to think what wordplay of this sort would do to RDF,
where I do in fact want to identify resources.
|
