Top AJAX tools deliver rich GUI goodness

Backbase, Bindows, JackBe, and Tibco General Interface bring fat features to enterprise Web clients

The buzzword AJAX (Asynchronous JavaScript and XML) is just a few months shy of its second birthday, but it’s already ubiquitous, and even the technology itself has begun to gather steam. Its success is no surprise to some of the major commercial AJAX-tools vendors -- they all started building their packages for conquering the JavaScript layer long before the buzzword arrived. Some are more than five years old, and it’s easy to use adjectives including “mature,” “established,” and “polished” to describe these wares.

For this roundup, we examined four of the leading products, in alphabetical order: Backbase, Bindows, JackBe NQ Suite, and Tibco General Interface. All offer broad widget collections, rich tools, sophisticated debuggers, and development platforms that rival any of the IDEs for traditional languages. Writing JavaScript used to be like taking a trip to the jungle, but now it’s as plush as a five-star hotel.

Many developers begin dabbling with AJAX by downloading some of the well-known open source toolkits (see "Surveying open-source AJAX toolkits"). Collections such as Dojo and Rico are good introductions that let you insert a widget in a Web page without too much work. It’s even pretty easy to link up these widgets to the server with some asynchronous code that syncs the browser page with information from a distant server. The open source kits are fertile, but they still feel somewhat experimental, and much rawer than the top-end, commercial products discussed here. You wouldn’t use Backbase, Bindows, JackBe, or Tibco General Interface to just put a fancy table here or an animated button there, although you could. These are full frameworks that function best when you buy into them and give your entire application over to their structure.

All of these systems are built around full collections of widgets that are joined with a central backbone of events and server calls that link the widgets in a cohesive set of panes. All of the standard parts of a Web form, including selection boxes, text boxes, and buttons are available for your use, but that’s not all. The developers have also automated many parts of a Web page that are normally fairly static. You can make tables reconfigure themselves, adding or subtracting data in response to clicks or distant changes in a database. Events flow across a central bus to all parts of the system -- much like many of the standard object-oriented application frameworks. It’s a programming experience that’s closer to creating a new desktop application than building a Web page, and the results show it. Your packages will look and behave like a desktop application with features such as pull-down menus and panels that aren’t a normal part of a Web designer’s repertoire. I’ve been examining these packages for several years now, yet I’m still floored by how easy it is to add OS-level features such as drag-and-drop icons to your homepage. This is not the 1990s Web.

The major differences among these packages lie not in the capabilities, but in the server support and the finer details of their approach. Although it may be easy to find one widget or design structure in each of the packages that outshines the others, the cores of the four packages are similar, and they’re all built around the standard UI widgets. They’re defined by the fact that all of them manipulate the Click for larger view. DOM (Document Object Model) tree, so they’re all guided by the folks who created HTML and implemented it in a browser. It should be noted that the results from these packages are strictly businesslike, featuring little of the shiny gimmicks associated with early JavaScript development, but this is changing as the packages add more and more animation to the mix.

48FEajaxBackbase.gif
The major differences among these packages lie not in the capabilities, but in the server support and the finer details of their approach. Although it may be easy to find one widget or design structure in each of the packages that outshines the others, the cores of the four packages are similar, and they’re all built around the standard UI widgets. They’re defined by the fact that all of them manipulate the Click for larger view. DOM (Document Object Model) tree, so they’re all guided by the folks who created HTML and implemented it in a browser. It should be noted that the results from these packages are strictly businesslike, featuring little of the shiny gimmicks associated with early JavaScript development, but this is changing as the packages add more and more animation to the mix.

The real differences appear in the integration with the server. Some of the packages expect the server to package the data in Web services. Others have extensive server frameworks that integrate the client application with the company’s databases and machines. All of them integrate with the major server technologies such as JSPs and PHP at some level, but some offer more extensive support for packages such as Java Server Faces and others.

The packages are also maturing rapidly. Although I tested fresh versions of Bindows (2.5), Backbase (3.2) and JackBe (4.6.1), new versions (3.0, 4.0, and 5.0, respectively) are right around the corner. A number of new features are working their way into the core of the projects; the real excitement lies on the edges where the companies are exploring the best way to integrate their core browser development environments with the servers. The vendors aren’t making as many changes to the core architectures of the products these days.

If there’s any bad news, it’s that JavaScript is still a bit flaky and browsers aren’t as stable as we would like them to be. I found glitchy behavior in many of these systems whenever I used them in slightly different configurations. The frameworks do a great job of abstracting away much of the trouble in dealing with JavaScript, but they can’t fix all of the underlying bugs.

Backbase 3.2

The Backbase package was born in Amsterdam, a fact that’s almost immediately apparent because of the European flavor to the design. The product itself uses an XML-based language to link the various widgets. You don’t really write JavaScript as much as drop together XML tags to specify everything from the event routines to the layouts. The code looks as clean and crisp as the IDE.

I’m finding myself split on the value of Backbase’s strict, clean abstraction layer. No doubt this hides much of the complexity of JavaScript in a very tidy way, but it also removes some of the understanding that makes it possible to squeeze out the most performance from the platform. If you’re a programmer who likes to write, as they say, close to the metal, then you’ll be put off by this abstraction. But if you’re the type who likes and trusts the abstraction layer to do the right thing for you, well, then the Backbase approach is heaven.

Backbase is aware that some people feel this way. Jouk Pleiter, the co-founder and CEO, told me that Version 4.0 will offer a variety of programming models. You’ll be able to use the standard Backbase XML, BXML, but you’ll also be able to use more generic Web standards such as XForms and the more standard JavaScript code.

Backbase has been concentrating on beefing up its support on the server. Its packages now include drop-in development tools for Java Struts and Java Server Faces. Microsoft .Net is supported, but only with the generic AJAX Client edition that connects with any server. If you’re heavily invested in these frameworks, then it makes sense to experiment with Backbase. It already speaks the same language, and it makes it relatively simple to drop these into place.

Bindows 2.5

The Bindows package is the most straightforward of the lot. You create your code in a mixture of XML with embedded JavaScript. Most of the layout is defined by XML tags, but some parts of the behavior are defined by creating JavaScript functions. If you want your package to load a bit faster, you can purchase a separate compiler that turns the XML into JavaScript.

The server support is minimal. After you build your application in XML and JavaScript, you let your server deliver it statically. (Using dynamic tools, if you needed to do so you could wire up with little trouble the XML defining the user interfaces.) In the normal design patterns, the server will communicate with the client via SOAP or XML-based Web services.

The Bindows language is one of the saner approaches to this domain. Although the applications are technically defined in XML, there are large blocks of JavaScript embedded in CDATA tags. The result makes it easier to use JavaScript when you need it. Others use a purer, more complete abstraction with a more extensive XML dialect.

48FEajaxBindows.gif
Click for larger view.

That may be prettier, but I’ve found it’s more likely to generate grief when you’re trying to do something in a manner that differs from what the XML language designer imagined. This is, however, largely a matter of taste, and I know competent people who take a completely opposite view.

Bindows is proud of the way its framework makes it easier to comply with the Section 508 regulations that require federal government Web sites to be accessible to the disabled. The Click for larger view. framework comes with additional hooks that pass the events to speech synthesizers for the blind. You can add functionality for the blind by editing a few extra definition files, and the results will be integrated with your site.

48FEajaxJackBe.gif
Bindows is proud of the way its framework makes it easier to comply with the Section 508 regulations that require federal government Web sites to be accessible to the disabled. The Click for larger view. framework comes with additional hooks that pass the events to speech synthesizers for the blind. You can add functionality for the blind by editing a few extra definition files, and the results will be integrated with your site.

The major thrust for development at Bindows seems to be adding more action to more sophisticated graphics. An alpha version of its animation framework lets you morph any of the parameters of the basic object. A linking package lets you link draggable icons with arrows and lines, providing a nice tool for illustrating flowcharts and other processes.

JackBe NQ Suite 4.6.1       

The last time I took a look at JackBe NQ Suite, the product was an IDE that let you build complete applications in a browser. It was like a newer, more streamlined version of Tibco’s General Interface without some of the sophisticated graphics. That core product has gotten better, and the scope of the product line has grown dramatically.

NQ Suite now offers a clean, crisp IDE called the JackBuilder. It’s a more mature approach that’s a bit easier to use. Although the user interface of the JackBuilder tool seems to have fewer buttons than Tibco’s tool, this simplicity may be an advantage. I often found myself getting lost in Tibco’s menus.

The most interesting part of the JackBe toolkit is on the horizon. The company is putting the finishing touches on Presto, a server-based back end for the tool that will knit together a wide range of Web services and translate the data into a simpler form that can be sent to the client. This adds another layer to the software stack in the hopes of reducing Web traffic and simplifying security.

JackBe points out, for instance, that it is substantially easier to consume Web services behind your firewall than it is to release their XML packets directly to the client. Legacy Web services floating around an IT shop may not have all of the security necessary for opening them to the public. It’s easier to let Presto make decisions about each client and then send the request off in its name than to get some uncooperative division to retool their Web service.

Presto also rewrites the XML from the Web services into the generally shorter and easier-to-parse JavaScript or JSON (JavaScript Object Notation). Some suggest that browsers can parse this data dramatically faster than they can parse XML, something that probably varies significantly based on your application.

This change also allows JackBe to enhance the connection. Clients that use Web services must initialize the XMLHttpRequest operation, something that’s generally acceptable unless you want the server to tell something to the browser. For example, a browser-based e-mail system, such as Google’s Gmail, won’t notice a new letter until it initiates a check or you push the refresh button.

JackBe’s Presto architecture can offer “pure push” by keeping the connection up as long as it’s needed. This allows you to build more interactive tools when you need to constantly keep data moving to the user. If you want to build a news ticker or chat into your application, this feature is a big architectural advantage.

Tibco General Interface 3.2

48FEajaxTibco.gif
Click for larger view.

Tibco’s decision to purchase General Interface in 2004 put the stamp of corporate IT acceptance on JavaScript. Since then, Tibco has put much of its marketing muscle behind the product, and it continues to innovate. The current version, 3.2, fixes a number of important limitations of 3.1 and completes a change to open source. (See my previous review.)

1 2 Page
Mobile Security Insider: iOS vs. Android vs. BlackBerry vs. Windows Phone
Join the discussion
Be the first to comment on this article. Our Commenting Policies