Lists Home |
Date Index |
Elliotte Rusty Harold wrote:
> At 8:57 AM -0700 6/11/04, Joshua Allen wrote:
>> Well, RDF "data model" is only slightly more constrained than XML, and
>> applications are welcome to use internal data models rather than that
>> implied by XML or RDF. By XML "data model", I mean:
>> a) you have a tree of nodes, and all nodes must have a name
>> b) a node may contain other nodes, literal values, or nothing
>> c) node values may reference other nodes
> If that model works for you, great. It is rarely if ever the model I
> use. In my preferred model there are many unnamed nodes (mostly text
> nodes) and nodes rarely reference other nodes explicitly. Nodes have
> values rather than containing values.
A correction on the statement that "all nodes must have a name".
In RDF nodes that don't have a name are called "b-nodes" (blank nodes),
or also called "anonymous nodes".
An example, suppose a Social Security Identifier in URI form, e.,g.
Now suppose the unnamed person who is identified by the SSN. This
person has not yet been named but has characteristics, and as such is
represented by a blank (unnamed) node. In RDF, the triple:
uid:ssn:1112223344 ex:SSNof _:1
_:1 ex:hasIncomeOf 1000000
_:1 ex:ownsHouse _:2
_:2 ex:hasAddressOf "1234 West Ridge Road"
OWL is great for this stuff because you can declare a property to be of
type owl:FunctionalProperty or owl:InverseFunctionalProperty which is
analogous to a relational key. When you say that in your preferred
model "nodes rarely reference other nodes explicitly", this is exactly
what OWL is great for, because aside from functional and inverse
functional properties there are a whole host of other things a property
can be (e.g. Transitive) as well as things that classes can be (e.g.
Unions of, Inverses of, Intersections of) and while *you* don't have to
explicitly reference the nodes, the fact that there are these known
characteristics about the nodes allows an inferencing engine to draw
*inferences* i.e. implicit relationships, between the nodes.
> But the data model is local. There's no reason my model has to be the
> same as your model. We exchange concrete documents, not models.
> However, I don't believe there is any such thing as a common XML data
> model, nor does there need to be one. In RDF, the triples do form a
> data model, and that makes RDF qualitatively different than XML.
That is one of the other initial design goals of OWL: to allow ontology
interoperability. That is, two parties should be able to use their own
ontologies and communicate via shared documents. This is explicitly
stated in the OWL specs, that RDF/XML is the interchange language. Now
we assume that both parties understand OWL -- that is really just
saying that you and your accountant agree to use the same type of
*math*, but each party may use its own Ontology (language/schema/data
model etc.) OWL is not like Cyc or SUO in saying that there needs to be
one overarching ontology. Every agent (program) might have its own
ontology. Where terms are shared between agents, they are assigned a
URI so that the agent may reference the ontology.
I know that this isn't answering your question, but OWL/RDF isn't
intended to be a program in and of itself, its more like we have
proposed a microarchitecture with bytecodes etc for a language and you
are looking for the killer application written in that language (which
certainly is a fair question). I'd just like to point out that in the
case of, for example, Java, the initial focus on creating Applets etc.
has largely given way to completely different applications that run on
the server (Servlets) which for *me* is the killer application of Java.
In the past there have been a number of DL applications etc. but never
a standard that a large number of people in both the DL communities as
well as the larger fields of "KR" and the "semantic web" have bought
into. What I would *like* to see is for folks to take some time and
find out what OWL/DL is all about (its not a competitor at all to XML).
As for triples being a common data model for RDF, that is like saying
that Unicode is a common data model for XML. It is sort of true on one
very basic level, but mostly misses the point. Triples are *simply* the
basic syntactic unit of RDF. They are used to *construct* more
complicated data models. The triple itself is, well, trivial, to the
extent that a character is trivial. Sure they generate discussion as do
Unicode characters. The RDF data model is a graph --- just as the XML
data model is a tree. That doesn't mean that all graphs and trees are
the same. Your desire for local data models is perfectly reasonable. It
turns out that I can model *any* data model that you can describe, in
words or as a diagram, as a graph. So the use of a graph to describe
individual data models is the most general way to do this. You can
still maintain your own private data models. You can describe these as
a graph. You can *now* share these data models as a document -- let's
call this an ontology, so *if* you want to let either your friends, or
trading partners, to know what data model you are using, you have a
good way to describe this to them.