John Boyer is a Senior Technical Staff Member for IBM Lotus Forms. He has co-authored and edited numerous W3C standards and is currently Chair of the W3C Forms Working Group. In 2001, John earned a Ph.D. in computer science, and he has published numerous journal, conference and professional papers on topics ranging from algorithmics to computer security to XML-related technologies.

The "Ubiquity" Strategy for Promoting W3C Standards Adoption with AJAX and Modularization

At the specification level, the W3C Forms working group is working on modularization of XForms as one means of promoting incremental adoption. This is following the simple business axiom that "embrace and extend" is economically preferable to "rip and replace". If you have existing web applications, and you want to start incorporating selected features of XForms to get at certain benefits, it helps to be able to get at just those features without having to change your entire application over to XForms in one development cycle. Modularization supports agile development.

The Forms working group is now also working on XForms 1.2, even as XForms 1.1 continues toward full W3C Recommendation status. In XForms 1.2, the second approach the Forms working group is using to promote incremental adoption is to stream-line web application authoring through emphasis on attribute decoration and exploitation of UI element nesting as a means of expressing the simpler classes of MVC applications. The attributes are attached directly to UI elements, but they imply a proper XForms MVC architecture. In other words, the XForms processor can read the attributes and auto-generate a proper model for you. To get an idea of what the stream-lined vocabulary might look like, and what canonical XForms it might correspond to, look here.

The approach of providing stream-lined syntax is simpatico with modularization for two reasons. First, it means we can provide the stream-lined vocabulary and processing model as a module separately from modules that provide the components of the core XForms engine (e.g. the instance data module, the submission module, and so forth). Second, the stream-lined syntax approach means that authors can start with attribute decoration and UI nesting, and then scale up in more complex functional areas as the need arises by adopting the core XForms modules appropriate to the problem at hand.

The stream-lined syntax approach is also interesting because techniques such as attribute decoration, UI nesting, and progressive elaboration of a document are techniques familiar to AJAX developers and made popular by AJAX libraries such as Dojo. In fact, I am really coming to the conclusion that AJAX libraries are a viable alternative to browser-maker adoption as a means of delivering the most web-centric components of the W3C technology stack. It should not be necessary for Microsoft, Mozilla, Apple, Opera and other browser makers to build a W3C technology into their browsers before it becomes widely adopted and deployed. More importantly, this means that the W3C, not the browser makers, defines the web and its standards.

XML Data Interaction for All via XForms Modularization

The XForms team finished our face-to-face meeting in Amsterdam last week. A major focus of the work on XForms 1.2 is called modularization.

The rationale for this work is the observation that the set of XML data processing problems which may have first arisen in the electronic form space are really more generally applicable to the XML data processing needs of RIAs and web applications. On the other hand, those who hear the word "form" may think they do not have a form problem because they still think of a "form" as a simple or static application like those for ordering pizza or flowers. However, XForms has solved numerous problems that keep coming up again and again throughout the W3C standards stack as well as the web application stack. By modularizing the components of XForms, we believe we can increase adoption of the components in other technologies which may not have need of all aspects of XForms.

The current view of the XForms 1.2 modularization can be viewed here. As an example of the rationale above, consider an application that may want to use the submission capability from XForms in a regular web application. The application would import the instance data module, but it might have an application-specific way of populating a data instance with data. The submission module would reference a data instance for the upload data and another instance for the submission results. An application-specific method would then be invoked to consume the submission result into the application, but the means of invoking that method could be an event handler for the xforms-submit-done event. The key issue here is that submission could be consumed by a non-XForms application without needing to incorporate the XForms recalculation engine, user interface controls and so forth.

The full elaboration of this modularization will allow applications to consume pieces of XForms incrementally, including the notion of data validation, data relevance, declarative data calculations, event-drive action scripting, repeats, switches, groups, basic user interface controls, and of course submissions.

Lotus Forms and ODF under Notes Platform at the Biztech Showcase

Within IBM, there is an "Extreme Blue for Employees" program called Biztech, which promotes innovative development within IBM by funding special projects developed by teams that can come from all across IBM. Today, the 6th Biztech Showcase is being held at the IBM T.J. Watson Research Lab, Yorktown. It consists of 12 projects including ours.

Our project, which will be presented this afternoon, is called Dual Forms. To understand the basic business problem, suppose you have a complex office document such as a contract, a patent filing or a new supplier agreement. It will have many sections to fill out, some with precise information like names, supply codes, dates, milestones, deadlines, and payment amounts. These are things that need to be validated in order to prevent errors, or which may need to match with data stored elsewhere. However, other parts of the document will contain free flowing text, such as special terms and conditions. The document may also contain pie charts, bar graphs, or other rich content that serves as visual aids. The key here is that the document is complicated and hard to complete, which frustrates those who must collaborate to complete and results in costly delays in completion.

Now imagine you had a technology that could augment the office document completion experience with:

• wizard behaviors that take the user step-by-step through the fill process and help correct errors immediately
• automatically invoke web services of an SOA to obtain data during the fill experience, rather than making the user responsible to type in matching data.
• digital signature security so that the legally binding agreement can be made electronically rather than having to print, sign, fax, scan and store document images.
• automatic submission of completed documents to the back-end workflow system or the repository of executed legal agreements.

This is the domain of Dual Forms. The Lotus Forms technology provides the above benefits as well as the ability to enclose any other files within a Lotus Form. One such enclosure can be an ODF office document. Lotus Symphony is an implementation that runs under the Lotus Notes application platform as well as the underlying Lotus Expeditor application platform. In this project, we've created a Lotus Notes composite application that allows the Lotus Forms Viewer to run under Notes, including read/write access to the running form. The composite application also hosts the Lotus Symphony ODF editors at the same time.

Using this project, the end-user can get access within a single application to the capabilities of office documents AND the capabilities of Lotus Forms (wizards, help, web services, signatures, document submission to the business process). The underlying technology that allows the two rich document formats to interoperate is... XForms.

Entry-level Web Forms and End-to-End Solutions with "TotalForms"

Today at the IMPACT 2008 conference, IBM made an announcement covered by the press about its new Web 2.0 Portal Software capabilities. That announcement included the following content from the Lotus Forms team:

"With diverse data sources and inefficient, time consuming processes needed to turn data into useful information, more companies are turning to web-based forms. In response, IBM announced today a new lightweight entry-level product code-named TotalForms which the company plans to ship in beta in June."

"TotalForms is an easy-to-use version of IBM's Lotus Forms software that will enable nontechnical people to quickly create, publish and route electronic forms submitted via the web. It can be used for a variety of tasks including customer satisfaction surveys, job applications and product orders. Based on an open and scalable nonproprietary software platform and Web 2.0 technology, TotalForms will integrate with IBM WebSphere Portal to provide one familiar interface for customers."

So you know, Total Forms, will offer not just web forms based on XForms, but also a web-based design experience for forms. More importantly, though, the value of Total Forms is that it provides a server-side repository for completed form data as well as listing and reporting functions. This means that users will have a point-and-click gestural design experience and run-time capability for the full, end-to-end Web 2.0 application. This puts the computing power into the hands of the people who have the problems that computing power can solve.

End-to-End Solutions with Lotus Forms and DB2 pureXML

I'd like to elaborate further, and in concrete terms, a blog post from late last year on Talking to C-Level Execs about XForms. This will also make more sense of the XForms is a killer app of Web 2.0 messaging you got from me in this post.

For a long time now, web applications have had to use middle tier coding to backfill for the underpowered client tier and its inability to talk directly to server tier applications like DB2 that provide the persistent storage for the web. The Web 2.0 movement generally is about defining web applications that factor out the middle tier, allowing users of client applications to create and collaborate on content that Web 2.0 server applications natively understand how to store and serve.

Applications like XForms and DB2's PureXML form an instance of this movement. The server tier (DB2) moves itself closer to consumability by the Web 2.0 client tier by providing the ability to expose web services that give direct access to database table operations. Meanwhile, the conceptual client tier (XForms) now contains a comprehensive interactivity layer to drive a rich front-end user experience as well as a communications layer that allows the client to speak directly to web services. The net result is that a large class of important applications are enabled without the need for middle tier programmers.

To learn more about this union of technologies, including reference customer information, have a look at the new Tax Solution Education Kit.

Lose the Paper. Free your Forms. Powered by XForms.

Check out this cool video that will help you understand how and why your business processes need to lose the paper and get on board with dynamic, interactive electronic forms... powered by the XForms standard of course!

Like XForms, my new GPS device "rules"... because it's declarative!

My wife got me one of those GPS devices for Christmas. I really like it. Actually, I work closely with Steven Pemberton on the W3C Forms Working Group, and every face to face meeting we manage not to get lost because Steven has one of these devices. His talks a bit much and sounds just a little pouty when you don't follow her directions properly, though I think that's just a skin.

Perhaps needless to say, I've wanted one of my own for some time now because I'm pretty good at getting lost. I once took 90 minutes to complete a 7 minute journey-- well, it was 7 minutes according to Google Maps, but my version of "take the first left out of the San Jose airport" occured earlier than their version, and next thing you know, I was headed for LA rather than San Fran.

Anyway, so I visited Research Triangle Park recently for the Forms face to face, and although it is an easy trip from the airport to the hotel, I took my new GPS device along so I could get used to using it before I have to truly rely on it. Well, my plan went slightly wrong in that I ended up relying on it after all.

You see, I had dutifully printed off and memorized the Google Map instructions before leaving the rental car lot, so I knew exactly what I was supposed to do. I knew exactly what script to run. And sure enough, my handy GPS device was rattling off the correct command "Turn right onto Exit 280" when an unfortunate arrangement of traffic prevented me from executing the command. Then something wonderful happened. Without a pout, my GPS device said "recalculating" and next thing you know the device was in control of getting me to my destination.

It was then, when "recalculating" happened to me alone as I hurtled down the interstate somewhere near the speed limit, that I realized what an excellent example this was of the power and efficiency of declarative programming. I had declared my intent to arrive at a location. The rule was: get me from where I am to this location. The device computed the best way to get there. And when a change event occured, then the device recalculated a new sequence of instructions for me to run in order to achieve my objective. I suffered so much less than I did that time in California. It's just so much more effective. It's just so like XForms.

Forms are Intelligent Interactive Applications that can be Generated Automatically

Someone recently asked me to explain why the XForms way of binding form controls to XML data with XPath was better than, say, using XSLT templates to match data with XPaths and output an XHTML form. Seemed a fair question.

An XSLT describes a transformation step that happens entirely before the user gets involved, so all the limitations of current XHTML forms still applies to the result of the transformation.

In comparison, XForms defines an intelligent, interactive layer that governs the fill experience for the data. Applying an XSLT to data does not, in and of itself, describes what happens as the user interacts with the data to create new content, so the author of the XSLT is left to encode the old script and HTML devices into the XSLT.

XForms standardizes the following:

1. schema-based validation as you fill out the form
2. dynamic validation constraints applied as you fill out the form
3. calculated dependent values (like tax and total values on a purchase order)
4. accessibility text
5. access to the web services to let an SOA enrich the fill experience
6. preservation of data hierarchy in the UI
7. access to template-based UI repetition responsive to data mutations
8. user interface switching (presenting panels of controls conditionally or in sequence)
9. dynamic user interface properties (readonly, visibility/display)
10. XML data submissions to the Web 2.0 server tier

Not only does XForms standardize these things, but it standardizes how they work together.

An XSLT stylesheet that transforms data into XHTML, or one that augments an XHTML with data, still leaves the application author with the problem of how to do all of the above in javascript and how to get it all to work together without any bugs.

To further drive home the point, note that XSLT transformation could actually be used as a sympathetic technology with XForms. You could, for example, write an XSLT that transforms an XML Schema into data+XForms rather than data+DHTML. Then, you'd still get all of the above value adds because XForms is a standardized interactivity layer that describes what happens after the XSLT generates the initial rendition.

Lotusphere 2008 and Forms

The Lotus Forms team will be out in force next week at Lotusphere 2008. To me, the most exciting presentations will be on a new product in development currently codenamed Total Forms. You can expect it to be shown in the Portal vignette during the OGS (opening general session), but there is also a focused session at 11:15 on the 23rd in SW Pelican. I don't want to spoil any surprises, so I won't say too much more, except it's a revolutionary new way to build XForms-based applications that really does put the computing power into the hands of the people. So go see the next killer app of Web 2.0.

Turns out the 23rd is a busy day for the forms team. At 10, there's a session on server-side mashups. Basically, we're talking new tooling that makes the Web 2.0 server accessible to non-coders. Again, putting computing power into the hands of the people, it's for people who want the next step up from Total Forms in application creation capability.

On the 23rd again, at 4:15, treat yourself to the latest in composite application development based on Lotus Forms under Expeditor and Portal. This talk will tell you, for example, how to get your portal and expeditor applications to push data into and extract data from live running Lotus Forms. This capability is brought to you buy the new Javascript APIs in our 3.0 release, which were added for tighter integration between Filenet applications and Lotus Forms.

OK, so now I should take a step back because I started out talking about the 23rd because of Total Forms, but we actually also have a fine session coming on the 22nd at 4:15pm to tell you about all the cool new stuff in our latest 3.0 release.

And on the 24th at 8:30 sharp, there's a session devoted to the integration of Lotus Forms, Portal and Process Server. This session gives you what it takes for the full meal deal of forms applications, those involving human centered workflows that allow people to collaborate on the business processes they are involved in every day.

And rounding out the Lotus Forms development team's showing at Lotusphere is the "Meet the Developer" pedestal, where you can talk one on one with some of our best software architects, development team leads, and even a red-headed senior manager whose technical gifts are the very antithesis of Dilbert's pointy-haired boss!

Declarative vs. Imperative

When I read the material on Yahoo! Blueprint, I was pretty pleased and shared the links with you in the last entry. However, I'd like to draw your attention to the first paragraph of their roadmap (emphasis is mine):

Declarative vs. Imperative

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.

In a nutshell, this is the multimodality story of XForms.

I should clarify, though, that this is not saying that XForms has no imperative scripting of its own. The difference, though, is that the XForms script commands are data-centric, which means that they essentially declare what has to happen to the data in response to a particular event (like pressing a button to add a row to a purchase order). The meaning of each script command in XForms is tailored by the declarative constructs that bind to the data. For example, when you add a node of data containing the subtree of nodes needed to represent a purchase order item, the declarative bindings of XForms automatically create the UI controls and the line calculation formula needed to drive that new data. XForms processors, including Blueprint, are able to decide where these behavioral updates go depending on what devices are at play.

This issue of declarative constructs tailoring the meaning of imperative script commands is extremely powerful. Using the same one line of code to insert or delete a node, the rest of the application may respond by creating or destroying an arbitrary amount of user interface, including nested tables, as well as creating, destroying or updating any formulae that may be needed for the data being created or destroyed. The same one command that removes a row of a purchase order could also remove the entire list of delinquent payments for a customer who has just paid up.

In conclusion, it's not so much "declarative versus imperative". Rather, it's a matter of being much more effective with a hybrid model in which the imperative is data-centric and augmented by the declarative.

How much more effective, you ask? In The Mythical Man Month, Brookes states empirical results showing a relationship between complexity and code length of N^1.5, where N is the number of lines of code. To put that in concrete terms, 10 times less code is not just 10 times easier to maintain, it's about 30 times easier. This is the kind of difference that turns years into months or months into days. For the services company this means lower RFP bids, which translates into winning more deals. And it means significantly lower TCO for the enterprise IT shop building that web-app in-house.

XForms starts 2008 with a Bang!

After the Candidate Recommendation announcement for XForms 1.1 at the end of last year, the public implementation report period now begins in earnest. To celebrate the candidate recommendation, today you can now access a 25-minute podcast (MP3) I made to explain to you What's new in XForms 1.1 and why you should care.

And now for a very interesting news item. You know how good it feels to see a prediction you made come true? Well, that's me right now, and oh is it sweet. For some time now, I've been telling you about the new wave Web 2.0 client tier based on technologies like XForms. We deliver that vision to today's to web browsers using either a server that boils things down to the "assembly language of the web" or a client plugin. Either way the web is not solely defined by web browser vendors. Well, at the XML conference in December 2006, I saw it clear as day that the search companies were going to play an important role in demonstrating this. What'd'ya know, the first thing this year and Yahoo! has announced its strategy to foster a mobile ecosystem and deliver the best mobile internet experience to billions of consumers. The underlying technology for delivering on this strategy is the Yahoo! Mobile Developer Platform, which includes XForms. Google can't be far behind!

Stellar XForms Presence at XML 2007 Conference

It was a great year for XForms at XML 2007. There were quite a number of presentations that featured XForms as a component, though in this blog I want to focus on the big event for XForms, which of course was the "XForms Everywhere" special session held on Monday evening.

It is no exaggeration to say it was an unqualified success. This was a 2-hour event consisting of six 15 minute presentations by some of the XForms community leaders, including Mark Birbeck, John Boyer (yours truly), Erik Bruchez, Dan McCreary, Keith Wells, and Charles Wiecha. This was followed by a 30 minute keynote from Elliotte Rusty Harold on "How XForms can Win". You can find program details here.

Naturally, we were a bit concerned that the evening slot (7:30-9:30) would test the stamina of the even most eager conference-goers, but the room was filled to capacity (about 60 chairs) and then there wasn't even standing room due to about 20 people standing or sitting at the back of the room.

And then the content was exquisite. The format of the session turned out to be a great idea. With only 15 minutes, each of us was required to refine our content to the cream of the cream. The order of speakers was defined by Leigh Klotz (Xerox) based on the most natural flow of thought about forms design, run-time case studies, general application architectures, and futures. Since I was talking about design, I went first. This created a happy coincidence because it made the most sense to start by announcing the most recent accomplishment the Forms Working Group, which is the transition to Candidate Recommendation of XForms 1.1. Not only did my own design-time presentation depend upon XForms 1.1, but also most of the other presenters used XForms 1.1 features as well.

With such a huge turnout, it occurred to me that quite a large fraction of people might not know much of what XForms is capable of. I started thinking back to the Compound Documents workshop of 2004 where Bert Bos, the chair of the CSS working group, said "Forms, I know what forms are. Name, address, pepperoni, extra cheese. I want to talk about more sophisticated web applications. The kind that can play games. Not necessarily Doom, but you know what I mean." When my turn came to talk at that conference, I started by launching my BlackJack form, and I played a few hands. Lady Luck was with me that day, and she was with me again on the XForms evening at XML 2007. I showed that form for effect, but then I showed a much more sophisticated "Mortgage Pre-approval Form" in both English and Chinese. Next I showed how much of the complexity of that form could be seen as simple aggregation of the concepts one can find in a reasonably small purchase order form. And at last, I launched into a 7 minute demonstration the XForms design experience for that purchase order form. You can see a video clip of that design experience here.

I enjoyed the presentations by Dan McCreary and Keith Wells because they demonstrated sophisticated applications of XForms that would be an order of magnitude harder to build with existing web application technology. During the breaks between speakers, I took the time to reiterate to the audience the business value here in terms of being able to win deals based on lower RFP bids.

I also enjoyed the two more forward-looking presentations by Mark Birbeck and Charlie Wiecha. Mark demonstrated and spoke about his experiences building a desktop application development environment called Sidewinder, which combines XForms and XHTML to allow very efficient creation of desktop applications, not just web applications. Charlie demonstrated and spoke about the applicability of the XForms architecture to creating robust mash-up applications out of components that actually are reusable.

Perhaps my overall favorite talk of the evening was given by Erik Bruchez. You can find out more about it here. Erik presented yet another application with high business value and low development effort that he created by combining XForms with the eXist database. The main point of his overall presentation was to illustrate that the XForms-based web application architecture consists of a rich client tier that can speak directly to server tier applications like databases with no coding in the middle tier. Clearly given my blog entry of Oct. 18, I couldn't agree more.

Whenever I explain that the XForms architecture is "rich client", I always stop to remind the reader that this is a mindset, not a deployment strategy. You can deploy an XForms rich client, or you can deploy XForms functionality to a thin client (a web browser only) using a server product such as the Lotus Forms Webform Server. The point is that the XForms mindset allows you to factor out the deployment issue and focus on what the application is supposed to do.

And as an IBMer, I am duty bound to my colleagues over in Information Management to point out that the database involved in the above mentioned example could instead be the scalable and robust DB2 9.x with pureXML support. Using a package like Lotus Forms that supports the XForms 1.1 submission enhancements for web services and REST-like services, forms applications can directly consume web services set up by the database adminstrator without the need to bring in a java developer to write the code in the middle. This is an important point that I'll return to very shortly in the conclusion.

The final presentation was the keynote by Elliotte Rusty Harold, who is a gifted speaker and thinker. He began by explaining how hard it has been over the past 15 years to make do with today's web architecture for building web apps. He was more eloquent at saying this, but it's a bit like trying to incrementally build a 15 storey building on the foundation for a single family dwelling. Of course, the point was that XForms can do the job that today's web just can't, and it can do it really well, but... As Elliotte explains it, XForms is currently a "Cambridge" technology built by really smart people, and that it needs to build the bridge to New Jersey where all the fast-and-cheap, quick-and-dirty... and successful... technologies live.

This is a fancy way of saying that while XForms is now hardened for the most demanding of enterprise applications, more focus is needed on making XForms more accessible to the much wider audience of people who perhaps start out with simpler problems that work their way up into being the complicated beasts that become those unmaintainable piles of jumble-fuss (my word; Elliotte would've come up with a better one) that cause so much trouble today.

XForms can win, Elliotte says, if three things happen. First, native support in the browser. Second, good design tools. Third, XForms needs a killer app.

Regarding browser support, he points out that it is well-known that IE will be hard, but that we should start out by getting the Firefox/Mozilla XForms plugin to be moved to the core browser, and not an 'additional' plugin anymore. To some extent, I agree, but in the spirit of New Jersey thinking, XForms can already run in all browsers because we have server-side products that can boil it down to the HTML and AJAX that all browsers, including IE, natively understand. Elliotte felt that was a bit of a hack, but we have to remember that he's also a professor, so he sometimes also falls into the Cambridge trap. Still, the point is well-taken, as long as we view things in terms of transition. The server products show that XForms is a viable technology for all browsers even if you don't want to deploy rich clients. A great next step, of course, to garner direct browser support, and we're working on it, but it's not impeding our ability to provide the business value of XForms to customers today.

Regarding design tools, well, it turns out that the reason I demonstrated the Lotus Forms Designer is because I agree with Elliotte on the importance of the role of good design tools for accelerating XForms development. Actually, I believe XForms is at a deeper level. Good design tools are actually critical for accelerating web application development. Since XForms simplifies web application development, of course it also enables the creation of more flexible and robust design tools for web application development. Indeed, XForms easily enables design constructs that would otherwise be impossible to create or brittle at best given only a purely imperative language like Javascript.

Finally, there's Elliotte's point about needing a killer app. Let me start with a Cambridge thought: XForms doesn't need a killer app because XForms is the killer app. The first killer app of computing was the word processor; the second was the spreadsheet. In a conversation I had with Elliotte the next day, he commented that the spreadsheet was even more of a killer app because it had to move the coder out of the way in order to put the computing power in the hands of the people. Sound familiar? XForms is the killer app of Web 2.0. The New Jersey reality check is that it has to walk like a killer app and quack like a killer app in order to be a killer app. The spreadsheet only became the killer app once the people saw what they could do with it and how to do it. The 'what' and the 'how', that's what made the XForms + database presentation and the design tool presentation so important in our XForms special session at XML 2007. The call-to-arms is simple: make more what, make more how, ... make XForms Everywhere.

XForms 1.0 Third Edition is now W3C approved

The World Wide Web Consortium, or W3C, produces the "standards" for all sorts of web technologies with which we are all familiar, including XML, XSLT, XML Schema, HTML, CSS, PNG, ..., and XForms. The W3C calls these things "Recommendations" because after due process and careful review and implementation, the World Wide Web Consortium recommends the technical specification for world-wide development and deployment. And this is what has happened to all the recommendations listed above.

But just as software goes through maintenance and refinement, so to do the specifications that describe the software. For example, XML 1.0 is itself currently at fourth edition, and XML Schema 1.0 is at second edition.

On October 29, 2007, the W3C approved the third Edition of XForms 1.0 as a Recommendation, superceding the second edition from March 2006 and the first edition from October 2003. This release of the specification is quite important to the XForms community as it represents over 300 refinements, clarifications and corrections that have arisen in the last 18 months. The W3C Forms Working Group has worked very hard these past 18 months on what I would call "enterprise hardening" of XForms, and the numerous differences produced by the group can be viewed in the second edition errata page as well as the third edition diff-marked version.

Next up from the W3C Forms Working Group is an expected transition of XForms 1.1 to Candidate Recommendation. Stay tuned for more on that...

Talking to C-Level Executives about XForms

A lot of talks about XForms are a bit technical in nature because the people who manufacture XForms processors tend to be technical people who understand the business value of XForms in terms like "model-view-controller" architectures, a superset of AJAX, and software engineering benefits like abstraction. But the C-level executive cares not about these things. It is important to connect them to what the C-level executive does care about.

The C-level exec is about efficiency, flexibility and accountability.

The CEO wants

• efficiency via reduced operating costs and decreased time to close deals
• flexibility to react to new business processes and changes of business partners
• accountability for control of expenditures and compliance with regulations

The CIO wants to achieve

• efficiency through end-to-end business process integration and ability to leverage business objects as IT assets
• flexibility through a malleable system architecture that can be rapidly reconfigured with replaceable, reusable components
• accountability through transaction record auditability

We need to speak about how XForms helps the organization to achieve better results along these metrics. This is where the global picture of what XForms does against the backdrop of the classic 3-tier architecture comes in handy.

The C-level exec is not up at night worrying about the server tier, where databases, content managers and workflow engines live. These may be expensive systems, but they are designed to be robust and highly scalable systems whose metrics relative to the size of the anticipated user base of a system are easier to quantify. In other words, they are low risk numbers that are easy to budget for.

The C-level exec is not as concerned about the client tier, where the browser and OS live, again because the metrics are easy and stable.

The C-level exec has the most uncertainty and risk at the middle tier. There are two parts to it. There is the part that uses APIs to talk to DBs, CMs and workflow engines to implement custom application logic as needed. This part is not as scary because we have reliable, robust, scalable, stable APIs, and because the components we're talking to are those reliable, robust, scalable, stable, expensive systems sold by companies with important people's ties to yank when there is a support problem. Then there's the scary, assembly-language-of-the-web-part of the middle tier. This is the part that has to juggle a dynamic, multistep end-user experience on the anything-goes client side, where the web browsers are free and you get what you pay for. The upfront cost of the thin client is low, but the time to market with new offerings is the most highly affected because a lot of unpredictable, time-consuming work lives here.

Enter XForms.

• It allows you to standardize and consolidate the end-user experience into a single business object that represents the overall transaction.
• It allows that business object to access the web services of an SOA as a natural part of the process of going from empty transaction data to completed transaction data.
• It fully represents the transaction and therefore can function as an integral part of the records needed for auditability.

As a final thought, it should be clear from the exponential scales of complexity and cost that the diagram above argues that XForms-based systems have business value through complexity containment, and that said value is rightly reflected in software product cost.

ANN: XForms Evening at XML 2007

I am pleased to announce that IDEAlliance has now announced the XForms Evening at the XML Conference.

This event brings together a number of the leaders in the XForms community to present the business value of XForms, including design experience, end-to-end solution development, case studies and driving business value through Web 2.0 integration. The session culminates in a keynote address by Elliotte Rusty Harold, who offers his vision and advice on the future of XForms.

You can find out the details by going to the conference main page and then clicking the XForms Evening link, or just click here.