Contents
| Last modified: June 19, 2008 |
| 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
[June 19, 2008] "Design and Customize XForms in OpenOffice." By Bryan Rasmussen. From DevX.com (June 13, 2008). "Most developers have heard of XForms as an XML-based forms language meant to replace traditional HTML Forms. This is essentially correct: XForms was created as the next generation version of HTML forms -- but the design goals are such that they can be implemented as forms in environments other than the web browser. One such environment is your typical office application. XForms is implemented as one possible method of doing forms-based applications in OpenOffice or Sun's StarOffice. The XForm discussed in this article has been tested on both a Microsoft Windows XP installation, and a Xandros Linux installation. The article presents an overview of how to design an OpenOffice form as an end-user, and provides the syntax for making an OpenOffice XForm match a required XML output format. It assumes that the reader has at least a simple knowledge of XML, XPath, and XML Schema; to follow along or use the downloadable code, you should have OpenOffice version 2.4 or higher installed... The XForms in OpenOffice implementation focuses on simple forms that end users can design themselves. This article provides a limited example of how an end user could use OpenOffice's design mode to build a form, including discussions of the XForms syntax, and common problems that users may encounter. You need an XML format for the form. The example discussed here uses a Danish governmental format that represents the data for a single postal address (only the address, not such extraneous information as the identity of whoever resides there) with additional constructs specific to Denmark. This format makes a decent example because it is simple enough to be comprehensible, yet real-world enough to be potentially useful... XForms in OpenOffice are analogous to the common MVC architecture: the Model is the XForm Model, the View is the rendered form fields, and the control is OpenOffice Forms. Note that the OpenOffice Forms Namespace abstractly describes a form and its properties -- the actual forms input portion of the XForms specification is not implemented. This varies from the XHTML model of XForms, because there's no clear analog to the Controller in that model..." [Note: Bryan Rasmussen is responsible for Core XML and Web technologies within the Danish Government's Data Standardization Project OIOXML.]
[June 18, 2008] "XML Data Interaction for All via XForms Modularization." By John Boyer. Blog. June 18, 2008. "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...
[June 04, 2008] "XForms and Ruby on Rails at the Doctor's Office, Part 2: Implementing the Patient Information XForm." By Michael Galpin. From IBM developerWorks (June 04, 2008). "This article is Part 2 in a four-part series about using XForms, IBM DB2 pureXML, and Ruby together to more easily create Web applications; the series develops a hypothetical application for managing patient information at a doctor's office. Article Part 1 discussed how the technologies allow you to use XML on the front and back ends of your application. One nice thing about this design is that it puts the XML data front-and-center. The design of your XML data model defines how you implement the XForms-based front end as well as how you retrieve data from DB2 using Ruby on Rails on the back end. So the logical place to start developing this application is to design the XML data model. The application will allow patients to enter information needed by the doctor and the staff in the office. You will need information such as the patient's name, insurance company, age, co-pay amount, and of course their symptoms. This article shows how to use XForms to create a data entry form for patients to enter their information. XForms takes care of binding patient data to an XML document and can even validate against an XML schema. The application submits this XML document to a Ruby on Rails controller. Ruby makes it easy to parse this input as XML and to serialize that XML as a string. DB2 understands the serialized XML string and can store it natively using pureXML technology. Rails is even able to display this data with no special work on your part. From here, you can use DB2 XML/SQL syntax to query the XML data or retrieve it and use Ruby to navigate and extract data. This article assumes familiarity with XML and with Web applications in general. It was written using the Mozilla XForms plugin version 0.8.0.3; this provides XForms runtime support in any Mozilla browser such as Firefox. Another very useful Mozilla plugin is XForms Buddy..."
[May 08, 2008] "XForms and DB2 pureXML. End-to-end XML Data Exchange with XForms and DB2 pureXML for IRS e-File Form 1120." By Keith Wells, Susan Malaika, and Christian Pichler. From IBM developerWorks (May 08, 2008). "The W3C Forms working group, comprised of W3C members and invited experts, is chartered by the W3C to develop the next generation of forms technology for the world wide web. The mission is to address the patterns of intricacy, dynamism, multi-modality, and device independence that have become prevalent in Web Forms Applications around the world. This article demonstrates end-to-end XML data exchange with XForms and DB pureXML for IRS e-File Form 1120. It presents you with technologies for quick creation of pureXML databases for XML messages, Universal Web Services to interact with these pureXML databases, and XForms which can be used to interrogate and visualize data from the stored XML messages to a user in a client-based browser. The Internal Revenue Service (IRS) is part of the United States Department of the Treasury that supports individuals and companies to report their income, credits, and other information. Therefore, the IRS defined e-file messages based on the Extensible Markup Language (XML). E-file messages are an electronic alternative to filing paper reports. In particular, the IRS e-File 1120 message is designed for corporations to determine the tax liability for the corporation. The XML Forms Generator tool is an IBM alphaWorks package (Eclipse plug-in) intended to jump-start XForms development. It produces valid and functional forms containing XForms markup embedded within an XHTML document. The input to form generation may be an XML message (optionally) backed by an XML schema or a WSDL document. Response processing templates and combination request/response forms also may be generated from a WSDL document. Any document the XML Forms Generator produces may serve as a starting point for further form, layout, and styling customizations. An extension point provides opportunities for post-processing during generation of a form. Integrating and submitting XML data from XForms through an SOA interface to a database means there are fewer steps between the user and the database, less server processing, and quicker development time to retrieve and process XML data from an XForms-capable browser..."
[December 16, 2007] "XForms: Who Needs Killer Apps?" By Kurt Cagle. In O'Reilly Opinion (December 16, 2007). The XML 2007 Conference has come and gone, with as usual a number of thought provoking talks and controversies. During the evening of the first day, there was a special XForms Evening, with a number of the industry gurus in that space providing very good examples of why XForms is a compelling technology and here to stay... When you stop and think about it, you might begin to realize how very unusual XForms is in that regard. It's an application layer that transcends the implementation it is written in. It doesn't matter whether I'm writing an XForms component in C++ or Java or XUL or JavaScript -- what is important is that I can send run the same 'applications' on any system, that the ecosystem is fitting XForms in where it can, despite the very best efforts of certain vendors to kill it... Pundits will continue declaring its imminent demise, year after year, and yet, year after year, it'll end up on more servers, more desktops, more browsers and mobile devices. Thus, my anticipation is that the number of XForms specialists will remain comparatively small for some time to come, but they will be educating others, who will quietly be incorporating XForms as a way of life into their applications. Some (many) of those will come from the AJAX community, both as AJAX implementations of XForms continue to proliferate and as many who work at the intersection of AJAX and XML understand that while they CAN continue to rebuild the wheel with every app, they can get a lot farther with XForms as part of their toolkit... I think that you need to make a distinction here between 'the industry' and a few companies such as Microsoft or Adobe. There are actually a number of vendors in this space that are doing quite well thank you, especially as interest in large XML vocabularies such as XBRL, HL7 and other vertical efforts continue to rise. IBM's Workplace forms incorporates XForms, as Sun had done with OpenOffice, Firefox has had XForms support ongoing for nearly two years, and products such as Orbeon, Formsplayer and Picoforms have continued to gain adherents. XForms support in desktop browsers is moving slowly, unfortunately, a space where more innovation needs to happen, but at the same time support DOES exist in one form or another, even if such support is not always native. On the flip-side, part of the change is also coming from the XForms working group, as they realize that while it is POSSIBLE to create a stand-alone application layer in XML, its not necessarily desirable to keep everything constrained to that one layer..."
[December 10, 2007] "Orbeon Forms 3.6 Final Release." By Orbeon Staff. December 10, 2007. "Developers have announced the final release of Orbeon Forms 3.6. Orbeon Forms is an open source forms solution that handles the complexity of forms typical of the enterprise or government. It is delivered to standard web browsers (including Internet Explorer, Firefox, Safari and Opera) thanks to XForms and Ajax technology, with no need for client-side software or plugins. Orbeon Forms allows you to build fully interactive forms with features that include as-you-type validation, optional and repeated sections, always up-to-date error summaries, PDF output, full internationalization, and controls like auto-completion, tabs, dialogs, trees and menus. Orbeon Forms 3.6 features over 170 improvements since Orbeon Forms 3.5.1, including major improvements in the areas of state handling, XML Schema validation, error handling, deployment within Java applications, and performance. In previous versions, XML Schema validation always followed a strict mode where all instances had to be strictly valid as per imported schema definitions. In particular, this meant that if you imported a schema, the top-level element of an instance had to have a valid schema definition or the instance would be entirely invalid. In version 3.6, Orbeon Forms implements a "lax" validation mode by default, where only elements that have definitions in the imported schemas are validated. Other elements are not considered for validation. This is in line with XML Schema and XSLT 2.0 lax validation modes. Founded in 1999, Orbeon is headquartered in Silicon Valley and maintains a field office in Switzerland..." See also the XML 2007 blog.
[December 18, 2007] "XForms and Ruby on Rails at the Doctor's Office, Part 1: Setting up IBM DB2 9 pureXML." By Michael Galpin. From IBM developerWorks (December 18, 2007). "This is the first article in a four-part series about using XForms, IBM DB2 pureXML, and Ruby together to more easily create Web applications. We examine how XForms, DB2 pureXML, and Ruby on Rails can help you more rapidly build XML-centric Web applications. We examine how XForms simplifies creating an interactive front end. You will get the interactivity of Ajax, but without having to write any JavaScript or mapping code. We look at how easy it is to store and query XML using DB2 pureXML: DB2's SQL/XML will let you mix SQL and XQuery together to easily access XML data in your database. Finally, we look at how to set up Ruby on Rails to work with DB2 pureXML. With just a few minor adjustments, we were able to create XML-enabled tables in DB2 using Ruby on Rails. XForms allows you to define your data in a simple XML model and your view using standard HTML form elements. XForms then provides declarative mapping between these elements. That means you will not have to write either client-side or server-side code for taking some submitted value and inserting into an XML structure. XForms handles it for you. It even does all of this asynchronously: changes in the HTML form are bound to the XML model and sent to the server for synchronization. You get the benefits of Ajax without having to write any JavaScript..."
[December 11, 2007] "The ROI of XForms. A Guide for Assessing the Economic Impact of Enterprise XForms Standards." By Dan McCreary. From IBM developerWorks (December 11, 2007). This article examines several methods of calculating the Return on Investment (ROI) of adopting enterprise-wide XForms standards. It explores ROI analysis from several different viewpoints, including the standards perspective and issues around vendor lock-in avoidance strategies. It discusses three ROI models for an enterprise XForms migration: The use of vendor knowledge to convert standard forms to a rich Web-client-based XForms application; an investment and savings calculation over a three-year period; and how XForms can form a synergistic relationship with XML-centric technologies such as Service Oriented Architecture (SOA) Business Process Management (BPM). The article concludes with a discussion on how to overcome common objections to an XForms initiative. HTML was never designed as an application development language. XForms is a powerful and deep-reaching technology that could have a large impact on an organization's overall IT strategy. On the surface, there are around twenty data elements that are added to XHTML pages to enhance usability. However, underlying XForms is a change in the contract between the browser and all Web-based applications. It changes the Web browser from a "dumb" device that allows you to navigate between Web pages to a "smart" device with a clean and elegant architecture that can load intelligent Web applications and execute as-you-type business rules. When coupled with other XML-centric technologies such as SOA/ESB and BPM, XForms can give an organization a large return on investment...
[November 29, 2007] W3C Issues XForms 1.1 Candidate Recommendation Call for Implementations. Edited by John M. Boyer. W3C Technical Report. With diff-marked version. W3C announced that the Forms Working Group has published the Candidate Recommendation of XForms 1.1. XForms is an XML application that represents the next generation of forms for the Web. An XForms-based Web form gathers and processes XML data using an architecture that separates presentation, purpose and content. XForms is not a free-standing document type, but is intended to be integrated into other markup languages, such as XHTML, ODF, or SVG. 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. 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. W3C publishes a Candidate Recommendation to indicate that the document is believed to be stable and to encourage implementation by the developer community. The W3C Forms Working Group expects to request that the Director advance this document to Proposed Recommendation once the Working Group has provided a test suite and an implementation report to demonstrate at least two interoperable implementations for each test of a required feature and at least one implementation for each test of a feature. The working group does not plan to request to advance to Proposed Recommendation prior to 14 February 2008 and expects sufficient implementation data will be available by 15 May 2008..." See also on XForms 1.0 Third Edition.
[November 06, 2007] "Use an XForms Document as a Custom XML Editor. Filling in a Bracket with XForms." By Doug Tidwell. From IBM developerWorks (November 06, 2007). A previous article in this series showed how to use XSLT 2.0 to transform an XML tournament document into an HTML bracket that displayed the tournament results. What we didn't address in that article is how to fill in the winners and losers for that XML tournament. In this article, we'll revisit our XML tournament and create an XForms document that lets us fill in the tournament results without an angle bracket in sight. The result is an attractive editor for our bracket document type, complete with Ajax-like effects. Best of all, our use of XForms means the custom editor is built with declarative markup and is based on the data structures in the XML document itself. The article addresses: (1) Defining the layout of the XHTML page; (2) Importing the data model (our XML bracket) into the XForms document; (3) Defining the panels that display the matchups; (4) Defining the panel that displays the bracket; (5) Defining the navigation buttons; (6) Defining the XForms actions to save and reset the tournament data. A user who selects the winners of the 15 matchups automatically creates a complete, valid XML document. To simplify development and maintenance, we refactored the markup in our XForms document by generating it with an XSLT stylesheet. In our example here, we simply wrote that document to a file; we could have just as easily submitted the XML document to a Web application. Best of all, everything in the XForms document is tied directly to the XML data model...
[October 30, 2007] "Extending XForms to Enable Rich Text Editing. A Simple Blog Example of How to Make It Happen." By Steve K. Speicher and Andy Smith. From IBM developerWorks (October 30, 2007). XForms provides a strict processing model for XML content. The XForms standard defines controls (text input, combo boxes, text areas, and more) that allow for editing text within a given XML element or attribute. Using the proliferation of rich text editing across many Web-based applications (such as e-mail, blogs, and wikis), the XForms set of controls can be expanded to accommodate this. This article shows to extend the standard XForms set of controls to provide this rich text editing. There are many HTML and ECMAScript rich text editors for HTML content;for the purposes of this article, we use Dojo, and provide a sample using FCKEditor as well. Since we require XForms and a rich text editor, we also need a mechanism to bind the editor's content to an XForm's instance. This could be accomplished by writing a bunch of JavaScript or using another technology for binding user instance controls, called XML Binding Language (XBL). Mozilla XForms provides a way of extending existing user interface controls using XBL, which also makes this choice desirable. By following some of the integration rules defined by XForms, XBL, and a rich text editor, the end result is a simple and powerful addition to the XForms set of controls. This can further enable the application of XForms in a variety of applications, such as blogs, e-mails, social networking sites, and more. These can then leverage the built-in capabilities of XForms for validation, XML submission, declarative programming, and more...
[October 30, 2007] "XForms 1.0 Third Edition Published as a W3C Recommendation." By Robin Cover. Cover Pages News item. 2007-10-30. W3C has 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 striva 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...
[October 16, 2007] "Integrate XForms with the Google Web Toolkit, Part 4: Creating Interactive Forms with GWT and XForms. Create a Web Application for Rock Star Hopefuls." By Michael Galpin. From IBM developerWorks (October 16, 2007). This is Part 4 in a four-part series demonstrating how to use the Google Web Toolkit (GWT) and XForms together to create a dynamic Web application. Part 1 looks at the JavaScript underpinnings of each technology. Part 2 shows how to use those JavaScript underpinnings to start mixing the two technologies together to build the rock star application. Part 3 refactors the application to use XForms and GWT together. In this concluding part, we continue to refactor and improve the rock star application. The article uses GWT version 1.4 and the Mozilla XForms plugin 0.8. The Mozilla XForms plugin works with any Mozilla-based Web browser, such as Firefox and Seamonkey. GWT requires knowledge of Java technology, and Web technologies such as HTML and CSS. This article makes heavy use of JavaScript as well. XForms makes heavy use of the Model-View-Control paradigm, so familiarity with that is helpful. In the article you see how to add interactive forms to your application. These forms can use GWT to create XForms controls that can then invoke GWT Ajax services. The response from these services can be handled through GWT, and can in turn use JSNI to alter your XForms model data and update your XForms UI controls. This tight integration between GWT and XForms allows XForms to take advantage of key features of GWT. You also see that you can localize your XForms using GWT's localization facilities. Finally, you see one of the lesser-known, but powerful, features of GWT: Java-style sorting. Features like this, as well features like localization and GWT's new image bundling, make it so beneficial to use GWT not only for new projects, but also to enhance other projects and technologies...
[October 12, 2007] XForms Evening Sessions at XML 2007. Staff, XML 2007 Organizers. Also in Daily Newslink Seven presentations on XForms are scheduled for Monday, December 03, 2007 at the XML 2007 Conference and Exposition in Boston, Massachusetts, USA. W3C 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." 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. Sessions include: (1) John Boyer, "Seeing is Believing: Intuitive Visual XForms Design" -- We will demonstrate that XForms can offer an order of magnitude simplification to the design and development of business applications. (2) Dan McCreary, "The Pure Declarative Approach: XForms in Real Estate Forms Case Study" -- We use almost no Java or JavaScript and use mostly on XML Schemas to capture requirements, XML transforms to transform requirements into XForms, native XML databases to store the data, Schematron to store business rule checks, and XQuery for manipulation and reporting of XML datasets. (3) Doug Tidwell, "Creating a Custom Editor for Everything" -- We'll demonstrate how to use XForms to create a custom editor for an XML vocabulary, using Service Component Architecture (SCA) as an example. (4) Erik Bruchez, "XForms and the eXist XML database: a Perfect Couple" -- We show how the XForms 1.1 submission module, which supports REST, can be used to perform CRUD operations in eXist; we also look at how XForms can directly submit XML database queries using the powerful XQuery 1.0 language implemented by eXist. (5) Mark Birbeck, "XForms, XHTML, and RDFa for Internet-Facing Applications" -- The applications include desktop widgets and gadgets, pure Ajax browser applications, web applications that use browser plug-ins such as formsPlayer, and complete standalone desktop applications, running independently of a browser. (6) Charles Wiecha, "Composition and Choreography of Web Components in XForms" -- We propose a programming model for composing and controlling Web 2.0 documents based on the Model-View-Controller design of XForms. (7) Elliotte Rusty Harold, "How XForms Can Win" (Keynote).
[October 09, 2007] "Integrate XForms with the Google Web Toolkit, Part 3: Using GWT to create XForms." By Michael Galpin. From IBM developerWorks (October 09, 2007). The Google Web Tookit (GWT) has become a very popular way to develop Ajax applications. It allows Java developers to rapidly create Ajax applications by leveraging their knowledge of Java technology without requiring any knowledge of JavaScript. XForms represents an evolution in the HTML standard, and allows for simple constructs to create complex, dynamic behavior. Both GWT and XForms are powerful enough to provide complete solutions to many problems. This four-part series demonstrates how to use the Google Web Toolkit (GWT) and XForms together to create a dynamic Web application. Part 1 looked at the two technologies and how both had JavaScript underpinnings. Part 2 shows how to create a small application with two pages. One page uses GWT to show a list of artists managed by a record company. The second page uses XForms to display the albums recorded by a particular artist. Part 3 uses GWT and XForms on the same page. It shows how to take advantage of each technology's bindings to JavaScript by using JavaScript to achieve interactivity between GWT and XForms. In this installment, Part 3, we refactor the rock star application built in Part 2. That application allows for record executives to manage artists and their albums. We don't change any of the functionality from Part 2; instead we change the implementation of that functionality by mixing GWT and XForms together. You'll see how GWT can be easily introduced to any existing Web page. We use a GWT-style Ajax call to load the data dynamically and then use GWT's JSNI to dynamically create the XForms model. This will allow you to simplify your page, and you'll simplify it even more by using GWT JSNI to dynamically create your XForms controls. Mixing GWT elements will not only simplify the server-side code, it will create smaller initial pages, with faster downloads and rendering...
[October 02, 2007] "Write XForms That Work Across Browsers." By Steve K. Speicher. From IBM developerWorks (October 02, 2007). "The W3C has developed the XForms standard for the presentation and collection of form data. XForms provides a number of advantages over existing HTML forms technology: "By splitting traditional XHTML forms into three parts -- XForms model, instance data, and user interface -- it separates presentation from content, allows reuse, gives strong typing -- reducing the number of round-trips to the server, as well as offering device independence and a reduced need for scripting." XForms documents feature a data model that contains one or more XML instance documents. The form manipulates such an instance document and provides for the submission of that XML to a back-end system. This article shows how XHTML and XForms documents should be hosted and written to ensure that your end users have the best experience with your XForms-based applications. Although the article attempts to show a thorough solution for a variety of deployment configurations, not all scenarios and configurations can be covered. XForms is intended to be used embedded within other markup. The most widely used, and the focus of this article, is within XHTML. There is a need to write your XHTML documents following some guidelines to ensure a smooth experience of a variety of browsers like Microsoft's Internet Explorer, Mozilla's Firefox, X-Smiles, and Opera, to name some. As of this writing, the only desktop browser that natively supports XForms is X-Smiles. Therefore, an add-on, or sometimes referred to as a plugin, is needed for a browser to process the XForms content. There are also solutions that convert XForms markup to ECMAScript and HTML, which are more widely supported in deployed browsers..."
[September 25, 2007] Lotus Forms 3.0 Now Available. By John Boyer. Blog. September 25, 2007. IBM today announced a new version of its electronic forms software that allows customers and partners to take advantage of rich, interactive, open-standards based electronic forms in a Web 2.0 environment. Using Web Services, Lotus Forms provides a wizard-based interface that works tightly with Service Oriented Architectures (SOA). This makes it simple for customers to pre-populate forms with existing system information to help reduce data entry errors and improve employee productivity by streamlining process automation and reducing operation costs. Boyer writes: "The biggest news overall is the performance enhancements to Web Form Server, which is a 'Rich Internet Application' platform that provides the capabilities of Lotus Forms directly to web browsers without the need to install 'rich client' software. We have also added digital signature capability to Web Form Server... The biggest overall language change goes to the support of bidirectional text and components for Hebrew and Arabic locales. This is a deep integration with the XFDL language that encompasses nested component orientations, text direction options, and even support for visual versus logical data representations. Finally, on the XForms front, there are several XForms 1.1 features now supported in the product line, including having Lotus Forms that communicate with the web services of an SOA. This release also supports half a dozen new functions that facilitate everyday programming, such as date math and better string comparisons for sorting and searching of data. The release also supports the new XForms datatypes that allow empty content and simplify authoring.." See also the Lotus Forms web site.
[September 18, 2007] "Integrate XForms with the Google Web Toolkit, Part 1: Introducing GWT's JavaScript Native Interface." By Michael Galpin. From IBM developerWorks (September 18, 2007). The Google Web Tookit (GWT) has become a very popular way to develop Ajax applications. It allows Java developers to rapidly create Ajax applications by leveraging their knowledge of Java technology without requiring any knowledge of JavaScript. XForms represents an evolution in the HTML standard, and allows for simple constructs to create complex, dynamic behavior. Both GWT and XForms are powerful enough to provide complete solutions to many problems. This four-part series demonstrates how to use the Google Web Toolkit (GWT) and XForms together to create a dynamic Web application. Part 1 starts with a bottom-up approach to the problem of using GWT and XForms together. It takes a look at some of the underpinnings of each technology, examining the common ground between them that will allow for their peaceful coexistence. This will lay the foundation for developing a Web application that uses both GWT and XForms together. XForms is a standards-based technology that will be central in the next generation of the HTML specification. XForms uses the familiar Model-View-Controller paradigm. The key to XForms is separating data from the physical view of the data. Sound like a familiar concept? With the data separated, it can be viewed in any HTML-way you can imagine. It can also be bound to form elements to allow for a seamless way to enter data and to edit existing data. With a model declared, you can easily create views from the data encapsulated by the model. XForms contains numerous common controls for working with model instance data. Each control can reference data from the model's instance data. The instance data is in an XML format, so we can easily navigate and reference it arbitrarily using XPath. XForms supports the full XPath 2.0 specification..."
[August 28, 2007] "Use PHP to Create XForms, Part 1: Creating a PHP XForms Library." By Tyler Anderson. From IBM developerWorks (August 28, 2007). This two-part article series is designed to get PHP developers up to speed in leveraging Web 2.0 XForms forms for their PHP forms development so that they can finally put their outdated Web 1.0 HTML forms away. This will be accomplished by creating a library of functions that generate XForms elements when called upon. In Part 1 of a two-part series, developers will create the XForms library using PHP, allowing each function to take in parameters and output XForm elements. XForms is a great Web 2.0 language with exciting features that allow developers to create cutting-edge forms. And why not use it with PHP? PHP developers traditionally output HTML, which generally limits the capabilities of their forms. The problem with XForms, however, is that the file type is strictly XHTML, which is a more refined version of HTML in that the XML format is strict, and doesn't allow mistakes, mismatched tags being one of them. On top of that, there is regular syntax for XForms, which can make the learning curve of XForms a bit steep for some PHP developers who are possibly just learning the PHP language itself. For this article you'll need PHP 5 and the Firefox XForms plugin. This article series was tested using PHP5 on WAMP5 Server Version 1.7.1 running Apache 2. In Part 2 of this article we will enhance the library just created with error checking and convenience methods. We will also use the library in Part 2 to create a proof of concept form...
[August 21, 2007] "Generating XForms Applications Using the National Information Exchange Model (NIEM). Creating Semantically Precise XForms Directly from Exchange Documents." By Dan McCreary. From IBM developerWorks (August 21, 2007). The NIEM is a federal XML-centric metadata standard created for the precise exchange of documents. Although the scope of many of the NIEM sub-domains concerns national security issues, the NIEM is successfully implemented in other domains, such as K-12 education and property taxation. The NIEM contains a general "upper ontology" that is applicable to many other domains that deal with concepts such as activities, documents, organizations, regions (GIS), and persons. There are many benefits for beginning a Web application with a controlled vocabulary or metadata registry such as the NIEM. Metadata registries contain useful information that can be used to create a consistent set of XML schemas and forms. Using a metadata registry also forces users to declare early in the application lifecycle exactly what data elements they will transmit between organizations. This article demonstrates how XForms applications can be automatically created from a NIEM constraint schema, and shows how graphical tools can allow non-programmers to automatically create rich Web applications using a model-driven approach. It gives an example of how a short XML transformation (XSLT) is used to achieve this task and how the transformation can be modified and extended by developers. By using NIEM XML Schema structure, naming conventions, and additional metadata, the transformation task is much easier to extend. Although the example code included in this article will create working forms, its intent is a starting point to enable non-programmers to create working XForms applications. A software developer willing to become familiar with and modify the transformation can facilitate the extension of the transform to meet specific business requirements. This transform is just one of the first steps an IT department can adopt to empower non-programmers to create precise specifications that automatically generate correct Web forms. This process and many similar processes like it are part of the declarative revolution that has great potential to lower overall IT development costs and empowers a much larger audience to play a direct role in Web development.
[August 17, 2007] "XForms, XML Schema, and ROX/x2o." By Kurt Cagle. From XML.com (August 17, 2007). This article begins with a fundamental question: "If I have an XML schema, is there any way that I can work with that schema to build forms for populating instances of that schema?" Over the years, I've seen a number of variations on this same question, and generally for a pretty good reason. It takes a lot of work to create a schema in the first place, but when you're done, what you end up with, in general, is something that seems like it should be good to generate something; you have data type information, constraint information, enumerations, and enough other pieces that it would seem that making forms from them should be a cake walk. However, the process is generally fraught with more land mines than you might expect... I announced the creation of a new Google Project called ROX Server (now: x2o Object Publishing System); if you are interested in XForms generation and building support for robust XML forms solutions, then I'd ask that you check out the site and become a contributing member... Once the core system is completed, there are three additional areas of code development. The first is a system for building a formal workflow engine into [x2o]. This project is ongoing now and is built partially upon the Schematron core language. When done, this should make it possible to create, comment on, and approve or reject appropriate forms as part of an orchestrated workflow. The second area is the creation of libraries of standard packs that enable functionality for commonly used schemas. The intent here is to make ROX Server usable right out of the box for common tasks... My goal with x2o [ROX Server] is simple: I believe that as we move to an increasingly interactive Web 2.0, the effective processing of XML-based objects not only will happen, but must happen. Currently an incredible amount of time and money is spent trying to build and manage form-based systems; by providing a set of tools for building rich XForms, I see ROX Server and technologies like it able to free up budgets for other, more important (and more interesting) development projects. Update: x2o is an open source project established for the following goals: (1) Create a system to use XML schemas to generate XForms and related XML-based GUIs (2) Build a customization layer into this process so that the generated forms can be tailored to specific needs and intents. (3) Establish a data publishing layer to simplify the creation, modification, submission and processing of XML designed to work with the GUIs. (4) Establish a work flow management system for viewing and approving or rejecting records built via x2o. To do this, x2o works on top of two open source technologies: the eXist XML Database and the Mozilla Firefox XForms add-on, though implementations to other projects and vendors will be included in the near future.
[August 07, 2007] "XForms Extensions to XPath. Going Beyond the Standard." By Elliotte Rusty Harold. From IBM developerWorks (August 07, 2007). XForms uses XML Path Language (XPath) as its basic function and evaluation language. XForms adopts the familiar XPath expression language for two purposes. First, it uses it as a query language for addressing and identifying fields within the form and the user-submitted data. In particular, it uses XPath expressions to bind input controls to particular parts of the form's data model. Second, it uses XPath as its basic calculation language for output, bind, and setvalue elements. The focus of this article is mostly on the second usage, though some of these functions are useful for binding as well. XPath was designed to be extensible both by users and implementers. XPath 1.0 defines a basic set of functions such as count and translate that are suitable for a broad range of purposes. Languages such as XSLT, XQuery, XML Pointer Language (XPointer), XML Signature, and XForms that adopt the XPath expression language are expected to expand on this basic set with additional functions. XForms takes advantage of this by introducing new functions useful in forms processing. In particular, XForms adds functions for math, dates, times, Booleans, and XForms-specific operations. You may never see these functions in an XSLT stylesheet or a Jaxen program, but you can use them today in any XForms 1.0 document. The X in XPath stands for extensible: XForms has extended XPath to provide extra power and unique features that are worth learning. While XForms supports the full range of XPath 1.0 you're used to from XSLT, it has quite a bit more. Some of these functions like days-from-date() and now() are just nice to have. Others like if() and instance() are critical components of any non-trivial XForm. More XForms use these functions than don't...
[July 25, 2007] W3C Proposed Edited Recommendation: XForms 1.0 (Third Edition) Edited by John M. Boyer and Micah Dubinko. W3C PER. July 25, 2007. The W3C Forms Working Group has published a Proposed Edited Recommendation (PER) for "XForms 1.0 (Third Edition)." The 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. Comments on the PER are welcome through 31-August-2007. 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, usually remote, agent. XForms separates presentation and content, minimizes the need for scripting and round-trips to the server, and offers device independence. XForms is not a free-standing document type, but is intended to be integrated into other markup languages, such as XHTML or SVG.
[July 17, 2007] "Ajax and Progressive Browser Enhancement." By Mark Birbeck. Blog XForms and Internet Applications. Progressive enhancement is an approach to web development that has been around for a few years now. At its most basic it suggests building our web pages in a 'clean' and uncluttered way, and then layering functionality onto the mark-up using various mechanisms, such as stylesheets and scripts. The principle actually underpins much of the work we've been doing on XHTML 2, which has involved taking HTML back to its semantic roots. In particular the work on RDFa has been to a large extent motivated by providing more semantic 'hooks' on which to attach increasingly focused functionality. But there is a new phenomena afoot, which I'd like to call progressive browser enhancement. It's something we've been doing for a while with our work on XForms and formsPlayer, but it also has wider applicability. To illustrate the idea of PBE, let's look at eventing in the browser. Many Ajax libraries have their own eventing architecture, and they are without exception non-standard. This is a shame, since the W3C has a standard for DOM events (DOM 2 Events) which has been around for years and is very clearly defined. Of course, part of the problem is that whilst it has been implemented in Firefox, Safari and Opera, it's not available in Internet Explorer. This meant that when we began our work on formsPlayer, our XForms processor plug-in for Internet Explorer, we had to implement a DOM 2 Events component ourselves. This does however mean that DOM 2 Events support is potentially available for all browsers... To fill the gap we simply implemented a DOM 2 Events library in JavaScript. Whilst most Ajax libraries went the route of creating their own non-standard eventing architectures, we went the other way and implemented the standard. The advantage of our approach is that if our end-user is running a browser with reasonable standards support such as Firefox, Opera or Safari, they'll get native support for DOM 2 Events, and hopefully a faster experience. Similarly, if our user is on IE and has installed the formsPlayer DOM 2 Events component, they will likewise get a faster experience.
[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 between form data, logic and presentation. The same form will be accessible as a sheet of paper or using a handheld computer resting on your palm. To meet the goals for richer presentation XForms will be designed for integration with other XML tag sets, such as XHTML itself, SVG for graphics and SMIL for multimedia forms. You will be able to use style sheet languages such as CSS and XSL to finely tune the presentation." [cache]
[April 19, 2000] "World Wide Web Consortium Issues First Public Working Draft of XForms Data Model. Next Generation Web Forms Separate Purpose from Presentation." [cache]
[April 19, 2000] Testimonials for W3C XForms Data Model Working Draft - From Cardiff Software, JetForm, PureEdge, Stack Overflow, and Xerox. [cache]
Forms mailing list at W3C: 'www-forms@w3.org'. "This is a public mailing list for discussion of ideas relating to W3C's work on XForms. The mailing list archive is available online from W3C.
"Can XForm Transform the Web? Transcending the Web as GUI (Graphical User Interface), Part II." 'Seventh Heaven'. By Rohit Khare (4K Associates). March 9, 2000. "There's a new space race of late: a quest to build the world's smallest Web server. The current record holder is the size of a match-stick head. iPic is a mere quarter cubic centimeter, yet includes a full TCP/IP stack and HTTP server! But what about the world's thinnest Web client? Would you believe less than .01 millimeter thick? Xerox PARC has turned an ordinary sheet of paper into a functional Web browser. They recently demonstrated Web access through a fax machine. In their demo, the client takes a regular HTML form, prints it out with gridlines and checkboxes for its input fields, faxes it to a field worker, applies Optical Character Recognition (OCR) to the filled-in-form, submits the resulting HTTP transaction to the original website, and faxes back the printed results. . . [the] XForms Working Group (WG) is tackling these interdependent issues. While XHTML brought existing HTML 4.0 usage into XML compliance, XForms was specifically chartered to innovate solutions to support handheld, television, and desktop browsers; deploy richer user interfaces to meet the needs of business, consumer and device control applications; improve internationalization; and decouple presentation, logic, and data. It also has more concrete engineering goals: supporting more structured data formats and multi-page forms; integrating well with other XML tag sets; and supporting suspend-and-resume of partially-filled-in forms. Broadly construed, the XForms subgroup is tackling a long-cherished dream of Software Engineering: automatic user interface construction. Compiling an abstract functional interface into a working UI has been tackled in many ways; stepping back to understand that context will help us better evaluate specific XForm contenders. Specifically, we'll look at proposals for Formsheets, which add interactivity to any existing tag just as stylesheets add presentation hints; Forms Markup Language (FML), which generates procedural forms; and XML Forms Description Language (XFDL), which replicates the role of paper forms precisely. Whether the whole Web will be upgraded to any of these approaches is another question entirely..." [cache]
Announcement from Stack Overflow: "Mozquito Commits Itself to the Implementation Of W3C's New XForms Specification." "Stack Overflow, a company specializing in enabling interactivity on the Web, applauds the W3C on the First Public Working Draft of the specification XForms 1.0: Data Model with a commitment to implement XForms. Sebastian Schnitzenbaumer, CEO of Stack Overflow and co-editor of the document: 'XForms is the missing link to Web interactivity. We will strive to enable the immediate use of XForms with Mozquito Technology.' Forms were introduced into HTML in 1993. Since then they have become a critical part of the Web. The Web has changed, and the publication of the XForms Working Draft is the first step in adapting better forms to the new Web environment. Schnitzenbaumer adds: 'The purpose of XForms is to merge XML-based back-end solutions with the ubiquity and simplicity of HTML.' Based on XML, XForms is also a significant step towards Mozquito's cross-device strategy. The tight integration of XForms with XHTML makes it easy to implement XForms in Stack Overflow's flagship product, the Mozquito Factory. Through XForms, Mozquito users will immediately be able to create applications for editing XML information directly in the browser'. [...] Stack Overflow's mission is to empower Web forms in order to simplify the development and increase the intelligence of interactive Web applications. Their flagship product - the Mozquito Factory - is the world's first XML-based XHTML authoring tool, enabling developers to use tomorrow's Web technologies with today's browsers."
[April 19, 2000] "PureEdge Announces Support for XForms in InternetForms Commerce System." - "PureEdge, a leader in XML e-commerce solutions for secure, verifiable, high-value transactions, announced its support for the XForms Data Model Working Draft specification published by the W3C, and also announced that the company will support XForms in its InternetForms Commerce System. 'As the first vendor to deliver an open protocol and product suite for legally-binding XML forms on the Internet, we are proud to be part of the W3C and a founding member of the XForms initiative,' said PureEdge CTO David Manning. 'We are excited about XForms and believe that it validates our vision of XML as the most powerful format for interactive documents on the Internet. The digitally-signed XFDL documents provided by our InternetForms Commerce System, used in combination with standardized XForms data, will provide a powerful combination for next-generation e-commerce applications.' A founding member of the XForms subgroup at the W3C, PureEdge has been helping to define the XForms Data Model. The company's work with this group evolved from its groundbreaking development of Extensible Forms Description Language (XFDL), the first XML protocol for legally-binding forms on the Internet. XFDL was co-authored by PureEdge and Tim Bray, co-editor of the original XML specification, and became an acknowledged submission at the W3C in October 1998. PureEdge is the global leader in creating binding transactions for e-commerce. Its award-winning InternetForms Commerce System (ICS) enables organizations to securely create, complete, sign, and process digital documents. ICS is the first legally-binding XML replacement for paper forms and processes."
XHTML-FML 1.0: Forms Markup Language. XHTML Modules for Dynamic Web Interfaces - Specification.
