W3C home > Mailing lists > Public > semantic-web@w3.org > December 2012

Re: Well Behaved RDF - Taming Blank Nodes, etc.

From: Henry Story <henry.story@bblfish.net>
Date: Wed, 19 Dec 2012 19:27:09 +0100
Cc: Lee Feigenbaum <lee@thefigtrees.net>, Pat Hayes <phayes@ihmc.us>, David Booth <david@dbooth.org>, semantic-web <semantic-web@w3.org>
Message-Id: <BCEECBC1-FA7D-4601-B6BC-5E27BA0992E9@bblfish.net>
To: Steve Harris <steve.harris@garlik.com>

On 19 Dec 2012, at 19:10, Steve Harris <steve.harris@garlik.com> wrote:

> On 2012-12-19, at 17:50, Henry Story wrote:
>> On 19 Dec 2012, at 18:43, Steve Harris <steve.harris@garlik.com> wrote:
>>> On 2012-12-19, at 16:36, Lee Feigenbaum wrote:
>>>>> Henry Story Wrote:
>>>>> In any case otherwise you end up with names that are just complicated blank nodes, and you
>>>>> then have exactly the same problem as blank nodes, except you just end up growning and
>>>>> growing your names as you go along.
>>>> Well, except they don't have the same problems as blank nodes: UUID URIs are stable from one query to the next and can be linked to and referenced across document/database-context.
>>> Yes, this is the key problem with bNodes, which means you have to be /really/ careful about how and when you use them.
>> No, its' the opposite. This is a key problem with UUIDs as I argued in my later mail
>> http://lists.w3.org/Archives/Public/semantic-web/2012Dec/0097.html
> Yes, but I don't buy your arguments.
> You can't "prove" that you "created" some http: URI either, unless the document is signed by an unrevoked key, and that works just as well for any kind of URI.

The point is that there is a way one can come to agree what the definition of a term means for http
URIs. You GET it.

There really is no way to do so for a UUID. If two people dispute the meaning of the term, there is no
way you can come to decide on who was right to use it that way, since either could have come
to mint it. But next, even if you really worked hard on it, how would you know what the meaning
of the term was? 

And all of that needs to be put into context of what a machine can do reasonably easily. Whatever
the proof procedure for finding the meaning of a UUID is it's not something that is going to be doable
automatically. It would require expert police officers, inquisitions, highly specialised teams to work
out what is what in there, with access to hardware etc...

Don't forget that I am responding to the following:
"UUID URIs are stable from one query to the next and can be linked to and referenced across document/database-context."

The name is stable yes, and there are advantages to that, but the meaning is not going to 
be understood, since you have no clear way of telling two divergent meanings apart. So they
are not really as linkable as you think. 

> Also, you say "If you use a UUID you could accidentally make a UUID that someone else has already used." well, it's either not a UUID (e.g. a bogus implementation) or there's some statistically insignificant chance http://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates
> neither of those cases is very relevant.

Well in one case you have no chance of making a mistake (bnodes), in the other you have what you think is
a statistically small chance, but you are not taking into account bad faith. Those are not at all the same
thing. It's the difference between a mathematical truth that is necessarily true, and one that is contingent. 

>> Not every thing that looks like a URI really works like one. For example file:///... URIs 
>> usually are not global identifiers, and even though software accepts it, it's just a hack 
>> people use to get around software that forces them into this kind of situation. 
> There are valid uses for file: URIs, but yes, you have to be careful.
>> UUIDs are not a good way to go. They make it look like there is agreement, when in fact
>> conceptually things are just as broken.
> How does that relate to bNodes? Software doesn't [typically :)] have opinions about the appearance of identifiers.

The point is that people use things that look like global identifiers, because some software
shoe-horns them into providing things that look like they are identifiers, even though
they don't really function in the right way.  So if you forced people to use URIs instead
of bnodes, they'd end up using URIs that were not global identifiers, but that just looked
like them.

> - Steve
>>> We have local hacks to get round the issue, but that's not great. RDF 1.1 bNode skolemisation provides a more generic solution.
>> Something I'd have to look into.
>>> - Steve
>> A short message from my sponsors: Vive la France!
>> Social Web Architect
>> http://bblfish.net/
> -- 
> Steve Harris, CTO
> Garlik, a part of Experian
> +44 20 3042 4132  http://www.garlik.com/
> Registered in England and Wales 653331 VAT # 887 1335 93
> 80 Victoria Street, London, SW1E 5JL

A short message from my sponsors: Vive la France!
Social Web Architect

Received on Wednesday, 19 December 2012 18:27:45 UTC

This archive was generated by hypermail 2.4.0 : Tuesday, 5 July 2022 08:45:31 UTC