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

XForms, XFDL and Lotus Domino

Just ran across a good developerWorks article on Integrating Lotus Forms with Lotus Domino.

Domino is a web application and web services platform that is often used in combination with the Lotus Notes rich client platform. However, as this article shows, it is possible for Domino to have broader reach out to all web browsers without a large client-side installation. The intelligence and interactivity of XForms are combined with the high precision presentation layer of XFDL to describe a rich client experience, but the Lotus WebForm Server is used to convert that to HTML and AJAX that is natively understood by the web browser. The net result is that XML data processing and web services from Domino servers are extended right out to the webtop.

Of course, if you do have the Lotus Notes client platform installed, then the story gets better because the Notes replication capabilities can be brought to bear for when a user needs to work in offline/disconnected mode. You can also use the Notes Composite Application Framework to create mashups involving Lotus Forms and other application components deployed to the Notes client. Whether you use the Lotus Forms Viewer or the Lotus Forms WebForm Server to render a Lotus Form in Notes application component, you have access to a running Lotus Form using an API. This gives you getters and setters, of course, so you can push data from other components into the Lotus Form, but you can also set up event listeners that are notified of changes made within the Lotus Form, so you can push changes from the Lotus Form to any other component in your mashup.

But net-net, if you want to extend your Domino applications and services beyond the usual enterprise IT boundaries and get access to new B2C and G2C market opportunities, using Lotus Forms is a way to do it. See the new article for technical details.

Consuming DB2 Web Services with Lotus Forms

Check out this developerWorks article for a step-by-step guide to deploying a DB2 web service and then consuming that web service using the Lotus Forms Designer.

Once the WSDL for a particular DB2 web service is pulled into your Lotus Forms Designer, you select and autogenerate a data instance and a specific service, drag-and-drop the data instance onto the design canvas to autocreate the user interface, and then generate the run-time XForms submission for the service. The article above shows exactly how to do each step.

A smart XForms client and a smart interface to the server database mean no custom code in the middle. Thus, computing power is made available to a broader class of IT knowledge workers who require only forms and database skills. Process democratization in action.

The Way Forward for HTML5

Despite all the excitement about the possibilities that HTML5 offers for a better world wide web, I believe there is a critical flaw in the go-forward plan of those who are feeling the momentum. The problem is that they still haven't got ~80% of the web browser makers on board! By which I mean they haven't got you-know-who.

There's really only one way to break the loggerjam and move forward with advancing the state of the web. We need to get you-know-who out of the way of progress by showing that we can innovate on the web with or without their participation. We have now shown that this is feasible by way of the ubiquity strategy based on our ability to deliver an interactive web application language in multiple web browsers with no client-side plugins and no server-side processing of the language. Click here to visit the project.

For all web advancement technologies, including HTML5, the longer term effect of the ubiquity strategy should be that the late bloomers are shamed into implementing the advancements, thereby obviating the need for the ubiquity code. But meanwhile the ubiquity strategy is the way to enable web advancement technologies including HTML5 to emerge (in the proactive verb sense of the word).

Angels and Demons... and XForms

So, I went to the movies recently and saw the new Dan Brown flick Angels and Demons. Probably not much of a spoiler to mention that the plot suspense is derived from the need to defuse an antimatter bomb placed somewhere in Vatican city, and everybody's favorite symbologist is called in to decipher the clues that may help lead to its location.

And they only have until midnight to find it. And the baddies are going to kill a Cardinal every hour before the big bang just to prove how serious they are.

As a taunt, the baddies provide a webcam view of the bomb, which is in a place lit by artificial light. So, someone in the story has the brilliant idea of shutting off the power around town until they see the lights go off where the bomb is located, and the law enforcement folks dutifully begin working through each section of the power grid in sequence.

This is the point where I had some difficulty maintaining a sense of edge-of-your-seat suspense. It seemed to me that they could find out where the bomb was located before the baddies killed their first Cardinal by turning off half the power grid, then a quarter, then an eighth, and so on just like a binary search. I managed to force myself out of this funk and enjoy the movie by convincing myself that nobody in the story would have reasonably known about a binary search, but the point remains that relying on the right algorithm can save you a lot of brute force work.

In the case of deciding whether to use an XForms-based solution or to hand-roll your own data-intensive web application with a pile of javascript to drive the client-side, it's the same issue really. Do you want to do a lot of brute force work yourself, or do you want to benefit from the topological sort algorithm built into the XForms computation engine? In a world of angels and demons, the declarative updating of XForms is like a get out of hell free card. The problem with the imperative approach of javascript is that it's process-based (step-by-step) whereas client-side usability is best served by a less structured, more free form experience. Users pick what they want to update and when, and the program has to be responsive to all permutations of their behavior. Better to let the machine figure out how to keep everything in synch. That's why we have machines.

It's a happy birthday...

Happy birthday to me!

Here's to XForms ubiquity;

In FireFox and IE.

Happy birthday to me!

But seriously folks, IBM is a proud sponsor and contributor to the Ubiquity XForms open source project, and the Lotus Forms team has exciting plans for capitalizing on the ability to have XForms support directly within a web page.

Gone is the distorting lens of limitations imposed by the fraction of language features that the dominating browser makers are prepared to support today. The Ubiquity movement is all about freeing us, as consumers of the interactive web, to express open standards for software that meets our customers' technical requirements and deploy our solutions directly to the web.

Gee, with all this birthday fun, the next thing I really ought to do is go on a Safari!

The open standards basis of XFDL and the value of Lotus Forms documents

A Lotus Form is a document currently expressed in an XML vocabulary called XFDL (html version, pdf version).

This is significant enough, in and of itself, to be set off in a paragraph. XML is a de facto industry standard from the W3C, and this means that widely deployed, interoperable, industry standard software toolkits can be used to introspect and manipulate the content of XFDL, i.e. Lotus Forms documents, thus mitigating issues of vendor lock-in.

But the story gets better...

The XFDL format internally employs W3C standard XForms, so without further reference to any vendor-specific documents, the standard indicates where in the XFDL document to look for the data content created by an end-user who fills in the Lotus Forms document. Anyone with access to a Java reference manual could write code to prepopulate data into an XFDL (Lotus Forms) document before it is delivered to an end-user, and they can write code to extract data from the document when it is returned to the server for processing.

But the story gets even better...

XFDL incorporates the W3C XML Signatures standard, so widely available industry standard tools are available from multiple vendors for validating the security of digital signatures in XFDL documents. In addition to the Apache XML Security implementation, it is notable that Java itself now natively contains support for XML Signatures (JSR 105).

These standards mean that the entire server-side lifecycle of the Lotus Form can be achieved without being locked into using any particular vendor's API. Any application server, any portal server, any server-side environment that can receive HTTP POSTs and process XML in the POST data can be used in combination with Lotus Forms.

And if you ever hear a vendor try to play up high availability of a client-side browser plugin for processing their favorite file format, ask them "Plugin?? What plugin??" With Lotus Forms, you don't need a browser plugin at all because the Lotus Forms Web Form Server converts the XFDL into dynamic HTML that can be processed directly by the browser with no plugins at all. Best of all, when the user finishes interacting with the Lotus Form, the resulting XFDL document is delivered to the application server endpoint, where it can be processed as XML using the standard APIs.

The spectrum: From Enterprise to Line-of-Business Applications with Lotus Forms and XForms

Well, my frieds, it seems a good time to draw your attention to a collection of available resources that can help you understand how you and your customers can address a full spectrum computing requirements, from the enterprise information application all the way down to the simple design-deploy-collect-analyze pattern for situational applications that arise throughout the enterprise

First of all, check out the Lotus Forms Enablement videos on YouTube. There are videos that show Lotus Forms in action in government, financial, and HR scenarios where enterprise-level functionality is a must. But you can also see videos on the new Lotus Forms Turbo product, which enables business users to design and deploy simpler survey style forms for themselves in a matter of minutes.

I want to make a pitstop here to plug the value of the XForms standard in creating this array of products. XForms as a language has a strong declarative component. This means that non-trivial relationships between data and sophisticated interactional and presentational objects is simply declared by the form developer, and it is up to the form run-time system to enforce the relationships. This maps very naturally to how we human beings think and work. We say things like "Whenever I get an email from domain X, put it in my super special high priority folder". We don't directly write batch jobs that run loops over our inbox to categorize our email, and even if we did, the time at which those jobs would run would be specified declaratively! In fact, I don't think it's hyperbole to say that the universe itself operates mostly on declarative laws. Gravity just happens. If you let go something, it drops. It's the law; get used to it ;-).

The point is that the declarative language constructs of XForms are what enable Lotus Forms to accelerate enterprise-level application design, to enable end-user design of simpler applications, and to ensure interoperability between these two types of applications so that the simpler situational applications can be scaled up to the enterprise level as their value becomes more broadly established. The declarative constructs of XForms accomplish all of this due to the simple fact that it is far easier to create software that maps point-and-click/drag-and-drop design experience gestures onto high-level declarative language constructs than it is to map the same things onto huge blobs of imperative scripted code from a general purpose programming language.

And don't just take my word for it. When you finish watching some of the videos at the YouTube link above, how about going for a test drive? You can get free trial downloads of the Lotus Forms, including the client-side runtime and design environments. If you like the enterprise-level capabilities, but you don't want to deploy a client-side runtime, you can also purchase the Lotus Forms Web Forms Server, which translates Lotus Forms into standard web pages. But once you're in test-drive mode with the client-side runtime viewer, check out the Lotus Forms catalog of sample forms. Finally, you can also test drive the new offering for non-technical users directly, without having to install a thing by visiting Lotus Forms Turbo on Greenhouse, or if you'd prefer to test drive it in-house, then just download it from the free trial downloads page.

Either way, once you've gotten Turbo, see a couple of the videos then think of your own simple survey app. Design and deploy it right onto Greenhouse and see how long it doesn't take!

Lotusphere

I'm about to start packing my bags to head out for Lotusphere 2009. Sunday is Business Development Day (BDD), and I'll be presenting at the Futurists Panel on Dual Forms: An open standard office document mashup for document-centric business processes, and the broader context of Interactive Documents as Web 2.0 Applications. I'm very pleased to be part of such an exciting panel, which also includes Mary Beth Raven (of Notes fame, speaking on task management) and Mathew Flaherty (from the Lotus CTO's Office, speaking on the value of open source and open standards). I've seen their talks in rehearsal of course, and they're well worth your time.

In addition to the talk above, the Lotus Forms team has quite a showing at the conference again this year. Here's a list of where you can find us and when:

Lotus Forms Exhibits (in Oceana, Mon. 10:30AM-8:00PM, Tue. 9:00AM-6:00PM, Wed. 9:00AM-5:00PM)

Meet the Lotus Forms Developers in the Labs (on the Showcase Floor in the Dolphin Exhibit Hall)

• Electronic Forms Ped #5
• DB2 and Lotus Forms at Ped #6

Business Development Day: Sunday, January 18

BDD 204, 8:45-9:45am
New Lotus Industry Solution-based Marketing & Sales Initiatives (will include Lotus Forms)
Click here to see full abstract
Speaker: Gary Dolsen
Location: Toucan 1 and 2, Swan Hotel

BDD102, 2:45-3:45pm
WebSphere Portal Product Family Applied to Real Business (will include Lotus Forms)
Click here to see full abstract
Speakers: Gary Dolsen & Jeffrey Seifert
Location: Pelican 1 and 2, Swan Hotel

Meet the Speakers/Product Experts Session 
5:00-6:00pm
Location: Fantasia Garden Pavilion, Swan Hotel 

Sessions & Other Related Activities:

The Client Reference Lounge: The IBM Client Reference team is hosting a high-end hospitality suite as a way to say "Thank You!" to our client reference customers and to invite potential reference customers to stop by and learn more about the program. Open all week, this suite is available to you to hold customer meetings or to use as a respite.

Monday, January 19

1:00-2:00pm
AD 507: BPM Made Easy: Looking forward with Lotus Forms and the Business Process Accelerator
Click here to see full abstract
Location: SW 1-2
Presenters: Dave Manning, Tony Fiorot

2:15-3:15pm
ID604: What’s New in Lotus Forms
Click here to see full abstract
Location: SW 1-2
Presenters: Bob Levy, Dave Manning

3:45-4:45pm
IDR604R: What’s New in Lotus Forms
Click here to see full abstract
Location: SW 1-2
Presenters: Bob Levy, Dave Manning

Tuesday, January 20

7:15-8:15am
Partner Round Table: WebSphere Portal & Lotus Forms
Location: Swan, Dove hospitality suite (breakfast is included)

10:00-11:00am
Customer Panel: Succeeding with IBM WebSphere Portal
Speakers: Pat Kozak of C-Lock and Matt Garst (EIM) 
Attend this panel session to hear directly from customers who have realized business 
advantages through their WebSphere Portal and Business Process Acclerator implementations. 
Learn how each approached their business requirements, organized investment value assessments 
and technical strategies, and are now offering leading edge portal-based services. Hear their 
insights on approaches that work well, lessons learned, and their plans for portal platform 
expansions supporting future growth.

1:30-2:30pm
Portal and Related Products Networking Session
Location: Dolphin, Europe 5
During this time customers can mingle with subject matter experts in a relaxed atmosphere.  
It is a great opportunity to thank the customers who contribute to our success.  
Invite your customers to come to the reference room, meet Portal and Forms experts encourage 
their participation in the reference program. 

4:15-5:15pm
AD514: Composing a Mashup Application with IBM Lotus Forms
Click here to see full abstract
Location: SW 1-2
Presenters; Dave Manning, Dave Shepherd

Thursday, January 22

7:00-8:00am
BOF 107: Getting Started with IBM Lotus Forms Turbo
Location: SW Parrot 1
Presenter: Ricardo Rossi

For more information and free trial software for XML powered electronic forms web applications using XForms, visit the Lotus Forms website today.

Separating Form from Function

The W3C Forms Working Group has published the First Public Working Draft of XForms for HTML.

XForms for HTML provides a set of attributes and script methods that can be used by the tags or elements of an HTML or XHTML web page to simplify the integration of data-intensive interactive processing capabilities from XForms. The semantics of the attributes are mapped to the rich XForms model-view-controller-connector architecture, thereby allowing web application authors a smoother, selective migration path to the higher-order behaviors available from the full element markup available in modules of XForms.

By separating syntactic form from semantic function of XForms, we now have a linguistic plan for providing the XForms processing model to web authors in a way that is initially more consumable to them and also applicable to their non-XML web pages. And, of course, work has already begun to provide this capability across web browsers via the Ubiquity XForms processor.

Categories : [   ubiquity  |  xforms  ]

Dec 22 2008, 11:20:07 AM EST Permalink

Web 2.0 Process Democratization for the Non-Technical User

As the world wide web transforms from a vehicle of information dissemination and e-commerce transactions into a writable nexus of human collaboration, the Web 2.0 technologies at the forefront of the tranformation may be seen as special cases of a more general shift in the conceptual application model of the web.

The classic 3-tier model has the web browser and OS on a thin client tier, the traditional server tier offerings for data persistence and workflow or business process managment, and a fat middle tier of custom JEE code. The custom middle tier code has two responsibilities. It has to invoke all the server tier API calls necessary to perform business transactions, persist data and the like. But frankly, the server tier has received work for decades, so its scalable, robust and has well-defined easy to use APIs. So, the bulk of the work in today's web applications consists of back-filling for the underpowered thin client tier. To achieve a single business transaction, we have to do a complicated juggling act of the multiple pages, some only conditionally presented, each collecting some small amount of information that has to be validated, and the results aggregated until the transaction is ready.

The Web 2.0 application model is essentially a 2-tier model. It was a little hard to recognize that this transition was happening in the early days when Web 2.0 just meant blogs and wikis. At that time, Web 2.0 just meant content democratization, which is the idea that non-technical users could create and share content on the web without needing to involve web application programmers. This was quite rightly viewed as a revolutionary breakthrough because it did for the web what the word processor did for the personal computer. But if you remember that it takes two points to make a line, and then look at at the history of the personal computer, it's trajectory as a revolution did not become evident until the second killer application of computing, the spreadsheet. This application created what we call process democratization. This is the idea that non-technical users, or semi-programmers, could define how computing power would be dispensed to solve problems without needing to involve high-end application programmers. This was revolutionary because the non-technical users who were enabled to define their own processes were closer to the business problems and also far more numerous. The same thing is now happening on the web, and it is the next phase of Web 2.0.

The Web 2.0 server tier is smarter than it used to be, exposing its capabilities directly to the Web 2.0 client tier with web services, REST services, or feeds and ATOM publishing. Similarly, the Web 2.0 client tier can connect directly to these services without needing the JEE web developer in the middle. Through AJAX presentational libraries like Dojo and AJAX data interaction libraries like Ubiquity XForms, the client is smart enough to drive not just simple user interfaces, but data validation, conditional user interface presentation, and access to web services throughout the end-user fill experience. It is even smart enough to offer webtop design and deployment experiences for these applications.

In this regard, I would like to draw your attention to the most exciting product addition in the new Lotus Forms 3.5 release. The new product, Lotus Forms Turbo, provides non-technical users with a web experience for the design and deployment of data collection forms and reporting functions. To get an idea of how the non-technical user is enabled, see the new YouTube videos on Lotus Forms Turbo. If a picture is worth a thousand words, these videos are priceless, so I'll stop writing because when you see, you'll know!

Going Beyond Office with Interactive Office Documents

For over 15 years now, the solutions built with the software products from the IBM Lotus Forms team have been based on a simplifying system architecture depicted below. This architecture uses a sophisticated, intelligent XML document as the unit of information that flows among collaborators in a business process.

To support such high-value intelligent interaction, the document has a number of layers as depicted below. These layers have different responsibilities. Foundationally, the document format is an XML format, which means it is based on the standard that allows introspection of the document to inject or extract information. This also means the full power of XML signatures can be brought to bear to meet archival and security requirements, particularly non-repudiation of the transaction effected by the business process based on the document. The XForms layer allows representation of a rich interaction layer for collection of structured data content.

Our work on Lotus Forms has been focused on the collection of structured content needed to drive a transaction through a business process, and this has included defining the XML vocabulary called XFDL to allow application developers to build the high precision user interface needed to drive interaction with end-users.

But consider for a moment the great number of situational applications that are constantly being created and deployed around the globe that are based on the requirement to have a mix of structured data and unstructured content. In other words, consider the case of office documents with high business value. We're talking purchase contracts, supplier agreements, insurance polices, RFP responses, financial arrangements, and the like. These are documents that can make effective use of multipage free-flowing unstructured content and graphics interspersed with fill-in-the-blanks content for names, dates, addresses, monetary values, milestones and so forth.

These documents support an important class of live, interactive applications in which multiple collaborators work together to solve a semi-structured content problem. The OASIS Technical Committee for the Open Document Format, in their wisdom, incorporated the XForms model into ODF, and this delightful feat of standards reuse allows us to reap the benefits of ODF's unstructured content creation features together with the interactive structured data collection and both the data and document submission facilities of XForms 1.1 at the same time. The layered document picture looks pretty much the same, except as you can see below the on-the-glass presentation layer is ODF, and otherwise the overall business process system architecture is the same as depicted above.

The result of these considerations is a focus on Interactive Office Documents as a strategic means of going Beyond Office, i.e. going beyond the traditional usage patterns for office documents that have become entrenched due to the office document limitations of the past and instead solving the real business problems that cause people to select the use of office documents in the first place. Using XForms 1.1, office documents based on ODF can be first class participants in collaborative business processes.

Document Engineering Smorgasbord

My last blog was about the best paper winner at the ACM Symposium on Document Engineering, and I mentioned there that I'd make another post to give you an idea of the breadth and depth of the papers presented. So, the bad news is you'll have to wait one more post for me to tell you about my own papers because I want to keep the focus on other people's ideas, and so the good news is that this is that follow-on post.

I can't tell you about every paper, nor even get close, and omissions here should in no way be construed as meaning anything. I just had to pick some. Did I mention it was a really interesting conference?

I was quite impressed with a pair of papers in which natural language processing techniques were used either to extract a meaningful summary of a text (a kind of lossy compression, where we expect high compaction and low information theoretic loss) or to rewrite the text into a format that is easier to read (the intent of which is to increase understanding by persons with literacy challenges). It isn't just the computer science of natural language analysis that excites me here. These endeavors are ripe for formal statistical experimental analysis on human subjects to prove out whether the computing techniques are actually benefiting humanity. That's exactly the kind of high-impact innovation for which IBM itself is world-renowned.

There was a really interesting paper on how to reuse and repurpose unstructured content entitled "Automated repurposing of implicitly structured documents." What interested me first was the work they do to analyze the style applied to character sequences to glean document structure like sections and subsections. But then I realized that what they were really up to was the repurposing angle, where one seeks to apply the content of a document to a new style format based on mapping the gleaned implicit structure from the first document onto the gleaned implicit structure of the second document.

Another interesting work was called PrintMonkey, which is not featured here because its authorship includes people from my alma mater (University of Victoria), nor because it has a really cool name. Simple fact is that the problem it addresses is one that I personally have struggled with, and it's nice to see there's progress being made on it. The issue is that sometimes you need a printed copy of a website, but the default web browser print algorithm is typically not suited at all to paper rendition. It spills over the edges of the paper, or takes chunks of the page and prints them on separate pages (ever print a google map?). But what's neat about this work is not just that they solve the problem but that they do so without requiring participation of website authors AND that they involve a social computing aspect in the work. Specifically, the solution allows people to share prior layouts of the same website. Who knows, maybe someone else has already laid out the site in a way suitable to your purposes. Very Web 2.0.

A short paper I enjoyed presented a concept called content-based identifiers (CBIs) for documents. When you store a document in a content repository, how about storing it at a URI that includes the hash of the document? This way, the document retrieval can be immediately be followed by a check to see whether the document you got has been altered. Moreover, a log of the document history can simply consist of the list of CBIs for the document, possibly followed by a hash of the CBI and its predecessor in the log. This latter step establishes a chain of evidence because the predecessor document must have existed in order for its hash to have been computed and combined with the hash of the current document.

Speaking of change tracking and document versioning, there was a good paper on Merging Changes in XML Documents using Reliable Context Fingerprints. The basic idea is that lots of XML documents contain element sequences, which can make it hard to identify where a patch change should go in the face of merged changes from multiple contributors. The naive method of saying "Change element /doc/e[3] as follows" from one person would break if another person adds a new e[2]. This paper attempts to identify the location where a change should go by doing a best match to node structure and content within a given "radius" of nodes.

A real brain opener for me was a paper about Improving Query Performance by generating XML schemas from system design artifacts that include not only the conceptual information to be manipulated by the system but also expected query workload, the idea being to reduce the number of nodes that have to be touched by a query to produce a result.

The last paper that I can reasonably present in this too-long blog entry deals with adaptability of multimedia document content. This is really a fascinating area that addresses the issue of presenting content in the face of spatial, temporal or interactivity constraints (e.g. limited visual space, limited bandwidth, limited available CPU).

Despite the number of things I did talk about above, I am even more mindful now than before about how many good things I've had to leave out. Hopefully you will at least have a better idea of the interesting concepts presented at this conference and take the time to peruse the DocEng conference series for other items of interest to you.

Next up in this blog, I will take the time to tell you about my own papers at this conference on Interactive Office Documents and Web 2.0 Applications and An Office Document Mashup for Document-Centric Business Processes.

On the Best Paper at the ACM Symposium on Document Engineering

I'm just leaving Sao Paulo after attending the ACM Symposium on Document Engineering. Great conference (people and technical content). I'd like to say more about a number of the other papers, but I'll focus here on the one that won this year's Best Paper Award: Enabling Adaptive Time-based Web Applications with SMIL State by Jack Jansen and Dick Bulterman.

The paper presents a very interesting mix of SMIL, XForms and other technologies to enable end-users to customize their experience of content where time dictates the major structure. One example given is of a video bike tour of Amsterdam created by the first author. Fragments of the video content can be identified and tagged with keywords. During run-time, an XForm is used to allow an end-user to select from the available keywords those which they find interesting, and the corresponding fragments of video are played.

This is the type of thinking that will clearly help make video content a first class citizen on the web. There is significant potential for the use of this technology for stream-lining educative experiences as well. Imagine, for example, a 2-hour audiovisual presentation that provides a thorough introduction to a topic, say CSS. But suppose the end-user really needs to know only about setting up borders on tables. By selecting the content, the user can find out what they need to know in 10 minutes. What's more, it is easy to imagine how the technology reported by Jansen and Bulterman could be refined to attenuate the video content download to the selected fragments.

A second example reported in [1] pertains to ad selection within video content. When you download free video for your favorite entertainment, you're going to get ads and you won't have the ability to skip them because otherwise how do people manage to make a living providing you with this free entertainment?? So, sprinkled through the video will be ad slots with default advertisements lined up. But, in addition there will be hotspots on the video where various product icons may appears from time to time, and if the user clicks the icon, then the default ad is replaced with an ad corresponding to the clicked icon. Thus, you could find out what's new at the electronics shop in lieu of an ad for laundry soap or some such.

It's a great example on the technical side of the need for interactive video, but this is because there's huge market potential for this idea. Not only does the user get a more pleasant ad experience with their free content, but the content provider gets to find out what their audience is most interested in, and the advertisers get to find out what content their customers are most interested in. Very Web 2.0.

I encourage you to download and read the paper.

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

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

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

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

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

XML Data Interaction for All via XForms Modularization

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

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

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

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