SKOS Browser

The latest release of my pet project, the Sesame 2 Windows Client (SWC), has a nice little feature that I though was worth sharing with you: a SKOS hierarchy browser.

Many ontology editors and viewers have the option of showing a class hierarchy but to my surprise I found very few tools that could display a SKOS broader/narrower hierarchy. So I hacked one together and put it in this client.

Add your SKOS thesaurus to a Sesame Repository, point the SWC at it, go to the "Browse Hierarchy" tab and choose "SKOS Hierarchy".

For now you can only click around in the hierarchy, you can not follow cross-taxonomical links or do any editing.

Sesame 2 Desktop Client

I recently needed a programming excercise in creating a Windows graphical user interface, and decided to create a simple Sesame 2 client. This has turned out to become quite a useful little tool so I've decided to make it available open source.

The Sesame 2 desktop client is a windows (.Net) application that can communicate with a (remote) Sesame 2 server, perform queries, add/remove data, and so on. It is somewhat similar to the Sesame Workbench application, but it has a couple of nice user-friendly options (such as implicit adding of namespace declarations to your queries, dynamic sorting of the query result, etc).

You can download it from sourceforge. Give it a spin, tell me what you think, suggestions most welcome!

Of and of course my thanks to the dotSesame people, whose work I've gratefully reused in this tool.

Sesame 2.0 final released (while you weren't looking...)

While everybody was busy stocking food and drink, the Sesame developers apparently have been at it in overdrive, managing to release the final release of Sesame 2.0 just in time for Christmas. From the openRDF.org announcement:

"Thanks to an overwhelming number of people that have tested the previous release candidates and reported any issues that surfaced, we can now proudly present Sesame, version 2.0!

After the second release candidate, only one serious issue was reported and fixed. We found and fixed some minor, non-critical issues ourselves and made some small improvements here and there, mostly related to HTTP communication and OpenRDF Workbench. All in all, we think the code is now sufficiently tested to call it 2.0-final.

The development focus will now shift to performance and scalability improvements. An RDBMS-based Sail implementation is currently under development and the first results look very promising. The performance of the native- and memory stores will also be improved. As there hasn't been put a lot of effort into this so far, we expect to achieve good results here."

I just want to take the opportunity to congratulate the people at Aduna with this important milestone! Great job, and thanks!

.Net is truly like a foreign country...

...they do things exactly the same there.

I have recently been involved in a project where an RDF ontology + instance set needs to be exposed through a web UI. Being a Java man myself I was immediately set to start fiddling about with JSP/JSF, Spring MVC and (obviously) a Sesame 2 store.

However, in this project my coworkers are .Net developers, so we were left with either me doing all the work myself or somehow figuring out a way of using a Sesame store in a .Net environment. Given that I only have one brain and two arms, and the project has a deadline that falls within the first half of this century, we decided to go for the second option. The web frontent will be in ASP/.Net, the server backend will run Sesame in Java. So, how to get them to talk?

Our first attempt involved using Spring-WS to write a Web Services wrapper (SOAP messaging, WSDL description, the works) around the Sesame store. However, this wrapper was application-specific (talking in terms of business objects from the application domain rather than being a generic sesame wrapper), and really rather large, clumsy and difficult to maintain, so we decided to try something else.

Enter IKVM.net. This is a Java implementation for Mono and .Net that can also be used to do a static porting of Java classes to .Net bytecode (or CIL as they call it in .Net-land). Using a handy little tool called ikvmc I managed (in about half an hour time, mostly spent on trying to figure out which of Sesame 2's impressive collection of jar files to in- and exclude from the process) to create a DLL and he presto! A Sesame 2-compatible HTTP Repository proxy API for .Net Is Born!

Using this DLL we can now access, in C#, a remote Sesame server in exactly the same fashion as we would from a Java environment: by simply using Sesame's own Repository API.

Perhaps not the most elegant and robust solution - and not nearly as much fun as spending several man-months on painstakingly building a .Net client library from scratch, including the creation of parsers and writers for N3, Turtle, RDFXML, Trig, TriX, SPARQL XML result format, SPARQL, SeRQL, and Sesame 2's transaction serialization format - but in a pinch and on a tight budget quite a satisfactory little workaround.

Moving on to new things

Some of you may have heard this already, but I have recently decided to take a new step in my professional career.

I will be leaving Aduna, effective August 1, and therefore also leave as lead developer of the Sesame framework. I will also leave my position at the Eindhoven University of Technology (TU/e).

I will take up a position as researcher/developer at the Wageningen UR (the Agrotechnology & Food Science Group, AFSG), where I will take part in projects dealing with the use of SW technology in the agrotechnology and food sector (think biology researchers, or food processing/distribution companies, etc.).

I have spent a wonderful 8 years at Aduna, working with a great team, and I take enormous personal pride in the fact that I have helped create an RDF framework that is used successfully by so many people. I have every confidence that the Sesame framework will continue to be the success it is today and that all the Sesame developers, both in the Aduna team and outside it, will continue to work on making it even better.

Java SemWeb developers wanted

Aduna, the company behind Sesame, is hiring. We have several open positions in our development team (we're looking for a Junior Java Software Engineer and a Senior Java Software Engineer) and are looking for talented people who are interested in helping us develop the building blocks of the Semantic Web. If you are interested, have a look at the job descriptions, and contact us.

Sesame 2 progress

Hofstadter's Law states that anything takes longer than you expect, even if you take Hofstadter's Law into account. I guess the development path of Sesame 2 is a textbook example of this principle in action.

On the bright side though, we are making good progress. The last alpha release was already shown to be quite mature. The next release will definitively freeze the APIs (and be called beta1). Real Soon Now. Honest.

The query algebra in Sesame 2 is IMHO an interesting piece of work: it allows us to map both SPARQL and SeRQL to an algebraic representation of a query. Query evaluation strategies can then ignore the specifics of the query syntax and just concentrate on manipulating the algebraic expression. Thanks to David Huynh, the object model has now been extended with operators for aggregate operations as well. This has not been fed back into the actual query languages yet, so that remains a ToDo.

I'm also quite pleased with they way in which the APIs have developed. It has taken several thinks and rethinks but the current way in which a user communicates with Sesame is both powerful and easy to use. The web client app is finally taking shape as well (I hope to show that in action soon).

We've also learned a lot about managing an (open source) project in the past few months. Our development environment has undergone some drastic changes: we switched from sourceforge CVS to our own SVN server, and we have started using maven to handle project management. Sesame is no longer a monolothic project but instead consists of about 33 modules, each of which can be checked out and edited separately. Sounds convoluted but it has a number of advantages, including the fact that we can very easily manage dependencies between different versions of parts of the code, and have made a very clear distinction between apis and implementations. This makes the whole framework a lot more extensible, flexible, and reusable. Which is sort of the point of a framework of course :)