Joe Triple: Deconstructed

I’m sure that the majority of you realised that yesterdays posting,
Joe Triple: A FOAF Tale was more
than just a bit of whimsy. The story is intended as an
illustration of a few semantic web principles.

In this post I wanted to review those principles in a
clearer way, although I can’t promise to have shed all the whimsy!

The first thing you need to understand is that…

There Is No Spoon

RDF is the Resource Description Framework, so it’s all about
Resources, correct?

Well yes, and no, it depends on your perspective. Obviously
a key concept in RDF is the notion of a Resource and the
primary goal of the technology is to provide the ability to
associate metadata with those resources.

But that’s only one perspective. The human one. A more
valid perspective is that RDF is all about properties.
In the RDF model a Resource does not, cannot, exist
if there are no statements that refer to it. A Resource
does not exist as an entity in its own right and it comes into
being when a statement is made about it. A Resource is therefore fully
defined by its properties. And, in the closed world of
an RDF triple store, if you delete all the statements about a
Resource then it ceases to exist.

So, you see, there is no spoon.

Just the Facts Ma’am

When you make the first assertion about a Resource you create it (again,
within the closed world of a given store), and this is where the story of Joe Triple began, with the creation of a Resource:

@prefix foaf:  <> .
</joe> foaf:name "Joe Triple".

But, for a RDF Schema-aware processor, by making
this assertion I’ve actually done a bit more: I’ve
also assigned a type to the Resources referenced in the
statement. In effect I’ve made some additional assertions
without knowing it.

If we look in the FOAF schema at the definition of the
property, then we’ll find something like this (I’ve translated
it into N3):

@prefix rdf:  <> .
@prefix rdfs: <>
@prefix owl:  <> .
@prefix foaf:  <> .
foaf:name a rdf:Property;
rdfs:domain owl:Thing;
rdfs:range rdfs:Literal.

Which defines foaf:name as an RDF property whose
values are Literals. It also says that when this property is
used then the subject of the statement will be of type
owl:Thing. The subject of the statement may have
other types either explicitly stated or implied, but the subject will always
be of type owl:Thing.

So, to an RDF application that has loaded (or been coded to understand)
the FOAF schema then, after asserting that Joe has a name, I’ve
also said:

@prefix owl:  <> .
</joe> a owl:Thing.

The rest of the story which charts Joe’s journey from being a
lonely owl:Thing to a fully rounded foaf:Person
is entirely defined by the progressive disclosure of more facts:
when we learn Joe has a foaf:birthday we know that
he’s also a foaf:Agent; once we know Joe has some
foaf:interests we know that Joe is a foaf:Person.

And at the end of the story, when we learn that code has become
the rel:mentorOf some other resources, we know that
they too must be of type foaf:Person, even without
knowing anything else about them, because that’s whats defined in the
relationship schema. That’s
the “world view” that the schema embodies.

There’s a certain conciseness here that appeals to me; a single
assertion may yield additional implied statements. While the
examples here are trivial, its not hard to see how in a more
complex data set with more complex ontologies, these additional
“implied” assertions may actually yield useful data for an
application. This data could be used to influence the applications
behaviour in various ways. For example by prompting the user for more information; adapting its user interface to better present the data; or recognising that additional information could be gleaned through some directed crawling or searching of a particular web service.

The World View of Crowds

Publishing an RDF schema or an OWL ontology involves expressing a
particular world view to which you believe your data conforms. And
when you reuse a particular vocabulary you’re subscribing to that
world view. And when we begin to connect up vocabularies, using
some of the techniques I described in my post on integration,
we’re coming to agreement onto a particular view or intepretation
of data that uses those schemas. It seems to me that this presents
further ways to benefit from “The Wisdom of Crowds”, as using Semantic Web technologies we can also share interpretations of data.