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...
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.
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: <http://xmlns.com/foaf/0.1> .
</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
foaf:name
property, then we'll find something like this (I've translated
it into N3):
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix foaf: <http://xmlns.com/foaf/0.1> .
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: <http://www.w3.org/2002/07/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.
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.
Posted by ldodds at December 1, 2007 11:05 AM | Feedback? |