Re: Semantic Web Languages

Tim--

Comments interspersed:

tim.glover@bt.com wrote:
> Frank, 
> 
> Thank you for your reply. You make some good points, but let me pursue
> my argument anyway, and see where it goes :)
> 
> You are right of course that to share code you need to be able to
> uniquely identify the resource you want to use. However, even in Java,
> user defined classes are distinguished from java keywords ("if",
> "class") which have special meaning. It is these words that I refer to
> when I talk about keywords.  

Yes, I understood that.  That's why I separated my comments about 
user-defined things from those about "keywords".

> 
> You say that in RDF these keywords are just like any other word, but I
> am not convinced. RDF has an official published semantics which gives
> special meaning to certain strings, such as "type" and "ID". These are
> not user defined, and they are distinguished from other strings. Every
> correct RDF implementation must do something special with these strings.
> It does not make sense to insist that they are "uniquely distinguished"
> by being URIs.  They are uniquely distinguished by the semantics, and by
> every valid RDF parser. 

Actually, I meant my two points about "keywords" to be taken together, 
rather than separated.  It's certainly true that RDF semantics gives 
special meaning to certain terms.  To be precise, though, the terms RDF 
gives special meaning to are URIs (rdf:type is an abbreviation for a 
URI), not strings like "type".  And as Danny noted in another message, 
such terms as "rdf:ID" are not defined as part of *RDF* semantics; 
rather, they are part of the syntax of RDF/XML.

However, in Java, the expectation is that you will only feed Java syntax 
to a Java compiler, and the expectation is that there will be no mixing 
of terms from multiple languages (so you wouldn't have to distinguish, 
say, "java:type" from "c#:type").  That isn't the case with RDF.  As I 
noted earlier, in RDF you can mix terms from multiple languages, and 
must be able to distinguish, for example, "rdfs:class" from "owl:class". 
  How such terms will be handled depends on what language(s) the 
processor "understands", e.g., just RDF, RDFS, or OWL.  You can 
certainly argue that this kind of "layering" of languages is a bad idea, 
but that's a slightly different argument.  My point here is simply that 
RDF is designed to support such layering, and the way terms are written 
has to be able to deal with the consequences.

> 
> My objection was not really to RDF, which is a rather special case for
> the reasons you mention, though I think even in the case of RDF the case
> for using URIs for keywords is thin. My objection is really to the surge
> in other web languages which fail to distinguish keywords from user
> defined words. There is a real difference, and the failure to
> distinguish them will lead to confusion.  

What web languages do you have in mind?

> 
> Similarly I object to the thoughtless use of XML for programming
> languages in order to make the syntax tree explicit, perhaps in the
> belief that writing a parser is the difficult part of designing a
> language. 

It wasn't my intent to try to justify the use of XML everyplace (I 
suppose a case could be made for that, but I didn't try to make one). 
Regarding RDF/XML in particular, I've said elsewhere (numerous times, 
including in the RDF Primer) that I think a subset of RDF/XML can be 
used in a relatively uncomplicated way to represent RDF triples, but 
obviously there are lots of other ways of doing the same thing (even in 
XML).

This seems like a situation where the Web development community could 
essentially "vote with its code".  That is, evolve toward (and gain 
agreement on) a better RDF interchange technique through experience and 
use, if what comes out of the W3C or any other development body is felt 
by a sufficiently-large population to be inappropriate.  If this 
happened, it wouldn't be the first time.   The "hump" of a possible lack 
of interoperability would have to be gotten over, but this sort of 
evolutionary activity would be more productive than simply complaining 
about RDF/XML, and using its deficiencies (real or imaginary) to detract 
from the larger Semantic Web enterprise.

--Frank

Received on Monday, 3 April 2006 16:04:09 UTC