Mark Birbeck

I'll be speaking about The possibilities of RDFa and the Semantic Web at a free Skills Matter seminar in London on July 13th. If you'd like to come along then head over to the event page on the Skills Matter web-site, and register there.

It also looks like some of the members of the newly-formed London Semantic Web Meetup Group will be coming along too, so it should hopefully also be a good opportunity for people to meet each other.

SemTech 2009 is turning out to be an interesting conference in many ways, and I've been to some useful presentations.

I did the first of my presentations this morning, on RDFa, and the slides are below. The PowerPoint itself contain speaker's notes which will explain quite a lot of what is going on, so if you're interested then it's probably worth downloading:

Google's announcement that they will be processing RDFa found whilst indexing our web-pages certainly got many people all of a Twitter last week. Many useful posts have examined the effect that this will have on search, especially when combined with Yahoo!'s already existing efforts in this direction (they began processing RDFa about a year ago).

Some commentators also point to the effect this could have on the semantic web, accelerating uptake (although as is often the case with semantic web enthusiasts, ground-breaking initiatives that could change the web as we know it, are never quite good enough).

This post isn't about either of those things though. It's about a point that hasn't yet been raised, but will have equally far-reaching effects, and that is the role that processing RDFa will have on how we manage our personal data.

This last week has been great for the profile of RDFa, and this post is a mixture of my own experiences and some broader news during that time.

With my semweb consultantancy hat on, I've been working for a few months now on a number of RDFa projects with the UK's Central Office of Information. These projects have generally followed the same pattern:

• define a vocabulary for some specific area of interest, such as job vacancies or government consultations;
• use that vocabulary in HTML pages, via RDFa;
• get my colleagues at webBackplane to build a prototype application using Drupal and ARC2, that both publishes and consumes pages in the right format;
• add an application to Yahoo!'s SearchMonkey to process the RDFa pages.

A couple of days ago the UK Civil Service web-site was updated with a new look, and some exciting new features, some of which stem from the projects I've been involved in. There is still some more testing to do, so there haven't been any firm announcements yet, but I'm allowed to talk about one particular feature that is very exciting, the presence of RDFa in each of the job vacancies.

One of the features of our RDFa parser (Ubiquity RDFa) is the ability to import RDFa from external documents. This is particularly useful for bringing in definitions for templates and other processing rules that you would like to have applied to the document being parsed, or for importing one definition into another (owl:imports is implemented this way).

The technique used to garner these triples is simply to import the external document into a hidden iframe, and then run the parser on it. However, as the JavaScript programmers amongst you will know, that only gets you so far; if the document containing the RDFa you want to import comes from a different domain to the one that your source document originates from, most browsers won't give you access to the DOM in the iframe.

There are all sorts of ways to try to work around this, and a common one is to use a server to convert the RDFa to JSON, since script tags aren't victims of the cross-domain limitation. We therefore decided to create a JSON format that was as close as possible to RDFa. Of course, since RDFa itself is a serialisation of RDF, then really we were actually looking to create a JSON format for RDF.

Just over a year ago I wrote a blog post that showed how to create a FOAF profile on a web page, using RDFa. The idea was not only to show how easy it was to do in terms of the markup, but also to illustrate that once you are able to publish RDF via a web page, you need nothing more than a blog page to join the semantic web.

This blog post updates that old post, by first adding some guidance on how to check your document (using the Ubiquity RDFa parser), and then proceeding to add more features to your blog page.

One of our customers recently asked:

"I have a question on how we can open an XForms page from a non-XForms page. We are trying to have a summary page which is a non-XForm page and we would like to try to open an already existing XForms page by populating data on to it dynamically, by clicking on a component in the summary page. More like a summary-to-detail functionality....

We are trying to find the best way to do this."

It's an interesting question, and although we have worked out a couple of ways of looking at this on the client side, I thought the best answer for now was to user the server.

In a recent code review on the Ubiquity XForms project, the question of whether to test for an element by name or properties came up. In this post we look at the benefits that can be had from using duck-typing as a way to manage objects' functionality, rather than the more usual hierarchical solutions.

In this post I look at how RDFa and other techniques to add extra information to documents evolved around the same time as Microformats, as part of the work at the W3C on the next generation of web languages. Whilst the traditional approach taken to language design at the W3C -- and now used in HTML5 -- seeks to anticipate authors' every needs, the RDFa approach resulted from a focus on clearly defined extension points that give authors control.

Like everyone involved in RDFa, I love seeing people use it to express information about themselves, using vCards, FOAF relationships, event information and so on. This type of information is often the first to get processed by new semantic technologies such as RDFa.

But to be honest, this is simple stuff. The real meat of RDFa is to be able to express much more complex collections of information, using nothing more than the tools of web-publishing.

When sending small comments via services such as Twitter, it's pretty straightforward to add links to other documents. The general pattern is to abbreviate the link using an online service, and then paste the shortened link into your post. Software that displays your posts can then replace any string that begins with http: with a real link.

However, there are many occasions where a link is just not good enough. Sometimes you'd like to embed an image, or even a video. But if we start trying to add HTML mark-up, we'll pretty soon hit the character limit imposed by micro-blogging platforms.

Enter compact HTML, or CHTML...for short.

Determining the behaviour of an application at run-time using parameters is a well-established practice. But whilst it's possible with command-line and server-side applications, the scope for passing information to client-side internet applications is limited. With the growth in internet-facing desktop applications, widgets and gadgets, there is a need to pass parameters directly to the application, rather than via a server, and this post looks at how that might be achieved.

I've had an interesting time lately, looking at SugarCRM for a potential customer. The project involves having an internal system for the sales team, and then a public system that needs to cope with tens or even hundreds of thousands of members.