W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > May 2002

RE: Dublin Core, the Primer and the Model Theory

From: Graham Klyne <Graham.Klyne@MIMEsweeper.com>
Date: Tue, 21 May 2002 13:30:15 +0100
Message-Id: <5.1.0.14.2.20020521120531.03a9be00@joy.songbird.com>
To: Dan Connolly <connolly@w3.org>
Cc: Jeremy Carroll <jjc@hplb.hpl.hp.com>, w3c-rdfcore-wg@w3.org
At 08:52 AM 5/17/02 -0500, Dan Connolly wrote:
>On Fri, 2002-05-17 at 04:57, Jeremy Carroll wrote:
>[...]
> > It is clear that
> >
> > <eg:doc1.html> <dc:creator> "John Smith" .
> >
> > is  a less precise model than
> >
> > <eg:doc1.html> <dc:creator> _:x .
> > _:x <eg:name> "John Smith" .
> >
> > What is not clear is that the more precise model is a *better* model.
>
>I spent most of yesterday afternoon thinking this over and chatting
>with a few folks. I'm convinced it is a better model.
>
>I'm no longer interested in re-opening the issues.
>
> > I see simpledatatype2 as given a formal and precise account of how the 
> overloading in DC works
>
>I see it as a horrible kludge/mess. I thought I could see a way to
>implement it, but it didn't stand up under scruitiny.
>
>As much as convincing DC folks to go back and separate
>creatorName from creator looks like pushing water
>up hill, I prefer that to kludging the RDF core treatment
>of literals.

The more I think about this, the less comfortable I am with forcing tidy 
literals.  I'm pursuing this here because I think I have some comments tio 
add here that I haven't said before, at least with respect to literal 
interpretation.

Most of your argument seems to be based on opinion, which I don't entirely 
agree with.  The only substantive point I can see above is that you can see 
no way to implement "it".  But I'm not sure what "it" is in this case.  In 
my work with RDF, I have not encountered any problems that cannot be solved 
with the approach to literals proposed in simpledatatype2, which to me 
seems a simple and elegant approach to handling literals (my opinion).

My concern is this:  I think that insisting on tidy literals will make it 
more difficult to persuade people to use RDF in their applications, because 
it will appear to be too arcane.  I have a real worry that we'll end up 
propagating some of the problems of lack of obvious correct use that were 
left over by the original RDF M&S.  I have made a small number of attempts 
to persuade other developers (outside the RDF/semantic web community) to 
adopt RDF in their applications, with mixed results.  The failures have all 
come down to a combination of (a) RDF is perceived as arcane and (b) RDF is 
unproven and not widely supported.  (b) is addressed if lots of developers 
end up using RDF in real applications, a prerequisite to which may be 
dispelling (a).  My one success was down to showing that RDF is easy, and 
doesn't involve any significant work or understanding beyond using XML;  to 
make it that simple meant being able to gloss over some of the semantic 
details, particularly of literals.

When I say:

    Jenny age "10" .

I can easily paraphrase this in English as "Jenny's age is 10", and allow 
intuitions of "age" to fill in the missing detail.  This approach maps 
easily to untidy literals, and the intuitions can be formalized by addition 
of RDF information.  But with tidy literals, to achieve the intended 
purpose, it is important that the property "age" must be interpreted as 
meaning "has an age which can be represented by the string ...".  No 
interpretation of "age" here allows me to conclude that it has the value 10 
years.

For myself, I think I understand the RDF well enough to work successfully 
with either approach to literals.  But I'm not sure I could convincingly 
sell the advantages of RDF while also dealing with the proper handling of 
tidy literals.  I think that trying to explain that in:

    ex:somePerson ex:drinksBeer "John Smith" .

and

    ex:someDiary dc:author "John Smith" .

the two occurrences of "John Smith" refer to the same thing.  Intuition is 
that one indicates to a brand of beer, and the other indicates to a 
person.  It seems like a small thing, but I fear it's enough to obstruct 
acceptance of RDF.

Here's another example, based on CC/PP.  Given:

    someComponent ccpp:pix-x "320" .

and:

    someDocument ccpp:pix-x "400" .

we wish to test the truth of:

    someDocument displaysOn someComponent .

which might be true only if:

    someComponent ccpp:pix-x _:x1 .
    someDocument ccpp:pix-x _:x2 .
    _:x1 comp:ge _:x2 .

The intuitive and intended interpretation of comp:ge is that it compares 
numeric values.  One can play games with having it defined over literal 
values as well as numbers, or having separate comparison relations for 
literal values and numeric values.  The effect is that the interpretation 
of properties beyond the original literal-using expression have to be 
adjusted to make the framework operate as intended.  By comparison, if the 
literals can be interpreted here as denoting numeric values, then 
everything else works out very easily, without further gymnastics.

#g


-------------------
Graham Klyne
<GK@NineByNine.org>
Received on Tuesday, 21 May 2002 08:56:03 EDT

This archive was generated by hypermail pre-2.1.9 : Wednesday, 3 September 2003 09:48:15 EDT