VU Dies Natalis: Web and Science

Yesterday, the VU University Amsterdam celebrated its 129th birtday (or Dies Natalis, as universities obviously do not have something as common as a 'birthday'). The theme of this year's celebration was "Web & Science".

The Dies Natalis lecture was delivered by Frank van Harmelen and centered on the question how Web technologies are not just speeding up communication between scientists, but how these new technologies change the way in which we do science itself: is the academic paper, the yardstick of academic achievement, getting out of date, and what other possible yardsticks do we have? Van Harmelen paints a picture of a future landscape of science where data-driven research, empowered by the web, becomes the dominant way of conducting research: the vast amounts of data produced by individual scientists can be shared on the Web and aggregated, integrated, interpreted, and be used to fuel new hypotheses on a scale that was impossible before. In this world, scientific achievement should not just measured by number of published papers or citations, but by number of published data sets or downloads of one's data sets. By using Semantic technologies it may become possible for computers to assist the scientist not just in writing his e-mail and marking up his paper, but in finding relevant data sets, hypotheses, arguments pro and contra, and so on. It would even be possible for the machine to point out contradicting results in two different publications and offer a suggestion for an experiment that shows which result is correct. Science fiction? Perhaps, but van Harmelen argues that at least some of these ideas are closer than we realize.

Highlight of the Dies celebration was the bestowing of an honorary Doctorate to Sir Tim Berners-Lee, not only for his achievement in creating the WWW, but in admiration of his personal commitment to keeping the WWW truly open and universal.
Tim, obviously a bit uncomfortable with the ceremony (which involved him standing in the middle of the podium, wearing a rather peculiar robe, while Guus Schreiber said all sorts of nice things about him), was characteristically humble and gracious in his acceptance, pointing out that all he did was working out a good idea, and that basically the Web came about not just because he had a good idea, but that other people also considered it a good idea and spent tremendous time and effort in making it happen.

The morning session was devoted to the dies symposium, titled "The World Wide Web and Social Development". The focus was very much on how Web technology can be more effectively employed to help developing nations. A highlight was the film and subsequent talk about Yacouba Sawadogo and the efforts in re-greening Africa's drylands, and how more effective communication technology is needed in order to scale up these efforts. Also, a very interesting talk was given about the creation of the WWW Foundation, which focuses on breaking down barriers to effective access to and use of Web technology in less priviliged countries.

All in all, an inspirational day. The beer (specially brewed for the occasion) was not bad either :)

Simple rules using construct queries in Sesame

A while ago I put together a simple rule-based reasoner for Sesame 2 (available in Aduna's Sesame extension SVN). The idea was to have a configurable rule-based reasoner that would reuse Sesame's query engine (in combination with SeRQL/SPARQL CONSTRUCT queries) to perform simple customized entailment.

The idea is fairly simple: the reasoner works as a stacked SAIL in Sesame's repository configuration (the SAIL is a Sesame internal api that wraps the physical data storage medium). Rules are defined in an RDF format that reuses SeRQL syntax for defining graph patterns. By adding these rules to the Sesame repository the reasoner picks up on them, creates actual SeRQL CONSTRUCT queries out of these rules and then uses Sesame's own query engine to execute the rules, adding the rule result back into the repository.

For example, a rule defining that an uncle of some person P is the brother of one of the parents of P would look like this (using Turtle syntax):

ex:defUncle a custom:Rule;
   rdfs:comment "my parent's brother is my uncle";
   custom:head "{X} ex:uncleOf {Y}";
   custom:body "{X} ex:brotherOf {} ex:parentOf {Y}" .

The reasoner would translate this to the following SeRQL query:

 CONSTRUCT {X} ex:uncleOf {Y}
 FROM {X} ex:brotherOf {} ex:parentOf {Y} 

For those of you not familiar with SeRQL, the SPARQL equivalent would look like this:

 CONSTRUCT {?X ex:uncleOf ?Y }
 WHERE {?X ex:brotherOf ?Z.  ?Z  ex:parentOf  ?Y. } 

I've recently returned to this reasoner, for use in the Tiffany project. In this project, we are developing a Research Management System for researchers in the food industry, and one core concept in this system is a hierarchy of Research Questions and associated activities. Each activity is used by at least one team, and we need to keep a number of things up to date. For example, if a Research Question has an associated activity that is used by team X, the research question itself should also be marked as "used by team X". Moreover, if a research question A has a subquestion B, and that subquestion is used by team X, then research question A should also be marked 'used by team X'.

Previously we tried to support this from code, by explicitly calculating and asserting RDF triples for the 'isUsedBy' relation whenever an activity is linked to (or unlinked from) a research question, or whenever the research question hierarchy is changed. However, the seemingly simple rules for entailment of isUsedBy quickly become devilishly complex when implemented in an imperative fashion. The function that deals with this is well over 100 lines of code. Now, compare that to the rule-based approach:

 tifrule:activityUsedBy a custom:Rule ;
    custom:body "{X} tifn:activity {Y} tifn:isUsedBy {T} " ;
    custom:head "{X} tifn:isUsedBy {T} " .

 tifrule:inheritanceUsedBy a custom:Rule ;
    custom:body "{X} rdf:type {tifn:ResearchQuestion} ;
                     tifn:isUsedBy {T} ,
             {Y} tifn:hasSubQuestion {X} " ;
    custom:head "{Y} tifn:isUsedBy {T} "

Simple. And from some early tests I ran, remarkably good performance too.

Next steps are to investigate how the performance of the approach holds up when I add more rules, and when I start doing many updates on the repository (after all, it's nice if querying is quick, but we also expect users to add new data or update existing information, and that requires that we do not have a large performance penalty for updates).

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.