W3C home > Mailing lists > Public > public-swbp-wg@w3.org > November 2005

[SE] Re: Making RDF/OWL A Useful Tool For Software Engineering

From: Holger Knublauch <holger@knublauch.com>
Date: Mon, 31 Oct 2005 15:50:51 +0000
Message-ID: <43663D5B.6040405@knublauch.com>
To: Scott Morehouse <smorehouse@esri.com>
CC: public-swbp-wg@w3.org

Hi Scott,

thanks very much for your feedback.  Comments inline - I could not
respond to all remarks and hope for input from others.


Scott Morehouse wrote:
> Here are some comments I wrote off list to one of the paper's authors
> (Holger).  He asked me to post them here for comment.  I am a
> newcomer to this community...
> --
> I just read the best practices note
> (http://www.w3.org/2001/sw/BestPractices/SE/ODSD/).  It is a good
> introduction and provides a sensible motivation and conceptual
> framework for a software engineer to consider semantic web
> technology.  It stimulated some thoughts and comments (which follow).
> Don't feel that I want you to answer all these questions - I just had
> fun putting ideas down in that way...
> *  Typo?  There is a bullet "Axioms can have multiple types and
> change their type as a result of classification."  Shouldn't this
> read "Individuals can..."?  (BTW - the only other use of the word
> axiom in the document is in the phrase "it is important to remember
> that OWL classes are sets of axioms".  If I really need to know what
> an axiom is to understand what a class is you better tell me!)  (On
> rereading this, I have a creeping sensation that ... axiom is
> knowledge talk for individual, instance, object, "description of a
> thing",...)

Yes, this is a typo - it should be Instance.  The term axiom is
overloaded with many different meanings and should be avoided unless
clearly defined.  It will be fixed in the next version of the paper.

> *  The idea that an individual can be treated as a member of
> different classes dynamically at run-time is very similar to the
> interface-based programming model (e.g.
> www.kbs.uni-hannover.de/~steimann/published/JOT2005.pdf).  In COM,
> Objects support interfaces, not classes.  Classes are just used to
> construct objects.  RDF/OWL can also be thought as representing
> useful aspects or views on individuals.

That's a very appropriate comparison.  I wasn't aware of the theory 
behind it.  I agree it is often cleaner to focus on interfaces, for 
example to abstract from implementation details (such as whether we talk 
to an enterprise bean or a local object).

> *  In explaining RDF/OWL to a software engineering person I think
> that it is important to avoid all philosophy and AI jargon. In my
> case, my interest in RDF/OWL comes from a desire to "describe
> instances" and to perform useful functions on the instance
> descriptions (show an instance description form, validate an instance
> description against a schema or ontology, determine if two instances
> are the same or similar, given a collect of instances find the set of
> instances that matches a set of predicates, etc.  The other
> meta-classes (class, property, etc.) are useful concepts to the
> extent that they actually help me do interesting things with
> instances.  The only reason programmers care about SQL and relational
> theory is because they want to "get records by value" and SQL does it
> pretty good.  They really don't care about the philosophy or theory.
> So, it might be useful to start with the story with instances (real
> things that you want to work with) not classes (concepts).  (It is
> probably true that there are other applications that live in the
> world of concepts and never deal with concrete objects, but I would
> suggest that is a much smaller set of applications.)

I agree that AI jargon should be avoided.  We tried to limit the usages 
of the term "ontology" for example, and to keep it easy to read.  Please 
point me to specific passages that need additional editing - as an 
author I may be blind to these terms.

However, ontology-based development is not only about instances.  In 
fact, many ontologists prefer to not use any instances at all. 
Technically, it is always possible to create a class out of an instance 
(e.g. with hasValue restrictions or enumerations).  Some reasoners are 
optimized to handle classes, and with classes you can exploit useful 
features like inheritance in your model.  It would be an unnecessary 
limitation of the paper if it only would focus on instances.

> *  Is it true that in RDF/OWL, there is no such thing as an incorrect
> instance description (because the set of possible classes is open)?
> But you can have an instance "which cannot be classified as a member
> of any class in the ontology"?  From a practical point of view, isn't
> that like saying that, according to Codd's theory, there is no such
> thing as a incorrect relational row, just relational rows that are
> not present in the data dictionary of a specific database?  One of
> the main reason that people want containers for information is
> because they want to ensure the quality and integrity of their data
> items.  Codd's theory is the basis of relational database engines,
> but it is not the practical definition for such systems.  Is
> something like this separation (functional/practical model vs.
> theoretical) necessary for RDF/OWL to expand its user base?

I don't find the quote above ("which cannot...") in the text.  It 
shouldn't be there: In OWL everything is an instance of owl:Thing. 
Therefore OWL cannot be compared with conventional database systems.

> *  What is the nature of an RDF/OWL engine?  The relational model is
> embedded in a RDBMS software engine and accessed through JDBC/ODBC
> via objects like connections, queries, and record sets.  The XML
> model is embedded in a XML engine (a DOM or a stream parser or a pull
> parser).  What is the corresponding encapsulation of RDF/OWL as an
> engine?  The objects used in the JDBC API are not the objects used
> internally in the implementation of the RDBMS engine.  (Nor are they
> the objects of Codd's theory.) Is there a similar separation for
> RDF/OWL engines?

The underlying mechanism below RDF is a triple architecture, i.e. a data 
structure of subject, predicate, object.  The XML syntax is just one 
possible rendering of this.  OWL/RDF APIs hide this triple architecture 
with the object-oriented metaphor (instances has values etc).

> *  It would be nice to hear a little more about the benefits of
> representing information in a model which supports reasoning tools.
> Two features are mentioned "automatic classification" and
> "consistency checking"  I would hope that any data structure I rely
> on in my application is capable of maintaining its own logical
> consistency!  What does automatic classification do for me, beyond
> helping me manage and understand the logic of my ontology?  Remember,
> for most people the ontology is simply a tool for doing work, it is
> not an end in itself.

I hope others can contribute more meaningful examples of this in the 
future.  I think a lot of what could be done with OWL/DL has not been 
invented and sufficiently explored yet.

> Thanks again for the paper and your work in making this stuff useful
> to people like me!
> -Scott
Received on Tuesday, 1 November 2005 03:05:31 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:09:45 UTC