September 25, 2003

Fabl: a new language based on RDF and DAML+OIL

Through Damien Stolarz, I just dicovered fabl, by Chris Goad. Fabl is "a programming language which is built within RDF", using DAML+OIL, and javascript as an external representation to input the code.

Damien blogged about RDFMapper, which is just a proof of concept application for fabl. I followed the link because RDFMapper implements an idea I had submitted to the LazyWeb last february in Apache maps its commiters based on GeoUrl: Lazyweb, give me a foaf based equivalent !. Not a very original idea, but a very useful functionality.

Chris sates his goals for Fabl as follows:

"The practicality of an RDF–based computational formalism is a central issue for this paper... ...

The full value of formalizing computation within RDF will be realized only by an open standard. We regard Fabl as a proof–of–concept for such a formalization."

The paper is a fascinating read. It's been years I've been reading about RDF, and I begin to get the state of mind you need to be into to think in terms of triples, subject, predicate, object, resources, and litterals; but this paper goes one step further, applying RDF to computation, which is not a small scope of application, and using the whole salsa: RDF Schemas and DAML+OIL !

RDF syntax and semantics can be viewed as having three layers: (1) a layer which assigns concrete syntax (usually XML) to RDF assertions, (2) the data model layer, in which RDF content is represented as a set of triples over URIs and literals, and (3) a semantic model, consisting of the objects and properties to which RDF assertions refer. DAML+OIL specifies semantics[7] constraining the relationship between the data model and the semantic model.

The proper level of description for computation over RDF is the data model; the state of an RDF computation is a set of triples . This triple set in turn can be construed as a directed labeled graph whose nodes are URIs and literals, and whose arcs are labeled by the URIs of properties.

Fabl is executed by a virtual machine. An invocation of the Fabl VM creates an initial RDF graph which is in effect Fabl's own self description: the graph contains nodes for the basic functions and constants making up the Fabl language. Subsequent activity modifies the RDF graph maintained by the VM, called the "active graph". The Fabl interpreter can accept input from a command shell, or can be configured as a server in a manner appropriate to the application.

One problem that I see for immediate use is verbosity.

Consider the simplest of data structures, a point on the plane with two coordinates, which can be expressed in Java by:

public class Point {
    double xc;
    double yc;

Here is an extract from a Fabl RDF file at defining the same structure:

  xmlns:rdf =""
  xmlns:xsd =""

<daml:DatatypeProperty rdf:ID="xc"/>

<daml:DatatypeProperty rdf:ID="yc"/>

<daml:Class rdf:ID="Point">
      <daml:onProperty rdf:resource="#xc"/>
      <daml:toClass rdf:resource=

      <daml:onProperty rdf:resource="#yc"/>
      <daml:toClass rdf:resource=

At a time when Ruby or Python programmers, and scripters in general find java too verbose, and that RDF doesn't take off in part because the syntax is too complicated to use, this RDF syntax for programming construct doesn't appear to me as very enticing ! But I guess tools need to appear to make that less painful. Maybe Danny Ayer's IdeaGraph could be a good base for that. He should turn it into an Eclipse plugin (it seems like Danny already invoked the LazyWeb for this one).

I wish Chris good luck in his endeavour: it's a pleasure to see this kind of really weird project blossoming, far from the endless controversies about RDF.

Posted by chanezon at September 25, 2003 06:41 PM | TrackBack
Post a comment

Remember personal info?