The Workshop Introduction is an easy to read summary of the development of Linked Data and the Linking Open Data Project over the past year. It includes the Linking Open Data “cloud” diagram which shows the relationships between the main currently available datasets. A good way to get a feel for the amount and scope of available Linked Data is to open each of dataset in its own tab in Firefox and look across the spectrum of data presented.

The home page of the Linking Open Data Project also lists recent developments such as new datasets, tools, publications and conferences becoming available. Conferences in the near future include the Linked Data Planet Conference in New York in June, and the I-Semantics 2008 in Austria in September. I-Semantics 2008 includes the LOD Triplification Challenge for show casing applications which demonstrate the benefits of linked data to end users.

DBpedia Mobile: A Location-Enabled Linked Data Browser provides an overview of DBpedia Mobile, a location-centric DBpedia client application for mobile devices. “The DBpedia project extracts structured information from Wikipedia and publishes this information as Linked Data on the Web. The DBpedia datasets contain information for about 2.18 million things, including almost 300,000 geographic locations. DBpedia is interlinked with various other location-related datasets. Based on the current GPS position of a mobile device, DBpedia Mobile renders a map indicating nearby locations from the DBpedia dataset. Starting from this map, users can explore background information about locations and can navigate into interlinked datasets. DBpedia Mobile demonstrates that the DBpedia dataset can serve as a useful starting point to explore the Geospatial SemanticWeb using a mobile device.”

There are a couple of options for trying out DBpedia Mobile from your browser including Viewing based on IP Address.

For getting up to speed with RDF, OWL and SPARQL, the technologies that form the basis of Linked Data, a good tutorial just published is Understanding SPARQL.

• Logon> mysql –user=userame –password=password
• Create a database> create database richard_projects character set utf8;
• Explain> explain select * from projects
• Alter Table> alter table PROJECTS add primary key (ID);
• Add Foreign Key> alter table`USER_ROLE` add foreign key(`USER_ID`) references `USER`(`ID`) on delete cascade on update cascade;
• Create Index> create index USER_PASSWORD on USER(PASSWORD);
• Create Unique Index> create unique index CATEGORY_NAME on CATEGORY(NAME);
• Insert> insert into CATEGORY VALUES (6, ‘Food’,'Generic Food Category’);
• Update> update CATEGORY set NAME=’Other’ ,DESCR =’Other’ where NAME=’Food’;
• Delete> delete from CATEGORY where NAME=’Food’;

User Management

Add a user with both remote and local access:

• Grant>GRANT ALL PRIVILEGES ON *.* TO ‘richard’@'localhost’ IDENTIFIED BY ‘password’ WITH GRANT OPTION;
• Grant>GRANT ALL PRIVILEGES ON *.* TO ‘richard’@'%’ IDENTIFIED BY ‘password’ WITH GRANT OPTION;

References

MySQL 5 Reference Manual Online

W3Schools SQL Quick References

The legislative documents are identified by:

• the information type (Act, Regulation, Bill, SOP)
• the legislation type or category (public, local, members, government, imperial etc)
• the year
• the number, padded with initial zeros to 4 digits. For Bills, the number will also include the Bar number and split letter (if applicable).

And a legislative document can currently be linked to in the following ways:

• To the documents table of contents.
• To the document as one HTML page
• To specific provisions within the document
• To specific HTML versions
• To the document to download as a PDF

In the same way that I want to link to photo sharing sites from within my web application there will be occasions when I want to link to legislation, standards and regulation documents.

For example in the context of a web based building project it could be useful to link to the Building Act 2004 Table of Content which gives an overview of the individual sections of the Building Act.

This is useful as a general reference but there will be occasions where I want to show a provision in a specific context relevant to the project. For example a building project needs to be issued with a building consent which can lapse after a period of time.

When showing the status of a project which has not yet started building it would be useful to indicate if its building consent is about to expire and if it is then link to the relevant provision to clarify the situation.

Currently there are two simple ways of linking to the specific provision, open it in the same page or open it in a new page.

• Lapse of Building Consent - Opened in the same page
• Lapse of Building Consent - Opened in a new page

Both of these approaches are a bit rough for todays modern Ajax-based web applications which would ideally take a smoother approach. I.e. take just the relevant content and slide it into the page at the required location, in this case inserting just the following:

“A building consent lapses and is of no effect if the building work to which it relates does not commence within—
(a) 12 months after the date of issue of the building consent; or
(b) any further period that the building consent authority may allow.”

This Ajax insertion can be achieved by first using a customized HTML reader which extracts the relevant content from the original provisions page.

The simpler display rendered by the customized HTML reader would also be more appropriate for a mobile phone based web application.

Note that in January 2008, as part of the PAL Project, a new site for accessing New Zealand legislation will be available.

The PAL Project stores the legislation documents as XML fragments that are combined for publication as HTML and PDF. It is likely that the documents will also be available as XML.

If the XML document is available then it should be simpler to access the content of the specific provisions when using the customized HTML reader discussed above.

A further simplification would be to provide a REST based web service for accessing the provisions. This would allow the content of the provision “Lapse of Building Consent” to be accessed via a URI similar to the following http://www.legislation.govt.nz/act/public/2004/se/072se52.xml.

What I want to do is provide these users with the ability to link these published photos to projects managed by our web application. Within our application only the published URL to the image would be stored.

The Flickr API, with its support for REST, is the ideal site to use as a proof of concept. At least one other site, 23 also implements the Flickr API, making it easy to support both 23 and Flickr.

The Ajax based Flickr Related Tag Browser provides a good example of how to use the Flickr API to browse and select photos by tag. Within our application a user wold browse their Flickr account and search by photo album, tag or date to retrieve specific photos which would illustrate the project site itself, tasks to be accomplished, problems associated with a task or as visual confirmation that a task had been completed.

As an example I have two projects that I am about to start.

• The first is to widen a driveway, add a front gate and landscape the front garden to link in with the new driveway and gate.
• The second is to complete the garage at the back of the property, which includes adding a couple of rooms that will link up with the existing studio kitchen and main room.

The photos for these two different projects I have tagged gate and garage respectively on my Flickr account.

The default Flickr web pages that open for

• http://www.flickr.com/photos/richard3kbo/tags/gate/ and
• http://www.flickr.com/photos/richard3kbo/tags/garage/

by themselves give good overviews of the two different project sites.

Linking specific photos to project tasks helps illustrate and clarify these tasks.

Using photos published on Flickr and similar sites allows our users to continue using the photo sharing sites they are used to and which have more features for image processing and sharing than our site.

svn: Commit failed (details follow):
svn: MKACTIVITY of ‘/repos/xxxxx’: 403 Forbidden

Took awhile to find the cause of the problem. It turns out that I had accidentally signed in the with an upper case in my username, which was fine for checking out the code but when trying to check in there was no matching username on Solaris.

Trouble was there was no visible indication that this was the problem. The cause was only revealed by looking at the server log.

Even then the fix was not straight forward, since I was using Eclipse and the Subclipse plugin, with no obvious way to reset the username and password.

So I checked out the repository again via the svn command line, explicitly setting my username.

(See: http://www.tigris.org/nonav/scdocs/ddUsingSVN_command-line.html ).

I made a change in the new repository and committed the change, again using the command line. This time the commit worked.

When I refreshed the project within Eclipse I could now see that the change I had just made was registered against my correct username while there were other outstanding changes registered against my incorrect username.

Funny thing was that as I made changes within Eclipse the new changes were now recorded against my correct username and I could successfully commit from within Eclipse.

It seems that the explicit check out of the repository to a different location had magically fix my username problem.

On the Powerbook I could also install the ActiverRDF adapters for Sesame and Jena to give me the functionality that I am after but that only works in my development environment. Sesame and Jena are Java based. When it comes to deploying an application onto the web my options are currently more limited. 3kbo is deployed into hosted environment which supports PHP, Python, Ruby and Ruby On Rails and PERL, but no Java. (There is C/C++, limited to my local user account.)

Currently there are two PHP SPARQL implementations, ARC and RAP. RAP also provides a reasoning engine InfModel, with support for owl:sameAs and owl:inverseOf.

So at this stage the architecture that is emerging is an ActiveRDF RESTful Ruby On Rails application that uses RAP as the triple store, SPARQL query engine and reasoning engine. To integrate Rails with PHP I am planning to implement a RESTful PHP interface that acts as a facade to RAP.

In this article I present the first example, based on the Friend of a Friend (FOAF) and Description of a Project (DOAP) vocabularies.

There is a similarity between the concepts and descriptions used in the DOAP vocabulary, which describes open source software projects and the descriptions and concepts which relate to the building and construction projects the “Compliance Data Management Service” is used on. Both types of projects bring together people from different locations and organisations to work together. On both types of projects people may assume one or more roles as they work on different tasks. The DOAP vocabulary imports the Friend of a Friend (FOAF) vocabulary which is widely used on the Semantic Web to describe people and the people they know. It is used by the DOAP vocabulary and is the logical choice for describing the people working on CDMS projects.

Since CDMS itself is a software project (but not open source) the easiest example to create is a static DOAP (Description of a Project) file describing the CDMS software project, combined with a number of static FOAF files describing the various people working on it. The example follows the recipe for serving static RDF files outlined in the tutorial “How to Publish Linked Data on the Web“. It creates the CDMS DOAP file and related FOAF files, demonstrating basic linking between people and the project they work on.

The CDMS software project is being developed at ABE Services by four people, John Anderson, Mike Evans, Rob Beasley and myself. To represent this I created the following five static RDF files at www.abeservices.com.au.

• CDMS DOAP file
• John Anderson FOAF file
• Mike Evans FOAF file
• Rob Beasley FOAF file
• Richard Hancock FOAF file

Also Irene Bell-Hancock has created some icons and images for us and has been added to the CDMS project description as a documenter. Irene already has FOAF file at 3kbo so the CDMS DOAP file references Irene using the URI http://www.3kbo.com/people/irene.bell-hancock/foaf.rdf#me.

The basic structure of the CDMS DOAP file is outlined in the image below.

But a better way to understand the RDF files and how they link together is to use a good RDF browser such as one of the following:

• Disco
• Zitgist
• OpenLink
• Tabulator Online

Each of these browser have an input field which accepts a URI. Once the URI has been entered the RDF browser follows the RDF links and displays them as HTML. For example Disco “renders all information, that it can find on the Semantic Web about a specific resource, as an HTML page”. “While you move from resource to resource, the browser (Disco) dynamically retrieves information by dereferencing HTTP URIs and by following rdfs:seeAlso links.” The other RDF browser work in a similar way. Tabulator requires some configuration as described on the Tabulator home page.

Also available from the Tabulator home page is the Tabulator Firefox extension which makes browsing RDF data with Firefox extremely easy. Below is what is seen with Tabulator Firefox extension when the CDMS DOAP URI ( http://www.abeservices.com.au/projects/cdms/cdms-doap.rdf#CDMS )is first opened.

Following the link to Irene displays her FOAF file (from 3kbo ) within the same html page that is displaying the CDMS DOAP file.

On 3kbo there are two foaf.rdf files, http://www.3kbo.com/people/richard.hancock/foaf.rdf and http://www.3kbo.com/people/irene.bell-hancock/foaf.rdf. In both files the foaf:knows property is used to show that Richard knows Irene and Irene knows Richard. Using Tabulator it is easy to navigate from Irene’s foaf file to Richard’s.

Navigation via RDF data across web servers is illustrated by starting at the CDMS Description of a Project (DOAP) at www.abeservices.com.au and following the CDMS “Documenter” link to Irene then Irenes “Knows” link to Richard.

Richard’s 3kbo foaf file uses the built-in OWL property owl:sameAs to indicate that Richard at 3kbo is the same individual as Richard at abeservices. Setting owl:sameAs to the following <owl:sameAs rdf:resource=”http://www.abeservices.com.au/people/rhancock/foaf.rdf#rhancock“/> in the definition of Richard at http://www.3kbo.com/people/richard.hancock/foaf.rdf#i allows Tabulator to recognize the equivalence of the two definitions and merges the information from the two sources. This is shown in the image below.

A visual indication of the merging is that the two images reside on different servers, within different FOAF definitions of Richard, i.e. http://www.abeservices.com.au/people/rhancock/richard-hancock.jpg resides on www.abeservices.com.au and http://www.3kbo.com/people/richard.hancock/richard-hancock.jpg resides on www.3kbo.com.

Tabulator follows the principles of Web Architecture outlined in the tutorial How to Publish Linked Data on the Web. When it finds that an RDF data link leads to a standard html web document or image these are displayed within the page showing the RDF data. In addition to showing embedded images (like those shown above) Tabulator can also displays web sites embedded in the same page. A good example is Irene’s home page http://picasaweb.google.com/goannagraphics. In the image below the picasaweb slide show of the embedded home page has been activated and is fully functional.

Examples of FOAF properties which lead to web documents include foaf:homepage, foaf:weblog and foaf:workplaceHomepage. foaf:homepage and foaf:weblog are defined to be properties of OWL Type: InverseFunctionalProperty. As such they uniquely identify the person whose homepage or weblog it is and within Tabulator can lead to the merging of information in a way similar to that seen when the owl:sameAs property is applied.

In summary, the example above shows a number of the benefits of using RDF data and reusing RDF and OWL vocabularies. These include:

1. Using standardized representations of people (FOAF) and (software) projects (DOAP) .
2. Interlinking between sites using RDF data links allows data from different sources to be easily combined.
3. Reasoning over data, e.g. the basic inferencing using owl:sameAs. Other examples include the foaf:homepage and foaf:weblog properties which are defined as owl:InverseFunctionalProperty. Taking selective advantage of the features of the Web Ontology Language (OWL) has the potential to reduce the amount of application specific code (e.g. java code) that needs to be written.

Future articles based on the examples created above and the existing CDMS application will include:

1. Demonstrating the ability to query the constructed RDF data files using the SPARQL Query Lanaguage.
2. Accessing existing data stored in a relational database as RDF using the D2R Server . The D2R Server enables RDF and HTML browsers to navigate the content of the database, and allows applications to query the database using the SPARQL Query Lanaguage.
3. Develop a prototype semantic web application using an RDF Triple Store that supports the SPARQL Update specification.
4. Create a SKOS glossary based on the blog entry Glossary of Common CDMS Term. The glossary would support the development of a building industry related ontologies.
5. Define an ontology which provides a “Description of a Building Project” and link it to a suitable ontology which describes the tasks undertaken as part of a building project.

The plan is to develop semantic web based applications using the Ruby based RDF framework ActiveRDF and deploy them at 3kbo. The 3kbo applications will also be leveraging the Ruby On Rails web framework.

The first step in getting started is to install Ruby On Rails on my new(ish) Mac PowerBook. Initially I will be using just two of the available ActiveRDF adaptors, “SPARQL” and “RDFLite”. RDFLite needs SQLite3, meaning that the default version that comes with Mac OS X needs to be updated. Since RDFLite can also utilize ferret , the Ruby search engine library, this was installed as well.

To install Ruby on Rails I followed the basic instructions outlined in Installing Ruby on Rails and PostgreSQL on OS X.

This approach uses MacPorts and overall worked well, apart from getting the following error at the very beginning:

“Error: search for portname ruby failed: No index(es) found! Have you synced your source indexes?”

The fix was to run the port selfupdate command:

$ sudo port selfupdate

After that ruby and ruby gems were successfully installed with the port command:

$ sudo port install ruby rb-rubygems

Well almost. The first attempt to install rails using gem ended with the error:

Bulk updating Gem source index for: http://gems.rubyforge.org
ERROR: While executing gem … (Gem::GemNotFoundException)
Could not find rails (> 0) in any repository

Problem solved by following the instructions at http://armyofevilrobots.com/node/418, i.e delete the gem source_cache and update gems.

$ sudo gem update

With gem updated rails installed fine.

$ sudo gem install -y rails

SQLite3 installed without problem

$ sudo port install sqlite3

So did ferret

$ gem install ferret

To test that all was fine I created a basic Rails app following the steps outlined in Rolling with Ruby on Rails Revisited

$ rails example
$ cd example
$ ruby script/server

And view at http://localhost:3000/

Or to check when running with Mongrel

$ mongrel_rails start

And view at http://localhost:3000/

With the basic Rails app working it was time to get started with ActiveRDF.

Richard and Steffen in Munich

Coming from a java background the workshop opened by my eyes to the flexibility of scripting languages, especially in the context of the semantic web. Now have a stronger focus on PHP, JavaScript, Ruby (Ruby on Rails) and Python, especially when developing lightweight semantic web apps. AJAX and REST design paradigms are taken as a given. Ripple also looks like a promising language to explore when working with RDF.

Also enjoyed meeting Danny Ayers. Danny has blazed a lot of the trail that I seem to be following, e.g. Danny’s Project Vocabulary Ontology provides a good start for the project management ontology needed as part of enabling CDMS for the Semantic Web.