It outlines one approach that I’ve been developing for the API in the BBC programme catalogue. One of the things I like a great deal about Rails is its URL routing and dispatch mechanism. Creating mappings from URLs to model instances makes a resource-oriented style feel very natural, which sits very well with REST.

Isn’t this a wonderfully literal interpretation of the article’s title?

It’s an expanded version of two previous posts previously made to hackdiary. It goes into a little more detail about how the code works, and gives more examples. There’s also more analysis, and more of an introduction for the uninitiated.

It’s a bit weird reading my text on another site after it’s been edited by someone else. I’ve never been entirely comfortable with the written word; I’m more of a face-to-face person, and I think better out loud than at a keyboard. When I started posting on this site, one of my goals was to get used enough to writing that I’d feel able to tackle articles, conference papers and the like. It’s good to be getting somewhere with that.

Take REST: An Analysis of Two REST APIS: Paul Prescod’s always interesting on this topic. I found his writings on REST convincing when I first discovered them a couple of years ago, and it was great to meet him at last year’s XML Europe in London.

Lessons From an XML Query-Qriven SVG+XHTML Web Site: always interesting to see how new technologies actually get used, rather than just sit listening to people talk through the specs. At a BOF at last year’s WWW conference, Liam and others were talking about the possibility of adapting XQuery as a query language for RDF.

Topic Maps are Emerging – Why Should I Care?: because I don’t know enough about topic maps despite being an RDFhead.

Semantic Blogging: Spreading the Semantic Web Meme: I’ve never met Steve Cayzer, but I know several people from ILRT who’ve worked with him and it all sounds like interesting work. He’s on in the same session as my talk, followed by two more fascinating semantic web talks from Damian Steer and Dave Beckett.

Hmm, RDF/XHTML: A New RDF Syntax or RDF, XForms, and the Law – Staying Out of Gaol?

The tutorials look rather good this year (Amazon web services, .NET and XML, XSLT2, XQuery, XML schemas, etc) but my employer didn’t have the money for me to attend. At least I’ll get to hear Jeff Barr at his keynote.

Oh, and I just found out I’ve got the go-ahead to attend www2004. Anyone else going?

The current XMLTV DTD turns out to be pretty RDF-friendly in its structure. This XML example looks very similar as RDF (graph). The major changes I made in the translation were in assigning URIs to channels and programme categories, using identifiers such as http://xmlns.com/2003/rdftv/channel#bbc3.bbc.co.uk and http://xmlns.com/2003/rdftv/category/ananova#News/CurrentAffair, and giving the tv data a namespace under http://xmlns.com. The conversion is performed by some XSLT.

Taking a complete TV feed as RDF, I can now write query code using Redland and Python to print out details of all films on TV this week.

A sample RDF graph drawn in OpenOffice looks like this:

(original file)

The output of the script run over this file is:

_:a11055796046 <http://example.com#pred2> <http://example.com#1> .
_:a11055796046 <http://example.com#pred1> "text" .
<http://example.com#1> <http://example.com#foo> <http://example.com#bar> .

Rectangles or ellipses with no text on them are taken to be bNodes. Those with text have URIs if they look like URIs (start with http:// or similar) and those with “quoted text” are literals (the quotes are discarded). Predicate URIs are taken from the text on the connectors.

The code uses the xpath processor from PyXML and is written for python 2.2. It’s worth setting up the ‘Default’ style in OpenOffice Draw so that it puts arrows on the end of each connector, otherwise it’s easy to get confused about which way round the connectors are.

Note: the example code below has been updated.

The commandline version looks like this:

wget -O - http://example.com | tidy -asxml - | xsltproc somexsl.xsl -

where somexsl.xsl looks something like this:

<?xml version='1.0'?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'>
<xsl:output method="text" />
<xsl:template match="/">
<xsl:value-of select="/html/head/title" />
</xsl:template>
</xsl:stylesheet>

It’s also possible to do the same thing entirely in Java. John Cowan wrote a wonderful HTML parser called TagSoup that outputs SAX events using a do-the-best-I-can approach (“Just Keep On Truckin’” as he describes it) that attempts to make the best job of even the nastiest badly-written HTML. It produces output in cases when HTML TIDY gives up and tells you that errors in the input must be corrected before it can continue.

Because the SAX events just look like XML to any downstream code, it can be plugged into an XPath processor such as Jaxen. XPath processors need DOM trees to work with (because of the backwards-and-forwards-looking nature of the language which makes streaming processing difficult). JDOM contains a nice class called SAXBuilder that can do this SAX-to-DOM conversion, and handily Jaxen can work with JDOM trees directly. So, the Java equivalent of the commandline above is:

URL url = new URL("http://example.com");
SAXBuilder builder = new SAXBuilder("org.ccil.cowan.tagsoup.Parser"); // build a JDOM tree from a SAX stream provided by tagsoup
Document doc = builder.build(url);
JDOMXPath titlePath = new JDOMXPath("/h:html/h:head/h:title");
titlePath.addNamespace("h","http://www.w3.org/1999/xhtml");
String title = ((Element)titlePath.selectSingleNode(doc)).getText();
System.out.println("Title is "+title);

RSS 1.0 (RDF Site Summary) is a well-known XML format commonly used for syndicating news headlines. By design it is an extensible format in which metadata expressed using any RDF vocabulary can be linked to its component items, while still maintaining compatibility with applications such as newsreaders that may be unaware of such vocabularies. This paper will discuss some interesting applications that can be built with RSS as a base. The annotation of collections of photographs is used as a case study.

Using an RDF representation of Wordnet, the lexical database of English, we attach keywords to photographs to indicate what they objects they depict. With simple inference logic, we create improved search engines over this data. For example, using the hypernym information in Wordnet to extrapolate from keywords, a search for buildings can find hotels, churches, houses and other related photographs. We can automatically build a Yahoo-like hierarchical web site of photographs organised by the meaning of their keywords.

Using the Friend Of A Friend (FOAF) vocabulary, we can record which photographs show particular people. Applications can then display related information with the photograph by using information gathered by spidering the existing network of FOAF information on the web.

Dynamically-built RSS channels are an ideal format for expressing search results; hence people who are interested could use newsreaders to subscribe to new pictures of any Wordnet noun, particular person or other metadeta criteria. This RSS is easily turned into web pages using templating tools. A Blogger-like front page can be built by building an RSS ‘meta-channel’ summary of the 10 newest photo collections.

Processing toolkits for RDF are available in many languages, and RDF’s natural integration with the web’s URI system makes it easy to build applications in a loosely-coupled style. Tools for this project built using the Redland API in Perl and the Jena toolkit in Java easily interoperate, using the RDF output of one as the input of another. New applications can be built by others using any language or environment with RDF and HTTP support (even Mozilla), without needing to be granted any special database access or other privileges.

Update: slides from this and other talks are available.

Subject: Re: [RSS-DEV] RSS and Libraries
From: mb@p…
Date: Tue Dec 17, 2002 9:18 pm

On Mon, Dec 16, 2002 at 05:14:33PM +0000, Libby Miller wrote:
> On Mon, 16 Dec 2002, se teague wrote:
> > I’m so happy to find this group! I’ve been developing an
> > RSS/Perl/PHP/MySQL based rss program to generate news and events for the
> > academic library I work for. i do have a question though; We haven’t
> > tackled associating images with RSS items rather than channels. Has
> > anyone done this before? Any best practices out there?
>
> I rather like what Matt Biddulph’s been doing, e.g.:
> http://www.picdiary.com/rss/barcelona_conf.rss

Thanks Libby. To (over)elaborate:

My site (http://www.picdiary.com) is just a blog of collections of
pictures. There’s not much text, the pictures are the main focus and
just have a few lines of description. For a while it’s been lacking good
search facilities, and was built out of static HTML.

I decided to use RSS 1.0 as the ‘container’ format for each picture
collection. RSS works just as well for pictures-as-items as it does for
html-pages-as-items – they’re all just web links. So I wrote a bunch of
simple perl scripts to read in RSS and display them as web pages. For
example, The link Libby gave above can be viewed at

or of course it can be viewed in a newsreader/aggregator.

If you look in the HTML source of that page, you’ll see a line like
this:

<link rel=”alternate” type=”application/rss+xml” title=”RSS”
href=”http://www.picdiary.com/rss/barcelona_conf.rss”>

This is following the rss autodiscovery standard so that spiders can
find the RSS metadata from the webpage.

Using RSS 1.0′s RDF capability, I can add all sorts of metadata to
channels and items with a few extra tags in the RSS. That particular
feed uses FOAF to say that certain pictures are of people like Libby.
Other (more recent) feeds such as
http://www.picdiary.com/rss/highwalk.rss also use Dublin Core to give
the creator and date of the channel, and Wordnet to list keywords
associated with each picture (item).

There’s a (prerelease) search engine that indexes all the RSS and uses
the Wordnet terms (and exploits Wordnet’s synonym and hypernym
relationships between words to give better search results) at
http://www.picdiary.com/cgi-bin/search.pl?word=building
If you look ‘behind the scenes’ of that search engine at
http://www.picdiary.com:8180/rss/search?word=building
then you’ll see that the search results themselves are returned as
dynamically-built RSS channels then rendered into HTML by some perl. So
you could subscribe to the search results if you wanted to.

Ramble ramble. There’s quite a lot to say, feel free to followup or mail
me off-list for more information.

Cheers,
Matt.