Customer Reviews

XForms: XML Powered Web Forms

5 star:		(5)
4 star:		(3)
3 star:		(3)
2 star:		(1)
1 star:		(0)

 

 

XForms is just the right length and weight for reading in bed, or on a flight (two hours or more). So those are the places where I read Raman's book. I openly admit that I got more out of the book in flight than between sheets.

Raman belongs to the school of tell them what you are going to tell them, tell them it, then tell them what you told them. His English is rather academic in style, but it is always clear.

Raman has put considerable thought into the problems addressed by XForms.The book ought not be read as a description of XForms syntax, nor is it really a tutorial on how to use XForms. Rather, Raman's book is a treatise that sets out the desirable characteristics of electronic forms, especially those deployed over the Web. By explaining requirements, and illustrating, by means of those examples, how XForms meets his requirements, Raman has produced a compelling justification for the design of XForms. He has also gone a long way towards providing a clear set of criteria against which other forms technologies might be measured.

XForms is divided into three parts. Very roughly, Part One describes the mess we are in today, and sets out the characteristics of a means to salvation, and just how these are embodied in XForms. The second is a blow by blow account of the act of salvation; while the third points to the state of grace we might achieve in the future, if we pursue the principles on which XForms is based.

So, Raman sets off on the journey with a description, by means of a simple example, of the tools and approaches used in typical Web forms projects at the moment. He then spends some time reworking the example as an XForms implementation, and highlights the key advantages of using XForms. In doing so he introduces us to the major components of Xforms.

The rest of Part One is an introduction to the array of other XML standards the potential XForms developer will face when using XForms. Raman lists six standards on which XForms has some dependency, including XML itself. This is a strength of XForms. Processors, can, at least partly, be amalgamations of existing implementations of standards, such as W3C XML Schema. Furthermore authors are likely to be using skills that are useful in other contexts.

Part Two consists of a more detailed examination of XForms. Raman first takes us through the UI itself, moving from simple constructs to the more sophisticated. Each section describes the use of XForms components, with worked examples, and so helps to put into context the architectural principles sketched out in Part One.

As an example, let's look at Section 3.4, Types of Selection Controls. Raman tells us that it is a common requirement that a user make a selection from a predefined list of values. He cites the various ways that this can be physically represented on different devices, but then makes the point that "XForms defines selection controls based on the functionality provided, rather than their appearance in a given environment. This design has the advantage of capturing the underlying intent in a given user interaction rather than its mere visual appearance." (p.63). Raman expands his argument with a worked example, that contrasts how a voice browser might struggle with an HTML implementation of a choice, but work very naturally with the XForms equivalent.

Having described the basic building blocks of the UI, Raman tells us how to combine them within groups, repeating groups, and the XForms equivalent of tabbed groups.

Next come accounts of the bits the author needs to make a form function; Model Item Properties (MIPs), Functions, Actions and Events. In these chapters Raman explains and justifies XForms declarative style, whilst carefully acknowledging that techniques such as scripting have proved their worth in allowing people to "experiment and innovate on the Web" (p.163). As an example of the power of the declarative approach, Raman sets out how an author can use dynamically evaluated MIPs such as relevant, and read-only, combined with CSS, to control the physical representation of forms, by hiding controls, or groups that are bound to nodes that become irrelevant, for example.

The last section of XForms lays before the reader Raman's hopes for a future Web in which XForms acts as a mediator between humans and Web services and so; "allows users to interact naturally with complex, structured data; and does so across many modalities, in a way that makes the Web universally accessible".

Raman devotes a chapter to each aspect of his vision. In the first, he points out that web services rely on the transfer of "well structured, rigorously validated" XML, all ready for machine processing. XForms allows people to interact directly with such user unfriendly data. Furthermore, XForms allows authors to create islands of well structured data within oceans of the kind of semi-structured document that people use all the time. So "XForms makes the original promise of the document is the interface a reality".

The last two chapters establish that XForms does not impose any particular view of what that interface should be. Raman makes very forcefully the point that XForms is through designed to support multi-modality and accessibility principles, and so makes it trivial for form authors to create forms that will work pretty much any way that is appropriate. Raman emphasises that accessibility and support for multiple modalities are all part and parcel of the same thing. Moreover he has illustrated his points very carefully, to make clear that accessibility is about improving everyone's experience of the Web. We all find ourselves in situations when we are functionally blind, or deaf, or physically impaired, every day of our lives, if we just stop to think about it.

After HTML and the browsers came out in 1993, there was a frenzied buildout of the web. Very quickly, the CGI-bin parsing method was supplanted by more powerful backend approaches like PHP, Java Server Pages and Active Server Pages. (And others.) For all of their competings with each other, which happens to this day, they had one thing in common. Their input and output was HTML. Granted, current HTML has improved since 1993. But not by much. It is as though it remains in a time warp, adrift while entire server side methodologies rose. There were several reasons. Primarily that the problems on the server side, like integrating with a data base, and separating business logic from presentation and from the data queries, were indeed harder problems. It was correct for developers to concentrate on the main issues.

But now, finally, attention has focussed on HTML itself, and indeed on broader interactive issues. Aided by the rise of cell phones and other media where you do not necessarily have a mouse or monitor. And where I/O might be audio with a limited keyboard. People asked, is there a way to write display logic that can easily handle both computers and phones? From this flowed a generalisation of HTML called XForms. The book emphasises XForms' close links with HTML. Deliberately so, to take advantage of the widespread knowledge of HTML. XForms is shown to have an elegant simplicity.

You should know, it IS more complex than HTML. It requires some knowledge of XML namespaces and XPath and CSS. But if you want to develop and easily support products that deploy on computers and phones and maybe other future platforms, then it is well worth it. Imagine XForms as a refactoring of HTML into XML.

By the way, the book talks of various motivations for using XForms, like making your products accessible to the blind. All to the good. But the blunt reality is that all other markets except those mentioned above are an afterthought.

This is a book which compresses a lot of good and useful information into just over 220 pages. It starts off by demonstrating how a small simple Web-based questionnaire can be rewritten as a XForms application. Unfortunately, the book is very vague on how to actually deploy XFroms applications and leaves it up to the reader to figure out how to deploy this sample application on their own system.

A companion CD is provided which contains all the book sample code sources. It would have been useful and user-friendly if a copy of one of more XForms implementations were included on the CD. I hope that this is corrected in a future edition of the book.

The book continues by reviewing the various XML standards used with XForms, followed by detailed chapters on XForms user interface controls, model properties, functions, actions and events.

Given the current scarcity of books on XForms, this book should be on the bookshelf of any serious Web application developer.

This book highlights the XForms technology.
For my opinion,it's not good tutorial materials for leaning XForms.
It intends to illusrate the functionaliy of XForms rather than teaching you how to use.
Be cautious, some sample codes are incorrect.

The book is a step up from the W3C documentation. The organization presents a nice ramp from some simple examples all the way to complex wizard style forms interfaces. You will see illustrations of the key points of the standard, but what I didn't see were examples about complex form validations or much in the way of best practices.

It's tempting to base the success of a book about a standard, especially one of the first few books on a standard, on the success of the standard itself. It would be wrong to do so as the book is an individual entity that has it's own unique merits. I haven't judged the book based on the success of the standard. I have judged it on it's translate the standard and to provide perspective. It certainly translates the specification into a readable text, but it fails to provide a large perspective about how to best apply the standard in the context of a complete application.

In about 200 pages or so, T. Raman has been able to convey the power of XForms to its readers. XForms leverage the power of using XML in creating web forms. It enables the developers to design simple, yet powerful and feature rich, browser-based interfaces for creating XML documents. It ensures the validity of the XML documents without the use of JavaScript, VBScripts and the entire headache and cumbersome that comes along with scripting languages. The author in a few chapters, using useful examples and just plain old good writing style, depicts the power of XForms, and shows the reader how the development time of creating a feature-rich web site can be dramatically reduced using this new technology. Website developers, technology managers and software architects would be able to realize the benefit of using XForms, and determine by reading this book how XForms can save their website project time and money.

This book is divided into three parts:
· Introduction - Gives the reader the 20-mile high overview of XForms and the various XML standards that it uses such as XML Schema, DOM2, Namespaces, XML Events and XPath.
· Components - Talks about the various components that make up the XForms architecture.
· Emerging Areas - Talks about the connection between XForms and other emerging Web-Services technologies.

If you were familiar with Struts, it would be very easy for you to learn XForms as it follows the same Model-View-Controller (MVC) design pattern. XForms consists of mainly three parts:
The "data" part of XForms is for any and all nonrepresentational aspects of Web applications. It is used for user data input, and for validation of that input. The metadata is also presented at this layer, which is necessary to communicate the user input with the Web Server.

The "UI" part of XForms defines a vocabulary that consists of abstract controls and aggregation constructs used to create feature-rich UI's. There is an abstraction layer built-in that allows the applications to be deployed on many different devices and platforms

The "submit" part of XForms allows the developer to specify how and what pieces of data need and can be passed to the Web Server. It also acts as the controller of the data in that it specifies the actions to be taken once a response have been received from the server.

The author then goes into detail talking about the various components that make up XForms. The MVC design pattern is broken down even more and the details of each component (properties of XForms, the UI to back-end bindings, XForms events, etc) are further discussed and examples are given to convey each topic better.
Chapter 4 puts the true power of XForms in perspective for the reader. It talks about a multi-stage UI Wizard and it shows thru an extensive example how it can be developed via XForms. The same application would take at least a couple of weeks to develop with Struts and JSP/Servlets. The author in a couple of pages, implements this example and shows the reader how much simpler and faster it is to develop with XForms. The author concludes his remarks on XForms with talking about the XForms processing model. The processing model defines various XForms specific events that can be raised, and talks about how and when these events take place. There are a total of 4 events that occur in XForms: Initialization, Interaction, Notification and Errors events. Each of these events is described in detail in chap 8 and examples are given so the reader can grasp the topic faster.
The last part of this book, the author talks about how XForms fits into the Web Services world, and more generally, with other XML technologies and standards such as SOAP, XHTML 2.0 and CSS.
For a book that would be considered an easy and a quick read, it sure has lots of information packed into it. In one weekend, you can become familiar enough with XForms that you would be comfortable in writing a Web application using it. I recommend this book to any developer involved in Web development.

Those of us that have been programming for decades remember the times when a form for data entry was created by writing the code. It was a slow, tedious and error prone process. Our efficiency dramatically increased when development packages containing the GUI objects became available, in most cases you simply selected the object you wanted and pasted it to the form. Once that was done, you assigned the values of the parameters and if necessary attached the appropriate event handler.
XForms is another way in which the GUI objects can be included on a form, specifically a web form. As the name implies, the syntax is that of XML, all of the parameters to be assigned are entries to be filled within the appropriate pre-defined tags. In this book each of the primary GUI objects of XForms are introduced, example code is given and then a small image of how the object will appear is included. If you have any experience with programming GUI objects and understand the fundamental syntax of XML then you will have no trouble understanding the presentation. The author also includes some of the more widely used values of the attributes.
This book is an excellent primer to the topic of XForms, easily understandable to get you comfortable with them as fast as possible.

If you are looking for the reasoning behind why XForms is built the way it is this book may be helpful.

If you are looking for code examples, hints, lessons, or pointers toward how to build an XForms application you should probably look somewhere else.

This book in an excellent review of the XForms standard. It is part tutorial and part reference book. It starts with about 50 pages of background material (XPath, XML Schema, XML, namespaces etc) and then starts with a conceptual overview with some examples. It then takes us through all the major XForms concepts and elements.

The book is well written in a compact and precise style. It also has several tables that I found to be handy as references although there is no full appendix listing all the XForms elements which would have been very useful. It does have some useful additional information such as how to use CSS with XForms.

T.V. Raman is also a very credible expert on XForms since he was on the w3c XForms standards body. He gives several insights into why the standard is structured to be device independent. This allows XForms to run on web pages and mobile phone applications.

The only reason I did not give this a 5 star is that the examples on the online on the web site have many problems. The book was written using LATEX and many of the examples on-line still have many LATEX codes in them and will not run without much editing. Somewhat sloppy.

My hope is that the author fixes these problems in the future so that all the examples would work with the FireFox XForms plug-in. That would be ideal for using this book in the XForms classes I teach. The book could also have used a bit more editing, I found several grammatical errors but no real conceptual errors.

XForms is one of those technologies that hasn't yet taken off, but could make a substantial impact if it ever does. I got a copy of XForms - XML Powered Web Forms by T. V. Raman in order to understand a bit more about the subject...

Contents:
Part 1 - Welcome to XForms: XML Powered Web Forms; Standard Building Blocks
Part 2 - XForms Components: XForms User Interface Controls; Creating Complex User Interfaces; XForms Model Properties; XForms Functions; XForms Actions; XForms Events
Part 3 - XForms and the Next Generation Web: Connecting the User to Web Services; Multimodal Access; XForms and Accessibility; Colophon; Bibliography; Index

In some ways, XForms is harder than just regular HTML forms in that there's more data architecture that needs to be considered beforehand. Conversely, you are able to achieve a much better separation of data and design than possible under the HTML model. Raman does a pretty good job in explaining the overall conceptual model of XForms, as well as how it hooks into all the other "X" technologies (XPath, XML Schemas, etc.). Once the groundwork is set in Part 1, Part 2 becomes the reference manual on how to use each XForm feature. It's not a huge reference manual, but the core information is laid out in such a way that you'd end up using it on a regular basis as you get up to speed. I found it all pretty easy to follow, and I see how this could become a fundamental part of your personal library if you're using XForms on a regular basis. Of course, the downside is that XForms isn't yet supported on any widely-available basis... :)

If I were asked to recommend a title for XForms information, this would probably be the one I'd point someone to...