learnlinkeddata

Understanding RDF serialisation formats

Mon, 07 May 2012 13:12:06 +0000

A couple of weeks ago, I wrote an Introduction To RDF. In that article, we discussed expressing a RDF single triple (which defined the location of my blog) as a blob and line diagram. But what if we want to describe more than one aspect of a resource?… or if we want to model the relationships between many resources? It probably wouldn’t come as a surprise that to do that, you’d need to create multiple triples. As I mentioned in that previous post, blob and line diagrams only work well for small numbers of triples, and they’re only really good for humans.

To communicate RDF between computer systems, we need something different. In this article, we’ll see how to serialise a graph (i.e. a collection, or set) of RDF triples in different ways, and explore the advantages and disadvantages of each.

In order to avoid me having to make up a contrived example, I’m going to use some data from the OpenDataCommunities site*, which contains a bunch of open data about English Local Authorities. The URI http://opendatacommunities.org/id/metropolitan-district-council/manchester identifies the Manchester Metropolitan District Council. If you click on that link, you’ll get an HTML representation of the data that the site holds about that authority.

But the site also offers the data in other formats via links at the bottom of the page. Let’s discuss each of those formats in turn.

RDF/XML

RDF is most commonly expressed in an XML format: RDF/XML.

A Single Resource as RDF/XML

The RDF/XML for what we know about the Manchester authority looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ns0="http://opendatacommunities.org/def/local-government/" xmlns:ns1="http://data.ordnancesurvey.co.uk/ontology/admingeo/" xmlns:ns2="http://statistics.data.gov.uk/def/administrative-geography/" xmlns:ns3="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ns4="http://www.w3.org/2000/01/rdf-schema#" xmlns:ns5="http://www.w3.org/2002/07/owl#" xmlns:ns6="http://xmlns.com/foaf/0.1/">
  <ns0:MetropolitanDistrictCouncil rdf:about="http://opendatacommunities.org/id/metropolitan-district-council/manchester">
    <ns1:gssCode>E08000003</ns1:gssCode>
    <ns1:hasCensusCode>00BN</ns1:hasCensusCode>
    <ns0:billingAuthorityCode>E4203</ns0:billingAuthorityCode>
    <ns0:governs rdf:resource="http://data.ordnancesurvey.co.uk/id/7000000000018821"/>
    <ns0:openlyLocalUrl rdf:resource="http://openlylocal.com/councils/157-Manchester-City-Council"/>
    <ns2:region rdf:resource="http://statistics.data.gov.uk/id/government-office-region/B"/>
    <ns3:type rdf:resource="http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority"/>
    <ns3:type rdf:resource="http://opendatacommunities.org/def/local-government/LocalAuthority"/>
    <ns4:label>Manchester</ns4:label>
    <ns5:sameAs rdf:resource="http://statistics.data.gov.uk/id/local-authority/00BN"/>
    <ns6:page rdf:resource="http://www.manchester.gov.uk/"/>
  </ns0:MetropolitanDistrictCouncil>
</rdf:RDF>

Multiple Resources as RDF/XML

A couple of local authorities serialised as RDF/XML look like this:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:j.0="http://data.ordnancesurvey.co.uk/ontology/admingeo/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:j.1="http://xmlns.com/foaf/0.1/"
    xmlns:j.2="http://opendatacommunities.org/def/local-government/"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:j.3="http://statistics.data.gov.uk/def/administrative-geography/"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" > 
  <rdf:Description rdf:about="http://opendatacommunities.org/id/district-council/babergh">
    <j.2:governs rdf:resource="http://data.ordnancesurvey.co.uk/id/7000000000015692"/>
    <j.0:hasCensusCode>42UB</j.0:hasCensusCode>
    <j.2:billingAuthorityCode>E3531</j.2:billingAuthorityCode>
    <rdfs:label>Babergh</rdfs:label>
    <j.1:page rdf:resource="http://www.babergh.gov.uk"/>
    <rdf:type rdf:resource="http://opendatacommunities.org/def/local-government/LocalAuthority"/>
    <rdf:type rdf:resource="http://opendatacommunities.org/def/local-government/DistrictCouncil"/>
    <j.0:gssCode>E07000200</j.0:gssCode>
    <owl:sameAs rdf:resource="http://statistics.data.gov.uk/id/local-authority/42UB"/>
    <j.3:region rdf:resource="http://statistics.data.gov.uk/id/government-office-region/G"/>
    <rdf:type rdf:resource="http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority"/>
  </rdf:Description>
  <rdf:Description rdf:about="http://opendatacommunities.org/id/london-borough-council/barking-and-dagenham">
    <owl:sameAs rdf:resource="http://statistics.data.gov.uk/id/local-authority/00AB"/>
    <j.0:gssCode>E09000002</j.0:gssCode>
    <rdf:type rdf:resource="http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority"/>
    <j.2:openlyLocalUrl rdf:resource="http://openlylocal.com/councils/19-London-Borough-of-Barking-Dagenham"/>
    <rdf:type rdf:resource="http://opendatacommunities.org/def/local-government/LondonBoroughCouncil"/>
    <j.2:governs rdf:resource="http://data.ordnancesurvey.co.uk/id/7000000000010949"/>
    <rdf:type rdf:resource="http://opendatacommunities.org/def/local-government/LocalAuthority"/>
    <j.0:hasCensusCode>00AB</j.0:hasCensusCode>
    <j.3:region rdf:resource="http://statistics.data.gov.uk/id/government-office-region/H"/>
    <j.1:page rdf:resource="http://www.lbbd.gov.uk/"/>
    <j.2:billingAuthorityCode>E5030</j.2:billingAuthorityCode>
    <rdfs:label>Barking and Dagenham</rdfs:label>
  </rdf:Description>
</rdf:RDF>

Mime Type

RDF/XML is typically requested and sent over the Web using a MIME type of application/rdf+xml.

RDF/XML Summary

In RDF/XML, the triples for each resource, are contained within <rdf:Description> nodes, with a sub-node for each property and its value (full spec here).

This format has the advantage that most programming languages have support for XML, and you can make use of XML namespaces to avoid having to use full URIs everywhere, which keeps the size down. On the other hand, I don’t find it that easy to read manually.

Turtle

Turtle (Terse RDF Triple Language) is an RDF-specific subset of Tim Berners-Lee’s Notation3 language.

A Single Resource as Turtle

The RDF triples about that single Manchester authority could be represented in Turtle like this:

@prefix gov: <http://opendatacommunities.org/def/local-government/> .
@prefix admingeo: <http://data.ordnancesurvey.co.uk/ontology/admingeo/> .
@prefix statsgeo: <http://statistics.data.gov.uk/def/administrative-geography/> .
@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/> .

<http://opendatacommunities.org/id/metropolitan-district-council/manchester>
   a gov:MetropolitanDistrictCouncil, gov:LocalAuthority, gov:CivilAdministrativeAuthority;
   rdfs:label "Manchester";
   admingeo:gssCode "E08000003";
   admingeo:hasCensusCode "00BN";
   gov:billingAuthorityCode "E4203";
   gov:governs <http://data.ordnancesurvey.co.uk/id/7000000000018821>;
   gov:openlyLocalUrl <http://openlylocal.com/councils/157-Manchester-City-Council>;
   statsgeo:region <http://statistics.data.gov.uk/id/government-office-region/B>;
   owl:sameAs <http://statistics.data.gov.uk/id/local-authority/00BN>;
   foaf:page <http://www.manchester.gov.uk/> .

Multiple Resources as Turtle

Multiple local authorities could be serialised in Turtle like this:

@prefix gov: <http://opendatacommunities.org/def/local-government/> .
@prefix admingeo: <http://data.ordnancesurvey.co.uk/ontology/admingeo/> .
@prefix statsgeo: <http://statistics.data.gov.uk/def/administrative-geography/> .
@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/> .

<http://opendatacommunities.org/id/district-council/babergh>
    a gov:LocalAuthority, gov:DistrictCouncil, gov:CivilAdministrativeAuthority ;
    rdfs:label "Babergh" ;
    admingeo:gssCode "E07000200" ;
    admingeo:hasCensusCode "42UB" ;
    admingeo:billingAuthorityCode "E3531" ;
    gov:governs <http://data.ordnancesurvey.co.uk/id/7000000000015692> ;
    statsgeo:region  <http://statistics.data.gov.uk/id/government-office-region/G> ;
    owl:sameAs <http://statistics.data.gov.uk/id/local-authority/42UB> ;
    foaf:page <http://www.babergh.gov.uk> .

<http://opendatacommunities.org/id/london-borough-council/barking-and-dagenham>
    a gov:LocalAuthority, gov:LondonBoroughCouncil, gov:CivilAdministrativeAuthority ;
    rdfs:label "Barking and Dagenham" ;
    admingeo:gssCode "E09000002" ;
    admingeo:hasCensusCode "00AB" ;
    gov:billingAuthorityCode "E5030" ;
    gov:governs <http://data.ordnancesurvey.co.uk/id/7000000000010949> ;
    gov:openlyLocalUrl <http://openlylocal.com/councils/19-London-Borough-of-Barking-Dagenham> ;
    statsgeo:region <http://statistics.data.gov.uk/id/government-office-region/H> ;
    owl:sameAs <http://statistics.data.gov.uk/id/local-authority/00AB> ;
    foaf:page <http://www.lbbd.gov.uk/> .

Mime Type

Turtle is typically requested and sent over the Web using a MIME type of text/turtle.

Turtle Summary

The URI for the each resource is followed by the predicates and objects of the triples about it (essentially, as key-value pairs). Each pair is separated by a semi-colon, and the information about a resource is closed off by a dot. Note that the whitespace is not important here, but for readability, the predicates and objects are often indented and appear on separate lines.

Turtle is my favourite RDF serialisation format: It’s fairly easy to read for humans due to the lack of punctuation noise, it groups together the triples about each resource, and it allows you to define common @prefixes. Its terseness also helps keep the amount of bandwidth required to communicate RDF down to a minimum, and it’s well supported by RDF toolkits and libraries.

Note that the standard encoding of Turtle is UTF-8 (though escaped Unicode is allowed in Turtle as well). Turtle literals can contain line breaks, using the """long literal""" approach. For more information, see the Turtle W3C submission.

N-Triples

N-Triples is a simplified version of Turtle.

A Single Resource as N-Triples

Here’s the RDF for the Manchester authority again, this time as N-triples.

<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://www.w3.org/2000/01/rdf-schema#label> "Manchester" .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://opendatacommunities.org/def/local-government/openlyLocalUrl> <http://openlylocal.com/councils/157-Manchester-City-Council> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://xmlns.com/foaf/0.1/page> <http://www.manchester.gov.uk/> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://www.w3.org/2002/07/owl#sameAs> <http://statistics.data.gov.uk/id/local-authority/00BN> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://data.ordnancesurvey.co.uk/ontology/admingeo/hasCensusCode> "00BN" .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://opendatacommunities.org/def/local-government/billingAuthorityCode> "E4203" .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/MetropolitanDistrictCouncil> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/LocalAuthority> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://opendatacommunities.org/def/local-government/governs> <http://data.ordnancesurvey.co.uk/id/7000000000018821> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://statistics.data.gov.uk/def/administrative-geography/region> <http://statistics.data.gov.uk/id/government-office-region/B> .
<http://opendatacommunities.org/id/metropolitan-district-council/manchester> <http://data.ordnancesurvey.co.uk/ontology/admingeo/gssCode> "E08000003" .

Multiple Resources as N-Triples

<http://opendatacommunities.org/id/district-council/allerdale> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://opendatacommunities.org/def/local-government/billingAuthorityCode> "E0931" .
<http://opendatacommunities.org/id/district-council/allerdale> <http://www.w3.org/2002/07/owl#sameAs> <http://statistics.data.gov.uk/id/local-authority/16UB> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://opendatacommunities.org/def/local-government/openlyLocalUrl> <http://openlylocal.com/councils/38-Allerdale-Borough-Council> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://opendatacommunities.org/def/local-government/governs> <http://data.ordnancesurvey.co.uk/id/7000000000013065> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://www.w3.org/2000/01/rdf-schema#label> "Allerdale" .
<http://opendatacommunities.org/id/district-council/allerdale> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/DistrictCouncil> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://xmlns.com/foaf/0.1/page> <http://www.allerdale.gov.uk> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://statistics.data.gov.uk/def/administrative-geography/region> <http://statistics.data.gov.uk/id/government-office-region/B> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://data.ordnancesurvey.co.uk/ontology/admingeo/gssCode> "E07000026" .
<http://opendatacommunities.org/id/district-council/allerdale> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/LocalAuthority> .
<http://opendatacommunities.org/id/district-council/allerdale> <http://data.ordnancesurvey.co.uk/ontology/admingeo/hasCensusCode> "16UB" .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://opendatacommunities.org/def/local-government/governs> <http://data.ordnancesurvey.co.uk/id/7000000000012941> .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority> .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/LocalAuthority> .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://opendatacommunities.org/def/local-government/billingAuthorityCode> "E0932" .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://www.w3.org/2002/07/owl#sameAs> <http://statistics.data.gov.uk/id/local-authority/16UC> .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://opendatacommunities.org/def/local-government/DistrictCouncil> .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://xmlns.com/foaf/0.1/page> <http://www.barrowbc.gov.uk/> .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://data.ordnancesurvey.co.uk/ontology/admingeo/gssCode> "E07000027" .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://data.ordnancesurvey.co.uk/ontology/admingeo/hasCensusCode> "16UC" .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://www.w3.org/2000/01/rdf-schema#label> "Barrow-in-Furness" .
<http://opendatacommunities.org/id/district-council/barrow-in-furness> <http://statistics.data.gov.uk/def/administrative-geography/region> <http://statistics.data.gov.uk/id/government-office-region/B> .

Mime Type

N-triples are typically requested and sent over the Web using a MIME type of text/plain or application/n-triples.

N-Triples summary

With N-triples, each triple appears on its own line, separated by a dot.

N-triples’ simplicity makes it easy for software to parse and generate, but it lacks some of the features of RDF/XML and Turtle (such as support for nested resources). Due to the repetition of the resource URIs, it’s not as compact as Turtle, and the triples for each resource aren’t necessarily grouped together which makes it harder to read by eye.

It’s also worth mentioning here that as N-triples is a text/plain literals are only allowed to contain US ASCII characters: non-ASCII Unicode characters need to be escaped (in contrast to Turtle whose standard encoding is UTF-8). Also, in N-triples, line-breaks always need to be escaped.

This section of the W3C Turtle submission gives a useful comparison between Turtle and N-Triples. You can also find more details about N-Triples here.

JSON

RDF can also be expressed in JavaScript Object Notation (JSON).

A Single Resource as JSON

{"http://opendatacommunities.org/id/metropolitan-district-council/manchester":{"http://www.w3.org/2000/01/rdf-schema#label":[{"type":"literal","value":"Manchester"}],"http://opendatacommunities.org/def/local-government/openlyLocalUrl":[{"type":"uri","value":"http://openlylocal.com/councils/157-Manchester-City-Council"}],"http://xmlns.com/foaf/0.1/page":[{"type":"uri","value":"http://www.manchester.gov.uk/"}],"http://www.w3.org/2002/07/owl#sameAs":[{"type":"uri","value":"http://statistics.data.gov.uk/id/local-authority/00BN"}],"http://data.ordnancesurvey.co.uk/ontology/admingeo/hasCensusCode":[{"type":"literal","value":"00BN"}],"http://opendatacommunities.org/def/local-government/billingAuthorityCode":[{"type":"literal","value":"E4203"}],"http://www.w3.org/1999/02/22-rdf-syntax-ns#type":[{"type":"uri","value":"http://opendatacommunities.org/def/local-government/MetropolitanDistrictCouncil"},{"type":"uri","value":"http://opendatacommunities.org/def/local-government/LocalAuthority"},{"type":"uri","value":"http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority"}],"http://opendatacommunities.org/def/local-government/governs":[{"type":"uri","value":"http://data.ordnancesurvey.co.uk/id/7000000000018821"}],"http://statistics.data.gov.uk/def/administrative-geography/region":[{"type":"uri","value":"http://statistics.data.gov.uk/id/government-office-region/B"}],"http://data.ordnancesurvey.co.uk/ontology/admingeo/gssCode":[{"type":"literal","value":"E08000003"}]}}

Multiple Resources as JSON

{"http://opendatacommunities.org/id/district-council/allerdale":{"http://www.w3.org/1999/02/22-rdf-syntax-ns#type":[{"type":"uri","value":"http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority"},{"type":"uri","value":"http://opendatacommunities.org/def/local-government/DistrictCouncil"},{"type":"uri","value":"http://opendatacommunities.org/def/local-government/LocalAuthority"}],"http://opendatacommunities.org/def/local-government/billingAuthorityCode":[{"type":"literal","value":"E0931"}],"http://www.w3.org/2002/07/owl#sameAs":[{"type":"uri","value":"http://statistics.data.gov.uk/id/local-authority/16UB"}],"http://opendatacommunities.org/def/local-government/openlyLocalUrl":[{"type":"uri","value":"http://openlylocal.com/councils/38-Allerdale-Borough-Council"}],"http://opendatacommunities.org/def/local-government/governs":[{"type":"uri","value":"http://data.ordnancesurvey.co.uk/id/7000000000013065"}],"http://www.w3.org/2000/01/rdf-schema#label":[{"type":"literal","value":"Allerdale"}],"http://xmlns.com/foaf/0.1/page":[{"type":"uri","value":"http://www.allerdale.gov.uk"}],"http://statistics.data.gov.uk/def/administrative-geography/region":[{"type":"uri","value":"http://statistics.data.gov.uk/id/government-office-region/B"}],"http://data.ordnancesurvey.co.uk/ontology/admingeo/gssCode":[{"type":"literal","value":"E07000026"}],"http://data.ordnancesurvey.co.uk/ontology/admingeo/hasCensusCode":[{"type":"literal","value":"16UB"}]},"http://opendatacommunities.org/id/district-council/barrow-in-furness":{"http://opendatacommunities.org/def/local-government/governs":[{"type":"uri","value":"http://data.ordnancesurvey.co.uk/id/7000000000012941"}],"http://www.w3.org/1999/02/22-rdf-syntax-ns#type":[{"type":"uri","value":"http://opendatacommunities.org/def/local-government/CivilAdministrativeAuthority"},{"type":"uri","value":"http://opendatacommunities.org/def/local-government/LocalAuthority"},{"type":"uri","value":"http://opendatacommunities.org/def/local-government/DistrictCouncil"}],"http://opendatacommunities.org/def/local-government/billingAuthorityCode":[{"type":"literal","value":"E0932"}],"http://www.w3.org/2002/07/owl#sameAs":[{"type":"uri","value":"http://statistics.data.gov.uk/id/local-authority/16UC"}],"http://xmlns.com/foaf/0.1/page":[{"type":"uri","value":"http://www.barrowbc.gov.uk/"}],"http://data.ordnancesurvey.co.uk/ontology/admingeo/gssCode":[{"type":"literal","value":"E07000027"}],"http://data.ordnancesurvey.co.uk/ontology/admingeo/hasCensusCode":[{"type":"literal","value":"16UC"}],"http://www.w3.org/2000/01/rdf-schema#label":[{"type":"literal","value":"Barrow-in-Furness"}],"http://statistics.data.gov.uk/def/administrative-geography/region":[{"type":"uri","value":"http://statistics.data.gov.uk/id/government-office-region/B"}]}}

Mime Type

JSON is typically requested and sent over the Web using a MIME type of application/json.

JSON Summary

This format serialises the triples by defining JavaScript objects, the identifier for each being the URI for the resource. Sub-objects are created for each predicate, the values being an array of the triples for that predicate. For each object of the triple, there is a JavaScript object with properties for its type (i.e. URI or literal), and actual value.

It’s not an official standard (the example above is an output from the rdf.rb ruby library, which is based on Talis’s RDF JSON spec), but many Linked Data sites are now supporting JSON as a serialisation format. It’s becoming popular due to the ease with which this kind of data can be consumed in JavaScript web applications. It’s not as easy to read by eye as Turtle (to me, at least), but it’s still not too bad in that respect. The limited punctuation also helps to keep the size down.

Conclusion

In this article, we’ve covered the most common serialisation formats for RDF triples. Hopefully it has helped you to understand the benefits and pitfalls of each, so that you can make an informed decision about which to choose for publishing or consuming your Linked Data.

If you’d be interested in more articles like this, please subscribe to our RSS feed, Twitter updates, or email alerts. We’ll try to keep the articles coming fairly regularly.

*In the interest of full disclosure: I should probably mention that my company worked on the OpenDataCommunities site.

Simple namespace lookup

Tue, 24 Apr 2012 16:33:41 +0000

prefix.cc is a very handy little service that I use a lot.

If you work with RDF a bit, you get to know the commonly used prefixes for ontology terms, such as rdfs:label, foaf:Person, owl:sameAs etc.

While I can remember the most important predicates and classes from these ontologies, it’s rare for me to be able to remember accurately what the full namespace is.

prefix.cc, created by Richard Cyganiak from DERI, lets you type in the prefix, e.g. owl and returns the full namespace (e.g. http://www.w3.org/2002/07/owl#) that you can use in a PREFIX definition in your SPARQL query.

It also has a simple API.

An Introduction to RDF

Fri, 13 Apr 2012 14:04:58 +0000

What is RDF?

Linked Data is based around describing real world things using RDF. A lot of articles about Linked Data assume you already know what RDF is all about: if you are coming to it for the first time, this article explains the basics.

RDF stands for Resource Description Framework. It’s a W3C standard for modeling information.

RDF Triples

RDF allows you to define statements about things (or resources), in the form of subject-predicate-object expressions (known as RDF-triples due to the 3 constituent parts).

This might sound very technical, but the meanings of subject, predicate, and object are essentially the same as in English grammar. i.e.

subject: The thing we’re talking about. In RDF, this is the resource in question.

predicate: A term used to describe or modify some aspect of the subject. In RDF, the predicate is used to denote relationships between the subject and the object.

object: In English the object of a sentence is the thing that the verb is acting upon. In RDF, it’s the “target” or “value” of the triple. It can be another resource, or just a literal value such as a number or word.

An example

That was all a bit hand-wavey, so let’s use an example to make it a bit clearer. Take the sentence:

Ric’s blog can be found at ricroberts.com

In this sentence, “Ric” is the subject, “blog” is the predicate and “ricroberts.com” is the object. (I know that this is probably not exactly grammatically correct, but bear with me…).

Our first RDF triple

Let’s deconstruct this a bit, and express it as RDF…

subject:
The resource in question is a person (me). In RDF, we use URIs to uniquely identify resources. Let’s use http://swirrl.com/ric.rdf#me as the URI to identify me. I’m fairly confident that no-one else will use that URI to identify themselves as I control the swirrl.com domain, so I can control what is returned when it’s dereferenced (looked up).

Aside: You may well have clicked on that link above. If you did, it will, depending on your browser, render or download an RDF graph (a collection of rdf triples) that describe some facts about me. Don’t worry about the contents of that for now: the point here is that looking up a URI can sometimes return useful information about the resource. For more about dereferencing URIs, see What is Linked Data?

predicate:
We need to find a term which we can use to mean “blog”. For this example I’m going to use a term from the FOAF (Friend-of-a-Friend) vocabulary. Predicates are also identified by URIs: FOAF’s URI for the weblog predicate is http://xmlns.com/foaf/0.1/weblog.

object:
The object of this triple is just a URL which identifies the home page of my blog http://ricroberts.com.

the triple:
Putting it all together, we have:
subject: http://swirrl.com/ric.rdf#me
predicate: http://xmlns.com/foaf/0.1/weblog
object: http://ricroberts.com

Serializing our triple

There are various ways to express our RDF triple:

Blob and Line

One of the simplest ways to express RDF is via what I call blob and line diagrams (someone correct me if there’s an official term for them). URIs are expressed as blobs, and predicates are lines. Literal values (numbers, words etc.) would be in rectangles, but we don’t have any in our triple.

Blob and line diagrams are easy for humans to understand at a glance, at least where you only have a small number of triples, but aren’t (easily) machine readable.

Machine readable formats

There are various ways of expressing RDF triples in more machine-friendly ways, including RDF/XML, Turtle and N-triples, which we’ll discuss in a future article.

What have we learnt here?

To summarise, we’ve learnt that you can use RDF to express facts as triples, where URIs are used to identify resources (things) and concepts. Dereferencing (looking up) resources by their URIs can yield more information about them.

Mapping the English Deprivation Stats: Part 3 - Using JavaScript to build and execute the query

Thu, 19 Jan 2012 14:03:52 +0000

It’s been a while coming, but (finally), I’d like to present this 3rd article in the series. Together, we’re building a Linked Data application to map the English Indices of Multiple Deprivation Stats. The final source code for the app can be found on github. If you missed the last blog post in the series, you can find it here.

Note: These articles use Github gists for showing code-snippets, and if you’re viewing this in a feed reader they might not show up. So I recommend you read it on the web instead.

What the app will do:

The basic principle of the app is that the user pans or zooms or searches by postcode to change which bit of the map they are looking at. The app detects that, retrieves the required data using SPARQL, then draws it on the map. You can play with the finished app on the OpenDataCommunities site here.

Last time…

In the last article we explored how the deprivation data was stored, wrote a template SPARQL query, and drew a standard Google map centred on a starting location.

By the way, I’ve created a new Github repo especially for this blog-series, so that you can watch the application evolve through the git commits. Everything that we did in parts 1 and 2 are in commit bce302.

In this article, we’ll write some JavaScript to build and execute the right SPARQL query (based on the template from last time), to retrieve the deprivation data about the LSOAs currently displayed on the map. The code from this article is in commit 17e211.

A note about CORS

On the web server on which OpenDataCommunities is hosted, we’ve enabled Cross-Origin Resource Sharing (CORS), so that Ajax requests for the data can be made from sites not on the same domain. However, for this to be honoured, you’ll need to host the app on a web server (such as Apache), while you develop it. Just opening the html from your disk in a browser won’t work.

Map Manager

Much of the code we’ll write in this article will be in a file called map-manager.js, in the javascripts/swirrl directory. As you might expect, the MapManager will be responsible for dealing with the interaction with the map. The following code snippet explains the structure of the file:

What’s going to happen?…

We’re going to add some code to the main JavaScript closure (in the HTML file) which will listen for Google maps idle events (i.e. when the map stops being zoomed or dragged).

When we notice that the map has become idle, we’ll ask the MapManager to refresh the map.

The MapManager will report back to the main closure, using jQuery events, so that it can start listening again for idle events.

The MapManager Constructor

The constructor for the MapManager takes the Google Map object and the initial score domain (from the drop down) as it’s parameters, and sets some stuff up.

Interesting things to note:

We assign this into a variable called self so that when this gets set to other things (in jQuery callbacks etc), we can always get a reference to the current MapManager object.
The lsoaDataRetrieved event will be triggered by another function when the deprivation data has been retrieved and is ready for use. For now, we’re just going to log out the results (there’s a gist later on with an example log-output), and tell the calling code that we’ve finished.
Finally, there’s a little bit of code to clean up if there are errors.

The refresh function

The refresh function (along with the constructor) will form the public API for the MapManager. Let’s add it to the prototype:

When execution of the function begins, we’ll trigger the started event to tell others that we’re starting the process of refreshing the map.
If the Google map’s zoom level is acceptable (if we’re too zoomed-out there’ll be too much data to handle), we proceed. Otherwise, we do nothing other than trigger a couple of events.
the getTiles function (for brevity, not included in this article – see the source on github for details*), interrogates the google map and determines which 0.1×0.1 lat/long tiles are visible in the viewport.
Next we remove any tiles that are no longer visible in the viewport, and add any new ones by comparing the results from getTiles with the set of tiles from the previous time refresh was called. The reason we do this is for efficiency: we don’t need to request data for tiles for which we already have data.
Finally, we call getLsoaData, passing in the set of tiles currently visible.

Getting the LSOA Data

The getLsoaData function is responsible for building the right SPARQL query to call (based on the template query in the previous article), and executing it against the OpenDataCommunities SPARQL endpoint.

That code might look a bit complicated, but it’s not really. Let me break it down a bit.

buildSparql is a nested function (as it wont be needed outside the scope of getLsoaData). It’s responsible for interpolating the bottom-left and top-right lat/long values of tiles into the template SPARQL query.
callAjaxSparqlPaging is another nested function, which calls itself recursively until all the pages of data have been retrieved (the SPARQL endpoint will return the data in 1000-result ‘pages’).
For each result of each page (in the $.ajax success callback), we call setLsoaData which just sets the data for an LSOA (such as label, centroid lat/long, score, and URI) into a nested object (with the top level properties being the tile’s corners, and the inner objects’ properties being the notation of the LSOA (e.g. ‘E01005061’). See the example log-output later on for an example of this structure.
The code at the end of the getLsoaData function, calls the SPARQL query for each tile in our list of tiles.

Calling the refresh function

As I mentioned earlier, the main JavaScript closure in the HTML file is responsible for instantiating a MapManager and calling refresh. Let’s see what that looks like:

The first bit of code is what we set up in the previous article to just create the Google map centred on Manchester.
Next, we instantiate a MapManager, with the map object.
At the end of this code-snippet, we define a bindMapIdle function, and then call it. As I described at the top of the article, this calls the refresh function when we see that the map is idle.
The started event listener makes a note of the time, and then removes the idleListener if it exists (so that we only call refresh once at a time). It also shows the busy ‘spinner’.
Once refresh has finished, we log how long it took, hide the spinner, and re-bind the idle listener.
The zoomToWide and zoomOK handlers, just show and hide the zoom warning message (shown if the user zooms out too much and we can’t show all the data).

Let’s run it!

We’re now ready to see what all our code does.

If you’ve been following along, just open the map.html file (from your web server) in your browser. (If you’ve not been following along, just check out the code from this commit in Github).

Open your browser’s debug/console window (i.e. Web Inspector in Chrome/Safari, or Firebug in Firefox), and hit refresh. You should see a bunch of log-output lines including information on what requests were made against SPARQL endpoint and how long it took (“busy duration”).

Just before the busy duration message, there should be an entry that looks like this: [>Object] (in Webkit-based browsers, at least). Click the triangle to expand the object, and you can see what data we have for the LSOAs with centroids in the current viewport. (This is what is logged out from the lsoaDataRetrieved handler in the MapManager constructor.)

As I mentioned earlier, the top-level properties are the tiles. Each tile is an object whose properties which correspond to the LSOAs. Each LSOA contains data such as it’s label, the lat/long, the score for the currently selected domain, and the URI of the LSOA.

For example:

Try dragging and zooming the map, and watch what happens in the console window. The further zoomed out you are, the more tiles of data you will see.

Next time

In the next instalment (I promise not to leave it so long this time), we’ll get the boundary information for all the LSOAs and plot that on the map as polygons. If there’s time, we’ll also make these interactive.

*To be honest, I’m not particularly proud of this bit of code – it’s pretty hacky, but it does the job!

Mapping the English Deprivation Stats: Part 2 - Querying the data

Fri, 30 Sep 2011 11:45:30 +0000

This article the 2nd in a series, where we’re building a Linked Data application to map the English Indices of Multiple Deprivation Stats. The final source code for the app can be found on github. If you missed the first part, you can find it here.

Note: These articles use Github gists for showing code-snippets, and if you’re viewing this in a feed reader they might not show up. So I recommend you read it on the web instead.

Last time…

In the last instalment, we got the basic page and code structure set up. In this article we’ll explore how the deprivation data is stored, write some SPARQL to query it, and draw a Google map.

Score Data

The score data is available as Linked Data in a variety of datasets: one for each deprivation domain (i.e. housing, crime etc), plus a dataset of combined scores. All of the data in these datasets is accessible through a SPARQL endpoint.

PublishMyData, the platform on which this Linked Data is hosted, caches the results of commonly executed SPARQL queries (and will therefore respond more quickly to common queries). This means that by making our app only make a relatively small number of distinct different queries against the server, we can ensure better performance. We should bear this in mind for later.

Boundary Data

The boundaries of the LSOAs are available as GeoJSON in two forms from the OpenDataCommunities.org server:

1. Individual polygon definitions with urls such as:

http://opendatacommunities.org/lsoa_boundaries/E01017190.json

2. Polygon-definitions for 0.1-degree lat-long ‘square’ tiles, with urls such as:

http://opendatacommunities.org/lsoa_tiles/lat53.4/long-2.3.json

Getting the data

There are over 32,000 LSOAs in England, and 8 different indicators of deprivation, which makes a total of over a quarter of a million observations (like this one). So, it wouldn’t make sense to just download all the data to the browser: we only want to get the data relevant to the portion of the map currently being viewed. Let’s do this via a SPARQL query.

Aside: Various other visualisations have been made using Google Fusion tables to map deprivation in England (such as this one by the Guardian). Google Fusion tables are neat because they allow you to quickly augment a Google map with data, but they limit what kind interaction you can build into the map. I want to be able to add custom JavaScript interactivity to the LSOA polygons on my map.

The following query will get all the LSOAs along with their scores and lat/long centroids within a certain bounded area:

(You can see the results of this query, and experiment with the SPARQL, here)

Bearing in mind what I said earlier about how the caching works for SPARQL queries on our server, let’s make our JavaScript code generate queries like that, which get the data for a 0.1×0.1 degree tile. There are roughly 2000 of these tiles which cover the country, so we’re fairly likely to get a cache hit once people start playing with the app …and handily it matches up nicely with how the LSOA boundary data is organised too!

Drawing the Map

Before we can do anything interesting, we’ll need a Google map object, so lets make one in our main closure (in the HTML page). The map will draw itself in the map_canvas element, and initialize its location to Manchester, where my office is (feel free to pick a different initial location if you like).

Refresh your browser, and you should see the map being rendered at your initial lat/long.

Next time…

In the next instalment we’ll add some JavaScript to generate the correct SPARQL query for the currently displayed area on the map, and hopefully get on to actually drawing the boundaries too.

Let's make a Linked Data app: Mapping the English Deprivation Stats

Mon, 26 Sep 2011 16:13:53 +0000

Earlier this year, we (Swirrl), launched the OpenDataCommunities site, on which we host a Linked Data version of the 2010 English Indices of Multiple Deprivation.

Map Explorer

Over the last week or so, I’ve been building a map-based web app (check it out here), which can be used to explore the data from OpenDataCommunities. The map shows the Lower Layer Super Output Areas (LSOAs) in England, coloured to indicate the level of deprivation in the area. It’s just a single web-page, built purely with HTML, CSS and JavaScript.

I thought it would be useful for others if I shared how I went about building this little app, to illustrate how the combination of Linked Data and JavaScript lets you create quite rich visualisations, and to explain some JavaScript techniques that could easily be re-used elsewhere.

The “Let’s make a Linked Data app” series of blog posts

This is the first of a series of blog posts which describes the process I went through. By following along with these blog articles, you’ll be able to build up the functionality step-by-step. The final source code for the completed app can be found on Swirrl’s Github account (it’s open-source, and you’re welcome to reuse it as you like).

Throughout this series, some basic knowledge of JavaScript and HTML and Linked Data is assumed, but I’ll be explaining everything that I don’t think is obvious.

In this first article, I explain how I set up the overall structure of the page and the code. In the next article, we’ll get on to retrieving and displaying some data.

Note: These articles will use Github gists for showing code-snippets, and if you’re viewing this in a feed reader they might not show up. So I recommend you read it on the web instead.

Features of the app

You’ll see from playing with the app that there are a few main aspects to it:

A Google map, on which the LSOAs are plotted, with a colour-key.
A dropdown, to change the deprivation indicator (Combined, Crime, Health etc) being plotted on the map.
A form, to centre the map by postcode.
A sidebar which shows additional information about the selected LSOA (area). This includes the frequency distribution of the scores for the current deprivation indicator, and links to the Linked Data resources.

Page Structure

First, let’s set up the basic HTML page structure that will be used for everything in the app.

We’re going to be using Google’s map API, jQuery and Raphael.js, so let’s include them in the page’s head. Also, in the head is a link to the stylesheet that I used for the page (you can find this file here. In the interest of brevity, I wont bother including it in this blog post).

In the body of the page, there’s a container element that wraps everything. This is useful for the way I wanted to do the stylesheet. The info element is the sidebar, and the map_canvas is where the map will be rendered. Next, we have the domain drop-down selector, and an element called colour_key in which the colour-key will eventually go. Finally, we’ll be putting some HTML in templates which we don’t want to render directly, but which we’ll reuse to display some information in the sidebar.

If you create that HTML page, and make the stylesheet available at the right relative path, you should be able to view the basic page structure in your browser.

Code Structure

To keep things nicely organised, let’s just put JavaScript code that deals with the DOM in the HTML file itself, and put everything else in separate JavaScript files, each with its own job.

To avoid polluting the global namespace (that is, to avoid any possible name clashes with other JavaScript that might be on the same page), the JavaScript that goes in the HTML page should go in its own closure – let’s add that at in the html page, just before we close the <body> tag.

Again to avoid polluting the global namespace, we can make a special namespace in which all our JavaScript classes and structures will live. I’m going to call my namespace swirrl, and add it to the window object. This code goes in a file called swirrl.js, which we’ll load in our page’s head.

We’ll be adding more JavaScript files as we go along, and they’ll add stuff to the swirrl object.

This code also adds a simple wrapper to console.log that checks if the console object exists. We can use window.swirrl.log in our code instead of console.log, and we won’t need to worry about removing all the logging before releasing.

Next time…

So that’s the basic structure of the app set up. There isn’t much to see yet, but we now have everything nicely organised. We’ll get cracking with adding some actual functionality next time. Stay tuned!

Real-life Linked Data: a diary

Wed, 13 Apr 2011 20:29:40 +0000

Last weekend we (Ric and Bill from Swirrl) attended the Lovely Data hack-day in Manchester.

For the event, we’d promised to make available a Linked Data version of the Transport for Greater Manchester bus stops and schedules data, which had recently been released as open data. So, during the week leading up to the event, Bill blogged a Linked Data Diary documenting the steps involved to make this possible, with the hope that it would be a useful illustration of what’s involved.

Bill’s diary entries: day1, day2, day3, days4-6.

At the event itself, as well as lots of interesting discussions around open and linked data, we were pleased to work with Ben Gibbs who spent the day creating a very nice timetable app. Ben’s app gets its data via SPARQL queries against our Linked Manchester buses dataset.

SPARQL example: finding data for a postcode

Thu, 24 Mar 2011 12:15:14 +0000

To help SPARQL newbies get to grips with the language and to see what kind of things you can do with it, we’re planning to run regular worked examples of SPARQL queries.

Aside: If you haven’t worked with SPARQL at all, you might want to do some background reading first, but this article is pretty much self-contained as long as you don’t mind that we don’t explain all the SPARQL details.

In this tutorial, we’re going to be building and running a query to find the names of all the schools in the London Borough of Brent, but we’ll take it one step at a time. The concepts we introduce here should come in useful elsewhere as so much Linked Data is geographically based.

Our example is based around UK datasets, so apologies to readers from other countries, but hopefully the principles will transfer to similar datsets elsewhere. All the data used in this example is available at PublishMyData’s SPARQL endpoint, if you want to follow along or experiment further.

Getting Stuck In

Let’s start with a postcode. We’ll use HA9 9HD, which as all of you will recognise, is the home of Brent Council. :)

The first thing we need is a URI for this postcode. The definitive set of geographical information on postcodes in the UK comes from the Ordnance Survey. The OS identifier for our postcode is:

http://data.ordnancesurvey.co.uk/id/postcodeunit/HA99HD

If you look up that URI in your browser, you can see what properties of it are available. We’re going to use the ‘District’ property, which has the URI:

http://data.ordnancesurvey.co.uk/ontology/postcode/district

(I found this out by simply clicking on the link for ‘District’ on the page for the postcode.)

Our first SPARQL query

The query below returns the district for the postcode HA9 9HD:


PREFIX pc: <http://data.ordnancesurvey.co.uk/ontology/postcode/>

SELECT ?district 
WHERE {
  <http://data.ordnancesurvey.co.uk/id/postcodeunit/HA99HD> pc:district ?district
}

If you try that yourself by entering the SPARQL at PublishMyData or Talis‘s SPARQL endpoint, you’ll see that the district for the postcode is identified by the URI:

http://data.ordnancesurvey.co.uk/id/7000000000011447

Looking that URI up in your browser will confirm that it’s the London Borough of Brent.

Linking up our Linked Data

There’s another key dataset of geographical regions in the UK and that comes from http://statistics.data.gov.uk. These identifiers are based on codes from the UK Office of National Statistics (ONS) that are used for most government statistical information. Handily, this data is cross-referenced with the Ordnance Survey identifiers, so we can use the URI for our postcode from before to find the ONS district:


PREFIX pc: <http://data.ordnancesurvey.co.uk/ontology/postcode/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>

SELECT ?district ?ons_district 
WHERE {
  <http://data.ordnancesurvey.co.uk/id/postcodeunit/HA99HD> pc:district ?district .
  ?ons_district owl:sameAs ?district  
}

Note the use of ‘owl:sameAs’ which specifies that the two URIs refer to the same real world thing.

So using the query above, we find the ONS identifier is:

http://statistics.data.gov.uk/id/local-authority-district/00AE

(Remember, you can try all the queries out yourself here)

Now what?

Well, we can use that to link up other datasets, for example to look up all the schools in the local authority with the given postcode. To do this, we’ll use another data.gov.uk dataset, this one covering all schools in England and Wales.

By exploring that dataset, we can see that there is a property called ‘districtAdministrative’ that relates a school to the local authority district it belongs to. We’ll use that to link the schools to the district for our postcode (and we include the label for the school to make it more readable).


PREFIX pc: <http://data.ordnancesurvey.co.uk/ontology/postcode/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX school: <http://education.data.gov.uk/def/school/>

SELECT ?school ?label WHERE {
<http://data.ordnancesurvey.co.uk/id/postcodeunit/HA99HD> pc:district ?district .
?ons_district owl:sameAs ?district .
?school school:districtAdministrative ?ons_district .
?school rdfs:label ?label
 }

This returns a list of 299 schools in the London Borough of Brent (try it by entering the query here).

The power of SPARQL

With just a few queries, we’ve done something pretty powerful, and hopefully you’ve realised that SPARQL isn’t that scary after all. We plan on writing some tutorials explaining the syntax in more detail soon.

If you’d like to see more articles like this, please subscribe to our RSS feed, Twitter updates, or email alerts.

A skim-read introduction to linked data

Mon, 14 Mar 2011 20:14:58 +0000

I recently came across this very nice presentation by Yves Raimond and Michael Smethurst of the BBC: A skim-read introduction to linked data.

It’s particularly worth reading for its great explanations of content negotiation and of the difference between information resources and non-information resources.

(Sorry for that bit of web architect jargon, but look at the presentation and all will become clear).

Ric mentioned this issue in his What is Linked Data? post the other day, noting that we have one URI for the City of Manchester local authority itself, and another one for a web page about it.

Their key point is:

“We want to be able to make different claims about the thing and the document about the thing”.

Yves and Michael explain very clearly why this is important, with lots of good examples. But enough from me – just go and read it.

What is Linked Data?

Thu, 10 Mar 2011 14:12:07 +0000

I suspect many of our readers may already have a black belt in Linked Data, but for others it’s all new, so I thought it was worth explaining what Linked Data means to me. The definitive description is Tim Berners-Lee’s Design Issues document, but I’ll try to illustrate what this means in practice.

In a nutshell, Linked Data is:

“a method of publishing structured data [on the Web], so that it can be interlinked and become more useful.” -wikipedia

Linked Data can be used to describe any real-world things, such as people, objects, events, observations etc. Let’s say we want to describe a unicorn (called Yuri).

1. We choose an http URI to identify our unicorn. This URI looks like a normal web address, but in essence it’s just a long name for Yuri (and is unique to him alone). For example, if I owned the unicornherders.com domain (I don’t!), I might choose:

http://unicornherders.com/id/unicorns/yuri

2. As you’d expect from a web address, people can look it up. Dereferencable (look-up-able) identifiers are a key feature of Linked Data. Looking up this URI would yield useful information about Yuri the Unicorn, such as his height, weight, eye colour, and horn-length.

3. The info also contains links that connect Yuri to related things (such as Yuri’s family members, owner, breed etc.), and be available in different useful formats. This puts Yuri in context, and allows the person originally interested in Yuri to continue browsing and discover other useful stuff.

A Worked Example

My description above hopefully sounds simple enough, but to clarify here’s a (more sensible) worked example…

This is the URI that the folks at data.gov.uk have chosen to identify the City of Manchester local authority district:

http://statistics.data.gov.uk/id/local-authority-district/00BN

If you click on the link above, you will be redirected (via a 303 “see other” response) to an HTML page which contains information about the City of Manchester.

http://statistics.data.gov.uk/doc/local-authority-district/00BN

Aside: It’s worth noting that your browser ends up at a different address to the original URI you entered. This is because in Linked Data we make a distinction between the real world thing, the City of Manchester local authority (…/id/…) and a document about the City of Manchester (…/doc/…). It can seem like nit-picking, but I think it’s an important point to get your head around.

On that web page, there are links to other related things, such as the containing county, Greater Manchester.

You can request the information about the City of Manchester in different formats by including an HTTP accept header.

For example, to get it as JSON:


curl --get http://statistics.data.gov.uk/doc/local-authority-district/00BN --header "Accept: application/json" -v

Alternatively, you can just add a format extension to the description page’s URL, like so:

http://statistics.data.gov.uk/doc/local-authority-district/00BN.json

Both of these approaches will yield something like this:


{"http:\/\/statistics.data.gov.uk\/id\/local-authority-district\/00BN":{"http:\/\/www.w3.org\/2004\/02\/skos\/core#altLabel":[{"value":"Manchester","type":"literal","lang":"en"}],"http:\/\/statistics.data.gov.uk\/def\/administrative-geography\/region":[{"value":"http:\/\/statistics.data.gov.uk\/id\/government-office-region\/B","type":"uri"}],"http:\/\/statistics.data.gov.uk\/def\/electoral-geography\/ward":[{"value":"http:\/\/statistics.data.gov.uk\/id\/electoral-ward\/00BNGQ","type":"uri"},{"value":"http:\/\/statistics.data.gov.uk\/id\/electoral-ward\/00BNHH","type":"uri"},{"value":"http:\/\/statistics.data.gov.uk\/id\/electoral-ward\/00BNHB","type":"uri"}
...

I’ve used JSON in my example as many developers are already familiar with that, but you can get the same information in other formats including RDF/XML (.rdf) and Turtle (.ttl).

Want more?

I’ve only scratched the surface here. If you’d be interested in more articles like this, please subscribe to our RSS feed, Twitter updates, or email alerts. We’ll try to keep the articles coming fairly regularly.