XForms Everywhere

I already posted about the W3C Technical plenary in Mandelieu and talked about the work we are doing in the XML Processing (”XProc”) working group. It’s now time to talk a little bit about XForms-related work done during that week.

On Wednesday, XForms working group members John Boyer, Steven Pemberton and Mark Birbek, along with Al Gilman from the Protocols and Formats and Hypertext Coordination groups (from right to left on the picture) participated in a panel about the “Rich Web Application Backplane”. The idea comes down to looking at how we could standardize on a backplane providing cross-markup services in compound documents so as to reduce duplication in functionality between languages. The thinking is that since XForms already provides a model for its own use which has been the subject of a lot of efforts, XForms is well positioned to inspire such a cross-language backplane.

The last two days of the week were dedicated to the meetings of XForms working group. With a few exceptions, I hadn’t met the members of this group face to face, but I have to say that this turns out to be a great team.

Now that XForms 1.0 Second Edition is a recommendation, the working group is progressing towards XForms 1.1 and trying to get it out of the door as soon as possible, hopefully this year. Public working drafts are already available online. This work does not preclude great post-XForms 1.1 ideas to float around and be discussed.

The meeting was also the opportunity for interesting “show and tell” sessions, where members presented their latest and greatest stuff. Besides Orbeon PresentationServer and XSmiles, of which we can of course talk about openly since they are open source, we had demos of Mark Birbek’s Sidewinder, of an application built by Sebastian Schnitzenbaumer, and demos by IBM’s John Boyer (Workplace) and Jan Kratky (IBM Emerging Software Standards). I hope I am not forgetting anyone who showed running software.

It’s good to see that XForms is not only progressing on the front of implementations, but that the working group of which we are a member is also constantly looking at the future of the XForms technology.

In XML Schema, true and false are Boolean values, but I am learning through Koranteng blog that there are two other valid values: 0 and 1. At first, I found that hard to believe. So I headed towards the Schema Sandbox and entered this as document to validate:

<root>0</root>

And this XML Schema:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs :element name="root" type="xs:boolean"/>
</xs:schema>

And yes, 0 and 1 are in fact valid Boolean values in XML schema!

It’s the weekend, a time when we try to be not-so-technical.

And this weekend I will just give you a link. A link to the commencement address given last year by Steve Jobs at Stanford. The first positive comments I heard about Steve Jobs speech didn’t get me to listen to it, as in general I don’t think much of talks given by CEOs, especially those in the IT world.

But I have to admit that this time Steve Jobs is truly inspiring. If you like reading, a transcript is available. But if you have iTunes installed, I recommend you get the audio version.

This morning, I was pondering a particular aspect of XML Schema. After checking the specification, I wanted to put it into practice by writing an XML document and a corresponding schema. To validate the document with the schema, the simplest thing would have been to do it in the browser, in one of our publicly accessible sandboxes. We already have sandboxes to run:

• XQuery
• XSLT
• XPath
• XUpdate
• XPL

But to my surprise we didn’t have an XML Schema sandbox! So I decided to put one together. Since our new Schema sandbox is using the PresentationServer validating processor, it will works as well with Relax NG, and will automatically detect if the schema you provide is a W3C XML Schema or Relax NG schema. The new schema sandbox is now up our web site: give it a try.

If you are not already reading this blog through a feed reader, you can now easily subscribe to this blog by email. Just enter your email address in the textfield at the top right corner of any page on our blog. Every time a new entry is posted here, you will then be notified by email. And if you decide to, you will then be able to unsubscribe just by clicking on a link at the bottom of each email. The service is provided by the simple but effective rssfwd.

Today, March 14, 2006, the second edition XForms 1.0 became a W3C recommendation. The intent of this 1.0 second edition is mostly to add clarifications and correct errors in the first edition.

Maybe the only really new feature is the introduction of an instance attribute on <xforms:submission>. An XForms form uses one of more XML documents called instances. Typically an instance is used to capture the data entered by the end-user in the form. An XForms submission can send an instance and receive back XML data that can be used in the form. This feature of XForms is very powerful and we use it in the XForms Instant Translation to do on-the-fly translation. With the new instance attribute introduced by the second edition, data that comes back doesn’t necessarily have to replace the instance that was sent, but it can instead be stored in another instance. This attribute is already implemented in PresentationServer 3.0.

Also of interest, the XForms working group has published an XForms Quick Reference (I for one will be using that one!), and the part 2 of XForms for HTML Authors. Quoting from the introduction:

Part 1 introduced mostly features that have some equivalent with features from HTML. This part introduces completely new concepts that have no HTML equivalent.

A few weeks ago Yahoo! released their Yahoo! User Interface Library, a set of JavaScript files with foundation classes to deal with events (YAHOO.util.Event) and the XMLHttpRequest object (YAHOO.util.Connect), as well implementations of three widgets: a calendar, a slider, and a tree view.

The JavaScript is nicely commented and HTML documentation is generated from the source code with JSDoc, which does a similar task for JavaScript as Javadoc does for Java.

My congratulations to Yahoo! goes not for having created such a library, but for releasing it under an open source license (BSD). Sure, Yahoo! is getting a lot of free QA this way. Having so many external developers look at what they are doing is certainly an additional motivation for the team, and getting external developers to use their library drives standardization which is a good for everyone. Those are all benefits for Yahoo! but I am sure that leading to this decision there were those at Yahoo! who were thinking that it would be better to keep code for themselves. So kudos to Yahoo! for making the right decision and open sourcing their JavaScript library. Here are Orbeon we are already looking at the library and considering to use it in future versions of PresentationServer.

We are glad to announce that we will be at XTech 2006 in Amsterdam (May 16-19), where we will talk about XForms and Ajax. Here is the abstract that was accepted:

XForms: an alternative to Ajax?

Last year, we introduced server-side XForms as the most promising way of making XForms a short-term reality on the web.

In this year’s presentation, we discuss how this promise has materialized with hybrid Ajax-based open source implementations, and we demonstrate the most exciting capabilities of XForms running on today’s deployed web browsers.

We not only show how XForms fulfils its initial promise of becoming the next generation web forms, but also how it serves as a general-purpose dynamic user interface technology.

Finally, we show how hybrid XForms implementations effectively offer an abstraction layer over Ajax technologies that greatly simplifies the implementation of common Ajax use-cases, therefore giving XForms a place of choice in the “Web 2.0″ ecosystem.

We are looking forward to a great conference, as well as meeting you there!

Update (March 14, 2006): The schedule is now online and you can find more details there about Erik’s presentation.

Stephan Wissel (TAO Consulting Pte Ltd) will talk about Orbeon PresentationServer and its XForms implementation in Singapore on March 15, under the title “XForms - Putting your form processing on steroids”. This talk will be part of the XML Standards Seminar 2006 organized by the XML Working Group of ITSC IETC.

In the words of the organizers, “The purpose of this seminar is to explain the business benefits as well as technical detail of open standards. It aims to provide critical information that help key business decision makers to set the directions for their businesses to remain competitive in the new business era.” For more information, contact IDA_STDS@ida.gov.sg.

Update (March 14, 2006): Stephan also has a post about his talk in his blog with some more information about the event.

I am just back from the W3C Technical Plenary week in Cannes-Mandelieu (South of France). The Tech Plenary is a week-long yearly meeting where all the W3C working groups are present. Overall, this is just a great opportunity to meet people and to get some work done.

On Monday and Tuesday, I attended the first face to face meeting ever of the XML Processing (”XProc”) working group. There were about eight of us working group members, and one or two observers. I had already met in the past with three members of the group, and it was a pleasure to see them again and to meet the rest of the group. Even in these days of email and voice over IP, nothing can replace meeting people face to face.

We obviously wanted to leverage as much time as we could to deal face to face with topics that are harder to deal with on the phone. So we went over some of the use cases collected so far, trying to reach agreement over their implications. This has proven a fairly difficult task, but overall quite beneficial. We also had presentations of WG members’ existing implementations. After all, we really want to standardize existing technology, and it is enlightening to see what current implementations do, or (in one case) how the lack of an actual implementation is worked around and what the hopes for an actual implementation are.

We tackled issues such as the data model (what flows between the pipes); components interface (how a component interacts with the pipeline language); conditionals, iterations and error handling; and even whether passing binary and text in a pipeline is something we want to contemplate.

We seem to have reached a certain consensus on the fact that we want components in a pipeline to be able to send and receive “sequences of documents”. In contrast, XPL allows a processor output or pipeline input to produce exactly one document when it is consumed (and no document when it is not consumed), and dealing with sequences of documents should be an improvement that allows certain use cases to be implemented in a better way. Case in point, the XPL for-each functionality currently requires document extraction and aggregation to work around the absence of sequences. This solution should also be contrasted with a more elaborate model whereby not only documents, but XDM instances are passed. The “sequence of documents” approach seems so far to be a good middle ground.

One question we have not yet resolved is that of component parameters. We now appear to agree that “parameters” are necessary, for such use cases as XSLT. Static parameters are not an issue, but the difficult question regards how you dynamically produce parameters. So far, this remains to be agreed upon. Another remaining question will be that of whether we opt for a “push” or “pull” execution model. The hope is that this decision does not have to be made and that implementations will be free to choose the execution model, but the consequences of such a decision have yet to be pondered.

Overall, while it may have looked at times that we were not progressing much, I do believe that we actually made quite significant progress. Let’s keep it up so that we get something out of the door this year!