XForms Everywhere

We just introduced for the first time at the ObjectWeb conference a new XForms example that runs on the Orbeon PresentationServer (OPS) 3.0 platform. The “DMV Forms” sample application shows how to implement dynamic web forms “the right way” with XForms, services and OPS. It is based on a real-life form, namely a California Department of Motor Vehicles form.

Access a live demo of the example within the OPS examples portal or standalone (faster).

The DMV Forms example tackles:

• Using XForms to capture and display form data. XForms was designed primarily to replace HTML forms, and of course it shines at capturing and displaying form data. We illustrate how to use XForms control to capture simple text data, dates, and flags.

• Using XML Schema to validate form data. By using XForms’s XML Schema support, you can write validation constraints once and use them both on the client and on the server. We also show how you can use other XForms constraints to ensure that certain fields are required.

• Using XForms to retrieve and save data from XML services. XForms is fully XML-aware, not only in its syntax, but in the way it communicates with the external world. This example retrieves and stores data through XML services thanks to the XForms submission facilities.

• Repeating homogeneous data sections. In this example we show how you can easily insert new rows and delete existing rows in a repeated section, using xforms:repeat, xforms:insert and xforms:delete, while controlling the minimal and maximal number of rows.

• Producing forms in formats such as HTML, XML or PDF. Storing form data in XML format makes it easy to exchange between systems. This example allows you to easily look at the resulting XML document. It also features a full template-based PDF export, which allows you to print an official resulting form. The PDF facilities are available in Orbeon PresentationServer.

• Implementing XML services. Many technologies and platforms can be used to implement services. Orbeon PresentationServer does not focus on services but on the presentation, however, we show how you can quickly implement XML services with OPS’s Page Flow Controler, XPL and the eXist XML database,

• Navigating between pages. XForms pages rarely exist in a vacuum, and are often part of a flow of pages. Here we show how you can easily go back and forth between a summary and detail page while passing information in the process using the OPS Page Flow Controller and XForms facilities such as xforms:load and xforms:submission.

• Externalizing resources. We show how easy it is to externalize text resources in order to facilitate maintenance and localization.

This morning I was fighting against some nasty little bug and it got to a point where I needed some additional tool to squash the villain: a tool that would show me the HTTP headers sent back by my web application. For this, I used LiveHTTPHeaders, a nice and simple extension for Firefox.

Accessing again my web application with LiveHTTPHeaders on, I was surprised to see how many requests were sent by the browser. Looking closely, I saw that for each page, there were two additional requests, and both were going to Google:

• http://www.google.com/safebrowsing/lookup?…
• http://toolbarqueries.google.com/search?…

Those queries happen because I have installed two Firefox extensions from Google: the Safe Browsing and the Toolbar extensions. Now of course, I am the one who has installed those extensions and was at the time well aware that “data will be transmitted to Google for your benefit”. But actually seeing all those queries done in the background has some chilling effect, even on someone who is not too concerned about privacy issues. I will keep those extensions, but Google has better stick to their “Don’t be evil” motto!

It is with great pleasure that we are announcing the availability of Orbeon PresentationServer (OPS) version 3.0.

Orbeon PresentationServer is an open source development platform for building form-based applications. OPS 3.0 makes it easy to build web forms by bringing standard W3C XForms to mainstream browsers thanks to user-friendly Ajax technology.

The complete list of changes since OPS 2.8 is available:

http://www.orbeon.com/ops/doc/home-changes-30

You can download OPS 3.0 from the ObjectWeb web site:

http://forge.objectweb.org/project/showfiles.php?group_id=168

Examples and documentation for OPS are also available online. Finally, feel free to join the community of OPS users by subscribing to the ops-user mailing-list:

http://www.objectweb.org/wws/subrequest/ops-users

Enjoy!

A recent discussion in the public-xml-processing-wg mailing-list raises the quite interesting question of which data model to choose for an XML processing language. Most XML processing languages have historically bet on simplicity. In the case of XPL, XML components (called XML processors in the XPL terminology) exchange complete XML information sets, that is, basically, XML documents. A component’s input reads a complete XML document, and a component’s output produces a complete XML document, that’s it.

It is interesting to contemplate this scenario: what if components could not only exchange full infosets, but just any sequence of items as defined by the XQuery 1.0 and XPath 2.0 Data Model (XDM)? Besides clearly increasing complexity, basing the processing data model on the XDM does bring some benefits:

• It has proven useful in the past to be able to pass text or binary data in an XML pipeline. One use case consists in sending an XQuery document to a component. The OPS XPL implementation, to solve this problem, currently allows you to embed textual and binary information within an XML infoset.

  Using the XDM, you can easily pass text information (as xs:string) and even binary information (as xs:base64Binary) using types native to the data model. Arguably, this is a cleaner solution than embedding text and binary data within an XML document.

• You can pass multiple documents in sequence (as document-node()+). Now whether you really need this is an open question. But in general, you could pass sequences of elements and more, therefore opening the door to components that are more versatile than components that just process XML infosets.

• You no longer need a special XML pipeline concept for so-called “parameters” (think XSLT stylesheet parameters): pipeline steps can now consume and produce such parameters in the same way they would read full XML infosets, possibly with a simple boolean flag allowing a component such as an XSLT processor to discriminate between regular inputs and parameter inputs.

• You can do simple type-checking, even possibly static type-checking, between components, if they declare the types they exchange (with something like XSLT’s as attribute). Without mandating it, you also open the door to performing full XML schema validation on the data exchanged by components, therefore reporting more useful errors at runtime.

• You do not reinvent the wheel, and you leverage an existing specification (the XDM recommendation). This will tend to make the XML processing language specification itself simpler and shorter.

So, is the solution worth the added complexity? The risk is to turn XML pipelines into something that goes too much over the scope of defining an “XML processing language”. However, if done in the spirit of XML (and I think following the XDM qualifies), I think it could work.

Models, even if sometimes crude, can help us better get a understanding of the world. After dividing the industry in 3 sectors (goods, services, and insurances), we have seen how this model applies to software. We’ll focus now specifically on open source software, and we’ll see how this model can help use categorize different types of open source business models.

Companies cannot charge for the license of an open source software. But they can still charge for the box or the CD that contains that open source software. The value there is in the convenience provided by getting all the bits on a CD. This is what RedHat, SUSE and others have initially done, in fact quite successfully, to monetize Linux distributions. With the growth of broadband it became convenient enough to download the bits, and selling packaged open source software as goods is now more of a rarity.

Today, when we pay for open source, it is because we want either some service or insurance. Service include things like training, custom enhancements, and consulting while insurance is often presented as a support subscription plan. While smaller open source vendors tend to be more oriented towards services, larger vendors like RedHat and JBoss prefer to sell subscriptions, or “insurances” as I like to say, or “piece of mind” as Marc Fleury, JBoss CEO likes to say. They find this model more scalable, and are able to make it viable thanks to the size of their community.

How do we pay and how should we pay for software: as a good, service, or insurance? Traditionally, software has been sold as a good, often even packaged in a box and available in a store. This was not unlike traditional goods where each additional “copy” has to be produced or manufactured, and shipped, at a cost to the vendor. Of course with the Internet, all of this has changed: now software can be delivered at virtually no cost.

This means that the vendor can go for other business models, for instance making the software less expensive (or even free!) and driving revenue through services. This is in fact what some of the biggest software vendors like IBM and Oracle are doing, making more revenue from software-derived services, also called consulting, than licenses.

Are there cases where software vendors get most of their revenue through an insurance-type business model? In fact, this is more common than one might think: for software this is just called support. We see support as a major source of revenue for two types of companies: those with open source products and those with mature products having customers who have used the products for years and are more worried about some problem happening with the version they are currently using rather than upgrading to the next version. Companies like SAP, RedHat, or JBoss fit in this category.

Unlike most products, software can be sold as a good, service, or insurance. This certainly gives the entrepreneurs and strategists a lot of latitude when picking or adapting their business model, but it also makes it harder to choose the business model that will work the best for their customers.

This “article” will be split in 3 parts, to keep each one short and focused. With absolutely no credential in the field of economics, we will start in this first part by looking at another way to divide our industry into 3 sectors. In the second part, we’ll see how this can help us better understand different business models for software. And finally we’ll look more specifically at open source software, a subject dear to our heart, and see how to classify different open source business models.

We are used to divide the industry into 3 sectors: agriculture, manufacturing, and services. Instead, let’s consider a different perspective and think about how we are spending our own money. From that perspective, the distinction between agriculture and manufacturing seems artificial: both produce goods, sometime even working hand in hand. So let’s call this the goods sector. We’ll keep services but I would like to add another sector, insurances, which seems to be distinct enough from goods and services: First, we spend a significant amount of money on insurances; Second, when we pay for an insurance we don’t get immediately any good or service for our money, but we rather get some “peace of mind” in the form of a promise to obtain later some service or good, under some condition.

In this new division of the industry, we have these 3 sectors: goods, services, and insurances. In the next part, we’ll see how this can help us better understand different business models for software.

Eric van der Vlist has interviewed Edd Dumbil about the XTech 2006 conference (Edd even mentions Orbeon!). We talked about server-side XForms last year at XTech 2005 and we will try to be present at this excellent conference this year again!