1

Introduction to the Semantic Web

(tutorial)
Johnson & Johnson
Philadelphia, USA
October 30, 2009
Ivan Herman, W3C
[email protected]

Towards a Semantic Web

Tasks often require to combine data on the Web:

hotel and travel information may come from different sites

searches in different digital libraries
etc.

Humans combine these information easily even if

different terminologies are used

the information is incomplete, or buried in images,
videos,

Example: automatic airline reservation

Your automatic airline reservation

knows about your preferences

builds up knowledge base using your past
can combine the local knowledge with remote services:

airline preferences
dietary requirements
calendaring
etc

It communicates with remote information (i.e., on

the Web!)

(M. Dertouzos: The Unfinished Revolution)

Example: data(base) integration

Databases are very different in structure, in content

Lots of applications require managing several

databases

after company mergers

combination of administrative data for e-Government
biochemical, genetic, pharmaceutical research
combination of online library data
etc.

Most of these data are accessible from the Web

(though not necessarily public yet)

This problem you know very well

Example: social networks

Social sites are everywhere these days (LinkedIn,

Facebook, Dopplr, Digg, Plexo, Zyb, )
Data is not interchangeable: how many times did
you have to add your contacts?
Applications should be able to get to those data via
standard means

there are, of course, privacy issues

Example: digital libraries

Sort of catalogues on the Web

librarians have known how to do that for centuries

goal is to have this on the Web, World-wide
extend it to multimedia data, too

But it is more: software agents should also be

librarians!

e.g., help you in finding the right publications

What is needed?

(Some) data should be available for machines for

further processing

Data should be possibly combined, merged on a

Web scale

Machines may also need to reason about that data

Create a Web of Data (beyond the Web of

Documents)

Find the right experts at NASA

Expertise locater for nearly 70,000 NASA civil

servants, integrating 6 or 7 geographically distributed
databases, data sources, and web services

Michael Grove, Clark & Parsia, LLC, and Andrew Schain, NASA, (SWEO Case Study)

10

So what is the Semantic Web?

11

It is, essentially, the Web of Data.

Semantic Web Technologies is a
collection of standard technologies to
realize a Web of Data

12

It is that simple

Of course, the devil is in the details

a common model has to be provided for machines to

describe, query, etc, the data and their connections
the classification of the terms can become very complex
for specific knowledge areas: this is where ontologies,
thesauri, etc, enter the game

13

In what follows

We will use a simplistic example to introduce the

main technical concepts

The details will be for later during the course

The rough structure of data integration

14

1. Map the various data onto an abstract data

representation

make the data independent of its internal representation

2. Merge the resulting representations

3. Start making queries on the whole!

queries that could not have been done on the individual data
sets

A simplified bookstore data (dataset A)

ID
ISBN0-00-651409-X

Author Title
id_xyz The Glass Palace

Publisher
id_qpr

ID
id_xyz

Name
Ghosh, Amitav

Home Page
http://www.amitavghosh.com

ID
id_qpr

Publ. Name
Harper Collins

City
London

Year
2000

15

1st: export your data as a set of relations

16

Some notes on the exporting the data

Relations form a graph

the nodes refer to the real data or contain some literal

how the graph is represented in machine is immaterial for
now

Data export does not necessarily mean physical

conversion of the data

relations can be generated on-the-fly at query time

via SQL bridges

scraping HTML pages
extracting data from Excel sheets
etc.

One can export part of the data

17

Another bookstore data (dataset F)

A
1

11
12
13

ID
ISBN0 2020386682

Traducteur
Titre
Original
Le Palais A13
ISBN-0-00-651409-X
des
miroirs

ID
ISBN-0-00-651409-X

Auteur
A12

2
3

Nom
Ghosh, Amitav
Besse, Christianne

18

2nd: export your second set of data

19

3rd: start merging your data

20

3rd: start merging your data (cont.)

21

3rd: merge identical resources

22

Start making queries

User of data F can now ask queries like:

give me the title of the original

well, donnes-moi le titre de loriginal

This information is not in the dataset F

but can be retrieved by merging with dataset A!

23

However, more can be achieved

We feel that a:author and f:auteur should be

the same

But an automatic merge doest not know that!

Let us add some extra information to the merged

data:

a:author same as f:auteur

both identify a Person
a term that a community may have already defined:

a Person is uniquely identified by his/her name and, say,

homepage
it can be used as a category for certain type of resources

24

3rd revisited: use the extra knowledge

25

Start making richer queries!

User of dataset F can now query:

donnes-moi la page daccueil de lauteur de loriginale

well give me the home page of the originals auteur

The information is not in datasets F or A

but was made available by:

merging datasets A and datasets F

adding three simple extra statements as an extra glue

26

Combine with different datasets

Using, e.g., the Person, the dataset can be

combined with other sources

For example, data in Wikipedia can be extracted

using dedicated tools

e.g., the dbpedia project can extract the infobox

information from Wikipedia already

27

Merge with Wikipedia data

28

Merge with Wikipedia data

29

Merge with Wikipedia data

30

Is that surprising?

31

It may look like it but, in fact, it should not be

What happened via automatic means is done every

day by Web users!

The difference: a bit of extra rigour so that

machines could do this, too

What did we do?

We combined different datasets that

are somewhere on the web

are of different formats (mysql, excel sheet, XHTML, etc)
have different names for relations

We could combine the data because some URI-s

were identical (the ISBN-s in this case)

We could add some simple additional information

(the glue), possibly using common terminologies
that a community has produced

As a result, new relations could be found and

retrieved

32

It could become even more powerful

We could add extra knowledge to the merged

datasets

This is where ontologies, extra rules, etc, come in

e.g., a full classification of various types of library data

geographical information
etc.
ontologies/rule sets can be relatively simple and small, or
huge, or anything in between

Even more powerful queries can be asked as a

result

33

What did we do? (cont)

34

35

The Basis: RDF

RDF triples

Let us begin to formalize what we did!

we connected the data

but a simple connection is not enough data should be
named somehow
hence the RDF Triples: a labelled connection between two
resources

36

RDF triples (cont.)

An RDF Triple (s,p,o) is such that:

s, p are URI-s, ie, resources on the Web; o is a URI or

a literal

s, p, and o stand for subject, property, and object

here is the complete triple:

(<http://isbn6682>,
(<http://isbn6682>, <http:///original>,
<http:///original>, <http://isbn409X>)
<http://isbn409X>)

RDF is a general model for such triples (with

machine readable formats like RDF/XML, Turtle,
N3, RXR, )

37

RDF triples (cont.)

Resources can use any URI, e.g.:

URI-s can also denote non Web entities:

http://www.example.org/file.xml#element(home)
http://www.example.org/file.html#home
http://www.example.org/file2.xml#xpath1(//q[@a=b])

http://www.ivan-herman.net/me is me
not my home page, not my publication list, but me

RDF triples form a directed, labelled graph

38

39

A simple RDF example (in RDF/XML)

<rdf:Description
<rdf:Description rdf:about="http:///isbn/2020386682">
rdf:about="http:///isbn/2020386682">
<f:titre
xml:lang="fr">Le
<f:titre xml:lang="fr">Le palais
palais des
des mirroirs</f:titre>
mirroirs</f:titre>
<f:original
rdf:resource="http:///isbn/000651409X"/>
<f:original rdf:resource="http:///isbn/000651409X"/>
</rdf:Description>
</rdf:Description>

(Note: namespaces are used to simplify the URI-s)

A simple RDF example (in Turtle)

<http:///isbn/2020386682>
<http:///isbn/2020386682>
f:titre
f:titre "Le
"Le palais
palais des
des mirroirs"@fr
mirroirs"@fr ;;
f:original
f:original <http:///isbn/000651409X>
<http:///isbn/000651409X> ..

40

Internal nodes

Consider the following statement:

the publisher is a thing that has a name and an address

Until now, nodes were identified with a URI. But

what is the URI of thing?

41

Internal identifier (blank nodes)

<rdf:Description
<rdf:Description rdf:about="http:///isbn/000651409X">
rdf:about="http:///isbn/000651409X">
<a:publisher
rdf:nodeID="A234"/>
<a:publisher rdf:nodeID="A234"/>
</rdf:Description>
</rdf:Description>
<rdf:Description
<rdf:Description rdf:nodeID="A234">
rdf:nodeID="A234">
<a:p_name>HarpersCollins</a:p_name>
<a:p_name>HarpersCollins</a:p_name>
<a:city>HarpersCollins</a:city>
<a:city>HarpersCollins</a:city>
</rdf:Description>
</rdf:Description>
<http:///isbn/2020386682>
<http:///isbn/2020386682> a:publisher
a:publisher _:A234.
_:A234.
_:A234
a:p_name
"HarpersCollins".
_:A234 a:p_name "HarpersCollins".

Syntax is serialization dependent

A234 is invisible from outside (it is not a real URI!);

it is an internal identifier for a resource

42

43

Blank nodes: the system can also do it

Let the system create a nodeID internally (you do not

really care about the name)
<rdf:Description
<rdf:Description rdf:about="http:///isbn/000651409X">
rdf:about="http:///isbn/000651409X">
<a:publisher>
<a:publisher>
<rdf:Description>
<rdf:Description>
<a:p_name>HarpersCollins</a:p_name>
<a:p_name>HarpersCollins</a:p_name>

</rdf:Description>
</rdf:Description>
</a:publisher>
</a:publisher>
</rdf:Description>
</rdf:Description>

Same in Turtle

<http:///isbn/000651409X>
<http:///isbn/000651409X> a:publisher
a:publisher [[
a:p_name
a:p_name "HarpersCollins";
"HarpersCollins";

].
].

44

Blank nodes: some more remarks

Blank nodes require attention when merging

blanks nodes with identical nodeID-s in different graphs are

different
implementations must be careful

Many applications prefer not to use blank nodes

and define new URI-s on-the-fly

45

RDF in programming practice

For example, using Java+Jena (HPs Bristol Lab):

a Model object is created

the RDF file is parsed and results stored in the Model
the Model offers methods to retrieve:

triples
(property,object) pairs for a specific subject
(subject,property) pairs for specific object
etc.

the rest is conventional programming

Similar tools exist in Python, PHP, etc.

46

Jena example
//
// create
create aa model
model
Model
model=new
Model model=new ModelMem();
ModelMem();
Resource
subject=model.createResource("URI_of_Subject")
Resource subject=model.createResource("URI_of_Subject")
//
// 'in'
'in' refers
refers to
to the
the input
input file
file
model.read(new
InputStreamReader(in));
model.read(new InputStreamReader(in));
StmtIterator
StmtIterator iter=model.listStatements(subject,null,null);
iter=model.listStatements(subject,null,null);
while(iter.hasNext())
while(iter.hasNext()) {{
st
st == iter.next();
iter.next();
pp == st.getProperty();
st.getProperty();
oo == st.getObject();
st.getObject();
do_something(p,o);
do_something(p,o);
}}

47

Merge in practice

Environments merge graphs automatically

e.g., in Jena, the Model can load several files

the load merges the new statements automatically

48

Integrate knowledge for Chinese Medicine

Integration of a large number of TCM databases

around 80 databases, around 200,000 records each

Form based query interface for end users

Courtesy of Huajun Chen, Zhejiang University, (SWEO Case Study)

49

50

One level higher up

(RDFS, Datatypes)

Need for RDF schemas

First step towards the extra knowledge:

define the terms we can use

what restrictions apply
what extra relationships are there?

Officially: RDF Vocabulary Description Language

the term Schema is retained for historical reasons

51

Classes, resources,

Think of well known traditional ontologies or

taxonomies:

use the term novel

every novel is a fiction
The Glass Palace is a novel
etc.

RDFS defines resources and classes:

everything in RDF is a resource

classes are also resources, but
they are also a collection of possible resources (i.e.,
individuals)

fiction, novel,

52

Classes, resources, (cont.)

Relationships are defined among classes and

resources:

typing: an individual belongs to a specific class

The Glass Palace is a novel

to be more precise: http://.../000651409X is a novel

subclassing: all instances of one are also the instances of

the other (every novel is a fiction)

RDFS formalizes these notions in RDF

53

Classes, resources in RDF(S)

RDFS defines the meaning of these terms

(these are all special URI-s, we just use the namespace

abbreviation)

54

Schema example in RDF/XML

The schema part:

<rdf:Description
<rdf:Description rdf:ID="Novel">
rdf:ID="Novel">
<rdf:type
<rdf:type
rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
</rdf:Description>
</rdf:Description>

The RDF data on a specific novel:

<rdf:Description
<rdf:Description rdf:about="http:///isbn/000651409X">
rdf:about="http:///isbn/000651409X">
<rdf:type
rdf:resource="http:///bookSchema.rdf#Novel"/>
<rdf:type rdf:resource="http:///bookSchema.rdf#Novel"/>
</rdf:Description>
</rdf:Description>

55

Further remarks on types

A resource may belong to several classes

rdf:type is just a property

The Glass Palace is a novel, but The Glass Palace is

also an inventory item

i.e., it is not like a datatype!

The type information may be very important for

applications

e.g., it may be used for a categorization of possible nodes

probably the most frequently used RDF property

(remember the Person in our example?)

56

Inferred properties

(<http:///isbn/000651409X>
(<http:///isbn/000651409X> rdf:type
rdf:type #Fiction)
#Fiction)

is not in the original RDF data

but can be inferred from the RDFS rules

RDFS environments return that triple, too

57

Inference: let us be formal

The RDF Semantics document has a list of (33)

entailment rules:

if such and such triples are in the graph, add this and this
do that recursively until the graph does not change

The relevant rule for our example:

If:
If:
uuu
uuu rdfs:subClassOf
rdfs:subClassOf xxx
xxx ..
vvv
vvv rdf:type
rdf:type uuu
uuu ..
Then
Then add:
add:
vvv
vvv rdf:type
rdf:type xxx
xxx ..

58

Properties

Property is a special class (rdf:Property)

properties are also resources identified by URI-s

There is also a possibility for a sub-property

59

all resources bound by the sub are also bound by the other

Range and domain of properties can be specified

i.e., what type of resources serve as object and subject

Property specification serialized

In RDF/XML:
<rdf:Property
<rdf:Property rdf:ID="title">
rdf:ID="title">
<rdfs:domain
<rdfs:domain rdf:resource="#Fiction"/>
rdf:resource="#Fiction"/>
<rdfs:range
rdf:resource="http://...#Literal"/>
<rdfs:range rdf:resource="http://...#Literal"/>
</rdf:Property>
</rdf:Property>

In Turtle:
:title
:title
rdf:type
rdf:Property;
rdf:type
rdf:Property;
rdfs:domain
rdfs:domain :Fiction;
:Fiction;
rdfs:range
rdfs:Literal.
rdfs:range rdfs:Literal.

60

What does this mean?

Again, new relations can be deduced. Indeed, if

:title
:title
rdf:type
rdf:Property;
rdf:type
rdf:Property;
rdfs:domain
:Fiction;
rdfs:domain :Fiction;
rdfs:range
rdfs:range rdfs:Literal.
rdfs:Literal.
<http:///isbn/000651409X>
<http:///isbn/000651409X> :title
:title "The
"The Glass
Glass Palace"
Palace" ..

then the system can infer that:

<http:///isbn/000651409X>
<http:///isbn/000651409X> rdf:type
rdf:type :Fiction
:Fiction ..

61

Literals

Literals may have a data type

floats, integers, booleans, etc, defined in XML Schemas

full XML fragments

(Natural) language can also be specified

62

Examples for datatypes

<http:///isbn/000651409X>
<http:///isbn/000651409X>
:page_number
:page_number "543"^^xsd:integer
"543"^^xsd:integer ;;
:publ_date
:publ_date "2000"^^xsd:gYear
"2000"^^xsd:gYear ;;
:price
"6.99"^^xsd:float
:price
"6.99"^^xsd:float ..

63

A bit of RDFS can take you far

Remember the power of merge?

We could have used, in our example:

f:auteur is a subproperty of a:author and vice versa

(although we will see other ways to do that)

Of course, in some cases, more complex

knowledge is necessary (see later)

64

Another relatively simple application

Goal: reuse of older

experimental data

Keep data in
databases or XML,
just export key fact
as RDF

Use a faceted
browser to visualize
and interact with the
result

Courtesy of Nigel Wilkinson, Lee Harland, Pfizer Ltd, Melliyal Annamalai, Oracle (SWEO Case Study)

65

66

How to get RDF Data?

(Microformats, GRDDL, RDFa)

Simple approach

Write RDF/XML or Turtle manually

In some cases that is necessary, but it really does

not scale

67

RDF with XHTML and XML

Obviously, a huge source of information

By adding some meta information, the same

source can be reused for, eg, data integration,
better mashups, etc

typical example: your personal information, like address,

should be readable for humans and processable by
machines

Two solutions have emerged:

extract the structure from the page and convert the content
into RDF
add RDF statements directly into XHTML via RDFa

68

Extract RDF

Use intelligent scrapers or wrappers to extract a

structure (hence RDF) from a Web pages or XML
files

and then generate RDF automatically (e.g., via

an XSLT script)

GRDDL formalizes the this general scheme

69

Formalizing the scraper approach: GRDDL

GRDDL formalizes the scraper approach. For

example:
<html
<html xmlns="http://www.w3.org/1999/">
xmlns="http://www.w3.org/1999/">
<head
<head profile="http://www.w3.org/2003/g/data-view">
profile="http://www.w3.org/2003/g/data-view">
<title>Some
<title>Some Document</title>
Document</title>
<link
rel="transformation"
<link rel="transformation" href="http:/dc-extract.xsl"/>
href="http:/dc-extract.xsl"/>
<meta
name="DC.Subject"
content="Some
<meta name="DC.Subject" content="Some subject"/>
subject"/>
...
...
</head>
</head>
...
...
<span
<span class="date">2006-01-02</span>
class="date">2006-01-02</span>
...
...
</html>
</html>

yields, through dc-extract.xsl:

<>
<>

dc:subject
dc:subject "Some
"Some subject";
subject";
dc:date
"2006-01-02"
dc:date "2006-01-02" ..

70

GRDDL with XML

The approach is very similar to the XHTML case

The appropriate attributes are added to the XML

namespace document

Otherwise it is identical

71

Bridge to relational databases

Data on the Web are mostly stored in databases

Bridges are being defined:

a layer between RDF and the relational data

RDB tables are mapped to RDF graphs, possibly on the fly

different mapping approaches are being used

a number RDB systems offer this facility already (eg,

Oracle, OpenLink, )

A survey on mapping techniques has been

published at W3C

A W3C group has just started to standardize this

72

73

Linking Data

Linking Open Data Project

Goal: expose open datasets in RDF

Set RDF links among the data items from different

datasets

Set up query endpoints

Altogether billions of triples, millions of links

74

Example data source: DBpedia

DBpedia is a community effort to

extract structured (infobox) information from Wikipedia

provide a query endpoint to the dataset

interlink the DBpedia dataset with other datasets on the

Web

75

Extracting Wikipedia structured data

@prefix
@prefix
@prefix
@prefix

dbpedia
dbpedia
dbterm
dbterm

76

<http://dbpedia.org/resource/>.
<http://dbpedia.org/resource/>.
<http://dbpedia.org/property/>.
<http://dbpedia.org/property/>.

dbpedia:Amsterdam
dbpedia:Amsterdam
dbterm:officialName
dbterm:officialName Amsterdam
Amsterdam ;;
dbterm:longd
dbterm:longd 4
4 ;;
dbterm:longm
dbterm:longm 53
53 ;;
dbterm:longs
dbterm:longs 32
32 ;;
...
...
dbterm:leaderTitle
dbterm:leaderTitle Mayor
Mayor ;;
dbterm:leaderName
dbterm:leaderName dbpedia:Job_Cohen
dbpedia:Job_Cohen ;;
...
...
dbterm:areaTotalKm
dbterm:areaTotalKm 219
219 ;;
...
...
dbpedia:ABN_AMRO
dbpedia:ABN_AMRO
dbterm:location
dbterm:location dbpedia:Amsterdam
dbpedia:Amsterdam ;;
...
...

Automatic links among open datasets

<http://dbpedia.org/resource/Amsterdam>
<http://dbpedia.org/resource/Amsterdam>
owl:sameAs
owl:sameAs <http://rdf.freebase.com/ns/...>
<http://rdf.freebase.com/ns/...> ;;
owl:sameAs
owl:sameAs <http://sws.geonames.org/2759793>
<http://sws.geonames.org/2759793> ;;
...
...

<http://sws.geonames.org/2759793>
<http://sws.geonames.org/2759793>
owl:sameAs
owl:sameAs <http://dbpedia.org/resource/Amsterdam>
<http://dbpedia.org/resource/Amsterdam>
wgs84_pos:lat
wgs84_pos:lat 52.3666667
52.3666667 ;;
wgs84_pos:long
wgs84_pos:long 4.8833333
4.8833333 ;;
geo:inCountry
geo:inCountry <http://www.geonames.org/countries/#NL>
<http://www.geonames.org/countries/#NL> ;;
...
...

Processors can switch automatically from one to the other

77

The LOD cloud, March 2008

78

The LOD cloud, September 2008

79

The LOD cloud, July 2009

80

Using the LOD to build Web site: BBC

81

Using the LOD to build Web site: BBC

82

Using the LOD to build Web site: BBC

83

Application specific portions of the cloud

Eg, bio related datasets

done, partially, by the Linking Open Drug Data task force

of the HCLS IG at W3C

84

Linked Open eGov Data

85

You publish the raw data, we use it

Examples from RPIs Data-gov Wiki, Jim Hendler & al.

86

87

Query RDF Data

(SPARQL)

RDF data access

How do I query the RDF data?

e.g., how do I get to the DBpedia data?

88

Querying RDF graphs

Remember the Jena idiom:

StmtIterator
StmtIterator iter=model.listStatements(subject,null,null);
iter=model.listStatements(subject,null,null);
while(iter.hasNext())
while(iter.hasNext()) {{
st
st == iter.next();
iter.next();
pp == st.getProperty();
st.getProperty(); oo == st.getObject();
st.getObject();
do_something(p,o);
do_something(p,o);

In practice, more complex queries into the RDF

data are necessary
something like: give me the (a,b) pair of resources, for
which there is an x such that (x parent a) and (b brother x)
holds (ie, return the uncles)
these rules may become quite complex

The goal of SPARQL (Query Language for RDF)

89

Analyse the Jena example

StmtIterator
StmtIterator iter=model.listStatements(subject,null,null);
iter=model.listStatements(subject,null,null);
while(iter.hasNext())
while(iter.hasNext()) {{
st
st == iter.next();
iter.next();
pp == st.getProperty();
st.getProperty(); oo == st.getObject();
st.getObject();
do_something(p,o);
do_something(p,o);

The (subject,?p,?o) is a pattern for what we

are looking for (with ?p and ?o as unknowns)

90

General: graph patterns

The fundamental idea: use graph patterns

the pattern contains unbound symbols

by binding the symbols, subgraphs of the RDF graph are
selected
if there is such a selection, the query returns bound
resources

91

Our Jena example in SPARQL

SELECT
SELECT ?p
?p ?o
?o
WHERE
{subject
WHERE {subject ?p
?p ?o}
?o}

The triples in WHERE define the graph pattern,

with ?p and ?o unbound symbols

The query returns all p,o pairs

92

Simple SPARQL example

93

SELECT
SELECT ?isbn
?isbn ?price
?price ?currency
?currency ## note:
note: not
not ?x!
?x!
WHERE
{?isbn
a:price
?x.
?x
rdf:value
?price.
WHERE {?isbn a:price ?x. ?x rdf:value ?price. ?x
?x p:currency
p:currency ?currency.}
?currency.}

Simple SPARQL example

94

SELECT
SELECT ?isbn
?isbn ?price
?price ?currency
?currency ## note:
note: not
not ?x!
?x!
WHERE
{?isbn
a:price
?x.
?x
rdf:value
?price.
WHERE {?isbn a:price ?x. ?x rdf:value ?price. ?x
?x p:currency
p:currency ?currency.}
?currency.}

Returns:
[[<..49X>,33,], [<..49X>,50,], [<..6682>,60,],
[<..6682>,78,$]]

Pattern constraints

95

SELECT
SELECT ?isbn
?isbn ?price
?price ?currency
?currency ## note:
note: not
not ?x!
?x!
WHERE
{
?isbn
a:price
?x.
?x
rdf:value
?price.
WHERE { ?isbn a:price ?x. ?x rdf:value ?price. ?x
?x p:currency
p:currency ?currency.
?currency.
FILTER(?currency
==

}
FILTER(?currency == }

Returns: [[<..409X>,50,], [<..6682>,60,]]

Other SPARQL features

Limit the number of returned results; remove

duplicates, sort them,

Optional branches in the query

Specify several data sources (via URI-s) within the

query (essentially, a merge!)

Construct a graph combining a separate pattern

and the query results

Use datatypes and/or language tags when

matching a pattern

96

SPARQL usage in practice

SPARQL is usually used over the network

separate documents define the protocol and the result

format
SPARQL Protocol for RDF with HTTP and SOAP bindings
SPARQL results in XML or JSON formats

Big datasets usually offer SPARQL endpoints

using this protocol

typical example: SPARQL endpoint to DBpedia

97

SPARQL as a unifying point

98

Remember this example?

The access to all the data is based on SPARQL

queries

Courtesy of Huajun Chen, Zhejiang University, (SWEO Case Study)

99

100

Ontologies
(OWL)

Ontologies

RDFS is useful, but does not solve all possible

requirements

Complex applications may want more possibilities:

characterization of properties
identification of objects with different URI-s
disjointness or equivalence of classes
construct classes, not only name them
can a program reason about some terms? E.g.:

if Person resources A and B have the same

foaf:email property, then A and B are identical

etc.

101

Ontologies (cont.)

The term ontologies is used in this respect:

defines
defines the
the concepts
concepts and
and relationships
relationships used
used to
to describe
describe
and
and represent
represent an
an area
area of
of knowledge
knowledge

RDFS can be considered as a simple ontology

language
Languages should be a compromise between
rich semantics for meaningful applications
feasibility, implementability

102

Web Ontology Language = OWL

OWL is an extra layer, a bit like RDF Schemas

own namespace, own terms

it relies on RDF Schemas

It is a separate recommendation

actually there is a 2004 version of OWL (OWL 1)

and there is an update (OWL 2) to be published in 2009

103

OWL is complex

OWL is a large set of additional terms

We will not cover the whole thing here

104

Term equivalences

For classes:

owl:equivalentClass: two classes have the same

individuals
owl:disjointWith: no individuals in common

For properties:

owl:equivalentProperty

remember the a:author vs. f:auteur

owl:propertyDisjointWith

For individuals:

owl:sameAs: two URIs refer to the same concept

(individual)
owl:differentFrom: negation of owl:sameAs

105

106

Connecting to French

Typical usage of owl:sameAs

Linking our example of Amsterdam from one data

set (DBpedia) to the other (Geonames):
<http://dbpedia.org/resource/Amsterdam>
<http://dbpedia.org/resource/Amsterdam>
owl:sameAs
owl:sameAs <http://sws.geonames.org/2759793>;
<http://sws.geonames.org/2759793>;

This is the main mechanism of Linking in the

Linking Open Data project

107

Property characterization

In OWL, one can characterize the behaviour of

properties (symmetric, transitive, functional, inverse
functional)

One property may be the inverse of another

OWL also separates data and object properties

datatype property means that its range are typed literals

108

What this means is

If the following holds in our triples:

:email
:email rdf:type
rdf:type owl:InverseFunctionalProperty.
owl:InverseFunctionalProperty.
<A>
:email
"
mailto:[email protected]
<A> :email "mailto:[email protected]""..
<B>
<B> :email
:email ""mailto:[email protected]
mailto:[email protected]""..

then, processed through OWL, the following

holds, too:
<A>
<A> owl:sameAs
owl:sameAs <B>.
<B>.

I.e., new relationships were discovered again

(beyond what RDFS could do)

109

Property chains (OWL 2)

Properties, when applied one after the other, may be

subsumed by yet another one:

if a person P was born in city A and A is in country

B then P was born in country B
more formally:

ex:born_in_country
ex:born_in_country owl:propertyChainAxiom
owl:propertyChainAxiom
(ex:born_in_city
(ex:born_in_city ex:city_in_country).
ex:city_in_country).

More than two constituents can be used

There are some restrictions to avoid circular
specifications

110

Keys (OWL 2)

Inverse functional properties are important for

identification of individuals

think of the email examples

But identification based on one property may not

be enough

111

Keys (OWL 2)

112

if two persons have the same emails and the same

homepages then they are identical

Identification is based on the identical values of two

properties

The rule applies to persons only

Previous rule in OWL 2

:Person
:Person rdf:type
rdf:type owl:Class;
owl:Class;
owl:hasKey
(:email
owl:hasKey (:email :homepage)
:homepage) ..

113

What it means is
If:
<A>
<A> rdf:type
rdf:type :Person
:Person ;;
:email
""mailto:[email protected]
:email
mailto:[email protected]"";;
:homepage
:homepage ""http://www.ex.org
http://www.ex.org""..
<B>
<B> rdf:type
rdf:type :Person
:Person ;;
:email
""mailto:[email protected]
:email
mailto:[email protected]"";;
:homepage
:homepage ""http://www.ex.org
http://www.ex.org""..

then, processed through OWL 2, the following

holds, too:
<A>
<A> owl:sameAs
owl:sameAs <B>.
<B>.

114

Classes in OWL

In RDFS, you can subclass existing classes

thats all

In OWL, you can construct classes from existing

ones:

enumerate its content

through intersection, union, complement
Etc

115

Classes in OWL (cont)

OWL makes a stronger conceptual distinction

between classes and individuals

there is a separate term for owl:Class, to make the

difference (a specialization of the RDFS class)
individuals are separated into a special class called
owl:Thing

Eg, a precise classification would be:

ex:Person
ex:Person rdf:type
rdf:type owl:Class.
owl:Class.
<uri-for-Amitav-Ghosh>
<uri-for-Amitav-Ghosh>
rdf:type
rdf:type owl:Thing;
owl:Thing;
rdf:type
owl:Person
rdf:type owl:Person ..

116

117

Classes contents can be enumerated

:
: rdf:type
rdf:type owl:Thing.
owl:Thing.
:
rdf:type
owl:Thing.
: rdf:type owl:Thing.
:
: rdf:type
rdf:type owl:Thing.
owl:Thing.
:Currency
:Currency
rdf:type
rdf:type owl:Class;
owl:Class;
owl:oneOf
owl:oneOf (:
(: :
: :).
:).

I.e., the class consists of exactly of those individuals

Union of classes can be defined

:Novel
rdf:type
:Novel
rdf:type owl:Class.
owl:Class.
:Short_Story
rdf:type
owl:Class.
:Short_Story
rdf:type owl:Class.
:Poetry
rdf:type
:Poetry
rdf:type owl:Class.
owl:Class.
:Literature
rdf:type
owl:Class;
:Literature rdf:type owl:Class;
owl:unionOf
owl:unionOf (:Novel
(:Novel :Short_Story
:Short_Story :Poetry).
:Poetry).

Other possibilities: complementOf,

intersectionOf,

118

For example
If:
:Novel
rdf:type
:Novel
rdf:type owl:Class.
owl:Class.
:Short_Story
rdf:type
owl:Class.
:Short_Story
rdf:type owl:Class.
:Poetry
rdf:type
:Poetry
rdf:type owl:Class.
owl:Class.
:Literature
:Literature rdf:type
rdf:type owl:Class;
owl:Class;
owl:unionOf
(:Novel
owl:unionOf (:Novel :Short_Story
:Short_Story :Poetry).
:Poetry).
<myWork>
<myWork> rdf:type
rdf:type :Novel
:Novel ..

then the following holds, too:

<myWork>
<myWork> rdf:type
rdf:type :Literature
:Literature ..

119

It can be a bit more complicated

If:
:Novel
rdf:type
:Novel
rdf:type owl:Class.
owl:Class.
:Short_Story
rdf:type
owl:Class.
:Short_Story
rdf:type owl:Class.
:Poetry
rdf:type
:Poetry
rdf:type owl:Class.
owl:Class.
:Literature
rdf:type
owlClass;
:Literature rdf:type owlClass;
owl:unionOf
owl:unionOf (:Novel
(:Novel :Short_Story
:Short_Story :Poetry).
:Poetry).
fr:Roman
fr:Roman owl:equivalentClass
owl:equivalentClass :Novel
:Novel ..
<myWork>
<myWork> rdf:type
rdf:type fr:Roman
fr:Roman ..

then, through the combination of different terms,

the following still holds:
<myWork>
<myWork> rdf:type
rdf:type :Literature
:Literature ..

120

What we have so far

The OWL features listed so far are already fairly

powerful

E.g., various databases can be linked via

owl:sameAs, functional or inverse functional
properties, etc.

Many inferred relationship can be found using a

traditional rule engine

121

However that may not be enough

Very large vocabularies might require even more

complex features

122

typical usage example: definition of all concepts in a health

care environment
a major issue: the way classes (i.e., concepts) are defined

OWL includes those extra features but the

inference engines become (much) more complex

Property value restrictions

Classes are created by restricting the property

values on its individuals

For example: how would I characterize a listed

price?

it is a price (which may be a general term), but one that is

given in one of the allowed currencies (say, , , or )
more formally:

the value of p:currency, when applied to a resource on

listed price, must be of one of those values
thereby defining the class of listed price

123

Restrictions formally

Defines a class of type owl:Restriction with a

reference to the property that is constrained

definition of the constraint itself

One can, e.g., subclass from this node when

defining a particular class

:Listed_Price
:Listed_Price rdfs:subClassOf
rdfs:subClassOf [[
rdf:type
owl:Restriction;
rdf:type
owl:Restriction;
owl:onProperty
p:currency;
owl:onProperty
p:currency;
owl:allValuesFrom
:Currency.
owl:allValuesFrom
:Currency.
].
].

124

Possible usage
If:
:Listed_Price
:Listed_Price rdfs:subClassOf
rdfs:subClassOf [[
rdf:type
owl:Restriction;
rdf:type
owl:Restriction;
owl:onProperty
p:currency;
owl:onProperty
p:currency;
owl:allValuesFrom
:Currency.
owl:allValuesFrom
:Currency.
].
].
:price
:price rdf:type
rdf:type :Listed_Price
:Listed_Price ..
:price
:price p:currency
p:currency <something>
<something> ..

then the following holds:

<something>
<something> rdf:type
rdf:type :Currency
:Currency ..

125

Other restrictions

allValuesFrom could be replaced by:

someValuesFrom

e.g., I could have said: there should be a price given in at

least one of those currencies

hasValue, when restricted to one specific value

Cardinality restrictions: instead of looking at the

values of properties, their number is considered

eg, a specific property should occur exactly once

126

Datatypes in OWL

RDF Literals can have a datatypes, OWL adopts

those

But more complex vocabularies require datatypes

restrictions; eg, numeric intervals

I am interested in a price range between 5 and 15

RDF allows any URI to be used as datatypes

ie, one could use XML Schemas to define, eg, numeric

intervals
but it is very complex, and reasoners would have to
understand a whole different syntax

127

Datatype restrictions (OWL 2)

For each datatype, XML Schema defines possible

restriction facets: min and max for numeric types,
length for strings, etc

OWL uses these facets to define datatype ranges

for its own use

128

Definition of a numeric interval in OWL 2

:AllowedPrice
:AllowedPrice rdf:type
rdf:type rdfs:Datatype;
rdfs:Datatype;
owl:onDatatype
xsd:float;
owl:onDatatype xsd:float;
owl:withRestriction
owl:withRestriction ((
[[ xsd:minInclusive
xsd:minInclusive 5.0
5.0 ]]
[[ xsd:maxExclusive
xsd:maxExclusive 15.0
15.0 ]]
)) ..

The possible facets depend on the datatype:

xsd:pattern, xsd:length, xsd:maxLength,

129

130

Typical usage of OWL 2 datatype restrictions

:Affordable_book
:Affordable_book rdf:type
rdf:type owl:Class;
owl:Class;
rdfs:subClassOf
[
rdfs:subClassOf [
rdf:type
owl:Restriction;
rdf:type
owl:Restriction;
owl:onProperty
p:price_value;
owl:onProperty
p:price_value;
owl:allValuesFrom
[
owl:allValuesFrom [
rdf:type
rdf:type rdfs:Datatype;
rdfs:Datatype;
owl:onDatatype
owl:onDatatype xsd:float;
xsd:float;
owl:withRestriction
owl:withRestriction ((
[[ xsd:minInclusive
xsd:minInclusive 5.0
5.0 ]]
[[ xsd:maxExclusive
xsd:maxExclusive 15.0
15.0 ]]
))
]]
].
].

ie: an affordable book has a price between 5.0 and

15.0

But: OWL is hard!

131

The combination of class constructions with various

restrictions is extremely powerful

What we have so far follows the same logic as

before

extend the basic RDF and RDFS possibilities with new

features
define their semantics, ie, what they mean in terms of
relationships
expect to infer new relationships based on those

However a full inference procedure is hard

not implementable with simple rule engines, for example

OWL species

OWL species comes to the fore:

restricting which terms can be used and under what

circumstances (restrictions)
if one abides to those restrictions, then simpler inference
engines can be used

They reflect compromises: expressibility vs.

implementability

132

Unrestricted OWL (a.k.a. OWL Full)

133

No constraints on any of the constructs

owl:Class is just syntactic sugar for rdfs:Class

owl:Thing is equivalent to rdfs:Resource
this means that:

Class can also be an individual, a URI can denote a property

as well as a Class

e.g., it is possible to talk about class of classes, apply properties

on them
etc

etc.

Extension of RDFS in all respects

But: no system may exist that infers everything one

might expect

OWL Full usage

Nevertheless OWL Full is essential

it gives a generic framework to express many things with

precise semantics
some application actually just need to express and
interchange terms (even with possible scruffiness)

Applications may control what terms are used and

how

in fact, they may define their own sub-language via, eg, a

vocabulary

thereby ensuring a manageable inference procedure

134

OWL DL

A number of restrictions are defined

classes, individuals, object and datatype properties, etc, are

fairly strictly separated
object properties must be used with individuals

i.e., properties are really used to create relationships between

individuals

no characterization of datatype properties

But: well known inference algorithms exist!

135

Examples for restrictions

136

The following is not legal OWL DL:

<q>
<q> rdf:type
rdf:type <A>.
<A>.

## AA is
is aa class,
class, qq is
is an
an individual
individual

<r>
<r> rdf:type
rdf:type <q>.
<q>.

## error:
error: qq cannot
cannot be
be used
used for
for aa class,
class, too
too

<A>
<A> ex:something
ex:something <B>.
<B>.

## error:
error: properties
properties are
are for
for individuals
individuals only
only

<q>
<q> ex:something
ex:something <s>.
<s>.
<p>
ex:something
54.
<p> ex:something 54.

## error:
error: same
same property
property cannot
cannot be
be used
used as
as
## object
and
datatype
property
object and datatype property

OWL DL usage

Abiding to the restrictions means that very large

ontologies can be developed that require precise
procedures

eg, in the medical domain, biological research, energy

industry, financial services (eg, XBRL), etc
the number of classes and properties described this way
can go up to the many thousands

OWL DL has become a language of choice to

define and manage formal ontologies in general

even if their usage is not necessarily on the Web

137

OWL 2 defines further species

a.k.a. profiles

Further restrictions on how terms can be used and

what inferences can be expected

138

OWL 2 profiles: EL

Goal: classification and instance queries in

polynomial time

Suitable for

very large number of classes and/or properties

not require complex expressions

eg: SNOMED

Some excluded features

no cardinality restrictions, fewer property restrictions

no inverse, reflexive, disjoint, symmetric, asymmetric,
functional or inverse functional properties
class disjunction

139

OWL 2 profiles: QL

Goal: conjunctive queries on top of relational

databases (essentially: query rewriting to SQL)

Suitable for

lightweight ontologies, but large data

Some excluded features

functional and inverse functional properties, sameAs, keys

fewer property restrictions
no cardinality restrictions
transitive properties, property chains

140

OWL 2 profiles: RL

Goal: polynomial reasoning on top of rule engines

Suitable for

relatively lightweight ontologies, but large data

Some excluded features

fewer property restrictions

fewer cardinality restrictions (at most 0/1)
constraints on class expressions (union, intersections, etc)
when used in subclass expressions
no datatype restrictions

141

Ontology development

The hard work is to create the ontologies

requires a good knowledge of the area to be described

some communities have good expertise already (e.g.,
librarians)
OWL is just a tool to formalize ontologies
large scale ontologies are often developed in a community
process

Ontologies should be shared and reused

can be via the simple namespace mechanisms

or via explicit import

142

Must I use large ontologies?

NO!!!

Many applications are possible with RDFS and a

just a little bit of OWL

a few terms, whose meaning is defined in OWL, and that

application can handle directly
OWL RL is a step to create such a generic OWL level

Big ontologies can be expensive (both in time and

money); use them only when really necessary!

143

Ontologies examples

eClassOwl: eBusiness ontology for products and

services, 75,000 classes and 5,500 properties

National Cancer Institutes ontology: about 58,000

classes

Open Biomedical Ontologies Foundry: a collection

of ontologies, including the Gene Ontology to
describe gene and gene product attributes in any
organism or protein sequence and annotation
terminology and data (UniProt)

BioPAX: for biological pathway data

144

Example: improved search via ontology

Search results are re-ranked using ontologies

Related terms are highlighted, usable for further

search

145

Example: improved search via ontology

Same dataset, different ontology

(ontology is on non-animal experimentation)

146

Eli Lillys Target Assessment Tool

Prioritization of
drug target,
integrating data
from different
sources and
formats

Integration,
search via
ontologies
(proprietary and
public)

Courtesy of Susie Stephens, Eli Lilly (SWEO Case Study)

147

Help for deep sea drilling operations

Integration of
experience and data in
the planning of deep
sea drilling processes

Discover relevant
experiences

uses an ontology backed

search engine

Courtesy of David Norheim and Roar Fjellheim, Computas AS (SWEO Use Case)

148

149

Rules
(RIF)

Rules

There is a long history of rule languages and rulebased systems

eg: logic programming (Prolog), production rules

Lots of small and large rule systems (from mail

filters to expert systems)

Hundreds of niche markets

150

Why rules on the Semantic Web?

There are conditions that ontologies (ie, OWL)

cannot express

a well known example is Horn rules: (P1 P2 ) C

(though OWL 2 property chains cover some cases)

A different way of thinking people may feel more

familiar in one or the other

151

Things you may want to express

An example from our bookshop integration:

a novel with over 500 pages and costing less than 5 is a

cheap book
something like (in an ad-hoc syntax):

If
If {{ ?x
?x rdf:type
rdf:type p:Novel;
p:Novel;
p:page_number
p:page_number ?p;
?p;
p:price
[
p:price [
p:currency
p:currency p:;
p:;
rdf:value
?z
rdf:value ?z
].
].
?p
?p >> "500"^^xsd:integer.
"500"^^xsd:integer.
?z
<
"5.0"^^xsd:double.
?z < "5.0"^^xsd:double. }}
then
then {{ ?x
?x rdf:type
rdf:type p:CheapBook
p:CheapBook }}

152

A new requirement: exchange of rules

Applications may want to exchange their rules:

negotiate eBusiness contracts across platforms: supply

vendor-neutral representation of your business rules so that
others may find you
describe privacy requirements and policies, and let clients
merge those (e.g., when paying with a credit card)

Hence the name of the working group: Rule

Interchange Format

goal is a language that

expresses the rules a bit like a rule language

can be used to exchange rules among engines

153

Notes on RIF (cont)

RIF does not concentrate on RDF only

ie, certain constructions go beyond what RDF can express

But there is a subset that is RDF and also OWL

related

For the coming few slides, forget about RDF

we will come back to it. Promise!

154

In an ideal World

155

In the real World

Rule based systems can be very different

different rule semantics (based on various type of model

theories, on proof systems, etc)
production rule systems, with procedural references, state
transitions, etc

Such universal exchange format is not feasible

The idea is to define cores for a family of

languages with variants

156

RIF core: only partial interchange

157

RIF dialects

158

Possible dialects: F-logic, production rules, fuzzy or

probabilistic logic,

Role of dialects

159

Role of dialects

160

Role of dialects

161

Role of dialects

162

However

Even this model does not completely work

The gap between production rules and traditional

logic systems is too large

A hierarchy of cores is necessary:

163

a Basic Logic Dialect and Production Rule Dialect as cores

for families of languages
a common RIF Core binding these two

Hierarchy of cores

164

Current status

Candidate Recommendation published in October

2009

what this means: technical work is done, cross-checked

against implementations

165

RIF Core

Core defines

a presentation syntax, which is really to present the

constructions (is not necessarily implemented in tools)
a formal XML syntax to encode and exchange the rules

A Core document is

some directives like import, prefix settings for URI-s, etc

a sequence of implications, possibly involving built-in
predicates on datatypes

166

RIF Core example

167

Document(
Document(
Prefix(cpt
Prefix(cpt http://example.com/concepts#)
http://example.com/concepts#)
Prefix(ppl
http://example.com/people#)
Prefix(ppl http://example.com/people#)
Prefix(bks
Prefix(bks http://example.com/books#)
http://example.com/books#)

))

Group
Group
((
Forall
Forall ?Buyer
?Buyer ?Item
?Item ?Seller
?Seller ((
cpt:buy(?Buyer
cpt:buy(?Buyer ?Item
?Item ?Seller):?Seller):- cpt:sell(?Seller
cpt:sell(?Seller ?Item
?Item ?Buyer)
?Buyer)
))
cpt:sell(ppl:John
cpt:sell(ppl:John bks:LeRif
bks:LeRif ppl:Mary)
ppl:Mary)
))

infers the following relationship:

cpt:buy(ppl:Mary
cpt:buy(ppl:Mary bks:LeRif
bks:LeRif ppl:John)
ppl:John)

Additional RIF Core features

RIF Core includes some extra features

built-in datatypes and predicates

notion of local names, a bit like RDFs blank nodes
classification, like typing in RDFS and OWL

p # T

168

What about RDF(S), OWL, and RIF?

Typical scenario: applications exchange rules that

refer to RDF data

To make that work:

RDF facts/triples have to be representable in Core

harmonization on the concepts is necessary
the formal semantics of the two worlds should also be
aligned

There is a separate document that brings these

together

169

Rules vs OWL?

In a SW application, should I use RIF, OWL, or

both?

The two approaches are complimentary

there are things that rules cannot really express or infer

there are things that ontologies cannot really express or in

only a very complicated manner

eg, inferencing complex relationships among classes

eg, complex Horn rules

Often, applications require both

170

171

What have we achieved?

(putting all this together)

Other SW technologies

There are other technologies that we do not have

time for here

find RDF data associated with general URI-s: POWDER

bridge to thesauri, glossaries, etc: SKOS

172

173

Remember the integration example?

Same with what we learned

174

Example: personalized tourist itinerary

175

Integration of
relevant data in
Zaragoza (using
RDF and ontologies)

Use rules on the

RDF data to provide
a proper itinerary

Courtesy of Jess Fernndez, Mun. of Zaragoza, and Antonio Campos, CTIC (SWEO Use Case)

176

Available documents, resources

177

Available specifications: Primers, Guides

The RDF Primer or OWL 2 Primer give a formal

introduction to RDF(S) and OWL

GRDDL and RDFa Primers have also been

published

The W3C Semantic Web Activity Homepage has

links to all the specifications and guides:

http://www.w3.org/2001/sw/

Core vocabularies

There are also a number widely used core

vocabularies

Dublin Core: about information resources, digital libraries,

with extensions for rights, permissions, digital right
management
FOAF: about people and their organizations
DOAP: on the descriptions of software projects
SIOC: Semantically-Interlinked Online Communities
vCard in RDF

One should never forget: ontologies/vocabularies

must be shared and reused!

178

Some books

179

J. Pollock: Semantic Web for Dummies, 2009

G. Antoniu and F. van Harmelen: Semantic Web

Primer, 2nd edition in 2008

D. Allemang and J. Hendler: Semantic Web for the

Working Ontologist, 2008

P. Hitzler, R. Sebastian, M. Krtzsch: Foundation of

Semantic Web Technologies, 2009

See the separate Wiki page collecting book references:

http://esw.w3.org/topic/SwBooks

Further information and Fora

Planet RDF aggregates a number of SW blogs:

http://planetrdf.com/

Semantic Web Interest Group

a forum developers with archived (and public) mailing list,

and a constant IRC presence on freenode.net#swig

anybody can sign up on the list:

http://www.w3.org/2001/sw/interest/

there are also similar list for Linked Open Data, OWL
developers, etc

contact me for details if you cannot find them

180

181

Lots of Tools (not an exhaustive list!)

Categories:

Triple Stores
Inference engines
Converters
Search engines
Middleware
CMS
Semantic Web browsers
Development environments
Semantic Wikis

Some names:

Jena, AllegroGraph, Mulgara,

Sesame, flickurl,
TopBraid Suite, Virtuoso
environment, Falcon, Drupal 7,
Redland, Pellet,
Disco, Oracle 11g, RacerPro,
IODT, Ontobroker, OWLIM, Tallis
Platform,
RDF Gateway, RDFLib, Open
Anzo, DartGrid, Zitgist, Ontotext,
Protg,
Thetus publisher, SemanticWorks,
SWI-Prolog, RDFStore

Conclusions

The Semantic Web is about creating a Web of

Data

There is a great and very active user and

developer community, with new applications

182

By the way: the book is real

183

184

Thank you for your attention!

These slides are also available on the Web:

http://www.w3.org/2009/Talks/1030-Philadelphia-IH/