I think that large parts of the Semantic Web community lost track of the actual (practical) goals of reasoning. Please think of actual, practical use cases. The actual kind of reasoning employed is then derived from this goal – not the other way round. In the following, I summarise the three different possible approaches to reasoning:

schema validation

This is the typical reasoning applied in the Semantic Web domain. I always found its usefulness very limited and therefore this is only mildly interesting to me. How often will you really need to check whether a model is consistent? Usually only during development, if at all. Even worse: when operating on the World Wide Web you will *inevitably* have inconsistencies, so it is better to simply live with them and not care too much about consistent schemas, it will only drive you crazy (see below).

For schema validation, you will probably use some of the existing OWL and description logics reasoners like Hermit, FaCT, Racer, … but be aware that they are all rather complex and inefficient when dealing with bigger datasets, as you identified as a problem yourself.

instance classification

Instance classification means, informmaly, to figure out the type of a resource based on the existance of a schema or ontology for the data. Now this is at least *a bit* more interesting than schema validation, because it provides you with actual new information that you can make use of. It allows you to treat a Blog Post as a Document, a Meeting as a Location, etc. On the other hand, every programmer can implement you this kind of reasoning in a couple of hours in Java without any need of a reasoner.

For instance classification you can in the most simple case use an RDFS reasoner (very efficient). OWL reasoners are obviously also capable of this, but usually in practice not much better than RDFS reasoners so it is not worth the added complexity. Instance classification can furthermore be considered a specific case of implicit/rule-based knowledge.

implicit/rule-based knowledge

In this case, you extend your factual, static knowledge base (i.e. triples) by rules that represent implicit knowledge (e.g. “if a meeting M is located in a place P and P has coordinates X and Y, then M also has coordinates X and Y). This kind of reasoning is the classical way of representing knowledge in knowledge based systems and adds, in my opinion, real additional value to the information, because much human knowledge is actually rule-based. I consider this kind of reasoning the most interesting in an information system. Rule-based reasoners can cover instance classification as a special case and with a few extensions even most parts of consistency checking.

Rule-based reasoning is currently still a bit esoteric in the Semantic Web domain (Jena only uses it for implementing RDFS/OWL reasoning), as the reasoning topic has been “hijacked” by the Description Logics people. I often criticised this because of its impracticality, but noone would really listen There is the RuleML initiative which resulted in the specification of SWRL, but SWRL is seen as an extension of DL reasoning and thus suffers from the inefficiency of these reasoners. Outside the Semantic Web, the most successful rule-based reasoning system is probably Prolog and Datalog, both highly efficient systems but unfortunately not really present in the Java and RDF world.

Inside the “Linked Media Framework”, which we intend to integrate with Apache Stanbol, I have implemented a Datalog-style rule-based reasoner over RDF triples that can be evaluated very efficiently (see the link I sent above for the specification). Even though this reasoner has a quite restricted expressivity, it is still sufficient to cover many useful scenarios.

 On the usefulness of consistency checking for the Semantic Web

1. Why do logics people care about consistency?

The whole topic of consistency checking is rooted in classical logics. It is founded in the “ex falsum quodlibet” rule of first order predicate logic, which basically says “if you have an inconsistency in your model, you can derive everything”. Maybe you still know the rule from your logics lectures

“false => A” is equivalent to “not false or A” is equivalent to “true”, regardless of A.

For example, in a strictly classical model sense, if you have a knowledge base saying “the car is red” and “the car is green” and “green is not red”, then you could derive that “the moon is made of green cheese and inhabited by small fur balls constantly discussing about how to best cook spaghetti”. Which is of course completey stupid, but completely valid in classical logic.

In a model in classical logics, this is a severe problem, because it means that you cannot derive anything useful at all even if you have just a small inconsistency.

2. Why is inconsistency irrelevant in many cases?

Inconsistency is only a problem in the ideal world of classical logics. Real-world implementations will never have the same kind of problems described above, how should they get the idea that the moon is made of green cheese based on the facts that the car is green and red at the same time? Software implementations are maybe constructive, but based on existing facts and not making up facts out of the blue sky.

The worst case that can happen is that the software will show some error behaviour. Instead of trying to enforce consistency (which in many cases you cannot), one challenge is to isolate the error as much as possible and keep it from spreading. Another challenge is to explain to the user why some unexpected behaviour takes place and how she can prevent it from happening.

The rule-based reasoner implemented in the LMF is completely ignorant to inconsistencies. It does not care at all about them. If you say the car is red and the car is green, then it will maybe derive that it should be tagged with “green” and with “red”. The error spreads maybe a bit, but the reasoner will never claim that the moon is made of green cheese. But maybe you were even right that the car is red and green at the same time (striped car)?

The rule-based reasoner implemented in the LMF will also display you explanations why it has inferred certain knowledge. If the car is tagged with red and tagged with green and you as the user wonder how this could be, you can hover the mouse over the tag and the reasoner will explain you that this is because someone said the car is green and someone said the car is red.

3. Why is dealing with inconsistency even desirable?

The world is full of inconsistencies. And the Web in particular. Neglecting this is the number one problem of the Semantic Web DL community. Accepting this is the number one success factor of the Linked Data initiative. Why is the Web so full of inconsistencies?

• people can have differing opinions about the world: you say “it is cold”, I say “it is warm”, and we are both right
• different cultural conceptions: Spanish has one word for “snow”, Icelandic has 16 different words for “snow”
• uncertainties: most circumstances do not fit into the ideal world of logics because of unknown or uncertain knowledge; a document might be concerned with a topic only to 30%, or the Stanbol entity recognition might only have a confidence of “15%” that “San Juan” is a person, “30%” that it is a city, … ; if you say “all ravens are black”, this is entirely based on observation and not on fact, there might be a white raven somewhere, you just don’t know it

The Semantic Web Winter Meetup took place on 1st December at a nice location for cultural events. KiWi was sponsoring the event, and we had both, a KiWi presentation there and a stand where Thomas could show the KiWi system in action. About 60 people attended, and since the meetup was co-located with ESTC and other meetings, there were quite a number of international attendees as well. The picture shows Andreas Blumauer, myself and Leo Sauermann as the three speakers at the end of the event:

And here is the KiWi demo stand mainly supervised by Thomas. We have one laptop running the demo in VirtualBox and powering three big screens at the same time, very nice:

We had a number of nice contacts and discussions at the event and I think it was really worthwhile to attend it. Especially since the audience were mostly practical development oriented and technologically very savy people that might join the KiWi community at some point.

On the 2nd and 3rd of December, we were sponsoring the European Semantic Technologies Conference (ESTC2010) also taking place in Vienna. This gave us the opportunity to again present KiWi in a invited presentation and a demo stand to interested audience, this time primarily industry people with a professional interest in Semantic Technologies. The following picture shows me and the KiWi waiting to give our presentation:

The presentation itself  was well attended (40-50 people) given the fact that many people were participating only the first day of ESTC and that there was a STI International general assembly in parallel. This picture shows the KiWi and me during the presentation:

The KiWi demo stand was also a well visited place on both days. Thomas gave many demonstrations to interested people and I think we left a quite good impression with most of the ESTC participants. In the following picture I have a discussion with Mark Greaves from Vulcan, Inc. in the US:

Even at ESTC we had many interesting discussions, particularly also with venture capitalists, startups and other funding agencies that might take up the KiWi technology. Altogether also a worthwhile event for the KiWi team, and a good opportunity to demonstrate what the KiWi team has achieved in the last years.

About many other things I was not very happy. First, I found the quality of the presented work often rather low, many presentations were really boring and repeating the same things the community has been working on the last 10 years – someone used the term “least publishable unit”, and I had the impression this holds for many presentations. I cannot really believe that with the low acceptance rate of ISWC there are still so many low-quality papers. But perhaps my notion of low-quality is different than the one of the rest of the community. After 10 years of ISWC, I would have expected more application-oriented results to be presented. Application-oriented in the sense of “solving real-world problems with semantic technologies”. But such papers were only few, even in the in-use track of the conference.

Second, I have the impression that the community is now divided into two large fractions: the “ontologists” and the “linked data people”, and some outsiders like the Social Semantic Web people. When I exaggerate a bit I would say that the ontologists still try to model all the world in schemas, preferrably description logics, ignoring all instance data, and the linked data people only care about instance data, ignoring most schema and ontology work. Even worse, both communities are now facing problems that the others have already addressed, but at least partly ignore the outcomes of the other communities. And both groups behave a bit arrogantly towards each other (and everyone outside). And again, neither of the two is really concerned with solving real-world problems. Which is ok for some time. But after 10 years …

Third, I found the selection of best paper and expecially of the winner of the Semantic Web Challenge really a bit strange. But maybe this is again my different perception of what is a good work (problem driven) and what is not… I would have voted for the Saffron explorer developed by the colleagues at DERI, because it is a useful application with a nice and simple user interface.

And finally, I find the way standardisation is carried out a bit strange (referring to both, RDF 1.1 and RIF). Most of the process is “design by committee”, which only rarely leads to an optimal outcome. Also, problems are only addressed when there is someone interested in solving them, and not because they are important problems that need to be solved. A very academic approach, because I think for the Semantic Web to take of we would also need to address the problems that nobody wants to work on, not only those that are fun.

Enough criticism. Otherwise I really enjoyed the conference, there were many nice presentations as well, many old friends, and many interesting discussions. And I am looking forward to ISWC2011 in Koblenz, particularly to the “Semantic Web Persona Challenge” proclaimed by mc schraefel

Many guests attended our demo, so that we were really happy that we both went to Shanghai instead of sending only one person. Since we had a large table, we could give the KiWi demo at two laptops in parallel! We had many interesting discussions, and I think that we could get quite a lot of people interested in the project. KiWi has so much to offer that there is something in it for almost all conference attendees. I didn’t check the download figures yet, but I am sure they are going to increase. Just a pity that we only had 3 hours (2 were planned) to give the demo …

As always, the KiWi release was a “just-in-time” job. We uploaded the final KiWi version to Google Code at 11:05, left the office for the train at 11:15, and then built up an ad-hoc network in the Railjet to Vienna to prepare the remaining issues: copying USB sticks, preparing the demonstration, preparing the booths, etc. We definately had much fun on the train. And luckily, when we arrived, almost everything was already prepared by Julia, John, and the Semantic Web Company people in Vienna.

The release party itself was a great event: after an inspiring keynote talk by Ross Gardler of the Apache Software Foundation, it was my turn to presented the demonstration that Thomas had prepared in the last days. I must say the system we were able to present is now something that is nice to present, rather stable to use (for a research prototype) and interesting to see.

After the presentations, we continued the evening with drinks and nice food at the bar – a nice opportunity to talk with interesting people. We also had several booths where the KiWi team offered to try out KiWi and helped in installing the system on the laptops of the guests who were interested. We had around 100 guests altogether at the release party, a good mixture of IT people, researchers and journalists. I am really looking forward to working with the interesting contacts we made…. The video gives a good  impression of the release party:

And finally, here is the collection of the most important pictures of the release party …

[Mit PicLens anzeigen]

But in addition to being fun, it was also a very productive week: even though we could not fix all outstanding issues, a lot of the remaining tasks could be pushed forward enough to be finished for the release, e.g. the reasoner, the information extraction, the editor, and the new user interface. We started the week with a brainstorming session, trying to figure out the most important topics:

For a real Open Source release, not only the software is important. If we want other developers to take up our work and improve on it, it is essential to also have good documentation. So the second half of the week was solely dedicated to documenting the KiWi platform. John did a great job in constantly reminding us to finish the documentation, although most of us would have preferred to continue coding…

We would like to thank everyone for participating. And if you are interested in what we have been doing throughout the years, you are invited to join us at the release party in Vienna on 14th October!

A Lüftal so lau ums Haus umaziacht,
a Fliagn no gonz damisch üba
d’Stadlwand kriacht.
Da spür i a Sehnen und s’Herz
werd ma weit “I werds wieda packn!”
Denn d’Alm is mei Freud!

Da Summa auf da Alm
im letztn Jahr war so hart.
Aba den ganzn Winta dahoam
hab i auf dös lau Lüftal scho gwart.
Da letzte Schnee auf dö Berg
werd kleana, s’werd Zeit,
daß is zammpack mei Zeug,
denn d’Alm is mei Freud!

Ob i gsund bleim im Summa?
Dö Angst werd vadrängt
Mei Sorg ghört dö Viecha
an deni so häng.
Mei Glück san dö Berg,
von dö Glock’n dös Gläut,
meine Sorgen wern kleana,
denn d’Alm is mei Freud!

Um an Herrgott sein Segn,
a innigs Gebet, daß da Summa
a dösmoi so guat umageht,
daß gsund bleibm auf da Alm,
dö Viech und dö Leut,
drum bitt i di Herrgott,
denn d’Alm is mei Freud!

Und zum Abschluß noch ein Bild von unsererm Skitour-Abschluß auf der Hochalm:

Core KiWi System

As usual, the annual meeting began with a presentation of the current state of the core KiWi system. Rolf presented the novel implementation of Semantic Forms (based on RDFa) in KiWi. KiWi’s Semantic Forms can be used as alternative editors for a content item and directly update the RDF metadata inside the KiWi system. Planned improvements of Semantic Forms are the support of RDFa object properties and the automatic generation of Semantic Forms out of types specified in an ontology.

Thomas then briefly presented the latest version of the TagIT implementation on top of KiWi. TagIT is accessible at http://tagit2.salzburgresearch.at and will go into a productive use by end of March (accessible under http://tagit2.salzburgresearch.at). Arpad concluded the Salzburg Reseach part with a presentation of the new vocabulary management tool for KiWi, which is at the same time a first experiment for using GWT (Google Web Toolkit) in conjunction with KiWi.

Peter Dolog summarised the various personalisation features that have been implemented in KiWi. Personalisation is available at several levels in KiWi: it can recommend related content to the currently displayed page based on the user’s preferences, it can recommend content interesting to the user based on his activities in the system, and it can be used for personalising the ranking of search results in KiWis search interface (so-called personalised search). In all cases, it is a prerequisite that there is sufficient data for the personalisation from previous (tagging-) activities of users.

Klara then presented the latest progress in using the query language KWQL in KiWi. Beyond ordinary search, KWQL is capable of issuing structured queries to the documents contained in the KiWi system. KWQL is available as part of the core KiWi system for some time already and can be used as an alternative to the default search mechanism.

Jakub showed the new explanation service for the reasoner in the KiWi system. The explanation service allows developers to inspect the justifications why the reasoner has inferred a triple in a graphical manner. It can also be used to show explanations to the user for certain kinds of behaviour (currently inferred types and incoming/outgoing relations).

Marek concluded the presentation of the KiWi core system with a demonstration of the various information extraction functionalities in the KiWi system. Currently, information extraction is used for tag recommendation. He is currently also working on using it for automatically recommending RDFa annotations for the textual content of a document.

Sun Use Case (Software Knowledge Management)

KiWi’s Sun Use Case is concerned with knowledge management in the SunSpace intranet of Sun Microsystems, now part of Oracle. Josef Holy and Peter Reiser started with presenting the three storylines they aim to evaluate as part of the use case: concept model management (i.e. how to manage the company’s internal thesaurus using KiWi and PoolParty), Text Extraction and Tag Recommendation (both, based on the company thesaurus and using free tags), and Searching and Browsing through the SunSpace intranet using KiWis Semantic Search functionality.

Sebastian and Mihai continued with a presentation of a reimplementation of the Community Equity system in KiWi. The new implementation uses a much simplified implementation as compared to the currently used system and gives at the same time more flexibility to admins and developers. Still unclear is how well the system scales in the presence of huge activity logs.

Further steps concerning the implementation and evaluation of the Sun use case are the connection of Confluence with KiWi using a plugin to “augment” Confluence with KiWi’s semantic technologies, the connection of KiWi and PoolParty, as well as the migration of content, particularly activity logs, from SunSpace into the KiWi system to preseed the system for evaluation.

Logica Use Case (Project Knowledge Management)

Daniel Grohlin, Karsten Jahn and Peter Axel Nielsen presented the implementation and scenarios of the Logica Use Case, which is concerned with managing project knowledge. The evaluation will cover the scenarios “project planning”, “project monitoring”, “development or project work”, and “process design”. All four scenarios will be evaluated using a combination of the KiWi system and the proprietary Logica application that complements and accesses KiWi using web services. The use case will be evaluated using an “agile evaluation” that refines the tests and implementation in several evaluation cycles (probably three). Particularly noteworthy is the feature matrix developed as part of the test plan that will be extended by the other partners and used for the Sun Use Case as well as as input for the dissemination and exploitation activities. The feature matrix is also useful to verify to which extent the KiWi technologies are covered by which of the scenarios.

Dissemination and Exploitation

The last of the very important topics of the KiWi Annual Meeting was the discussion on dissemination and exploitation. While dissemination was quite successful in the first two years running with only little resources, the project now moves on into the third phase where it is important to increase the resources spent on making the project known and “selling” its results to the outside world. To this aim, John started with presenting a timeline for the next year, highlighting the most important milestones of the dissemination and exploitation activities. As a major step, KiWi will relaunch its websites and split them into a “research project page” targeted primarily at researchers (as it is now), a “system page” targeted primarily at decision makers as well as a “community page” targeted at developers that want to make use of the KiWi technologies. Further steps in the dissemination area are still confidential, but stay tuned on updates! And don’t miss the KiWi release party for version 1.0 – it will probably take place in September!

Oder wie mein (Pongauer) Kollege Rupert auf Facebook kommentiert hat: “In Bayern braucht ein Mensch 1er Klasse vor allem Geld. In Österreich muss er den Mund halten können”.:-)