A number of discussions are taking place in the new W3C RDFa Working Group about how to enable authors to use tokens in place of URIs. How do we avoid conflicts if anyone can define their own tokens? This post looks at how this might be achieved.

Since URIs are often conveyed as strings it's tempting to manipulate them as such, but it's better--and safer--to delegate URI manipulation to special functions. These can then have their own unit-tests, which will take into account the edge-cases that can catch us out.

I did a couple of talks at SemTech 2009 this year, one of which was a panel discussion called A Shift in SEO. This is a summary of the main points.

Two exciting pieces of RDFa news arrived within ten minutes of each other in my Twitter client. Both concerned governments making data open -- one in the US, and the other in the UK.

I was recently lucky enough to take my first trip to Australia, where I was doing a couple of talks on RDFa.

Next week Mark Birbeck is in Australia, doing a number of talks on RDFa

The next big task that I'm about to tackle on the Ubiquity XForms project is support for Safari and Chrome. In general, UXF has seemed to work pretty well in the WebKit-based browsers whenever I've tried it, but I've never run exhaustive tests.

Mark Birbeck's Tech Talk at Google, on RDFa, is now online

We're pleased to be launching two new initiatives to help people who are interested in XForms.

The first is the all new XForms Developer Zone web-site -- or xformsdz, as we're calling it.

Whilst the Developer Zone will be unashamedly biased towards XForms, within that, we'll have discussions, articles, code snippets, and tutorials about any XForms processor we can find, and any application framework in which it's used.

To accompany the web-site, we're also launching a regular newsletter, and a London XForms User Group.

Co-ordinating code reviews, commits and issues.

About a month ago Google added license filtering to Image Search, and provided a video tutorial on how to add licensing information using RDFa.

Here's another experiment from my 'tests' forms directory. It shows a few XForms features including the use of an extension function and inline (not that it has to be) XML Schema for validation.

The form I was writing used an XML Schema to dictate the strucure of the instance data. Within the schema there were also restrictions on some of the patterns of the XML data content that's allowed to be entered to be considered valid.

Having spent the majority of my last four years working on the likes of Ubiquity XForms, Hubbub and UBX, I've found it rather nostalgic to get back to working on Ubiquity formsPlayer during the last few weeks. So much so, in fact, that I decided to take the opportunity to delve back through the source control logs and brush up on the old girl's history a bit.

I was lucky enough to be interviewed about RDFa yesterday, by Paul Miller for his weekly podcast.

For the last few days, I've been working with Buildbot and Ant to improve the automated testing process for Ubiquity XForms. They are both seriously cool technologies in their own right, but together they are a genuinely awesome prospect. Buildbot is an automated client/server build system that enables remote builds to be triggered by events such as commits to source control or commands issued on an IRC channel. Ant is essentially a cross-platform, hyper-extensible version of make, although it is so far advanced from make that comparing the two feels slightly disparaging towards Ant. They have really captured my imagination because of the tessellation they share with the extreme programming practice of continuous integration.

In the light of the Google announcement that they will be processing RDFa, we look at the implications for data publishing -- and in particular, the key question of who owns your 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.

Recently I added an initial implementation of the navindex and accesskey attributes to Ubiquity XForms. Both attributes enable an XForms author to improve the navigation experience for their users; navindex by defining the order in which form controls are navigated and accesskey by defining shortcuts for navigating to particular controls.

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.

(* apologies to Shakespeare for the flagrant misquotation)

A common response that we've had, when making the case for UBX as an application platform, is for people to say "Okay, show me an example". This poses a problem for us because, being a small team, we're often so busy working on our software that we have insufficient time left over to build demo applications. The last six months have been different for me, however, as I've had the opportunity to concentrate solely on the development of Hubbub, a new application that is built on UBX and Ubiquity formsPlayer.

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.

Now that all of our software is open-source, we have started the process of moving it from our own source control repositories to projects hosted on Google Code. As well as easing the load on our servers, doing this helps to make our projects more visible to the wider open-source development community. The last of our projects to move is Sidewinder, which has been my main focus for the last three-and-a-half years.

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.