...that declarative programming has many advantages over imperative programming in the
modern context of creating smarter transaction / query / test / search systems. My two
favorite declarative tools right now are Pellet and Prova, both of which are open source java
SemWeb tools that are highly compatible with Jena, which recently got a bump to 2.3 with
fairly complete SPARQL support. Pellet is an implementation of OWL-DL and some related
description logic facilities by the Mindswap guys in Maryland, who have absorbed some of
the l33t Kowari/Tucana guys, too (Tucana was recently picked up by Northrop, BTW).
These three tools, folks, together with Laszlo or AJAX on the client, are a perfectly lovely alternative
we have now and forever to whatever shiny semantic doodads Microsoft dangles in front of our
occasionally less-than-discerning general IT population when the Longbone WinFS triplestore finally
gets its $1B TV commercial next year. Oh, I'm chafing to know, who will be the spokesmodels?
I'm hoping it's John Madden and Catherine Zeta Jones, explaining how the semantic future has
arrived through a series of incredibly witty and erotic super bowl spots, maybe punctuated
by Gwen Stefani and Carrot Top in some kind of steamy jungle Shakespeare parody. Whatever
they do, I predict M$ will get at least a 6-month Windows-95 "The semantic web is finally here,
because Microsoft says it is!" kind of wave, and tech stocks will run up somewhat on that. Email
me for other hot stock tips and tomorrow's picks for Golden Gate Fields!
But my big question is: How little if any RDF/OWL compatibility will M$ shoot for? Perhaps
a winderz-Maven can clue me in. For those who are married (willingly or shotgun-style)
to Microsoft as a dev platform I will again suggest RDFGateway as a very nifty and highly
standards-compatible native Windows (C or C#) implementation of an RDF+rules portal for
windows (free for personal use, pay for commercial use). Runs like a dream, though I've
seen the rules engine get slow if you trick its optimizer. One neat feature is that it will
monitor it's own query performance and draw you a picture of the query plan with performance
annotations. Schweet!
Back to them big 3 open source java tools (Pellet, Prova, Jena): While the Jena is a wonderful piece
of code for which HP's SemWeb group deserves a lot of credit, and the Pellet seems to be
coming along nicely and being well received, the Prova is a bit more off the beaten track,
and probably represents a more idiosyncratic choice of tools on our part. Allow me to esplain.
Prova is a prolog-variant built on top of Mandarax. It is a very effective and fun medium for scripting
of high-level relationships and operations. The integration of prolog unification, java types, java
methods, and java exceptions is done very nicely, and yields fine code economy. There are some
rough edges in the docs, but we are helping to get these worked out in the pretty soon.
Note that in prova, like many java compatible scripting environments (including javascript)
java objects can be accessed without explicit type declaration. You need to mention the
package or class of an object only when you invoke a constructor or a static method.
In this way, a substantial chunk of the productivity gain found in dynamically typed environments
can be bolted on to the JVM and JAR infrastructure, without abandoning the advantages of
that framework (Java the language and JVM + JAR are not the same thing!) and all the lovely
libraries like Cocoon. Oh, how I heart teh Cocoon. It rocks my declarative world. I will gladly match
up Cocoon + Prova + Pellet + Jena (= Peruser) against this "Ruby-o-Reilly" or whatever
it is that the kids keep babbling about, at least for building a big system with defined authoring
workflows, as I've discussed in recent posts.
Pellet is a more standards-focused effort, implementing OWL-DL and a growing subset of SWRL,
via a tableaux reasoner. Dynamically, OWL-DL straddles the line between backward and
forward chaining, while SWRL moves further in the direction of forward chaining. I know that these
characterizations miss the point in some ways of what OWL and SWRL are, but I'm trying
to relate them to some other concepts that people are familiar with.
If you have a better characterization, lay it on me! Anyway, since prova is a purely
deterministic backward chaining paradigm (but, crucially, with side effects via java), I feel like
it's a nice complement to the more jumpy (and yet purely declarative, with no side-effects)
OWL + SWRL paradigm, which is in turn more predictable and conservative than a straightahead
RETE forward-chaining production rules paradigm, which is essentially a dynamical system
rather than a logical system.
The backward chaining paradigm, where the system waits to be asked a question, is more
appropriate in my mind for building question answerers, although when you want to process
lots of updates and get matches in real time, the issue of event registration
must be considered. In pure forward chaining, the system jabbers like a toddler and requires
clumsily asserted goals and often-grueseome regulation of agenda priorities in order to satisfy
queries, but event handler registration is straightforward. This kind of system is good for simulations
and
some kinds of real-time pattern matching agents, but generally not so great for
support of deeper
human-triggered queries for visualization and analysis. For doing those deep broad query matches,
we usually want backward chaining. Since human knowledge matters more to us than machine
knowledge, my team is squatting mostly in the pure-backward (prova) + OWL + SWRL (conservative
forward) highlands, eschewing the open prarie of pure-forward matching where the Agenda lions
might eat us.
Of course, it is possible to emulate forward-chaining
with backward-chaining, and v.v., just like it's possible to emulate dynamic typing with static typing,
and v.v., or to mix beer and wine with soy sauce, if that's the theme of the party. Whatev's.
I would like to experiment with the RETE/OWL boundary, but
Drools doesn't seem to support OWL, and Bossam is not open source. Kinda cheeses me off
that Bossam is listed at SemWebCentral, actually, when the banner says "Open Source" on it...
Whasssup with that?
OK, enough rambling, time for more goodies. In other news-that-makes-me-happy, Laszlo 3.1 (the
declarer's answer to AJAX) is out! So of course, is firefox 1.5. Sweet, sweet, draggable tabs...
like pumpkin cheesecake. Who else is in heaven?
The peruser 2.0 release will be sometime this winter, and will include most of the stuff I've mentioned
in here. Nifty interactive ontography demo coming too, Jah willin.
Any idea which open source RDF engines perform best with relational backends?
Posted by: k2 | 2006.06.29 at 05:22 PM