This post is part one of a two-part guest post by Yarden Katz,
a student in the MINDSWAP lab at the
University of Maryland, College Park.
Must We Mean What We Say (In OWL)?1
1With infinitely many apologies to Stanley Cavell (and in turn, Kendall Clark)
Here’s a claim shared by several people in the Semantic Web community:
ontologies will be everywhere. Regular web authors−meaning the people who
are technically competent enough to make web pages, or maintain a
blog through some automated software−will create and use them. Not
surprisingly, those who advance this general claim usually have different ideas about
how it should be implemented. For some, “ontologies” means “OWL” (Web
Ontology Language), and for others it might mean something else, perhaps
proposal, or perhaps a
a formal semantics altogether. In this modest post I will focus on the first group, mostly because I think OWL is an interesting
language, but also because it is a
standard, and a significant one (at least in the Semantic Web
community.)
I think one would be hard pressed to argue that OWL is inexpressive.
While there are many desirable extensions to it depending on your
domain or application, there’s a whole lot you can still say, much of
which is not expressible in various popular knowledge representation
(KR) systems. However, this great expressivity also means that those
advocating the implementation of the Semantic Web vision using OWL
have a non-trivial problem on their hands: OWL is hard. It’s hard to
learn, it’s hard to teach, and until
it was virtually impossible to debug in a robust way. This spins out
several key questions:
- How do I say X in OWL?
- Here’s what I wrote in OWL, does it say X?
- I want to say both X and Y in OWL, are they compatible?
- I want to say X in OWL and I know I can’t, but how can I still
say X?
There are at least two major distinct perspectives on how to solve this: (1)
with great and comprehensive tool support, the average user of OWL will
not need to meddle in these low-level details; creating OWL
will be easy, in the way that creating a highly sophisticated webpage
nowdays does not require editing HTML by hand (no logic course needed!), or (2) with lots of
examples, documentation and ontologies to reuse, very minimal tool
support will be enough to allow people to use OWL effectively; writing
OWL will be easy. Of course, these are both extreme positions and
there are many people who want both, and many in between. I
believe that nothing short of a revolution in the history of tools for modelling in KR will
enable (1) to happen in its full glory.
I am leaning towards the second position, in the following sense: with a lot of work and
motivating domain-specific applications, OWL can be effectively
learned and used to say interesting and useful things by
decently-sized communities of web users. A consequence of this
realization is that the community of people actually writing OWL will
be narrower, and that it won’t be as easy to write OWL as it is HTML.
The average OWL user will require much more technical sophistication
than the current average Joe Blogger, and given the nature of OWL, I
don’t think this will change. Perhaps only communities like the
technically capable biologists (who have some great work in
bioinformatics to build on and use) will actually write non-trivial
ontologies and use reasoners directly. This does not imply that OWL
will not affect the experience of web users outside of that
community−quite the contrary, it certainly doesn’t prevent end-user
software from making use of OWL−it just means that the average web
user will not be modelling and publishing OWL ontologies.
So the punchline: Semantics are hard in general, and especially hard
to automate. OWL is semantically rich and this makes the problems
extra hard. Expecting it to be otherwise, especially at this
stage, is unrealistic.
With this excessive intro, I am hoping to make a baby contribution to
perspective (2) on this problem, of actually explaining the semantics of OWL. In the
next post I will outline some common pitfalls of modelling things in OWL (some of which
are characteristic of many other KR formalisms), and briefly review
some useful semantic extensions to OWL.
This post is part one of a two-part guest post by Yarden Katz,
a student in the MINDSWAP lab at the
University of Maryland, College Park.
