Check out this cool video that will help you understand how and why your business processes need to lose the paper and get on board with dynamic, interactive electronic forms... powered by the XForms standard of course![Read More]
Smarter Everyone, Smarter Everything, Smarter Everywhere
My wife got me one of those GPS devices for Christmas. I really like it. Actually, I work closely with Steven Pemberton on the W3C Forms Working Group, and every face to face meeting we manage not to get lost because Steven has one of these devices. His talks a bit much and sounds just a little pouty when you don't follow her directions properly, though I think that's just a skin.
Perhaps needless to say, I've wanted one of my own for some time now because I'm pretty good at getting lost. I once took 90 minutes to complete a 7 minute journey-- well, it was 7 minutes according to Google Maps, but my version of "take the first left out of the San Jose airport" occured earlier than their version, and next thing you know, I was headed for LA rather than San Fran.
Anyway, so I visited Research Triangle Park recently for the Forms face to face, and although it is an easy trip from the airport to the hotel, I took my new GPS device along so I could get used to using it before I have to truly rely on it. Well, my plan went slightly wrong in that I ended up relying on it after all.
You see, I had dutifully printed off and memorized the Google Map instructions before leaving the rental car lot, so I knew exactly what I was supposed to do. I knew exactly what script to run. And sure enough, my handy GPS device was rattling off the correct command "Turn right onto Exit 280" when an unfortunate arrangement of traffic prevented me from executing the command. Then something wonderful happened. Without a pout, my GPS device said "recalculating" and next thing you know the device was in control of getting me to my destination.
It was then, when "recalculating" happened to me alone as I hurtled down the interstate somewhere near the speed limit, that I realized what an excellent example this was of the power and efficiency of declarative programming. I had declared my intent to arrive at a location. The rule was: get me from where I am to this location. The device computed the best way to get there. And when a change event occured, then the device recalculated a new sequence of instructions for me to run in order to achieve my objective. I suffered so much less than I did that time in California. It's just so much more effective. It's just so like XForms.
Someone recently asked me to explain why the XForms way of binding form controls to XML data with XPath was better than, say, using XSLT templates to match data with XPaths and output an XHTML form. Seemed a fair question.
An XSLT describes a transformation step that happens entirely before the user gets involved, so all the limitations of current XHTML forms still applies to the result of the transformation.
In comparison, XForms defines an intelligent, interactive layer that governs the fill experience for the data. Applying an XSLT to data does not, in and of itself, describes what happens as the user interacts with the data to create new content, so the author of the XSLT is left to encode the old script and HTML devices into the XSLT.
XForms standardizes the following:
Not only does XForms standardize these things, but it standardizes how they work together.
To further drive home the point, note that XSLT transformation could actually be used as a sympathetic technology with XForms. You could, for example, write an XSLT that transforms an XML Schema into data+XForms rather than data+DHTML. Then, you'd still get all of the above value adds because XForms is a standardized interactivity layer that describes what happens after the XSLT generates the initial rendition.[Read More]
The Lotus Forms team will be out in force next week at Lotusphere 2008. To me, the most exciting presentations will be on a new product in development currently codenamed Total Forms. You can expect it to be shown in the Portal vignette during the OGS (opening general session), but there is also a focused session at 11:15 on the 23rd in SW Pelican. I don't want to spoil any surprises, so I won't say too much more, except it's a revolutionary new way to build XForms-based applications that really does put the computing power into the hands of the people. So go see the next killer app of Web 2.0.
Turns out the 23rd is a busy day for the forms team. At 10, there's a session on server-side mashups. Basically, we're talking new tooling that makes the Web 2.0 server accessible to non-coders. Again, putting computing power into the hands of the people, it's for people who want the next step up from Total Forms in application creation capability.
OK, so now I should take a step back because I started out talking about the 23rd because of Total Forms, but we actually also have a fine session coming on the 22nd at 4:15pm to tell you about all the cool new stuff in our latest 3.0 release.
And on the 24th at 8:30 sharp, there's a session devoted to the integration of Lotus Forms, Portal and Process Server. This session gives you what it takes for the full meal deal of forms applications, those involving human centered workflows that allow people to collaborate on the business processes they are involved in every day.
And rounding out the Lotus Forms development team's showing at Lotusphere is the "Meet the Developer" pedestal, where you can talk one on one with some of our best software architects, development team leads, and even a red-headed senior manager whose technical gifts are the very antithesis of Dilbert's pointy-haired boss![Read More]
John M. Boyer 060000VMNY 1,174 Views
When I read the material on Yahoo! Blueprint, I was pretty pleased and shared the links with you in the last entry. However, I'd like to draw your attention to the first paragraph of their roadmap (emphasis is mine):
Declarative vs. Imperative
Much of Blueprint's philosophy and syntax comes from XForms. We opted for a full declarative language because it was the only way we could effectively run on the wide range of devices out there, some of which have no scripting at all. By using declarative syntax, we can encapsulate and hide the scripting specifics. In some cases, the code could run on the phone, in other case, such as XHTML, we can put the logic on our servers. It's the perfect way to deal with the various environments and their capabilities.
In a nutshell, this is the multimodality story of XForms.
I should clarify, though, that this is not saying that XForms has no imperative scripting of its own. The difference, though, is that the XForms script commands are data-centric, which means that they essentially declare what has to happen to the data in response to a particular event (like pressing a button to add a row to a purchase order). The meaning of each script command in XForms is tailored by the declarative constructs that bind to the data. For example, when you add a node of data containing the subtree of nodes needed to represent a purchase order item, the declarative bindings of XForms automatically create the UI controls and the line calculation formula needed to drive that new data. XForms processors, including Blueprint, are able to decide where these behavioral updates go depending on what devices are at play.
This issue of declarative constructs tailoring the meaning of imperative script commands is extremely powerful. Using the same one line of code to insert or delete a node, the rest of the application may respond by creating or destroying an arbitrary amount of user interface, including nested tables, as well as creating, destroying or updating any formulae that may be needed for the data being created or destroyed. The same one command that removes a row of a purchase order could also remove the entire list of delinquent payments for a customer who has just paid up.
In conclusion, it's not so much "declarative versus imperative". Rather, it's a matter of being much more effective with a hybrid model in which the imperative is data-centric and augmented by the declarative.
How much more effective, you ask? In The Mythical Man Month, Brookes states empirical results showing a relationship between complexity and code length of N1.5, where N is the number of lines of code. To put that in concrete terms, 10 times less code is not just 10 times easier to maintain, it's about 30 times easier. This is the kind of difference that turns years into months or months into days. For the services company this means lower RFP bids, which translates into winning more deals. And it means significantly lower TCO for the enterprise IT shop building that web-app in-house.[Read More]
John M. Boyer 060000VMNY 1,136 Views
After the Candidate Recommendation announcement for XForms 1.1 at the end of last year, the public implementation report period now begins in earnest. To celebrate the candidate recommendation, today you can now access a 25-minute podcast (MP3) I made to explain to you What's new in XForms 1.1 and why you should care.
And now for a very interesting news item. You know how good it feels to see a prediction you made come true? Well, that's me right now, and oh is it sweet. For some time now, I've been telling you about the new wave Web 2.0 client tier based on technologies like XForms. We deliver that vision to today's to web browsers using either a server that boils things down to the "assembly language of the web" or a client plugin. Either way the web is not solely defined by web browser vendors. Well, at the XML conference in December 2006, I saw it clear as day that the search companies were going to play an important role in demonstrating this. What'd'ya know, the first thing this year and Yahoo! has announced its strategy to foster a mobile ecosystem and deliver the best mobile internet experience to billions of consumers. The underlying technology for delivering on this strategy is the Yahoo! Mobile Developer Platform, which includes XForms. Google can't be far behind![Read More]
It was a great year for XForms at XML 2007. There were quite a number of presentations that featured XForms as a component, though in this blog I want to focus on the big event for XForms, which of course was the "XForms Everywhere" special session held on Monday evening.
It is no exaggeration to say it was an unqualified success. This was a 2-hour event consisting of six 15 minute presentations by some of the XForms community leaders, including Mark Birbeck, John Boyer (yours truly), Erik Bruchez, Dan McCreary, Keith Wells, and Charles Wiecha. This was followed by a 30 minute keynote from Elliotte Rusty Harold on "How XForms can Win". You can find program details here.
Naturally, we were a bit concerned that the evening slot (7:30-9:30) would test the stamina of the even most eager conference-goers, but the room was filled to capacity (about 60 chairs) and then there wasn't even standing room due to about 20 people standing or sitting at the back of the room.
And then the content was exquisite. The format of the session turned out to be a great idea. With only 15 minutes, each of us was required to refine our content to the cream of the cream. The order of speakers was defined by Leigh Klotz (Xerox) based on the most natural flow of thought about forms design, run-time case studies, general application architectures, and futures. Since I was talking about design, I went first. This created a happy coincidence because it made the most sense to start by announcing the most recent accomplishment the Forms Working Group, which is the transition to Candidate Recommendation of XForms 1.1. Not only did my own design-time presentation depend upon XForms 1.1, but also most of the other presenters used XForms 1.1 features as well.
With such a huge turnout, it occurred to me that quite a large fraction of people might not know much of what XForms is capable of. I started thinking back to the Compound Documents workshop of 2004 where Bert Bos, the chair of the CSS working group, said "Forms, I know what forms are. Name, address, pepperoni, extra cheese. I want to talk about more sophisticated web applications. The kind that can play games. Not necessarily Doom, but you know what I mean." When my turn came to talk at that conference, I started by launching my BlackJack form, and I played a few hands. Lady Luck was with me that day, and she was with me again on the XForms evening at XML 2007. I showed that form for effect, but then I showed a much more sophisticated "Mortgage Pre-approval Form" in both English and Chinese. Next I showed how much of the complexity of that form could be seen as simple aggregation of the concepts one can find in a reasonably small purchase order form. And at last, I launched into a 7 minute demonstration the XForms design experience for that purchase order form. You can see a video clip of that design experience here.
I enjoyed the presentations by Dan McCreary and Keith Wells because they demonstrated sophisticated applications of XForms that would be an order of magnitude harder to build with existing web application technology. During the breaks between speakers, I took the time to reiterate to the audience the business value here in terms of being able to win deals based on lower RFP bids.
I also enjoyed the two more forward-looking presentations by Mark Birbeck and Charlie Wiecha. Mark demonstrated and spoke about his experiences building a desktop application development environment called Sidewinder, which combines XForms and XHTML to allow very efficient creation of desktop applications, not just web applications. Charlie demonstrated and spoke about the applicability of the XForms architecture to creating robust mash-up applications out of components that actually are reusable.
Perhaps my overall favorite talk of the evening was given by Erik Bruchez. You can find out more about it here. Erik presented yet another application with high business value and low development effort that he created by combining XForms with the eXist database. The main point of his overall presentation was to illustrate that the XForms-based web application architecture consists of a rich client tier that can speak directly to server tier applications like databases with no coding in the middle tier. Clearly given my blog entry of Oct. 18, I couldn't agree more.
Whenever I explain that the XForms architecture is "rich client", I always stop to remind the reader that this is a mindset, not a deployment strategy. You can deploy an XForms rich client, or you can deploy XForms functionality to a thin client (a web browser only) using a server product such as the Lotus Forms Webform Server. The point is that the XForms mindset allows you to factor out the deployment issue and focus on what the application is supposed to do.
And as an IBMer, I am duty bound to my colleagues over in Information Management to point out that the database involved in the above mentioned example could instead be the scalable and robust DB2 9.x with pureXML support. Using a package like Lotus Forms that supports the XForms 1.1 submission enhancements for web services and REST-like services, forms applications can directly consume web services set up by the database adminstrator without the need to bring in a java developer to write the code in the middle. This is an important point that I'll return to very shortly in the conclusion.
The final presentation was the keynote by Elliotte Rusty Harold, who is a gifted speaker and thinker. He began by explaining how hard it has been over the past 15 years to make do with today's web architecture for building web apps. He was more eloquent at saying this, but it's a bit like trying to incrementally build a 15 storey building on the foundation for a single family dwelling. Of course, the point was that XForms can do the job that today's web just can't, and it can do it really well, but... As Elliotte explains it, XForms is currently a "Cambridge" technology built by really smart people, and that it needs to build the bridge to New Jersey where all the fast-and-cheap, quick-and-dirty... and successful... technologies live.
This is a fancy way of saying that while XForms is now hardened for the most demanding of enterprise applications, more focus is needed on making XForms more accessible to the much wider audience of people who perhaps start out with simpler problems that work their way up into being the complicated beasts that become those unmaintainable piles of jumble-fuss (my word; Elliotte would've come up with a better one) that cause so much trouble today.
XForms can win, Elliotte says, if three things happen. First, native support in the browser. Second, good design tools. Third, XForms needs a killer app.
Regarding browser support, he points out that it is well-known that IE will be hard, but that we should start out by getting the Firefox/Mozilla XForms plugin to be moved to the core browser, and not an 'additional' plugin anymore. To some extent, I agree, but in the spirit of New Jersey thinking, XForms can already run in all browsers because we have server-side products that can boil it down to the HTML and AJAX that all browsers, including IE, natively understand. Elliotte felt that was a bit of a hack, but we have to remember that he's also a professor, so he sometimes also falls into the Cambridge trap. Still, the point is well-taken, as long as we view things in terms of transition. The server products show that XForms is a viable technology for all browsers even if you don't want to deploy rich clients. A great next step, of course, to garner direct browser support, and we're working on it, but it's not impeding our ability to provide the business value of XForms to customers today.
Finally, there's Elliotte's point about needing a killer app. Let me start with a Cambridge thought: XForms doesn't need a killer app because XForms is the killer app. The first killer app of computing was the word processor; the second was the spreadsheet. In a conversation I had with Elliotte the next day, he commented that the spreadsheet was even more of a killer app because it had to move the coder out of the way in order to put the computing power in the hands of the people. Sound familiar? XForms is the killer app of Web 2.0. The New Jersey reality check is that it has to walk like a killer app and quack like a killer app in order to be a killer app. The spreadsheet only became the killer app once the people saw what they could do with it and how to do it. The 'what' and the 'how', that's what made the XForms + database presentation and the design tool presentation so important in our XForms special session at XML 2007. The call-to-arms is simple: make more what, make more how, ... make XForms Everywhere.[Read More]
The World Wide Web Consortium, or W3C, produces the "standards" for all sorts of web technologies with which we are all familiar, including XML, XSLT, XML Schema, HTML, CSS, PNG, ..., and XForms. The W3C calls these things "Recommendations" because after due process and careful review and implementation, the World Wide Web Consortium recommends the technical specification for world-wide development and deployment. And this is what has happened to all the recommendations listed above.
But just as software goes through maintenance and refinement, so to do the specifications that describe the software. For example, XML 1.0 is itself currently at fourth edition, and XML Schema 1.0 is at second edition.
On October 29, 2007, the W3C approved the third Edition of XForms 1.0 as a Recommendation, superceding the second edition from March 2006 and the first edition from October 2003. This release of the specification is quite important to the XForms community as it represents over 300 refinements, clarifications and corrections that have arisen in the last 18 months. The W3C Forms Working Group has worked very hard these past 18 months on what I would call "enterprise hardening" of XForms, and the numerous differences produced by the group can be viewed in the second edition errata page as well as the third edition diff-marked version.
Next up from the W3C Forms Working Group is an expected transition of XForms 1.1 to Candidate Recommendation. Stay tuned for more on that...[Read More]
A lot of talks about XForms are a bit technical in nature because the people who manufacture XForms processors tend to be technical people who understand the business value of XForms in terms like "model-view-controller" architectures, a superset of AJAX, and software engineering benefits like abstraction. But the C-level executive cares not about these things. It is important to connect them to what the C-level executive does care about.
The C-level exec is about efficiency, flexibility and accountability.
The CEO wants
The CIO wants to achieve
We need to speak about how XForms helps the organization to achieve better results along these metrics. This is where the global picture of what XForms does against the backdrop of the classic 3-tier architecture comes in handy.
The C-level exec is not up at night worrying about the server tier, where databases, content managers and workflow engines live. These may be expensive systems, but they are designed to be robust and highly scalable systems whose metrics relative to the size of the anticipated user base of a system are easier to quantify. In other words, they are low risk numbers that are easy to budget for.
The C-level exec is not as concerned about the client tier, where the browser and OS live, again because the metrics are easy and stable.
The C-level exec has the most uncertainty and risk at the middle tier. There are two parts to it. There is the part that uses APIs to talk to DBs, CMs and workflow engines to implement custom application logic as needed. This part is not as scary because we have reliable, robust, scalable, stable APIs, and because the components we're talking to are those reliable, robust, scalable, stable, expensive systems sold by companies with important people's ties to yank when there is a support problem. Then there's the scary, assembly-language-of-the-web-part of the middle tier. This is the part that has to juggle a dynamic, multistep end-user experience on the anything-goes client side, where the web browsers are free and you get what you pay for. The upfront cost of the thin client is low, but the time to market with new offerings is the most highly affected because a lot of unpredictable, time-consuming work lives here.
As a final thought, it should be clear from the exponential scales of complexity and cost that the diagram above argues that XForms-based systems have business value through complexity containment, and that said value is rightly reflected in software product cost.[Read More]
I am pleased to announce that IDEAlliance has now announced the XForms Evening at the XML Conference.
This event brings together a number of the leaders in the XForms community to present the business value of XForms, including design experience, end-to-end solution development, case studies and driving business value through Web 2.0 integration. The session culminates in a keynote address by Elliotte Rusty Harold, who offers his vision and advice on the future of XForms.