Contents
| Last modified: October 30, 2007 |
| XML and Forms |
Overview
"XForms is a markup language that addresses the modern needs of electronic forms. It is based on XML and can deliver the collected values as an XML document. It addresses questions of authorability, usability, accessibility, device independence, internationalization, integration into different host languages, and reducing the need for scripting."
XForms is an XML application that represents the next generation of forms for the Web. XForms is not a free-standing document type, but is intended to be integrated into other markup languages, such as XHTML or SVG. An XForms-based web form gathers and processes XML data using an architecture that separates presentation, purpose and content. The underlying data of a form is organized into instances of data schema (though formal schema definitions are not required). An XForm allows processing of data to occur using three [MVC] mechanisms:
- a declarative model composed of formulae for data calculations and constraints, data type and other property declarations, and data submission parameters
- a view layer composed of intent-based user interface controls
- an imperative controller for orchestrating data manipulations, interactions between the model and view layers, and data submissions
Thus, XForms accommodates form component reuse, fosters strong data type validation, eliminates unnecessary round-trips to the server, offers device independence and reduces the need for scripting.
XForms 1.1 refines the XML processing platform introduced by XForms 1.0 by adding several new submission capabilities, action handlers, utility functions, user interface improvements, and helpful datatypes as well as a more powerful action processing facility, including conditional, iterated and background execution, the ability to manipulate data arbitrarily and to access event context information. [Abstract from XForms 1.1 W3C Working Draft, 22-February-2007]
W3C XForms Activity
[October 30, 2007] XForms 1.0 Third Edition Published as a W3C Recommendation. W3C announced the publication of XForms 1.0 (Third Edition) as a W3C Recommendation, signifying that there is significant support for the specification from the Advisory Committee, the W3C Team, W3C Working groups, and the public. Forms are an important part of the Web, and they continue to be the primary means for enabling interactive Web applications. Web applications and electronic commerce solutions have sparked the demand for better Web forms with richer interactions. XForms 1.0 is the response to this demand, and provides a new platform-independent markup language for online interaction between a person (through an XForms Processor) and another agent, usually remote. XForms is an XML application that represents the next generation of forms for the Web. It splits traditional XHTML forms into three parts: XForms model, instance data, and user interface. By this means, XForms separates presentation from content, allows reuse, and provides strong typing. This design reduces the number of round-trips to the server, and offers device independence with a reduced need for scripting. XForms 1.0 XForms strives to improve authoring, reuse, internationalization, accessibility, and overall usability. The XForms Recommendation document responds to implementor feedback, brings the XForms 1.0 Recommendation up to date with second edition errata, and reflects clarifications already implemented in XForms processors. W3C reports that the Recommendation-level specification contains 343 diffs that have significantly hardened XForms for enterprise deployment. The XForms 1.0 Third Edition Test Suite was used in interoperability testing, including tests for: Document Structure; Processing Model; Datatypes; Model Item Properties; XPath Expressions in XForms; Form Controls; XForms User Interface; XForms Actions; Submit Function; XForms and Styling. More than twenty-five (25) XForms Implementations were reported as of 2007-10-29.
[February 22, 2007] Last Call Working Draft Review for XForms 1.1. John M. Boyer (ed). W3C Technical Report. Also in non-normative diff-marked HTML. W3C's XForms Working Group has published a Last Call Working Draft for the "XForms 1.1" specification, and invites public comment through 05-April-2007. Web applications and electronic commerce solutions have sparked the demand for better Web forms with richer interactions. XForms is the response to this demand, and provides a new platform- independent markup language for online interaction between a person (through an XForms Processor) and another, usually remote, agent. XForms are the successor to HTML forms, and benefit from the lessons learned from HTML forms. XForms is not a free-standing document type, but is intended to be integrated into other markup languages, such as XHTML or SVG. An XForms-based web form gathers and processes XML data using an architecture that separates presentation, purpose and content. The underlying data of a form is organized into instances of data schema (though formal schema definitions are not required). An XForm allows processing of data to occur using three mechanisms: (1) a declarative model composed of formulae for data calculations and constraints, data type and other property declarations, and data submission parameters (2) a view layer composed of intent-based user interface controls (3) an imperative controller for orchestrating data manipulations, interactions between the model and view layers, and data submissions. Thus, XForms accommodates form component reuse, fosters strong data type validation, eliminates unnecessary round-trips to the server, offers device independence and reduces the need for scripting. XForms 1.1 refines the XML processing platform introduced in XForms 1.0 by adding several new submission capabilities, action handlers, utility functions, user interface improvements, and helpful datatypes as well as a more powerful action processing facility, including conditional, iterated and background execution, the ability to manipulate data arbitrarily and to access event context information...
[April 19, 2000] From a W3C announcement: "The World Wide Web Consortium (W3C) announced the release of the first Public Working Draft of the XForms Data Model. The XForms Data Model Working Draft, along with the XForms Requirements document, provide the first cross-industry efforts in seven years to produce the next generation of Web-based forms. When HTML Forms were introduced to the Web in 1993, they provided a means to gather information and perform transactions. The structure of forms served the needs of many users at that time, as well as the devices used to access the Web. Seven years later, the Web is a space where hundreds of millions of users expect to use many different devices to perform increasingly complex transactions, many of which exceed the limitations of the original forms technology. The W3C HTML Working Group has a charter to develop a form archictecture that provides a better match to workflow and database applications, to the proliferation of new Web-enabled devices, and to the XML-driven Web. The XForms Subgroup has accepted the challenge and produced a forms architecture that separates data modeling, logic, and presentation. The XForms Data Model has emerged as the first in a series of XForms specifications. XForms aims to ease the transition of the Web from HTML to XML. As XHTML 1.0 allows HTML content authors to make a smooth entry into the XML world, XForms allow Web application authors to combine the modularity of XML with the simplicity of HTML to gain key advantages in the areas of device independence, accessibility, business-to-business and consumer e-commerce, and embedded devices. The XForms Data Model deliberately separates the purpose of a form from its presentation. This allows the application author to rigorously define the form data, independent of how end-users interact with the application. The separation facilitates the development of Web applications with user interaction components, and provides advantages to Web application developers."
'Key Goals' in the XForms design effort include: (1) Support for handheld, television, and desktop browsers, plus printers and scanners; (2) Richer user interface to meet the needs of business, consumer and device control applications; (3) Decoupled data, logic and presentation; (4) Improved internationalization; (5) Support for structured form data; (6) Advanced forms logic; (7) Multiple forms per page, and pages per form; (8) Suspend and Resume support.
[April 19, 2000] Note 'Some work in progress' as of 2000-04-19: "To test our understanding we want to try out ideas for XForms on reasonably complex examples. The starting point is an working implementation in HTML and ECMAScript that demonstrates the functionality. We could then demonstrate alternative representations in XML, compiling them to HTML+script code, and see how well the different approaches stack up against each other. To set this in motion, we are working on an order form involving, customer details, one or more line items, payment details and a summary report. Here is a link to a sample order form. It works best in IE4+ where the table of line items smoothly expands as needed, and the total, tax and shipping fields are dynamically updated as new line items are added. Pressing the submit button invokes checks on missing fields, and if all is well, you will see a pop-up window showing how the form's data would be encoded in XML. A cross-browser version is planned. Dave Raggett has provided his idea of how this could be represented declaratively in XML, avoiding the need for the complex ECMAScript code in the HTML representation. The representation is still at an early stage and currently lacks the detailed form logic described in the comments. Gavin McKenzie has provided an XFA implementation of the sample form. Note that this models an earlier version of the form where the payment details were placed near the start of the form. Sebastian Schnitzenbaumer has provided an FML implementation of the form, and you can try a live demo of this implemented in Mozquito..."
Principal References
- Primary W3C Resources
- W3C Forms Working Group. 'XForms - the next generation of Web forms'
- W3C Forms Working Group Charter
- W3C XForms Activity Statement
- W3C XForms Group Wiki
- Archives for W3C public list 'www-forms'
- W3C Interaction Domain
- XForms Implementations
- XForms 1.0 Implementation Report. Based on the XForms 1.0 public Test Suite.
- XForms 1.0 public test suite. "This XForms 1.0 test suite has been created by the XForms working group during the CR phase. Test cases are categorized by chapter, and the cover page for the test cases for each chapter is linked from this page. Test cases for each chapter are maintained in a separate directory."
- XForms Patent Statements
- Comments: send email to www-forms-editor@w3.org, and see the public archive.
- XForms Working Group Charter - 2002
- Other Resources
- XForms Tutorial and Cookbook - Wikibooks
- XForms.org - Maintained by Kurt Cagle, as a "news and code portal for the XForms and XQuery community"
- Xforms Community Forum
- Orbeon - XForms Everywhere
- XForms for UBL - "This project is to provide XForms which allow creation, processing and editing of UBL documents and XLST stylesheets to generate such forms."
- Mozilla XForms Project
- Mozilla XForms Add-On
- Early References
- "XForms 1.1 Requirements." Edited by John Boyer (PureEdge Solutions Inc), Roland Merrick (IBM), and Sebastian Schnitzenbaumer (SAP). Produced by members of the W3C XForms Working Group. W3C Working Group Note. 26-January-2004 Version URL: http://www.w3.org/TR/2004/NOTE-xforms-11-req-20040126/. Latest version URL: http://www.w3.org/TR/xforms-11-req/.
- Announcement 2003-10-14: "World Wide Web Consortium Publishes XForms 1.0 as a W3C Recommendation. W3C's Next-Generation Forms Technology Ready to Use."
- Testimonials for W3C's XForms 1.0 Recommendation. From CWI, Cardiff Software, Chibacon, HUT, IBM, Mozquito, Novell, Origo Services, PureEdge Solutions, SAP, Sun Microsystems, U.S. CIO Council, and x-port.net.
- W3C Publishes XForms Version 1.0 as a Proposed Recommendation." News story August 01, 2003.
- "W3C Announces Creation of a New XForms Activity." News story February 04, 2003.
- "W3C XForms 1.0 Advances to Candidate Recommendation Status." News story November 12, 2002.
- "W3C Publishes Preview Candidate Recommendation for XForms Specification." News story August 21, 2002.
- XForms 1.0. W3C Candidate Recommendation 12-November-2002. Also as single HTML document and ZIP archive.
- [April 04, 2001] XForms Requirements. W3C Working Draft 04-April-2001. Previous version 2000-08-21. Editors: Edited by Micah Dubinko (Cardiff), Sebastian Schnitzenbaumer, Mozquito Technologies), Malte Wedel Mozquito Technologies), and Dave Raggett (W3C).
Articles, Papers, News
[July 10, 2007] "Use XForms and Ajax to Create An Autosuggest Form Field." By Michael Galpin. From IBM developerWorks (July 10, 2007). "This article shows how XForms can be used to complement Ajax. It uses many of the same paradigms as Ajax, but provides several simplifications and optimizations. It's easier to send and receive data from the server using XForms, and you get 'smarter' events from it. It can also simplify the JavaScript needed, providing a lot of 'boilerplate' functionality that JavaScript must implement normally. In conclusion, it's often beneficial to let XForms be the 'A' and the 'X' in Ajax. An autosuggest-form field is a prototypical Ajax feature. One of the applications that first popularized it was Google Suggest. In Google Suggest, you start typing a keyword to search on and the application suggests search terms based on popularity. This is nice for users, as they don't have to type all of their search term and it helps prevents data-entry mistakes. This technique is used widely in Web applications now. XForms is a standardized technology, but it is not yet implemented by default in most browsers. This article uses the Mozilla XForms add-on. This is an add-on that can be used with any Mozilla Gecko-based browsers such as Firefox, Seamonkey, and Flock. All of the XForms code used here is standard, so any compliant XForms implementations should be similar, but it's been tested against the Mozilla XForms Add-on version 0.8 installed on Mozilla Firefox 2.0..."
[June 26, 2007] "Cool Things You Can Do With XPath in XForms." By Nicholas Chase. From IBM developerWorks (June 26, 2007). "If you've done any work in XML, you're probably familiar with XPath, the expression language that enables you to select portions of an XML document. If you've worked with XForms, you're definitely familiar with it; you can't build an XForms form without it! But XPath enables you to do much more than just select a node for display on the page. This article shows you how XPath and XForms interact to enable you to create functionality you may not have considered, such as displaying a list of unique values in one easy step, or using XPath in conjunction with interface elements such as radio buttons or drop-down lists to control the data displayed, as opposed to just the data submitted. XForms is based heavily on what you can do with XPath. The article explains how to: (1) Automatically populate a node using the results of an XPath function; (2) Select data in one location based on user choices in another location; (3) Display only unique items from a list; (4) Filter results based on multiple criteria; (5) Provide a wild-card value for an XPath expression.."
[June 05, 2007] "Understanding XForms: Viewing and Creating 'Adventure' Scenarios." By Kurt A. Cagle. From IBM developerWorks (June 05, 2007). "One critical difference between imperative and declarative programming methodologies is the notion of completeness. In most procedural languages, it is perfectly permissible to start writing code without having anything designed up front, as the code can work on snippets and pieces and then get factored together over time with other code. With XML in general, and XForms in particular, you have to have at least a minimal data model in place before you can see anything working, but once the model exists, then the presentation of that model (the form elements) usually progresses very quickly. As such, XForms tends to enforce a more disciplined methodology of programming where you need to spend more time up front designing in order to gain faster development efforts in the back end. With XML-based technologies such as XForms, XQuery, and XSLT, it is possible to create complex multi-user applications, from interactive help systems to custom "game" applications in which multiple users can interact with at once. This article shows how to create you fairly simple scenario games. The article also showcases the eXist XML database, the Saxon 8.9 processor (for XSLT2 support), and the Mozilla XForms plugin for Firefox. It should be possible to adapt this same technology for use with other XML databases and XForms Implementations, but these tools provide a quick way to experiment with these technologies and to work with XML bindings. This particular application is comparatively simple except for all the XPath expressions, but obviously it has a lot of ramifications. For instance, the sample here has just used a selection of paragraphs and literal output of content to display the scenario bodies and links, but in many respects it makes more sense for that content to be markup code of some sort. This way you can include images, text formatting, and related manipulation. You can also include additional XForms control elements, perhaps feeding into another data model. The second part of this series will look at both how to go about creating a rich-text version of the scenario editor as well as building an editor that lets you create new scenarios on the fly and save them to an XML database..."
[May 15, 2007] "X-Trapolate: Use XForms to Create An Accounting Tool." By Nicholas Chase. From IBM developerWorks (May 15, 2007). "This six-part series demonstrates how to leverage the power of XForms in conjunction with MySQL and PHP for support processing to create an online accounting tool called "X-Trapolate." Every good programming technology possesses a range of problems it excels at solving. The series highlights some of the problems that the XForms solves effectively, such as the need for live calculations and greater interactivity. This article, Part 1 of the series, provides an overview of the different forms and functionality that will be created in this series, examining some of the aspects of this type of tool you must consider when undertaking the design. XForms brings desktop-like interactivity into the picture while eliminating all of these differences. It provides a standardized way to perform tasks like form validation, calculations, and conditional output. It enables users to save a form to the local machine while offline and submit it to the server later. Perhaps most of all, it separates form from function, providing a way to specify what a form does while leaving the presentation up to the browser or other user-agent. That means that a browser, a PDA, and a voice recognition system can all use exactly the same form. XForms also provides a way to work with XML data directly. The X-Trapolate accounting toolset showcases a variety of standard XForms development methods and resources. The reader follows through the interface development of a functional XForms implementation. Fundamental form controls such as input, output, select, text entry, and secret play appropriate roles in the accounting tool. The introduction of each form control associates with a description of the control and a discussion of the choices made while implementing that control. Other non-visual XForms features also play an important role and the tutorial addressing that feature highlights the usefulness of that feature. Some examples of the features that will be covered include calculation, relevant, and required properties, toggles in conjunction with case and switch, interfacing to PHP, and interfacing to native XML servers. Part 1 is an introduction to the entire series, summarizing the facets of the XForms specification each part covers. Part 2 covers logging in and account management. Part 3 covers the development of forms pertaining to asset management. Part 4 continues the coverage of the development of asset management and reporting of various accounting aspects of a business. Part 5 covers liability management and more enhancements. Part 6 concludes the series with a summary of the developed tools, and some suggestions for improvement and further work for the tool set..."
[March 06, 2007] "Use XForms to Create a Dynamic Web Search: The Flexibility of XForms." By Stony Yakovac. From IBM developerWorks (March 06, 2007). "This article demonstrates the creation of an interface flexible enough to view the results of multiple XML-based APIs by implementing a search engine client in which the user selects the engine the data comes from and automatically receives the appropriate entry fields and data. In addition, the form loads the data "in the background," so to speak, displaying the results on the page without requiring a full reload. In this case, the APIs involved are those of search engines Yahoo! and Teoma, but the concepts covered in this article apply to any situation in which you have an API that returns XML. Both search engines have a REST-based interface, which means you feed them a URL with all of your parameters and they give you back XML with the results. XForms implements dynamic changes to the content without re-submitting the page from the server by linking the XForms visual presentation to an XML data structure. When the XML data structure is changed, the visual presentation is re-calculated and changes without having to reload the page. There are many methods of changing the XML data behind the presentation. You can take these concepts and use them for your own XForms-based applications, creating interfaces that adapt to user choices and the available data..."
[February 20, 2007] "Creating an XForms-based Logo Generator." By Nicholas Chase. From IBM developerWorks (February 20, 2007). "Scalable Vector Graphics (SVG) provides an easy way to declaratively create an image using XML, and XForms provides an easy way to edit XML. In this article we put the two together to create an XForms-based XVG editor for creating SVG images such as logos. Although you might imagine that the editing of an XForms form and having an SVG image in the browser window update automatically, it is not that easy. But that doesn't mean it can't be done. This article shows you how to create an XForms-based logo generator using SVG. The code in this article has been tested with Firefox and the Mozilla XForms extension, but the concepts should apply to any XForms implementation. In this example, we want a form that enables us to edit the properties of existing shapes, or to remove those shapes altogether. We also want to be able to add new shapes, edit those shapes, and save the data to a logo file. Once you've done that, we want to be able to see the changes right there on the page. What you learn in this exercise is that you can use XForms' ability to insert new elements and copy information into them in order to add new content. You can also use XForms' traditional element- and attribute-editing capabilities to alter the properties of SVG objects. From there, you can save the data to a file and view changes to the file. In a production environment, you will want to make several changes. For one thing, you'll want each individual user to have his or her own logo.XML file, probably based on a unique username. You might want to expand the users' choice of shapes, or the properties available for editing. You might also provide a way to download a non-SVG version of the logo, such as in a PDF or PNG file..."
[January 30, 2007] "XForms as an RSS Reader/Editor." By Nicholas Chase. From IBM developerWorks (January 30, 2007). "RSS, Atom, and other syndication strategies involve making XML data available for download. XForms, which is designed to view and edit XML, is the perfect environment for an XML editor and reader. This article explains how to create an XML reader and editor using XForms. The article assumes that you are familar with the basics of XForms and at least one syndication format such as RSS. The article uses RSS 1.0, but the concepts are the same for not only any version of RSS, but also Atom and any other XML-based format. The code was tested using Mozilla Firefox with the XForms extension, but the concept should work in any XForms-capable browser. he idea is to create a page that enables the user to request a specific feed to read based on its URL, displaying its information on the page. The page also includes a button that lets the reader switch to an editor. The editor enables the user to change existing information, add a new item, delete existing items, and save the feed — assuming that you have the appropriate permissions. The first step is to create the basic page that enables the user to specify a feed to read. To do that, start with a basic XForms form, embedded in an XHTML page. You also need a way for the user to specify the feed with which he or she wants to work. Fortunately, you can take advantage of how XForms works to accomplish this task. You're probably already aware of how changing a value in one XForms control can lead to the browser automatically displaying new information somewhere else. What you might not know is that the XForms processor reacts that way to virtually any change. For example, you can create a form that automatically changes the value of the instance element's 'src' attribute. XForms provides an excellent basis for editing RSS, Atom, and other XML-based syndication formats. In a production application, you will also need to determine the version of the feed at hand and alter your forms accordingly..."
[January 23, 2007] "XForms in Firefox." By Elliotte Rusty Harold. From IBM developerWorks (January 23, 2007). "This article demonstrates basic XForms processing as currently supported by Firefox and the Mozilla XForms plug-in. Using the experimental Mozilla XForms extension, you can process XForms in your browser today. While not yet deployed widely enough for use on the public Internet, XForms may be suitable for some intranet applications. XForms is not only a more powerful means of designing and laying out forms than classic HTML forms; it's an easier one too. Because content is separated from presentation, CSS can be used to full effect. Furthermore, you can put the form elements anywhere on the page you like, intermixed with any markup. Finally, form tricks that require lots of JavaScript code, such as updating one field when the user enters data into another, are a trivial amount of declarative code in XForms. Except for one little detail, developing with XForms would be a no-brainer. That detail is that no current browsers actually support XForms out of the box. Needless to say, this severely limits what you can do with XForms and where you can deploy them. However, there are workarounds. Browser plug-ins exist for both Windows Internet Explorer and Firefox that add XForms support to these market-leading browsers. XForms processors have also been written in Flash that can be deployed to any browser with a Flash runtime. Finally, there are server-side solutions that precompile all XForms markup to classic Hypertext Markup Language (HTML) and JavaScript programs. Client-side XForms processing won't be possible for public-facing sites until XForms is more widely deployed in browsers. However, that doesn't mean you can't deploy it on your intranet today. If you're already using Firefox (and if you aren't, you should be), all that's required is a simple plug-in. After that's installed, you can take full advantage of XForms' power, speed, and flexibility..."
[December 05, 2006] "Applying XML Signatures to XForms-based Documents." By John Boyer (Senior Product Architect, IBM). Presentation slides for XML 2006. "The W3C XForms Recommendation provides a standard markup language for documents that allow content creation into the XML data structures that drive business-oriented web applications. The XForms architecture provides an open platform for expressing the core processing model and view of XML data while delegating presentation to a host language most suited to application-specific requirements. This architecture presents an interesting security challenge for digital signatures, which must protect not only data but also its presentation. The W3C XML Signatures Recommendation provides a standardized markup language for expressing digital signatures in XML that secure both XML and binary resources. The usage patterns and features of this language are designed to support the full range of security requirements, so it is important for all features of XML Signatures to be available to XForms-based document authors. Prior researchers have presented an integration of XML Signatures and XForms in which the XForms processor generated an enveloping signature containing the XML data and references to all external resources used to present the data. The solution is good at creating a single signature that follows the XML Signatures maxim 'What you see is what you sign.' However, due to validating signature only on the server, the non-repudiable nature of the signatures is not well-preserved when later users view the signed information. In essence, the system does not adhere to the corollary of the above maxim: 'What you validate is what you see.' On the client-side, core validation must not only occur, but it must be augmented to ensure that signed resources are the ones being used to present the document. One challenging aspect of this unification stems from the design of XForms, in which XML instance data is separated from the document and processed independently. Since the signatures must be added to the data, the XML signature processing model uses the separated data as the resolution to same-document references, not the XForms document containing the data. This paper includes an answer for this problem, which enables document-centric XForms host languages to consume the signature solution. Client-side validation flushes out another issue: multiple signer scenarios. In these cases, the XForms author needs the flexibility to author the references and transforms of the XML signature, which is not possible if the XForms processor generates the references and transforms..." [cache]
[October 03, 2006] "XForms and OpenDocument." By J. David Eisenberg. Updated 2006-08-15 or later. 20 pages. "This tutorial covers the basic concepts of XForms. You can create form controls whose data is bound to parts of an XML data instance, and you can save that data in a local file or send it to a server.The tutorial provides enough information to start using this new technology. Let's say you're in charge of a database of chartered clubs for an amateur sports association. Club directors send you papers like the one in Appendix A, and you enter the data into an XML file, which is used to create an online searchable database of the clubs. Clearly, the better option is to send the club directors a machine-readable document with form fields that they fill in. The directors send the file back to you, and, rather than having to decipher their handwriting and re-enter the data, you run a program to extract the information. The idea of having a document with user-modifiable fields is not a new one, but OpenDocument's use of the World Wide Web Consortium's XForms recommendation is especially noteworthy, because the data that is stored with the document is in XML format, not in some proprietary format dependent upon a single vendor's tools. A form in XForms is described by XML elements. Each form is composed of a model and form controls. The model contains: (1) Instance data - an XML 'template' that will be filled in by information in the form controls. (2) Submission - a description of where the instance data is to be sent and how it is to be sent. A form can have multiple ways of being submitted; one to save the data into a file, one to send to a web URL, another to send to a different URL. (3) Binding - a connection between a node in the instance data and a form control (text box, drop-down menu, etc), or a connection between instance data and a constraint in a model item. XForms is not a stand-alone system; instead, you put the XForms markup into a document and hand the document to an application that is XForms aware. Under the guidance of the bindings, the application handles all the interaction between the controls (which the application owns) and the instance data. In the fine tradition of separating content and presentation, XForms provides the structure; the application provides the presentation. In this case, we put the XForms markup into an OpenDocument word processing document, and hand it OpenOffice.org. Of course, we don't type all the XML elements by hand. Instead, we use the GUI in Openoffice.org to create the form. The first step is to create a new XML forms document from the menu..." [source ODT]
[September 12, 2006] "Introduction to XForms, Part 1: The New Web Standard for Forms." By Chris Herborth (Consultant, Freelance Writer). From IBM developerWorks (September 12, 2006). "XForms is the next generation of Web-based data processing. It replaces traditional HTML forms with an XML data model and presentation elements. In this three-part series, you'll be introduced to XForms and its capabilities, including the basic XForms model and form, the various types of controls, and basic and advanced form submission. Its flexibility and power make it attractive to Web developers, and its small footprint and client-side processing make it attractive to systems administrators. The W3C is currently reviewing XForms 1.1 as a Working Draft document; 1.0 is an official Internet Recommendation, which puts it on par with things like XHTML, PNG, and CSS, and IBM is currently spearheading an effort to merge competing XML-based forms' standards with the features and abilities of XForms. The XForms standard, which has been in discussion for several years now, is supported by quite a few applications (including Firefox, Mozilla, and Seamonkey if you install the XForms extension), and is intended to be an XML replacement for the chaos of HTML forms. Other popular Web browsers support XForms through plugins (such as formsPlayer for Internet Explorer 6, available from Resources). Any standards-supporting browser can also make use of FormFaces, a pure JavaScript XForms implementation that translates XForms to and from standard HTML controls on the client system. Additionally, major products such as IBM Workplace Forms implement XForms. A form's data model — how it behaves when data is submitted, initial values, and more — is separated from its presentation. The same presentation can be interpreted differently based on a style sheet, or whatever is appropriate for the user's browser. A browser running on a cell phone might, for example, use different techniques to display the controls; menus and lists are easier for cell phone users than pop-up choice boxes..." [What about Web Forms? Web Forms 2.0 builds on HTML's existing forms capabilities, adding many of the features found in XForms, but taking a simpler, more backwards-compatible approach. There is a movement underway to combine XForms and Web Forms into a single part of the upcoming XHTML 2.0 specification.]
[August 08, 2006] "XForms for HTML Authors, Part 2." By Steven Pemberton (W3C/CWI). Updated August 08, 2006. "This is the second part of XForms for HTML Authors. Part 1 introduced mostly features that have some equivalent with features from HTML. This part introduces completely new concepts that have no HTML equivalent... Events and actions: XForms uses XML Events for handling events: this is a more flexible way of doing the onclick style of event handling used in HTML. The important thing to know about XML Events is that it uses exactly the same event mechanism as HTML, only written differently... Switch: The switch element allows you to expose and hide different parts of the user interface, for example to give wizard-like behavior. Here is an example that first asks for name, city, and email address, and then asks for favorite food, drink and music... Repeat: Repeat can be used for shopping-cart like behavior where items can be added and deleted. The essence of a repeat is that it binds to a repeating element in an instance... Getting User Interface values from the model: In all examples [up to now], user interface text such as labels have been text directly in the controls. However, XForms allows you to include such text from instance values as well. These techniques often require the use of more than one instance... Defining your own types: if you already have a schema defining some data types, then all you have to do to use it in your XForms is to refer to it from the model element..."
[June 13, 2006] "Develop Forms Using the Visual XForms Designer." By Jan Joseph Kratky, Keith Wells, and Kevin E. Kelly. From IBM developerWorks (June 13, 2006) "In March 2006, the World Wide Web Consortium (W3C) released the second edition of the XForms 1.0 specification. Shortly afterwards, IBM alphaWorks released a new round of free tools to accelerate the development of XForms documents. Newest in this suite of tools is the Visual XForms Designer, which lets you construct forms visually. The Visual XForms Designer integrates with Eclipse, and among the familiar Eclipse constructs are a perspective, a set of views, and an editor with a palette-driven design canvas. This article takes you on a whirlwind tour of the Visual XForms Designer. Discover how the tooling helps with the major phases of form development with XForms: define data, create user interface controls, provide for submission, and test the finished form... Of course, the Visual XForms Designer has more to offer. The best way to become familiar with it is to install it and experiment with it yourself. You can install the Visual XForms Designer from IBM alphaWorks. The designer comes with extensive documentation built into the Eclipse help system. This documentation includes an animated tutorial that takes you, with detailed step-by-step instructions, through the creation and testing of a form. Finally, like most alphaWorks releases, the Visual XForms Designer has its own user forum that you can use to share your questions and comments. While you're there, you might want to take a peek at some related alphaWorks tooling: the XML Forms Generator and Compound XML Document Toolkit..."
[April 20, 2006] "XForms: The Big Picture and the Details." By John Boyer (Senior Product Architect, IBM Workplace Forms). IBM Blog 'Workplace Forms and Next Generation Web Applications'. April 20, 2006. "XForms does seek to standardize the language for the core information processing asset expressed within a form. XForms does not seek to standardize the exact presentation of a user interface. XForms delegates this task to different XML host languages like XHTML or XFDL (or others in the future like, hopefully, VoiceXML). These host languages exist to satisfy different requirements that exist beyond the core information processing requirements, but XForms allow us to design the underlying application once and handle presentment and other orthogonal requirements as the separate issues that they are..." See also "What XForms Does, and What It Doesn't Do," [April 14, 2006]: "The purpose of XForms is to express the core XML data processing asset used in sophisticated data collection scenarios. In fact, it would be better if XForms were called the XML data processing language (XDP or XDPL) because XML is about standardizing data and about 80% of business transactions are based on filling out some kind of form to collect the transactional data. An XForm contains one or more XML data instances. An instance is an arbitrarily structured XML data document that is typically an instance of some XML schema that expresses the static validation rules for a target namespace. One can write an XForm without an XML schema by just expressing the XML data in an instance. This is because XForms provides other channels of data validity checking that can be easier to work with when only simple data type validation is needed. For example, you can use an XForms type declaration to associate an xsd:date or similar data type to an XML data node without writing an XML schema for your XForm. But XForms validity checking is also dynamic, in recognition of the fact that validity of some values can be based on other values or the aggregation of other values. For example, in an interlibrary article request, the upper bound page number in the journal must not be less than the lower bound page number. Or, the user is only authorized to make a purchase order with less than $10,000 total value. The latter example is important because it leads to the conclusion that we not only need a way of testing data values relative to other data values, but also that we need a way of calculating data values that are then used in validity tests..." See thread responses in the blog entry from Joseph Ottinger and others, TheServerSide.com.
[March 30, 2006] "Update of IBM ETTK - Compound XML Document Toolkit." By Kevin E. Kelly, Jan Joseph Kratky, Steve Speicher, and Keith Wells. From IBM alphaWorks (March 30, 2006). "The Compound XML Document Toolkit is a standards-based, schema-driven toolkit for mixed-namespace XML documents; the new version contains support for Java 1.5.0. A compound XML document combines XML mark-up from several namespaces into a single physical document. A number of standards exist, and continue to be developed, that are descriptions of XML mark-up within a single namespace. XHTML, XForms, XML Events, Scalable Vector Graphics (SVG), VoiceXML, and MathML are prominent examples of such standards, each having its own namespace. Each of these specifications focuses on one aspect of rich-content development: XForms focuses on data collection from end-users, SVG on graphics, and MathML on the display of mathematical notations. To authors, each of these standards is useful and important. However, it is the combination of elements of any number of these standards that lends true flexibility and power. A document may exist in order to be displayed within a Web browser for the purpose of displaying an input form, a scalable graphic, and a bit of mathematical notation, all on the same page. XHTML, XForms, SVG, and MathML, respectively, serve these needs and could, therefore, be combined into a single multi-namespace or compound document. The Compound XML Document Toolkit (formerly Compound XML Document Editor) is an Eclipse plug-in that provides for the creation, directed editing, and serialization of such documents. The Compound XML Document Toolkit uses XML schemas to define the semantics of constructing documents spanning one or more namespaces. Those semantics include the order and placement of elements, the allowable child elements, and available attributes for each element... As an Eclipse plug-in, the Compound XML Document Toolkit is easily integrated into an installation of Eclipse or one of the many Eclipse-based development tools..."
[March 20, 2006] "Why XForms Matter, Revisited." By Kurt Cagle. From O'Reilly Developer Weblogs (March 19, 2006). "A profound change is likely about to shake up your world if you're a web developer, one that I suspect will make the recent efforts in the AJAX space pale in comparison as far as its effect. Very quietly, over the last few weeks, the Mozilla team has been upgrading their XForms capabilities through the use of an XForms extension... I've been working a lot lately with mixed XML/Javascript frameworks, and curiously enough, the more complex the applications become, the more that they in fact begin to resemble — well, XForms. You have one or more XML data stores that can represent anything from a personal schema to a description for an entire set. You have a series of bindings that determine the boundaries and secondary processing of data between components, you have event notifiers that get passed from object to object in a subscription oriented framework. All of these facets, and more, are critical pieces of the XForms space. You can create some incredibly rich 'web experience' applications that are mixed XHTML and XForms, and can do so in a remarkably short amount of time. XForms bears about as much resemblance to HTML forms as a Bengal tiger has to a ferret... XForms is not a complete solution, though its usually close to it. Sometimes you need to write extensions, and many XForms engines have mechanisms for extending the default XPath implementation in various ways. Additionally occasionally you will run into situations where you want to replace the default XForms standard controls — for example, turning an <xf:output> element into an image display control. The XForms model in this case works very well with other binding languages, such as Mozilla's XUL or the SVG sXBL binding language... Given the rising proliferation of component toolkits, I see a coming period where everyone's going to be trying to get THEIR component interfaces accepted as the 'standard' ones. The XForms components actually handle almost all of these cases, provides a standard, open, non-proprietary solution that suffers only from lack of education and exposure, and with its presence now in Mozilla — and numerous versions available in IE, including both ActiveX and pure Javascript versions — I see XForms poised to become the de facto forms technology within the browser world..."
[April 2005] "XForms & Cause-and-Effect Programming. A Clean Separation of Presentation, User Interface, and Business Processing Model." By John M. Boyer (PureEdge Solutions). From Dr. Dobb's Journal #371 Volume 30, Issue 4 (April 2005), pages 32-37. "Forms provide a fundamental way in which users interact with web applications. However, the now familiar HTML-based forms have shortcomings ranging from poor integration with XML to device dependence. To address these problems, the W3C has turned to XForms, an application that combines XML and forms. XForms combines its own vocabulary with that of XPath and XML Schema to allow the expression of the core business processing model of a web-based application. This includes not just a structured XML-based data model, but also many constructs that simplify the application-design experience, including a declarative business rules engine for automatic calculation of data values and other properties, input validation by XML schema and dynamic constraints, event-driven action sequences, intent-based user-interface definition, and language features for specifying the properties of data submissions. In essence, the XForms processing model provides a cause-and-effect programming paradigm that backs user-initiated and event-driven modifications of data with a declarative business rules engine. With XForms, you define a business processing model that includes: (1) Instances of XML data to be processed. (2) XML schema for the data instances. (3) Declarative business rules describing the calculated relationships among the data. (4) Declarative business rules defining properties of and dynamic constraints on the data. (5) Event-driven invocation of imperative action sequences. (6) An intent-based user interface definition that provides the core behaviors of the subsuming host language's presentation layer. (7) Definitions for submission of XML data..."
[January 27, 2004] "Learn XForms Today: XForms Institute." By Micah Dubinko. In O'Reilly ONLamp.com (January 05, 2004). "Readers have asked for a gentler tutorial to W3C XForms, and others have asked to see some examples of 'real-world' XForms. Here are both, together on one fun site, XForms Institute (Interactive XForms School). The XForms web site has what you'd expect from a tutorial: progressive lessons, each building upon the last. It also has interactive quizzes, written without script in XForms. These run fine in nearly any browser, thanks to a remarkable Flash program called DENG, the Desktop Engine. In a mere 120k of SWF files, this small applet implements a huge swipe of XForms, XHTML, and CSS level 3. Each live example includes a 'View Source' link so that you can see how it works in the full context of a complete document..." See also: (1) the XForms Institute RSS Channel and the online book XForms Essentials.
[January 27, 2004] "XForms 1.1 Requirements." Edited by John Boyer (PureEdge Solutions Inc), Roland Merrick (IBM), and Sebastian Schnitzenbaumer (SAP). Produced by members of the W3C XForms Working Group. W3C Working Group Note. 26-January-2004 Version URL: http://www.w3.org/TR/2004/NOTE-xforms-11-req-20040126/. Latest version URL: http://www.w3.org/TR/xforms-11-req/. "XForms is an XML application that represents the next generation of forms for the Web. This document specifies the requirements for XForms 1.1. XForms Version 1.1 will build upon the solid foundation set forth by XForms 1.0 -- the Next Generation of Web Forms. The 1.1 version makes incremental improvements over version 1.0 to provide expanded behaviors for the existing and established XForms Model-View-Controller Framework and by embracing SOAP. It also makes adjustments to XForms to facilitate its adoption in other host languages. The incremental improvements to XForms 1.0 include Repeat/Insert Enhancements; Bind Attribute on Bind Element; Email-address Datatype; XForms Processor as XML Editor; Power Function; Referencing Bind Sites in XPath Expressions; and Improved Search for Instance Data by Key Value... XForms expresses a processing model and user interface for the modification of data expressed in XML. Currently, the XML can be obtained from within the document or from a server. It would be useful to allow XForms processors to edit XML obtained from the local computer, and to return the edited XML to the local computer. To avoid security issues, this cannot be done by simply using a file scheme in the src attribute of the XForms instance element. [The requirement is to] allow an XForms processor to provide an XML editing capability... To increase widespread adoption of XForms in web applications, it is necessary to reduce the difficulty of authoring XForms in XHTML, which is currently hindered by the incessant need to flip between the host language namespace and the XForms namespace when authoring the user interface component of a form..."
[January 23, 2004] "Next-Generation E-Forms." By Jon Udell. In InfoWorld (January 23, 2004). ['Paper will never die. Instead, it's going digital and providing a better, XML-enabled way to enter critical data.'] "The transition from paper to electronic forms seems like a no-brainer. Who wouldn't want to abolish the anachronism of paper forms in capturing and relaying business-critical information? ... E-forms provide a more accurate, intuitive replacement for paper forms than plain HTML forms or antiseptic data entry screens -- and in the latest e-forms software, they wrap captured data in XML format. These products also provide design tools that allow you to build attractive XML-enabled forms quickly and easily. Microsoft's XML-oriented InfoPath, which shipped with Office 2003 in October, is now deployed and in use. Adobe plans to ship a beta version of its PDF- and XML-oriented forms designer in the first quarter of this year. And e-forms veterans such as PureEdge and Cardiff, whose offerings are built on an XML core, are lining up behind XForms, an e-forms specification that became an official W3C recommendation in October 2003. Common to all these vendors' approaches is the use of XML as the bridge between applications that gather data from end-users and the back-office systems that absorb that data... Within this broad XML consensus, there are differences that reflect the legacies of Microsoft, Adobe, the e-forms vendors, and the customers they serve. The relationship of e-forms solutions to printed forms, and to the processes that surround them, is a major source of differentiation. For all their inefficiency as data-gathering instruments, printed forms are highly engineered information displays. People who scan and process forms often rely on their layout and typography, which is why some industries -- insurance, for example -- standardize the look and feel of forms as well as their content... XForms, which can be thought of as HTML forms on steroids, specifies a processing model and set of user-interface controls that are device-neutral and platform-independent. So a form's interactive behavior and to some extent its business logic can be made portable, too. A key aspect of that portability is the relationship of XForms to its so-called host markup language. In one implementation, the XML syntax defining an XForms form might be embedded in a Web page, using HTML as its host language, and a list of choices would be rendered as an HTML pick list. In another implementation, the same form definition might be embedded in a smartphone application, using VoiceXML as its host language, and the same list of choices would be rendered as on a voice menu..."
[December 09, 2003] "Microsoft, Adobe and W3C to Shake Up Electronic Forms Market." By Bill Trippe. In The Gilbane Report Volume 11, Number 8 (October 2003), pages 1-10. "eForms technology has grown by providing better functionality in at least three areas: (1) improvements in the rendering of the forms; (2) Improvements in the validation and user interface; (3) improvements in the interoperability of the forms technology with other software... InfoPath is an impressive new offering, but it will not immediately dominate the eForms market... InfoPath is also, intentionally, not a total eForms solution. Several of the existing eForms vendors have more comprehensive product offerings (e.g., Cardiff's Liquid Office), some of them do a better job of providing a more open and standards-based solution (e.g., PureEdge), and several of them successfully deliver page fidelity (what others might call pixel perfect form) to the original paper forms... InfoPath will propagate with the latest version of Microsoft Office; typically it takes more than a year for the latest version of office to replace earlier versions on the majority of desktops. In the meantime, Adobe will be introducing their new Forms Designer product, and continuing to emphasize the need for page fidelity and presentation in eForms applications. Adobe also can already point to the significant number of applications that already leverage Acrobat and the product lines they added in the Accelio acquisition. The good news for the eForms market is that Microsoft and Adobe bring new strategic thinking to what has been a relatively small market. InfoPath will have the immediate effect of bringing eForms to the attention of the CIO, and will help bring a new focus to improving the client experience for the business user. As organizations deploy more applications to a distributed workforce and partners, eForms will become a more strategic piece of the ECM mix. Indeed, eForms have a growing role beyond ECM itself, as they are emerging as the primary interface between people, process and programs. It is no accident that the significant initiatives nowSarbanes-Oxley, HIPAA, and the likeare forms-centric. Moreover, initiatives such as Sarbanes-Oxley are all about improving business process management while making access to both content and data more transparent and comprehensive. To this end, eForms must continue to evolve from a standalone artifact to a flexible interface intimately connected to enterprise infrastructure. The implications of this are profound. The vendors and organizations that can successfully manage this evolution will realize more success, more quickly, and will lead the next wave in integrated content and information technology..."
[October 14, 2003] "PureEdge Strengthens Support for XForms. XForms 1.0 Released Today as a W3C Recommendation." - "PureEdge Solutions Inc., the leader in secure, XML forms-based business process automation, congratulates the World Wide Web Consortium (W3C) and the XForms Working Group on its release today of XForms 1.0 as a W3C Recommendation. PureEdge is a founding member of the W3C's XForms Working Group. 'We're pleased to have co-authored XForms 1.0,' said Dr. John Boyer, a PureEdge Senior Product Architect and Research Scientist. 'PureEdge has played a leading role in shaping open standards based on our secure and dynamic XML forms language, XFDL.' Dr Boyer played an active role in the working group and is the author of the computation engine featured in XForms 1.0. PureEdge electronic forms are 100% native XML. XFDL, the original XML e-forms language published as a W3C Note, provides a secure and auditable equivalent to paper transactions. It binds together questions, answers, presentation format, logic, attachments and metadata in a single, signable XML file. To meet the rigorous security and functionality requirements demanded by many government, financial services and insurance organizations, PureEdge enables XML data markup, in any XML vocabulary and conforming to any XML schema, to be deployed with the key security features and rich, dynamic presentation functionality of XFDL. By transforming XFDL into a host presentation and security layer for XForms, PureEdge will be able to scale up XForms applications to any level of security anytime. With the movement of XForms to recommendation status, PureEdge will move to provide a fully XForms compliant implementation of XML model concepts already inherent in XFDL..."
[August 19, 2003] "Hands-on XForms. Simplifying the Creation and Management of XML Information." By Micah Dubinko (Cardiff Software). In XML Journal Volume 4, Issue 8 (August 2003). "Organizations have evolved a variety of systems to deal with the increasing levels of information they must regularly process to remain competitive. Business Process Management (BPM) systems presently take a wide variety of shapes, often including large amounts of ad hoc scripting and one-off implementations of business rules. Such systems tend to be developed incrementally, and pose a significant obstacle to continued development and maintenance. A World Wide Web Consortium (W3C) specification called XForms aims to change this situation. This article compares XForms to ad hoc solutions to produce a real-life application: the creation of XML purchase orders... Of the several efforts that are under way to define XML vocabularies for business, the most promising seems to be UBL, the Universal Business Language. At the expense of being slightly verbose, the vocabularies defined by UBL do a remarkable job of capturing all of the minor variations that occur in real-world business documents across diverse organizations. For the sample application I chose a purchase order... Microsoft InfoPath, currently in beta as part of Office System 2003, offers a better user experience than HTML forms, but still relies heavily on scripting through an event-driven model. As the remainder of this article will show, a declarative approach as used in XForms can eliminate a substantial amount of complexity from the overall solution. Since XForms is designed to be used in concert with a 'host language,' I chose a combination of XHTML 1.1 and XForms for the solution, even though a DTD for the combined language isn't available... The two main challenges facing developers deploying XForms solutions today are deciding on a host language and configuring stylesheets for all target browsers. Eventually XHTML 2.0, including XForms as the forms module, will be finalized, providing a known and stable target for browsers to implement and designers to write toward. Until that time, however, a reasonable approach is to use XForms elements within XHTML 1.0 or 1.1, without the luxury of DTD validation... XForms has made vast strides in 2003, becoming a technology suitable for production use by early adopters. Already, businesses are using XForms to produce real documents. The combination of an open standard with a wide variety of both free and commercial browsers makes a powerful business case for deploying XForms solutions. Unlike many other XML standards, XForms has remained small, simple, and true to its roots, addressing only well-known and well-understood problems, and providing a universal means to express solutions to these problems. Part of the appeal of XForms is the reuse of proven technologies, such as XPath, for which developers are more willing to invest the time necessary for learning. XForms can also leverage existing XML infrastructure, including XML Schema and Web services components..." A fuller treatment is presented in "UBL in XForms: A Worked Example." [alt URL]
[August 19, 2003] "XForms Building Blocks." By Micah Dubinko (Cardiff Software). Draft Chapter 2 (20 pages) from XForms Essentials: Gathering and Managing XML Information, [to be] published by O'Reilly & Associates as part of the Safari Bookshelf. 'More Than Forms; A Real-World Example [based upon UBL]; Host Language Issues; Linking Attributes. "This chapter goes into greater detail on the concepts underlying the design of XForms, as well as practical issues that come into play, including a complete, annotated real-world example. A key concept is the relationship between forms and documents, which will be addressed first. After that, this chapter elaborates on the important issue of host languages and how XForms integrates them... Despite the name, XForms is being used for many applications beyond simple forms. In particular, creating and editing XML-based documents is a good fit for the technology. A key advantage of XML-based documents over, say, paper or word processor templates, is that an entirely electronic process eliminates much uncertainty from form processing. Give average 'information workers' a paper form, and they'll write illegibly, scribble in the margins, doodle, write in new choices, and just generally do things that aren't expected. All of these behaviors are manually intensive to patch up, in order to clean the data to a point where it can be placed into a database. With XForms, it is possible to restrict the parts of the document that a given user is able to modify, which means that submitted data needs only a relatively light double-check before it can be sent to a database. One pitfall to avoid, however, is a system that is excessively restrictive, so that the person filling the form is unable to accurately provide the needed data. When that happens, users typically either give bad information, or avoid the electronic system altogether..." About the book XForms Essentials: "The use of forms on the web is so commonplace that most user interactions involve some type of form. XForms -- a combination of XML and forms -- offers a powerful alternative to HTML-based forms. By providing excellent XML integration, including XML Schema, XForms allows developers to create flexible, web-based user-input forms for a wide variety of platforms, including desktop computers, handhelds, information appliances, and more. XForms Essentials is an introduction and practical guide to the new XForms specification. Written by Micah Dubinko, a member of the W3C XForms working group and an editor of the specification, the book explains the how and why of XForms, showing readers how to take advantage of them without having to write their own code. You'll learn how to integrate XForms with both HTML and XML vocabularies, and how XForms can simplify the connection between client-based user input and server-based processing. XForms Essentials begins with a general introduction to web forms, including information on history and basic construction of forms. The second part of the book serves as a reference manual to the XForms specification. The third section offers additional hints, guidelines, and techniques for working with XForms..." See also the preceding bibliographic entry, online version of the book, and the author's XML and XForms blog.
[April 15, 2003] "Simplifying the Development of Transactional Web Apps." By David Litwack. In XML Journal Volume 4, Issue 04 (April 2003). "XForms, the next generation of forms to be included in the XHTML standard, and now a W3C Candidate Recommendation, improves on HTML forms by cleanly separating data, logic, and presentation. This new standard will not only make development better structured, but will also pave the way for a new generation of development tools. XForms arrives as an ever-increasing percentage of information is moving across the Internet as XML. As the use of Web services increases, more business systems are being exposed using this standard. With new, easy-to-use tools to define XML integration, transformation, and mapping, there will soon be a huge repository of information and transactions available as distributed XML. The primary benefits of XForms are abstract description of presentation, independent of device; data binding between presentation components and XML instance data; and a range of interaction and logic capabilities without procedural programming. XForms provides an abstract metadata description of presentation components such as selection lists and edit boxes. At runtime, this metadata is processed by 'renderers' - server- or client-side components that translate the abstract to a specific implementation. As a result, XForms may be flexibly rendered in browsers by generating XHTML (either from the server or via a built-in or plug-in renderer), in rich clients by Java or Windows renderers, in specialized document formats such as PDF, and eventually by device-specific, vendor-supplied renderers in a variety of handheld devices... XForms presentation components may be bound to XML instance data, moving this burden to the underlying renderer. XForms will allow for end-to-end Web services, making the consumption of services as simple and high-level as the creation. Most dramatically, XForms will enable the next generation of development tools to be more appropriate and productive for the mainstream business developer..." [alt URL]
[February 03, 2003] "XForms for Managing Forms-Based Data." By Anthony Tomasic. In XML & Web Services Magazine Volume 3, Number 7 (December 2002/January 2003), pages 24-27. ['XForms defines a mini XML-based programming language that simplifies data-entry implementations dramatically.'] "The W3C's draft XForms standard defines a set of XML elements that expand vastly the power of data-entry devices, such as browsers, to capture and validate forms-based data. The XForms Working Group has focused on device independence, data validation, and improved internationalization support to give you a new, elegant, and powerful way to code data-entry systems. By centralizing form behavior and data validation into a single location, XForms eliminate the hassle of browser scripting, the associated quagmire of multiple browser-language versions, and the mind-numbing coding of data-validation checks... You can leverage your knowledge of the existing W3C standards XForms builds on -- XML, XHTML, Cascading Style Sheets (CSS), XML Schema, XPath, and XML events -- for a lower XForms learning curve. XForms' features help you spend more time on creative, application-specific work and less time on routine infrastructure... A traditional implementation of this system would consist of four pieces. First, Java Server Pages (JSP) present a form, and, second, JavaScript client code validates some of the data entry. Data that users enter on a form goes to a server by HTTP POST, and the result is in Java. If data-entry errors are detected by the server-side validation code -- the third component -- the system delivers another form (containing the partially valid data the user entered on the previous form) to the user. Otherwise, the result of data entry is transformed into the fourth element -- an XML document -- and sent on for the next processing step. Web designers and developers might write a thousand lines of JSP, JavaScript, and Java code for even a simple form. An XForms-based implementation of the same system consists of three parts. The first is a set of XForms documents the Web designers and developers write. The second is a shared XML schema data model a developer or XML administrator defines. The third part -- an XForms standard engine -- interprets the XForms documents and XML schema. Each XForms document handles all four aspects of the traditional implementation. The documents reference the shared XML schema, designed explicitly for data entry, that provides explicit support for data validation. A user browser generates an HTTP request for an XForms document; the XForms engine manages the interaction with the user according to the rules defined in the XForms document; the XForms engine validates data entry; and valid data-entry results are delivered to the server as XML documents, ready for the next step in processing. This system requires far less time and labor to construct than the traditional implementation, and it's easier to modify..."
[January 31, 2003] "XML Forms, Web Services and Apache Cocoon." By Ivelin Ivanov. From XML.com January 29, 2003. ['Ivelin Ivanov introduces Cocoon's XMLForms features, which allow a model-view-controller paradigm for web applications, helping to separate the user interface from the business logic.'] "Server side business logic is often invariant with regard to client devices. An email client supports the same basic operations whether it's used from a cellular phone, PDA, or a PC. To address the needs of web developers who build applications for a variety of devices, the W3C has formed the XForms working group. In this article we discuss the Cocoon XMLForm framework's separation of the purpose from the presentation of a form, maximizing its reusability for a variety of client devices. We also explain how this technology allows us to extend web applications to Web Services. Apache Cocoon XMLForm is aligned to a large extent with the W3C XForms standard. While XForms requires that client devices understand the XForms markup, XMLForm can be used with any browser for any client device. The trade-off for this convenience is that XMLForm lacks some of the client side features of XForms, such as events and actions... XMLForm is a middle-tier framework based on the MVC (Model-View-Controller) design, which combines the best from Jakarta Struts, W3C XForms, and Schematron... XMLForm allows developers to build and edit an XML document, called the form model or instance -- subject to constraints from some schema: WXS, Schematron, and so on -- by interacting with a series of form pages... [The article] introduces a new perspective on form handling in web applications, a technique for connecting the business logic and the UI layer, while preserving a thin line which cleanly separates them. Programmers can now focus on the implementation of the application workflow without the burden of tedious HTML coding. Web page authors on the other hand can work on the presentational aspects of the application without knowing how to code in Java or even run the application server. Usability experts can sketch UML activity diagrams and write the initial XML form documents. And quality assurance professionals can write regression tests against the web pages in their XML stage, rather than manually testing poorly structured HTML..."
[September 17, 2002] "What Are XForms?" By Micah Dubinko. From XML.com (September 11, 2002). ['As the XForms specification evolves at the W3C, Micah has been keeping his article up to date. This week we're publishing the third revision, which includes changes made to XForms in August.'] "A new technology, XForms, is under development within the W3C and aims to combine XML and forms. The design goals of XForms meet the shortcomings of HTML forms point for point: (1) Excellent XML integration [including XML Schema]; (2) Provide commonly-requested features in a declarative way, including calculation and validation; (3) Device independent, yet still useful on desktop browsers; (4) Strong separation of purpose from presentation; (5) Universal accessibility. This updated article gives an introduction to XForms, based on the 21-August-2002 Working Draft, which is described as being a close precursor to a Candidate Recommendation draft... What does the future hold for XForms? One certainty is that connected devices are becoming more diverse than ever, appearing in all shapes and sizes. Web forms no longer lead sheltered lives on the desktop. By offering a more flexible, device-independent platform, XForms will provide interactivity on such devices. Most organizations now have substantial investments in XML. Since XForms technology reads and writes XML instance data, it enables existing investments to be leveraged as building blocks in a larger system more smoothly than with ordinary XHTML forms. Additionally, Web Services (or the Semantic Web, depending on your upbringing) will increase the amount of information interchange over the Web, which will in turn increase the need for information to be entered -- through XForms. Those who have struggled with traditional forms and associated scripting will appreciate the consistent set of form controls and declarative actions in the specification, as well as the powerful and familiar XSLT-like processing model. Calculations, validations, and business logic will also be expressible without scripts. Updated forms are one of the major changes in XHTML 2.0, the most significant change to HTML since its conception in 1993. Developers and users alike are looking forward to the final W3C Recommendation for XForms..."
[September 10, 2002] "Get Ready for XForms. Next generation of Web forms will help you build online forms that are extensible and suitable for any platform." By Joel Rivera and Len Taing (Summer Interns, IBM Research). From IBM developerWorks, XML Zone. September 2002. ['Traditional HTML forms violate many of the tenets of good markup language design, frequently mixing presentation and data. In this article, Joel Rivera and Len Taing introduce you to XForms, an extension of XHTML that represents the next generation of Web forms. Though XForms is still in an embryonic state, it holds great promise: For instance, a form written with XForms can be written once and displayed in optimal ways on several different platforms. This article will give you a head start on this important emerging XML technology.'] "XForms enables support for multiple devices and structured form data, like XML documents. With XForms, developers can also generate dynamic Web forms without scripting, to include multiple forms within the same page, and to constrain data in various useful ways. Finally, while each of the XForms parts -- namely the data model, the view, and the controller -- is completely separable and usable with other technologies, significant additional value can be realized through how well these parts integrate together into an application. In this primer, we present an introduction to some of the most useful aspects of XForms, and guide you through a simple application example. This article is based on the XForms 1.0 Working Draft, issued in July 2002... With XForms, you can define Web forms in a way that successfully separates purpose from presentation. You focus more effort on the content of the form and the data being collected, and less on the style of presentation. The language defines a powerful event model that obviates the need for custom scripts to handle simple, form-related tasks. With XForms, the developer's primary focus is on the data to be collected. Using standard XML schemas, the structure and type of the data is explicitly defined. XForms extends this model by allowing for the specification of additional constraints and dependencies. The XForms processor evaluates and enforces these constraints without the need for additional code. The processor checks data types and constraints before the data is submitted for processing. The XForms specification also allows for the creation of dynamic forms through data-driven conditionality. You no longer must write special code to generate custom forms based on user responses. XForms can adapt forms on the fly, as data is collected and conditions change. Navigation through XForms is handled by the XForms event model, independent of the client rendering. You can present the same XForms as a single page on one client and as multiple pages on another, without having to worry about saving state and presenting appropriate navigation controls. Because of its concise specification and powerful features, forms created with XForms tend to be much easier to maintain than traditional Web forms. Code is not intermixed with presentation markup. Additional data type checking code is not necessary. Data structure is divorced from form presentation markup..."
[October 01, 2001] "Interactive Web Services with XForms." By Micah Dubinko. From XML.com. September 26, 2001. ['The W3C's new XForms technology can be used to attach user interfaces to web services, making efficient use of existing infrastructure. Micah shows how the common core of XML between XForms and web services simplifies the creation of user interfaces.'] "A form -- whether a sheet of paper or a web page -- represents a structured exchange of data. Web services, as typified by emerging standards like SOAP, WSDL, and UDDI, is an excellent approach to exchanging data in a structured way, although usually the exchange is between machines. Since computers are much better at, well, computing, web services is an important and overdue development in the evolution of the Web. Nevertheless, web services applications exchanging information only between machines isn't very interesting: lots of electronically accessible information originates with ordinary human beings... WSDL talks about transmission primitives between endpoints defined for Web Services, including (1) Request-response (The endpoint receives a message, and sends a correlated message); (2) Solicit-response (The endpoint sends a message, and receives a correlated message). It's not hard to imagine either of these scenarios applying to an 'endpoint' constituted by a person using a networked device. Such a point of view is attractive since it simplifies the creation of web applications that contain the necessary semantic hints to be equally valuable to people or machines. For this concept to gain widespread acceptance, however, a better method is needed to combine forms and XML across a wide variety of devices, including alternate accessibility modalities (such as audio browsers), and to do so in a streamlined way that fits well with XML and Schema-based back ends. XForms provides this critical link between people and interactive web forms, enabling the best of both worlds: a Web populated with resources which are accessible to humans and machines... Authoring XForms is simple, taking only two steps, and you can reuse Schemas and instance data already available in a web services environment. The main issue at this point is the lack of conforming XForms Processors with which to utilize forms on the client side. The XForms specification is still a moving target, still in the Working Draft phase. The XForms Working Group is actively seeking feedback and implementation experience. In the short term, server-side tools that transform XForms into browser-digestable HTML are a good solution..." See also the W3C XForms web site.
[September 13, 2001] "What Are XForms?" By Micah Dubinko. From XML.com. September 12, 2001. "XForms are the new XML-based replacement for web forms. Think about how many times a day you use forms, electronic or otherwise. On the Web, forms have truly become commonplace for search engines, polls, surveys, electronic commerce, and even on-line applications. Nearly all user interaction on the Web is through forms of some sort. This ubiquitous technology, however, is showing its age. It predates XML by several years, a contributing factor to some of its limitations: poor integration with XML, device dependent, running well only on desktop browsers, blending of purpose and presentation, [and] limited accessibility features. A new technology, XForms, is under development within the W3C and aims to meld XML and forms. The design goals of XForms meet the shortcomings of HTML forms point-for-point: (1) Excellent XML and Schema integration; (2) Device independent, yet still useful on desktop browsers; (3) Strong separation of purpose from presentation; (4) Universal accessibility. This document gives an introduction to XForms, based on the 28 August 2001 Working Draft. The most important concept in XForms is 'instance data', an internal representation of the data mapped to the more visible 'form controls'. Instance data is based on XML and defined in terms of XPath's internal representation and processing of XML. It might seem strange at first to associate XPath and XForms. XPath is perhaps best known as the common layer between XSLT and XPointer, not as a foundation for web forms. As XForms evolved, however, it became apparent that forms needed greater structure than was possible with simple name-value pairs, as well as syntax to reach into the instance data to connect or "bind" form controls to specific parts of the data structure. XForms processing combines input and output into the same tree: (1) From an input source, either inline or an XML document on a server, "instance data" is parsed into memory. (2) Processing of the instance data involves interacting with the user and recording any changes in the data. (3) Upon submit, the instance data is serialized, typically as XML, and sent to a server... The XForms specification fully adopts the XML Schema data-types mechanism (including a narrower subset for small devices such as mobile phones) to provide additional data collection parameters such as maximum length or a regular expression pattern like an email address. This, combined with form-specific properties, is called the 'XForms Model' and is the basis for creating powerful forms that aren't dependent on scripts..." See the XForms 1.0 Working Draft published 28-August-2001.
[August 21, 2000] Members of the W3C XForms working group have released a working draft document specifying the XForms Requirements. Reference: W3C Working Draft 21-August-2000, edited by Micah Dubinko (Cardiff), Sebastian Schnitzenbaumer (Mozquito Technologies), Malte Wedel (Mozquito Technologies), and Dave Raggett (W3C/HP). This document has been produced as part of the W3C work on XForms. "Forms were introduced into HTML in 1993. Since then they have gone on to become a critical part of the Web. The existing mechanisms in HTML for forms are now outdated, and W3C has started work on developing an effective replacement. This document outlines the requirements for 'XForms', W3C's name for the next generation of Web forms. After careful consideration, the HTML Working Group decided that the goals for the next generation of forms are incompatible with preserving full backwards compatibility with browsers designed for earlier versions of HTML. A forms sub-group was formed within the HTML Working Group, later becoming the XForms Working Group. It is our objective to provide a clean new forms model ('XForms') based on a set of well-defined requirements. The requirements described in this document are based on experience with a broad spectrum of form applications. This document provides a comprehensive set of requirements for the W3C's work on XForms. We envisage this work being conducted in several steps, starting with the development of a core forms module, followed by work on additional modules for specific features. The Modularization of XHTML provides a mechanism for defining modules which can be recombined as appropriate for the capabilities of different platforms." [cache]
[August 15, 2000] The XForms Working Group, operating within the domain of the W3C HTML Activity, has released a revised (interim) working draft document for the XForms data model: XForms 1.0: Data Model. Reference: W3C Working Draft 15-August-2000, edited by Micah Dubinko (Cardiff), Sebastian Schnitzenbaumer (Stack Overflow), and Dave Raggett (W3C/HP). W3C 'XForms' is the next generation of Web forms: "The key idea is to separate the user interface and presentation from the data model and logic, allowing the same form to be used on a wide variety of devices such as voice browsers, handhelds, desktops and even paper. XForms bring the benefits of XML to Web forms, transferring form data as XML. XForms aim to reduce the need for scripting, and to make it easier to achieve the desired layout of form fields without having to resort to using nested tables etc." The present draft effectively obsoletes the previous working draft document issued on 06-April-2000. The XForms Working Group is currently "studying how to support forms where the data model is defined by an XML Schema plus form specific properties. The plan is for the next revision to this Working Draft to provide a description of the functional requirements for the XForms data model and logic, together with proposals for meeting these requirements using XML Schema plus XForms property annotations, and an alternative lighter weight syntax aimed at HTML authors. Later specifications will focus on the user interface aspects of XForms, and the means to submit, suspend and resume forms." Further information on the XForms activity may be found in the XForms Working Group Charter and the XForms Requirements document.
[April 19, 2000] W3C Working Draft for the XForms Data Model - 'Next Generation Web Forms'. The W3C has released an initial working draft specification for the XForms 1.0: Data Model, complementing the XForms Requirements document published on March 29, 2000. Reference: W3C Working Draft 06-April-2000, edited by Micah Dubinko (Cardiff Software), Stacy Silvester (Cardiff Software), Sebastian Schnitzenbaumer (Stack Overflow), and Dave Raggett (W3C/HP). Part of the HTML Activity, XForms is being developed within the HTML working group. Document abstract: "This document presents a proposal for explicitly representing data models for XForms, the next generation of Web forms. Apart from other mechanisms described in this document, it is based upon the framework provided by XML Schema. While XML Schemas are used to define XML grammars, the XForms data model is intended to capture the device-independent data model and logic of form-based Web applications. Although both specifications address different problems, they overlap in the definition of simple datatypes. Therefore, the datatypes defined in this specification are a close match to the datatypes found in XML Schema Part 2: Datatypes. In some cases, however, the XForms datatypes differ from the ones in XML Schema, due to different usage scenarios and target audiences. In Appendix A, an XSLT filter will be provided for translating the XForms data model into the corresponding syntax defined in the XML Schema specifications. A later specification will focus on the user interface aspects of XForms." Additional description of 'XForms - the next generation of Web forms' can be found on the W3C web site. [cache]
[March 29, 2000] XForms Requirements. The W3C HTML Working Group has issued a working draft specification relevant to the next generation of web forms: XForms Requirements. Reference: World Wide Web Consortium Working Draft, 29-March-2000; edited by Micah Dubinko (Cardiff Software), Sebastian Schnitzenbaumer (Stack Overflow), Malte Wedel (Stack Overflow), and Dave Raggett (W3C/HP). The document "provides an overview of the requirements currently under discussion within the Forms Subgroup of the HTML Working Group. Forms were introduced into HTML in 1993 and have proven to be a valuable part of many Web pages. The experience of the last few years has led to demands for improvements to HTML forms. XForms are a major revision of HTML Forms. Key goals for the next generation of web forms include ease of migration, improved interoperability and accessibility, enhanced client/server interaction, advanced forms logic, support for internationalization and greater flexibility in presentation. [The working group] envisages this work being conducted in several steps, starting with the development of a core forms module, followed by work on additional modules for specific features. The Modularization of XHTML provides a mechanism for defining modules which can be recombined as appropriate to the capabilities of different platforms. [...] XForms should be an application of XML 1.0 plus Namespaces. It should be possible to define a rich form, including validations, dependencies, and basic calculations without the use of a scripting language. XForms should be usable in XHTML and other XML-based languages, such as SVG. XForms should be usable by clients without XHTML capabilities. To enable Web content developers to meet these challenges XForms will be designed to cleanly distinguish