<img id=“id202742” src=“http://ecx.images-amazon.com/images/I/51VH71S80XL.jpg” border=“0” align=“right” class=“rightAlignedOpeningPicture” alt="[“Semantic Web for the Working Ontologist” cover]" width=“160px”/>
I recently finished Dean Allemang and Jim Hendler’s book Semantic Web for the Working Ontologist, and I strongly recommend it to anyone interested in OWL, RDF, or the Semantic Web. I’m surprised that their publishers even agreed to the title; there may be some people who look at the book’s title and say “Hey, I’m a working ontologist, so I need that book!”, but I think that it would benefit a much wider audience: not just people who consider themselves working ontologists, but anyone who needs to work with standards-based ontologies or with people who do.
The book describes many modeling issues and then shows how to work through them using concrete examples that are explained well enough to generalize them to other domains. Anyone who reads this book and then works with ontologies will come back to it saying to themselves “I know I saw something in here about how to handle this particular information relationship…” Examples are not presented as working code per se, but there are many examples showing a set of triples, a few RDFS and/or OWL statements, and the resulting new triples implied by the combination. Many of these examples made me want to type them into a text editor, run them through Pellet, and then start modifying the examples to see what happened, because to me, those implied triples are the coolest part of OWL: the new facts that you get out of an existing set of facts by adding metadata.
I’ve wondered before about what good RDFS was without OWL. I started to get a better appreciation for the possibilities when I played a bit with Sesame, and Dean and Jim’s book gave me a much better idea of what you can do with RDFS when you don’t have OWL support, so there’s a reason for Sesame developers to get the book.
In addition to showing people who are dabbling with Semantic Web technologies how to get deeper into the technology, the book does an especially good job of showing experienced software developers which aspects of Semantic Web development are different from what they’re used to and why these differences open up new possibilities instead of limiting them. For example:
The ability in OWL to infer class relationships is a severe departure from Object Oriented modeling. In OO modeling the class structure forms the backbone of the model’s organization. All instances are created as members of some class, and their behavior is specified by the class structure. Changes to the class structure have far-reaching impact on the behavior of the system. In OWL, it is possible for the class structure to change as more information is learned about classes or individuals.
And this is a Good Thing! Got that, OO folks? If not, there’s plenty more in the book to demonstrate this to you. For example, an early chapter in the book asks “How can we accommodate variation of sources if we can’t structure the entities they are describing into a class model? The Semantic Web provides an elegant solution to this problem… any model can be built up from contributions from multiple sources”. Or this: “it is never accurate in the Semantic Web to say that a property is ‘defined for a class.’ A property is defined independently of any class, and the RDFS relations specify which inferences can be correctly made about it in particular contexts.”
Some great advice for all software developers:
…you might think that modeling for reuse is best done by anticipating everything that someone might want to use your model for, and thus the more you include the better. This is a mistake because the more you put in, the more you restrict someone else’s ability to extend your model instead of just use it as is. Reuse is best done, as in other systems, by designing to maximize future combination with other things, not to restrict it.
Closing the book with chapters such as “Using OWL in the Wild”, “Good and Bad Modeling Practices”, and a “Frequently Asked Questions” appendix help even more to connect the theory to the practice, and the final chapter’s “Beyond OWL 1.0” section shows what deficiencies the experts currently see in OWL and what kind of new features a future release might offer us. All in all, for people who are strongly interested in OWL and the Semantic Web, or even just a little curious, this book will give you a solid grounding in both the theory and practice of what the technology can bring to new applications that you might be working with.
Thanks for the review, Bob!
A resource you might not be aware of includes source code for most of the examples (soon to come - an ontology browser that will let you examine them and play with inferencing)
Check it out a WorkingOntologist.org
If you find errata (are you using the second printing or first printing?), please record them there, as well.
I agree completely.
It is only a shame that the book was published with so many errors in the code and figures.
Got that, OO folks?
Bob, I would say that even those of us who say we’ve got it don’t, it’s profoundly different. The way I keep things straight is to classify OWL as POP, or Property Oriented Programming. Classes don’t have properties…properties have classes by way of range/domain. Even then I still find myself confused and making invalid assumptions based on my OOP background…in other words, for some it may be simple, but I caution anybody from making quick comparisons between OWL classification and OOP subclassing. It’s required me to think hard and ask questions and get feedback when I get lost.
By Erik Hennum on May 28, 2009 4:02 PM
To shake up the OO mindset (for what it’s worth), the papers at http://www.w3.org/TR/sw-oosd-primer/ and http://www.hpl.hp.com/techreports/2005/HPL-2005-189.pdf have been helpful to me. It sounds like this book goes much deeper; thanks for the alert.
Thanks Erik, I had no idea that that W3C paper was even there. It looks very useful.
Bob, thank you for posting this review! I am trying to budget the time to buy and study this book. I still have questions in the SW vs. OO area! I will certainly read the W3C SW vs. OO paper. I also have questions as to how to properly model statement metadata in such a way as not to make my triple store incompatible with other tools such as inference engines. Finally, I would like to know how to properly model higher-order predicates. I guess you could call these SW “recipes”, or “best practices”, or SW patterns + anti-patterns. I hope this book covers some of these topics.