Monthly Archives: December 2007

Twinkle 2.0

Nearly three years ago now I announced a little GUI tool , called Twinkle for working with SPARQL queries. Since then a number of nice people have asked whether I’m going to update the tool to add various features, like support for querying persistent data, inferencing, etc. And Danny pointed out that the UI wasn’t exactly twinkly; and he was right it was crap.
Anyway, I’ve finally gotten around to releasing a new version, Twinkle 2.0, which has all the features that everyone has asked for, and I’ve even tried to accommodate Danny and make the user interface a bit nicer. The project page lists the features which I think are reasonably comprehensive.
The tool isn’t going to languish for another three years as its going to become part of our toolset at work. So, I’ve got a growing list of further improvements I’d like to make to it, including adding SPARQL update support, I18N of the user interface, and some performance improvements. If you have a feature you’d like to see then drop me a mail.
So, happy christmas to all you nice Semantic Web folk, this is an Xmas present from me to you.

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:  <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.

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.

Follow

Get every new post delivered to your Inbox.

Join 28 other followers