Great channel for semantic web videos

Check it out on Vimeo.

Teaching RDF

I recently held a 90min lecture on RDF. In it, I’ve followed the obvious path of explaining the usefulness of RDF by showing how it can be interpreted in several ways (set of triples, resources, graph). For a hands-on session, I needed a way to interactively create and query RDF, so I’ve added functionality to Hyena: In the “Query” zone, one can edit a graph in Turtle Syntax and query the repository with SPARQL. It turned out that there was a nice synergy between this zone and the rest of Hyena, because the encoded wiki pages plus attached tags provided nice “real-world” example data. As an exercise, I asked my audience to express in SPARQL the query “all wiki pages that are tagged with ‘Todo’”.

Update: More RDF shells

• sparql-query: A shell for accessing SPARQL endpoints. [Source: Mischa Tuffield]


• OntoWiki has an interactive query shell with SPARQL syntax highlightning, saved queries and other features. [Source: Sebastian Tramp]


• The SparqlTrainer is an e-learning tool to practice SPARQL interactively. [Source: Sebastian Tramp]

Related reading:

• Free text book on RDF (foundation of Semantic Web)

RDF (almost) is the next generation of relational databases

I love RDF and SPARQL, especially their elegance and simplicity. They surely deserve a lot more attention and not just as a formalism for ontologies and semantics, but also as a next step for relational databases. Especially with the “No SQL” movement becoming popular, RDF could be an alternative that builds on the achievements of the relational database community instead of shunning them. Note that the No SQL implementation Couch DB offers JavaScript-centricity and is a little bit simpler than RDF, so one might prefer it for some scenarios. On the other hand, RDF is not much more complicated and offers other features (composable data, standardized symbols, a general-purpose query language, etc.) that Couch DB cannot match. Alas, some of the basics are still complicated in RDF, such listing properties in a table. My paper “Using RDF for social information management” has more on this topic.

Free text book on RDF (foundation of Semantic Web)

My dissertation is online. While many chapters are specific to the topic of the dissertation, some chapters of it should be very readable introductions to RDF and related ideas such as Linked Data. While RDF is the foundation of the Semantic Web, there are two communities using it:

1. RDF as a knowledge representation: This community is concerned with semantics, ontologies, etc.


2. RDF as data: This community uses RDF as next-generation relational database

The focus of this dissertation is (2). Recommended reading:

• Part I: Background. Explains RDF, Linked data on the web, folksonomies, ontologies, schema and ontology languages.


• Part VI: Related work. Mentions work that is related to Hyena: information management, hypertext, etc.

Facebook adopts RDFa

This is a big deal. RDFa allows one to search web pages as if they were databases. Think Google, but with additional options such as: “Show me movies that ...” or “Show me books written by ...” or even “Show me opinions on books written by ...”. With Facebook’s weight behind it, we will hopefully see wider adoption. Publishers that initially support Facebook’s Open Graph standard are IMDb, Microsoft, NHL, Posterous, Rotten Tomatoes, TIME, and Yelp. That already includes quite a bit of useful data. Well, at least as far as movies are concerned.

Requirements: RDF and social applications

Update 2009-08-06: added more information on named graphs, a reference to AliBaba, and a clarification on text handling.

RDF data is managed in a decentralized manner which makes it ideal for social applications (where many people collaborate). In this post, I've collected requirements for RDF engines on which a social application is to be built. The main features are

• Named graphs: are supported by almost all RDF engines. They partition the RDF repository. Social applications should authorize access at graph granularity. That way, some graphs can be private and others public. RDF allows one to hide the “seams” between graphs at will. An RDF repository should support this by enabling one to show and hide graphs on the fly, during access. SPARQL and Sesame can both do this. The former by constraining the graph URI, the latter by specifying a set of contexts when invoking RepositoryConnection.getStatements().
  
• Distributed version control: provides two abilities. First, versioning is useful for personal use (history, undo) and collaborative use (conflict management, tracking who made what changes). Second, peer-to-peer synchronization is useful for offline use, backup, and collaboration. Pastwatch is an example of very clever (file-based) distributed version control.
  
• Text handling: to make long texts that are stored in RDF literals more accessible, one should be able to configure what property values are to be indexed. Ideally, version control would only store changes between versions (as opposed to the complete text). As an alternative to storing the text in the RDF repository, one can let the property point to an external document management system. Still, the necessity for version control remains.
  
• Record the author of a statement: so that a social application can track who contributed what.
  

Less important features:

• Support for XML literals in SPARQL
• Ease of use: should be easy to install and use; should focus on core RDF repository features.
  

Three RDF engines come close:

• Open Anzo: an RDF engine that supports versioning, user-based authentication, and text indexing. Replication is possible, but not in a distributed manner. Open Anzo’s philosophy is very much in line with this post.
  
• IBM Semantic Layered Research Platform: does not seem to be updated any more. Poorly documented. I'm not sure if it can do distributed synchronization. Update: This is Open Anzo's precursor (see comments below).
  
• OpenLink data spaces: powerful, offers all kinds of import and export services. But the free version does not have replication. I'm not sure how far beyond two-way replication its features go.
• KiWi (Knowledge in a wiki): an intriguing social content platform that rolls its own RDF engine. Its content model deviates from pure RDF. It also cannot do distributed synchronization. Not publically available, yet.
• Sesame has a new project called AliBaba that provides repository federation and change logging.
  

Related technologies:

• Changesets: an RDF vocabulary for keeping a history of changes. Useful for exporting data from a repository that supports versioning.
  

Proposed features for SPARQL

The W3C has published a wiki page with proposed features for the RDF query language SPARQL. My favorite is “Parameterized Inference”: I've always found how inference is done in RDFS and OWL very cumbersome (i.e. by creating statements). My needs for inference have always been very basic, but just having transitivity available directly in SPARQL would be great.
Other interesting proposals:

• Aggregate functions: such as COUNT etc.
• Accessing RDF lists: it is currently impossible to express “a list that has a member that matches pattern P”.
• Query References to Blank Nodes in the Data: even though a blank node ID b is not stable, it can be expressed as the pseudo-URI _:b. During a single session, it would be quite handy if one could use these pseudo-URIs like normal URIs.
• Full-text search: Proposal to adapt XQuery full-text extensions to SPARQL.
• Project expressions: The values in the columns can be the result of an expression and not just a single variable.

I am missing two things:

• A way to get matches that are only in the default graph. One can do graph-based restriction, but only for named graphs. That is, the variable involved in the GRAPH construct always has to be bound. A work-around that I use in Hyena is to look for matches in all graphs and then exclude a match if it also appears in a named graph.
• A more object-oriented way of returning query results. That is, one should be able to return one resource per row, where some columns (“all values of rdf:type”) contain multiple values (are in non-first normal form). LIMIT per resource mentions this feature, but does not go into detail.

Update: To clarify the work-around.
Query: all subjects that *only* exist in the default graph.

SELECT DISTINCT ?subj
WHERE {
    ?subj ?pred ?obj .
    OPTIONAL {
        GRAPH ?__graph__ {
            ?subj ?pred ?obj .
        }
    }
    FILTER( !bound(?__graph__) )
}

A simpler version would be (where one does not have to write the same pattern twice which quickly becomes cumbersome with larger patterns):

SELECT DISTINCT ?subj
WHERE {
    GRAPH ?__graph__ { ?subj ?pred ?obj . }
    FILTER( !bound(?__graph__) )
}

A Semantic Web Reference Card

Description: The UMBC Semantic Web Reference Card is a handy "cheat sheet" for semantic web developers and programmers. It can be printed double sided on one sheet of paper and tri-folded. The card lists common RDF/RDFS/OWL classes and properties, popular namespaces and terms, XML datatypes, reserved terms, grammars and examples for encodings, etc.

Really neat: this reference card covers most of the stuff one needs when working with RDF "manually". [source: Planet RDF]