Experimentation with Jena & prototyping

Over the past few weeks, I have been experimenting with a prototype application written using the Jena framework. Jena is a fairly decent library that supports RDF, OWL, and DAML+OIL ontologies, as well as reasoning across those models.

The basic prototype that I’ve built allows you to view and navigate individual models, as well as perform some basic set operations on those models, such as inspecting their union and difference. Most of what the prototype does right now is just an effort to teach myself the functionality of Jena rather than to build an application that does anything revolutionary.

The prototype itself might have a useful life as an Internet-accessible service to browse ontologies that would otherwise be opaque XML files. I’m not really as interested in the browser functionality right now though.

Where I’d really like to take the application is to be able to make it a feed generator for all things semantic web. For example, let’s say there are two ontologies, A and B, hosted on two different sites. What I’d really like is a system that:

  • Allowed users to subscribe to an RSS feed that contained changes or updates to those ontologies over time
  • Allowed users to subscribe to a feed that corresponded to the union (or difference) of those two models
  • Provided a facility for arbitrary external annotation of those ontologies.
    • Allow users to specify which classes in A are equivalent to which classes in B
    • Associate comments or additional text or properties to classes in A, but have those assertions be stored outside of A’s serialization. (I.e. “add-ons” for A’s ontology, but not actually stored in the file that is A’s content

I’m running into the same problem with this application prototype as I have with many others in the past. I have reached the point with development that in order to make substantial steps towards the goal functionality requires learning loads and loads of things that aren’t as interesting, in order to know how implementation can happen. Examples of what I mean would include database persistence for ontologies, how to get around jena memory management issues, RSS libraries in java, and existing annotation standards on the web. Learning that stuff requires a substantial time investment that goes beyond the bounds of what I can accomplish in a “spare time” prototype.

Then again, there’s always an application for research funding. If I could articulate the idea a bit more, maybe it could grow legs.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s