W3C home > Mailing lists > Public > public-rdfa-wg@w3.org > August 2010

Re: Comment on RDFa 1.1 Core: Profiles, term mappings, and URIs as literals (ISSUE-39)

From: Mark Birbeck <mark.birbeck@webbackplane.com>
Date: Thu, 12 Aug 2010 11:55:22 +0100
Message-ID: <AANLkTin1mn+AdQK9YqpsTVNybMDTxgo_nxA+e9utvW+W@mail.gmail.com>
To: Ivan Herman <ivan@w3.org>
Cc: Richard Cyganiak <richard.cyganiak@deri.org>, public-rdfa-wg@w3.org
Hi Ivan and Richard,

> Anyway. As I said above, I may have been a bit too cautious or pedantic on this
> issue. Could you do a favour for me? DERI has a major concentration of RDF
> heads around; could you see with other people there if your proposed changes are
> indeed acceptable for the pedantic web community as a whole? If so, I am happy
> to accept it and propose the changes to the WG. As an RDFa implementer it would
> certainly simplify my code...

One of the reasons that RDF is such a solid foundation on which to
build a myriad of applications is because people have been "pedantic"
over the years. :)


BACKGROUND

The problem we have here is that as far as RDF is concerned, resources
are simply identifiers of things -- they are the 'name' of things.
That might seem obvious, but it raises an issue in this context
because what is being proposed is to assign properties to the name
rather than the entity represented by the name, and that's not
possible in RDF.

As you rightly say Ivan, if we could put a literal in the subject
position there would be no problem. Literals are defined as naming
themselves, which essentially means that the entity "Ivan" (i.e., the
string comprising those four characters) and the name "Ivan" are one
and the same; if I could make statements about the string "Ivan" I'd
also be making statements about the name for the string "Ivan".

But that's not the case with resources; if I make a statement about
<http://purl.org/dc/terms/> I am making statements about the /entity/
this URI refers to. The URI is the name for the entity, and it's not
possible to say anything about the /name/ in RDF (i.e., about the
URI).


THE NEW PROPOSAL

For this reason, the following technique is a non-starter:

  <http://xmlns.com/foaf/0.1/name> rdfa:term "blabla" .

The desire is to make a statement about a string of text that can be
substituted during RDFa parsing, but this statement doesn't do that;
instead it is making a statement about the *entity represented by the
URI*. No matter which way we twist and turn, it is not possible to do
anything otherwise in RDF.


URIs AS VARIABLES

If this is confusing to people, it's probably because it's not always
obvious that URIs have a mysterious life in the world of RDF. We tend
to think of them as the most concrete of things, representing
something real, and that's because we're always talking about URIs as
the most important concept in RDF. However, for RDF to work URIs need
be nothing more than placeholders, and need only be applied
consistently.

I realise that's counterintuitive to the way we normally look at RDF,
so I'll illustrate.

Imagine that I name the entity 'Ivan' with the URI <A> and then add
some properties to it:

  <A> p1 "Ivan" .

(This represents the real Ivan...not the string we were playing with earlier.)

Someone else comes along and also wants to make statements about
'Ivan' and they also decide to use the same URI to 'name' that entity:

  <A> p2 "W3C" .

We now have two statements that in RDF terms are known to be about the
same entity -- 'Ivan'. However, the fact that they are referring to
the same entity (i.e., the same thing in the real world) is not
because there is anything special about <A>, but simply because we
have both used <A> to denote the entity we want to talk about.

In other words, if everyone agreed to use <B> to represent 'Ivan'
rather than <A>, then the combined global graph of statements about
'Ivan' would now be:

  <B> p1 "Ivan" .
  <B> p2 "W3C" .

Yet with this graph nothing has changed...the /meaning/ that this
combined graph contains is *exactly* the same as this combined graph:

  <A> p1 "Ivan" .
  <A> p2 "W3C" .

In other words the URI we use to identify 'Ivan' is merely a
placeholder (a variable name, if you like), and it has no other
meaning.

As long as people don't use the same placeholder/variable name to
identify completely different entities then we can combine statements
together and build up our knowledge about something -- but that
doesn't change the fact that these URIs are placeholders and have no
other meaning than that.

Programmers familiar with pointers will recognise this idea as being
like having a variable that contains a pointer to an object; if you
change the variable name it has no effect on the object being pointed
to. And as long as you change the name throughout your program,
nothing actually changes in relation to the functionality.


CONCLUSION

I realise that was a long-winded explanation, but the short version is:

 * in RDF you can't saying anything about the lexical form of a URI;
 * any properties we add to a URI concern the entity that URI
represents, and not
   the string of characters itself;
 * I think you should stick to your pedantry, Ivan! ;)

Regards,

Mark

--
Mark Birbeck, webBackplane

mark.birbeck@webBackplane.com

http://webBackplane.com/mark-birbeck

webBackplane is a trading name of Backplane Ltd. (company number
05972288, registered office: 2nd Floor, 69/85 Tabernacle Street,
London, EC2A 4RR)
Received on Thursday, 12 August 2010 10:56:18 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Friday, 27 April 2012 04:55:07 GMT