Take the Tour

As Tim Berners-Lee and others have described it, the Semantic Web creates a web of data that allows computers to find, extract, share, re-use information, and potentially even reason with it. Semantic content can be embedded in web pages, published from databases, and gathered into online repositories. Most important, semantic data itself contains “meta-information” so that other services are able to make sense of it. For example, the Semantic Web uses markup not only to indicate how something should be rendered, but also to express content (e.g. the authorship, title, and date of an article).

The Semantic Web is the next step in the evolution of the Internet. But making this technology meaningful and accessible to everyday users is where Twine comes in. Twine is an application that helps people organize, share and discover information around their interests. And while users certainly don’t need to understand the Semantic Web in order to appreciate Twine, several technologies are hard at work behind the scenes of its simple user interface. Let’s take a closer look at one of the most important—the Resource Description Framework language or RDF.

Twine and RDF

Twine’s “smarts” are derived from the simplicity of three-part RDF statements, often called triples or tuples. In fact, all information in Twine— whether about a particular object, person, note, bookmark, tag, email message, or even a video—is expressed in a set of tuples.

For instance, here is a Twine item page for the book, Jurassic Park.

Let's Take a Look
OWL
Accessing the RDF in Twine
RDF and the Semantic Graph
References

However, if the same URL is accessed by a system that asks for data in the form “application/rdf+xml”, instead of returning a page of HTML, an RDF document appears as shown below.

<rdf:RDF

   xmlns:basic="http://www.radarnetworks.com/2007/09/12/basic#"

   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

   xmlns:s="http://www.w3.org/2000/01/rdf-schema#">

   <rdf:Description about="http://www.twine.com/item/1sj51123-2g5">

          <s:label>Jurassic Park</s:label>

          <basic:author>Michael Crichton</basic:author>

          <basic:manufacturer>Arrow Books Ltd</basic:manufacturer>

          <basic:tag>Science Fiction</basic:tag>

          <rdf:type rdf:resource="http://www.radarnetworks.com/2007/09/12/basic#Book"/>

          <radar:wasCreatedBy rdf:resource="http://www.twine.com/user/lew"/>

          <app:hasComment rdf:resource="http://www.twine.com/item/1slbszfg-2x9"/>

          </rdf:Description>

   <rdf:Description about="http://www.twine.com/item/1slbszfg-2x9">

          <rdf:type rdf:resource="http://www.radarnetworks.com/shazam#Comment"/>

          <basic:description>One of my favorites</basic:description>

          <radar:wasCreatedBy rdf:resource="http://www.twine.com/user/lew"/>

    </rdf:Description>

</rdf:RDF>

RDF documents like the one above are made up of simple three-part statements in the form <subject, predicate, object>.

For example, a system will see that Jurassic Park

has an author: Michael Crichton
was released on: 9/07/2006
and has a comment, made by /user/lew.

Processing data in this clear 1, 2, 3 format is much faster and less error-prone than “screen scraping” the web page in the hope of retrieving the correct fields. Twine’s knowledge of Jurassic Park is simply the set of all tuples that have this book as the subject. When two tuples refer to the same object, they become linked and in this way start to build a semantic graph. In short, Twine uses tuples to access a tremendous breadth and depth of information about any given subject.

Another important aspect of RDF is that each object or resource, no matter its location on the Internet, is referred to by a universally distinct identifier or URI. In the case above, the URI is:

“http://www.twine.com/item/1sj51123-2g5”.

This distinct identifier allows Twine to specify the book object and not confuse it with any other book object that might have the same title or author. A book might be collected by one or more users in the system, so it’s important to uniquely identify the book by its URI in order to know precisely what object is a favorite of a particular user.

By building on the foundational technologies of the Semantic Web, specifically RDF, Twine hopes to provide its users with an open and extensive platform for organizing, sharing and discovering information. By making information accessible to a wider audience, Twine also seeks to foster the growth of the Semantic Web.

OWL

So where do the properties such as author, manufacturer and label come from? Twine uses another important technology called OWL (Web Ontology Language) to define these properties and classes, and to determine their uses. Over the past several years, different organizations and companies in a wide range of disciplines have defined various ontologies. Twine does the same, but also leverages a much larger definition set produced by the W3C and other organizations. This allows the Twine knowledge base to interoperate with other information repositories.

Accessing the RDF in Twine - Try It Yourself

If you have a Twine account, you can add an optional parameter to the URL to force the content type into RDF.

To try this with the example used above, first go the item detail page for the book Jurassic Park.

http://www.twine.com/item/1sj51123-2g5/jurassic-park

Now, replace the trailing item name “/jurassic-park” with our optional parameter: “?rdf”.

http://www.twine.com/item/1sj51123-2g5?rdf

Depending upon the browser, you may see the RDF return directly as a single string, or as a download. Either way, RDF isn’t very pretty, so you’ll typically need other programs to help parse the XML.

One useful Firefox plug-in, distributed by the W3C for reading RDF on the web, is called Tabulator. Once installed, you can visit an item page in Twine, set the Tabular plug-in to request data in RDF (through the tools menu: data browser > Make Firefox Request RDF), refresh the page, and then view the RDF. (If you are interested in trying Tabulator, make sure to get the Firefox plug-in version and not the bookmarklet, which requires a server-side component.)

Here's the same example, this time viewed through Tabulator:

Click on the URIs in this view to “walk the graph” and explore the information within Twine. Because Tabulator requests RDF, there is no need to add the optional “rdf” parameter to each URL.

Note: Tabulator and a few other RDF readers also exist as server-side components. However, because Twine requires users to login during its beta period, most server-based RDF readers will not be able to access the site. Following the beta period, Twine will be open to these and other services that consume RDF.

RDF and the Semantic Graph

RDF statements form a graph of arcs and nodes. Data input into Twine connects to people, places and other pieces of information. You can see the graph-like nature of RDF with the simple Java Web Start application RDF Gravity. The graph below was made by RDF Gravity to virtually display the RDF description of Jurassic Park.

The above graph shows that there is not only a book by Michael Crichton, but there is also a comment linked to the book. Both the book and the comment were made by /usr/lew. As more books are authored by Michael Crichton or published by Arrow Books, these objects continue to link together. Twine uses the data and properties in the graph to link related information, allowing users to search along different dimensions. As more information is added, the richer and more useful the graph becomes.

References

http://www.w3.org/TR/rdf-primer/

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

http://en.wikipedia.org/wiki/Resource_Description_Framework

RDF Gravity: http://semweb.salzburgresearch.at/apps/rdf-gravity/index.html

Tabulator: http://www.w3.org/2005/ajar/tab