W3C home > Mailing lists > Public > semantic-web@w3.org > August 2007

summary - was: RDF's curious literals and RDFON

From: Story Henry <henry.story@bblfish.net>
Date: Thu, 2 Aug 2007 17:09:48 +0200
Message-Id: <60E76F13-5011-4DFA-B8E3-C1230E5CFA3A@bblfish.net>
To: Semantic Web <semantic-web@w3.org>

Here is my take at a synthesis of the previous two discussions.

Garret is not in fact trying to solve the problem he wants to by  
creating RDFON. The problem is not one of RDF being difficult to read  
- Turtle and N3 take care of that. The problem is simply the java and  
javascript apis for dealing with RDF are way to close to the abstract  
model. This is the core of Garret's frustrations as shown in the  
message he sent recently to this list and to which I replied in more  
detail in [1].

An API like Jena or Sesame that is close to the model, is useful for  
reasoning engines, is close to the spec, and is a good basis to build  
quality tools on, but it will always seem unnatural to OO  
programmers, or at least remind them badly of JDBC. JDBC could get  
traction because one had to deal with databases for a living, but we  
are not there yet with RDF. For most applications there should be no  
need to program at the level of the model, when one is working within  
OO languages, especially when one has to apply the objects created to  
other OO libraries, which will never parse Literal, Statement or  
Graph objects.

Everyday programmers should be using the OO object graphs to  
manipulate the RDF graph using Plain Old Java(script) Objects. This  
may limit somewhat what they can do when compared to the full power  
of RDF, but that is not really the problem: there are millions of  
people who can benefit tremendously by using RDF immediately with a  
minimal learning curve. Furthermore this is completely compatible  
with the RDF model.

I had the same problem and that is why I developed so(m)mer . Using  
@rdf annotations on java can be thought of in two ways:

   1. either as creating a new rdf syntax closer to the java syntax
   2. as a way of mapping the rdf model onto Java by giving a way to  
name things using URIs

Both of those are correct. But they have different consequences.

If you think of so(m)mer as as new rdf syntax (1) then you may be  
tempted to expose your rdf as java source code, or as something with  
a very similar syntax, by placing the code directly on web servers.  
Now I think it is quite obvious here why this is not going to go  
anywhere, if not just because the C# people are going to scream that  
their syntax is better. Java, C#, lisp, etc are all pre-web  
languages. They were not built with URIs in mind, so they will be  
painful to adapt them for this task.  XML or N3 are much better  
suited to it. The JDIL [2] and RDFON ways of attacking the problem  
are it seems to me making that type of mistake.

What is needed instead is a way to make it easy for that data to be  
manipulated by software on the other side of the wire. What is needed  
is to map the RDF into POJOs (2). This is what so(m)mer does. And I  
recommend seriously that people put together a library that allows  
one to do something similar with JavaScript, or any other of the old  
languages out there. This will help people grok RDF immediately, and  
so discussions about Literals being weird will disapear. Clearly they  
are not any more special than Java ints.

I hope I have caught the essence of this discussion well, and that  
this will help people focus their energies on the productive and  
interesting task of making life easier for consumers of data.

Henry

[1] http://lists.w3.org/Archives/Public/semantic-web/2007Aug/0060.html
[2] http://jdil.org/
Received on Thursday, 2 August 2007 20:00:03 GMT

This archive was generated by hypermail 2.3.1 : Tuesday, 26 March 2013 21:45:17 GMT