Subscribe: XForms and Internet Applications
Added By: Feedage Forager Feedage Grade A rated
Language: English
applications  blog  data  document  foaf  google  mark  microformats  new  page  profile  rdfa  rel license  rel  web  xforms 
Rate this Feed
Rate this feedRate this feedRate this feedRate this feedRate this feed
Rate this feed 1 starRate this feed 2 starRate this feed 3 starRate this feed 4 starRate this feed 5 star

Comments (0)

Feed Details and Statistics Feed Statistics
Preview: XForms and Internet Applications

XForms and Internet Applications

Stuff to do with producing a new generation of Internet Applications...biased towards XForms!

Updated: 2017-09-17T21:20:48.298+00:00


Linked Data and RDFa in US and UK government web-sites


And finally, I find this announcement exciting because the guidelines document uses the term 'Linked Data' throughout. This reflects an extremely deep understanding of the implications of what COI are doing with RDFa; the COI do not simply explain to people how to publish vacancies and consultations to the web -- they are describing how to publish that data to the Linked Data cloud.

Read more in Linked Data and RDFa in US and UK government web-sites, at my webBackplane blog.

Understanding the XForms dependency engine


A key component of any XForms processor is the dependency-engine. The idea is pretty straightforward, and will be familiar to anyone who has used a spreadsheet; if some item has its value set by a calculated expression that contains references to other items, then when any of those items change, the first item must be recalculated.

Read more in my introductory article on the XForms Developer Zone site, Understanding the XForms dependency-engine.

RDFa Tech Talk, at Google, 2009


Although my talk Beyond Web 2.0 -- How RDFa Can Help to Democratise Data on the Web, took place back in June, it's only just now been made available online, due to technical problems.

(I should say too, that those same technical problems also mean that the video is in 50's style black and white; maybe it gives it a bit more authority.)

I really enjoyed the session, and you'll hear at one point near the end I get to put some questions to Othar Hansson and Kavi Goel, and the rest of the Rich Snippets team, about how they'll be using RDFa going forwards.

Read more at RDFa Tech Talk, at Google, 2009 on my webBackplane blog.

XForms Developer Zone and User Group launched


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.

Read more at XForms Developer Zone and User Group launched on my webBackplane blog.

Tokenising the semantic web


To summarise the argument; first, we know that we need to be able to tokenise URIs, because they tend to be long and unwieldy. However, whilst the current use of prefixes to abbreviate URIs is useful, it only allows us to tokenise URIs that are used to identify vocabularies, and not full URIs. It's also not ideal that these prefixes are being expressed using a document architecture mechanism -- @xmlns.
By adding a new attribute -- @token -- to the CURIE processing rules, we can tokenise full URIs, which gives authors the same level of simplicity that Microformats has. The key difference though, is that this tokenisation is completely scaleable, and so overcomes one of the major drawbacks of Microformats.

Read more at Tokenising the semantic web on my webBackplane blog.

More RDFa goodness from UK government web-sites


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.

Read more at More RDFa goodness from UK government web-sites on my webBackplane blog.

RDFj: Semantic objects in JSON


"Essentially, what we've done with RDFj is to map JSON to RDF -- with a few extra tweaks thrown in -- rather than simply mapping RDF to JSON. (RDFa took the same approach, starting with HTML, and then working out what RDF various patterns might represent.)

"There are of course many uses for the straightforward serialisation approach, taken by RDF/JSON. But we're finding that as our applications increasingly use both JavaScript and RDF, it's very useful to blur the lines between the two. RDFj takes us an important step towards that."

Read more at RDFj: Semantic objects in JSON on my webBackplane blog.

Update to 'Getting started with RDFa: Creating a basic FOAF profile'


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.

Read more at Getting started with RDFa: Creating a basic FOAF profile, on my blog.

Customising initial instance data in an xform


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.

Read more in Customising initial instance data in an xform, on my webBackplane blog.

Duck-typing and XForms


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.

Read more in Duck-typing and XForms, on my webBackplane blog.

Compact HTML: A mark-up language for micro-blogging


This post also appears on Mark Birbeck's webBackplane blog.

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.

Compact HTML

The simple idea of CHTML is that we use keywords to indicate the mark-up. For example, to add an image you would ordinarily write:
Which would give you this:


Of course, we can shorten the fragment by using a URL service:

But we can go further if we make the mark-up compact:
That's a pretty efficient way to transmit an image in a post.


You could ask how this relates to HTML?

The idea is that all elements and attributes from HTML can be used in a generic way. So the full version of the image we just saw, would actually be:
We could also write:
img(src=,alt=A picture of Stooky Bill)

Each element would have a 'default attribute' that anonymous values would set. In the case of img it would obviously be @src, so:
is equivalent to:

Other tokens

Since all we're really doing is looking for patterns of the form:
then we needn't limit ourselves to HTML in our compact mark-up.

For example, we could express a YouTube video like this:

An example

To see this in action, take a look at the Compact HTML Twitter sample from the Ubiquity RDFa library. Note how two tweets from Stooky Bill are shown, one containing an image, and one containing a video. As you can see from Stooky's Twitter page, the actual tweets contain simple Compact HTML.

Microformats and RDFa are not as far apart as people think


The BBC have caused a bit of a storm recently by announcing that they won't be using the hCalendar Microformat on their pages. The reason is the well-known problems with accessibility. One of the proposed solutions is to look at RDFa.

Read more in Microformats and RDFa are not as far apart as people think, at my webBackplane blog.

Openness and Innovation Presentation at Media Futures 2008


Yesterday I had a lot of fun at the Media Futures 2008 conference at Alexandra Palace. The panel I was on was called Openness and Innovation, and included Robert Cailliau, Ian Forrester, Matt Webb and myself. The chair was Bill Thompson.

My slides are here:


@role values for SVG


Something which was part of the early design concepts from the XHTML Role Attribute Module, which has got a little lost, is that elements from any language can provide a handy source of role values too.

To reconstruct the logic:

A role value is simply a URI, or resource. The reason for this is so that the extensibility hook that we're creating puts us straight into the world of RDF.

Now, some values of @role will need to be invented. This might be because they simply don't exist, or because we want the values to be 'cross-cutting', and apply to many different mark-up languages.

But there are many values that already exist, that are suitable for use in a variety of situations. For example, XForms has a hint element, that can apply to its form controls:

Please enter your surname or family name
The semantics of 'XForms hint' and pretty well defined, so it should be straightforward to apply them to other situations. For example, an Ajax library could pick up a hint and do something with it in an (X)HTML document, even without XForms:

Please enter your name


This whole topic came up recently because someone asked whether it would be possible to add some new values for role which would identify paragraphs, sections, headers, and so on, and that could e used in languages like SVG; but the answer is that if we use the XHTML p, section, h1, h2, etc., values then we don't need to invent new roles:

Metadata is data about data...which is also data...kind of
turtles all the way down...
As you can see, a role-aware voice system would be able to provide feedback to a user in any mark-up language, simply by knowing XHTML role values.

Upcoming talks on RDF, RDFa and XForms


May is going to be pretty busy with talks about XForms, RDF and RDFa coming up.

First up is my talk XForms, REST, XQuery...and skimming at XTech 2008. The talk embraces themes I've been pursuing for a couple of years now; that as we put more functionality into the client, and servers get 'cleverer', it becomes much easier to build sophisticated web applications. Of course server technologies are moving so fast now that this whole approach is making more and more sense, so I'm looking forward to taking in recent developments in my talk. For example, both Amazon and Google effectively have 'databases in the cloud' that can be used to store data and query it, via APIs, with literally no configuration.

A few weeks later I'm going to be giving a tutorial on RDF at SemTech. This is an interesting development for me, because RDF and the semantic web were always my first interests--before XForms and before XHTML 2. (As well as writing RDF parsers, and designing applications, I also contributed chapters on RDF and RDFS to a couple of books on metadata and XML.)

But one problem I always had when trying to build semantic-web applications was that defining the user interface was pretty hairy. This was partly because RDF Schema is tricky to process, but also because HTML was insufficiently powerful in its core feature-set, so the translation from RDF to HTML involved a lot of work.

The need for a user interface language that was much richer than HTML was therefore why I got involved in the XForms standard (and worked with a team of people to produce the first fully conforming XForms processor, formsPlayer). So although it may not seem directly connected to the semantic web, I believe that in the coming period XForms will start to become a key part of the semantic web's architecture.

Another problem I kept coming up against whilst developing for the semantic web was the difficulty in actually publishing metadata. In particular I always found it frustrating that there was a lot of really useful metadata just sitting in ordinary web pages, and no-one could get at it. Attempting to resolve this problem gave rise to RDFa, and I'm excited that the RDFa in XHTML working draft is extremely close to becoming a stable recommendation. And as interest in RDFa grows, I'm pleased to say that some of my other presentations in May will be 'tech talks' on RDFa at Yahoo!, eBay and Google. (I'm really excited that I might be getting to meet some of the guys behind Yahoo!'s SearchMonkey.)

My final talk of the month will be at the excitingly-named Kings of Code, and I'm looking forward to talking about XHTML, XHTML 2, HTML 5, XAML, and anything else I can think of in relation to web languages.

So how about using RDFa in Microformats?


Yes, I know...everyone seems to think that RDFa and Microformats are at war. And maybe some would prefer it to be that way. But whatever way you look at it, the work of the Microformats community has been key in getting people fired up about what they might do with metadata that is placed in HTML and XHTML pages. And RDFa is benefiting from the vibrant atmosphere which they have created.That doesn't mean I'm saying we can ignore the problems and limitations that Microformats have, such as the difficulty in mixing different formats in one document, the work involved in creating new formats (often wastefully duplicating work that has already been done, since specialist formats invariably already exist), or perhaps most significantly, the inability to refer to things that are not 'the current document'.So I have a suggestion.Why don't we emphasise the 'micro' in Microformats?Emphasise the 'micro'One of the original motivations for Microformats was that they were small, self-contained sets of rules that authors could apply to their documents, which would give the author some kind of benefit. Nothing in that broad definition says 'so therefore steer clear of all other formats or you'll catch the plague'.So why not use RDFa features within microformats, as appropriate? But Microformats could still retain the compactness of a particular format.I'll use rel-license as an example.rel-licenseThe rel-license microformat is simply the use of the value "license" in the @rel attribute, in some mark-up. For example, if we want to say that the current document is licensed under one of the Creative Commons licenses, we might use the following mark-up in our document:cc by 2.0However, what if we have a search page that returns lots of images or videos? What if each image or video is available under a different license to other images or videos on the page, or to the license for the page itself? Trying to solve this problem within the framework set by Microformats is proving quite difficult (see the open issues on the rel-license issues page), so at some point we need something more than rel-license.Reusing @src attributeThe mark-up we gave earlier to indicate that 'this document' is available under a certain license, amounts to two attributes, @rel and href:cc by 2.0RDFa lets us take that little 'package' (or 'microformat') and use it anywhere that we can set a 'subject'. Of course normally the subject is the current document, which is why the rel-license microformat looks just the same to an RDFa parser as it does to a Microformats parser. But RDFa allows this 'package' to be used with the @src attribute, giving us the following possibilities:(image) (object) As you can see, this straightforwardly solves the problem that rel-license is presenting to those who want to put many items in a page, so all that would be required to take this solution into the Microformats world would be to slightly extend the rel-license microformat to allow the src attribute as a subject.RDFa or Microformats?This example illustrates that if we see RDFa and Microformats as playing slightly different roles, then there is no need to take an 'either/or' approach to the two techniques.Since RDFa is a general-purpose syntax that is capable of supporting any vocabulary that anyone comes up with, now or in t[...]

First steps in RDFa: Creating a FOAF profile


Please note that this article has been updated to Getting started with RDFa: Creating a basic FOAF profile.Now that the RDFa syntax document is in last call, and people like Yahoo! are starting to index the data, it's worth putting more of your own data into your web-pages, using RDFa. A simple place to start is to modify your home-page or blog profile so that it includes FOAF information.FOAFIf you're not familiar with FOAF, or Friend-of-a-friend, it's a set of terms that can be used to describe people, organisations, and their relationships to each other. For example, we can mark up our names, point to our home-pages, indicate the companies and projects we work on (and point to their home-pages), and so on.Since this vocabulary is gaining in popularity, and since RDFa allows us to use any vocabulary we like without having to re-write it (or ask anyone), we'll use FOAF via RDFa to mark up our pages. We won't use every part the vocabulary, so if you want to find further properties, or more detail on the properties used below, look at the full FOAF specification.Creating a personThe first thing we need to do is to create a person object that will hold our information. This is done using the RDFa typeof attribute, which is much like @class in HTML. The type of the object we want to add is a Person and since 'person' comes from the FOAF vocabulary, we write it like this: Mark Birbeck's profile
Now we're ready to add our personal information to this block.Adding personal informationThe FOAF vocabulary is packed with useful properties that we can set, so let's start with some basics such as our name and the URL for our blog.We can add our name using the foaf:name property, which is set via the new RDFa property attribute:
Mark Birbeck
Our blog is indicated using the foaf:weblog property. However, unlike foaf:name which is simply a string of text, the item we're going to refer to is a URL, so we must use the HTML rel attribute instead of @property: Creating a profileWe now have a person with some properties about them, but in FOAF terms that's slightly different to having a profile about the person. If that seems a little subtle, it is, but what it amounts to is that the document that contains information about me, is not actually me. In many situations it won't appear to make any difference, but unfortunately it can cause a lot of problems. For example, if the document is used to represent both my profile and me at the same time, what would be the result of adding some information about when the document was created? How do we know whether the information is indicating when I was born, or when the document was?FOAF allows us to prise these two things apart with the foaf:primaryTopic property, so we're going to use this to say that the main subject-matter of our profile (a web document) is me (a person): Mark Birbeck's profile

My Profile


The following is a sample profile, created using the techniques described in the post First steps in RDFa: Creating a FOAF profile:

Mark Birbeck has spent the last 7 years designing, building and thinking about a framework that enables dynamic user interfaces, driven by data content. Such a framework can dramatically increase programming productivity, and open up the world of application-building to many more people. Since he believes that the framework should be built on open standards, Mark is heavily involved in the W3C, as an invited expert with the XForms and XHTML 2 Working Groups, and also as the designer of RDFa.

His companies created the formsPlayer XForms processor, and Sidewinder, an open source, next-generation semantic web browser.

His blog focuses on building a new generation of internet applications, and a number of entries relate to Ajax, XForms, the semantic web, and the use of declarative mark-up. You can find him on Twitter, where his ID is markbirbeck.

RDFa is now in last call


After a great deal of effort by some very dedicated people, the RDFa in XHTML: Syntax and Processing document has entered last call. The full story is on the front-page of the W3C site, or at this permalink. The status of 'last call' means that as far as the people who have been involved in creating the spec are concerned, any technical problems that might have existed have been resolved. Now it's the turn of the wider community to make comments about the document, and even try to implement RDFa processors.

If you want to read more about RDFa, I've blogged a lot about RDFa, written an Introduction to RDFa, and presented on it. Bob DuCharme's Introducing RDFa is, as we'd expect from him, a great introduction, and Manu Sporny uses his vocal and artistic talents to provide RDFa Basics in video form.

Google's Social Graph API, RDFa and the future of web search


One of the main goals of RDFa (syntax and primer), and its precursors, is to provide richer semantic information for search engines. In one of my early drafts I gave the example of a news story that referred to the British Prime Minister:Yesterday in Parliament the Prime Minister said that we will fight them on the beaches.Such an article would be easily understood on the day of its publication, and even years later, someone reading this would probably know who the Prime Minister in question was, and possibly even be able to decipher 'yesterday'.But what about trying to find this article? If I search in Google for articles about Prime Ministers I'll retrieve articles about the Australian and Malaysian PMs, both of whom are in the news this week, as well as links to the 10 Downing Street web-site, stories about Gordon Brown, and so on. And if I search for "Winston Churchill" the article we're using as an example won't appear, since his name does not occur in the text.So the original proposals for RDF in XHTML--now called RDFa--suggested that one way to solve this problem would be to allow metadata about anything to be added to HTML and XHTML documents. The example given above was extended as follows:Yesterday in Parliament the Prime Minister said that we will fight them on the beaches.The identifier p:WinstonChurchill was a made up placeholder, indicating simply that we need a unique identifier that tells us that this particular person is Winston Churchill, but since writing that early draft, DBPedia has come along, which means that assigning a unique identifier for the person Winston Churchill is easy.So if we have the identifier, and we have a way of adding the mark-up, all we need now is to get the data into the search engines, so that we can use them to find the article.And Google's Social Graph API shows that this is already possible.Google have released an API that allows us to search for people and their relationships to each other. The data is gathered during the normal indexing process, as long as it is provided to the indexer using the XFN microformat or via an external link to a FOAF document. This shows some interesting developments; first, that the Google indexing process is flexible enough to pick up different sorts of information and tie it back to a URL, and second that the search process is flexible enough to allow users to search for these different types of information in different contexts.So the logical next step is to add an RDFa processor to the Google indexing pipeline. Since RDFa is a generic language, able to express not just FOAF, but any RDF vocabulary, then Google will only ever need to add one RDFa processor to their system, and that processor will allow them to index all current and future RDFa, even if documents use vocabularies that hadn't even been invented at the time the processor was installed.This is a very different approach to the Microformats technique, since with Microformats, each format is unique and has its own parsing rules, which would mean that Google would have to add a different processor for each format. Not only that, it's very difficult to make multiple Microformats in the same document play together, and since each Microformat has to be centrally approved, there is no great momentum being built towards formats for disciplines such as engineering or chemistry.None of which is to belittle the fact that getting XFN indexed by Google is a great start. But whilst I've given examples here that use people, since [...]

Creating desktop applications with Popfly and the Sidewinder Viewer


I've seen a lot of impressive Silverlight and Popfly applications, but one of the limitations I see is that they always have to be run through the web browser. So I've posted a set of video tutorials to YouTube that show how to use a Popfly mashup as a desktop application, using the Sidewinder Web Applications Viewer. The complete collection is available as a tutorial on the Sidewinder Viewer site.

The first tutorial creates a Popfly mashup that shows Facebook friends in a rotating carousel, to be used in the later tutorials. (So if you are comfortable with Popfly, or you already have a mashup that you would like to use as a desktop gadget, you can safely skip to the second tutorial.)

The second tutorial makes use of the mashup created in the first tutorial, to show different ways that it can be run as a gadget on the desktop, simply by altering the URL that is used by the Sidewinder Viewer to load the mashup. No manifest files are needed to control an application on the destop -- we can control size, position, chrome, opacity, transparency, docking and autohide behaviour through the URL that is passed to the Sidewinder Viewer -- so all you need is the URL of a Popfly mashup to get started.

The final tutorial first shows how to make the carousel float on top of all other applications on the desktop, with no chrome or background. It then goes on to describe how to write an event handler in JavaScript that will control how new windows are created; clicking on a friend in the image carousel causes a new window to open showing the friend's Facebook profile, and thanks to the event handler, this new window will be docked to the side of the screen, and set to automatically hide when it loses focus.

It's also possible to pass events between the windows that are created, which creates all sorts of possibilities for one Popfly gadget to communicate with another. I'm planning to create further tutorials to illustrate what can be done thing, but I'm also interested to hear what applications people are thinking of building, so I look forward to any comments.

Welcome to Planet XForms


I quite like the 'planet' format of community web-site. It essentially consists of an automated site that reads RSS feeds from blogs and news servers on a particular topic -- MySQL, Gnome, Linux, microformats, etc. It's quite an important service within any community, since not only does it provide a useful place to keep up with what's happening, it's also a way for anyone new to get a 'view from 50,000 feet'. (Or metres.)

So I decided to set one up for XForms, motivated partly by the simple need for such a service myself (Google News Alerts doesn't always catch items on source such as Flickr or SlideShare), and partly by the belief that when a company like Yahoo! mentions XForms, people are going to start looking for more information about it, and we need to ensure that it's available.

After much configuring, tweaking and cursing, the site is live, and called Planet XForms. It aggregates a number of XForms-related blogs, as well as various XForms-tagged resources, such as images from Flickr, presentations from SlideShare, videos from YouTube, events from Upcoming, links from Magnolia and, and news from Google. It also provides a Feedburner feed if you want to get the whole lot in your RSS reader.

The idea is that Planet XForms is completely automated, and not tied to any particular company or processor. This means that if you have a product screenshot you want the world to see, you don't need anyone's permission to get it onto the site; just place it on Flickr, tag it with 'xforms', and it will soon show up on Planet XForms. Have a useful tutorial? Just make a YouTube video, or upload your slides to SlideShare, and as long as you don't forget the 'xforms' tag it will quickly be available to the whole XForms community.

If I've missed any sources of data (I'm holding out on Twitter...), or you'd like your blog included, then please do let me know. And I hope that what we have so far proves to be of use to the growing XForms community.

(One last thing is that I must acknowledge the excellent Planet Microformats site, which has a very different feel to it, than the more 'old-fashioned' style used on most of the planet sites that I came across whilst looking for inspiration. Excellent work by Brian Suda.)

Yahoo! uses XForms for 'write once, run anywhere' mobile applications


Yahoo! recently announced their entry into the mobile web applications space, with a service that allows applications to be built and hosted using Blueprint, a purpose-built mark-up language based on XForms.

The Blueprint roadmap describes the underlying philosophy:
Much of Blueprint's philosophy and syntax comes from XForms. We opted for a full declarative language because it was the only way we could effectively run on the wide range of devices out there, some of which have no scripting at all. By using declarative syntax, we can encapsulate and hide the scripting specifics. In some cases, the code could run on the phone, in other case, such as XHTML, we can put the logic on our servers. It's the perfect way to deal with the various environments and their capabilities.
At the moment Blueprint is simply converted to XHTML plus JavaScript for delivery to devices, but the mention of XForms gives a clear indication of where they are heading. And given that Google did something similar with the launch of its Google Mashup Language, it all bodes well for a new wave of web applications that won't be built using JavaScript (or even Java and GWT) but will use straightforward, device-independent, mark-up.

Write once, run anywhere, anybody?

For more on why XForms is Ajax on steroids, see:

skimming at XML 2007 (and The Cloud's Silver Lining)


I've not yet had a chance to write up my experiences at XML 2007 in Boston last week, but an announcement today by Amazon prompts me to at least summarise one of the talks I did, called XForms, REST, XQuery...skimming. (Slides)It's a theme I've touched on a little in this blog, and have spoken on before (at an XML UK meeting, last year, and at XTECH 2007, this year), and the idea goes something like this; building web applications by dynamically generating user interfaces that contain data, is awkward, and difficult to maintain. Web services (which includes REST and APP) removes some of the dependency on databases by hiding the data behind a simple abstraction layer--a kind of 'ODBC for the web'--and XQuery takes this further by giving us a standard language to get at the data.But XForms is the icing on the cake, since it gives us a rich-client language that can be deployed like traditional web applications, yet is one that ensures a clean separation of the data and the user interface.During the course of the presentation I showed how incredibly easy it is to create an application with XForms, since forms can be first created on the desktop--loading and saving their data from local XML files--before being deployed to any type of web server. By creating static forms that load their own data, rather than the more common model of dynamically generating static files that contain data, we end up with files that are completely agnostic about where they are delivered from. My demonstrations took them from the desktop, to a simple web server, to eXist (an XML database).But these applications could even run in 'the cloud', with no web-server. That may sound odd, but I could store any of these XForms applications in SVN or Amazon's S3 and they would work as well as if they were in IIS or Apache. This is the ultimate in simple maintenance and future-proofing, since you are no longer reliant on any particular operating system or server-side language...the forms just 'are'.GDataThe final step of my presentation was to take this a little further and show an XForm that interacts with Google's GData; the form is simple, and accepts a longitude, latitude and comment which is then inserted as a row into a Google Spreadsheet, using Atom Publishing Protocol (APP). Another form is then used to retrieve the entire spreadsheet, and each row is used to create a pin on a map.The great thing about this demonstration is that it shows that not only are our forms now agnostic about where they run--desktop, server-side, S3, etc.--but now the data becomes agnostic; we don't care how the data is stored, all we are concerned about is the protocol used to interact with it.And crucailly, XForms' ability to get at this data shows that it really is the missing link when it comes to building a new kind of web application.SimpleDBBut this generalisation about data just took another leap with the announcement today by Amazon of a closed beta called SimpleDB. This will allow programmers to store and query for data in a manner similar to the way that GData works.By putting data into the cloud, and then using an easily deployed, declarative rich-client language like XForms, it is possible for the architecture of web applications to be altered in a quite fundamental way, in a direction that is completely different to what we're used to.[...]

RDFa, @profile, and following your nose


a monument to Gogol's "Nose" Originally uploaded by Incandenzafied One of the issues that people continually return to in relation to metadata in HTML (and with RDFa in particular), is how to know when it is safe to interpret some mark-up as 'additional' metadata. This often gets termed 'following your nose', since the idea is that you should be able to obtain from the document you are processing the information you need to add an extra layer of interpretation to the mark-up.(This shouldn't be confused with the other form of 'following your nose', practised by Gogol's Major Kovalyov, which is an altogether more fraught experience.)For example, if we were processing an HTML document that contained the hCard microformat, we might have:Mark BirbeckThe nose-related question being posed is, how do we know that it is legitimate to interpret the value called out by "fn" as a full-name? Is it not possible that on some occasions an author has simply created a @class value of "fn" to help their CSS?@profileOne way this question is answered in the world of microformats is to use the profile attribute to 'scope' these values; if the author has added the following, to the top of their document:then it is pretty clear that they want "fn" values to be interpreted as a 'full name', and it would be quite legitimate for a parser to extract this value and do something with it. The complete mark-up might look like this: . . . Mark Birbeck This is a good solution for microformats, since there are quite a few of them. Each microformat has different rules for parsing, so indicating the presence of one or more microformats in the profile attribute works well, and is very much in the spirit of the original meaning of @profile in HTML.But what of a generic solution like RDFa? Does the same situation arise?RDFa is unambiguousRDFa uses new attributes, as well as full identifiers for properties and values, so the problem of ambiguity does not arise. To make use of the FOAF value name an author would declare a namespace prefix, and then use any values that are enabled by that prefix, as follows: . . . Mark Birbeck This is about as good as it gets, since it makes use of existing, well understood XML techniques to define properties unambiguously. And since it is using the new property attribute, it is nigh on impossible that we would happen upon this mark-up in a situation where the author intended some non-RDFa meaning. In other words, RDFa provides a far better solution than the usual 'follow your nose' approach, which would have us load some kind of profile (as practised by microformats and GRDDL), since it requires no other indications in the document to help discern meaning, other than a few simple, generic, rules.Indicating the presence of metadataHowever, there is a separate problem that is often raised in conjunction with RDFa, which is how to know whether to actually parse the document or not; if an author has not included any RDFa, why spend time processing it?This is not a problem unique to RDFa, b[...]