General Interface pushes JavaScript farther

While the programming world is in a mad rush to develop complete applications written in JavaScript alone, a few companies are able to claim that they were hacking JavaScript long before the acronym AJAX (Asynchronous JavaScript and XML) appeared. Few have more history than General Interface, a company acquired by Tibco one year ago. General Interface started distributing its JavaScript toolkit in 2001, and now Tibco is slowly rolling out Version 3.1.

Free IT resource TechNet: More ways to know it, share it, and keep it running. Sponsored by Microsoft Free IT resource Attend the SOA Executive Forum: Breaking SOA Bottlenecks SOAExecForum.com/may2007 Sponsored by InfoWorld Tibco General Interface 3.1 Tibco Software, tibco.com/ Excellent  8.8 criteria score weight Capability 9 30% Ease of development 9 30% Documentation 8 15% Performance 9 15% Value 8 10% Cost: Pricing for Professional and Enterprise editions of Version 3.1 TBD; enterprise licenses for Version 3.0 start at $25,000 Platforms: IDE and apps built by it run only on Internet Explorer; future versions will be compatible with Firefox Bottom Line: Tibco General Interface is a friendly, capable toolkit for building sophisticated JavaScript Web applications that run in a browser — Internet Explorer now, Firefox in the future. The results are as rich as the best client applications and as easy to distribute as putting up a Web page. This is one of the best ways to produce big AJAX applications that display large amounts of data on one page. About our Reviews and Scoring Methodology

The system is a complete set of GUI widgets that will run in Microsoft's Internet Explorer. The completely browser-based IDE is written in the same set of widgets, itself serving as one of several very good examples of what the toolkit can do. There are panes within panes to hold the source code, and many of these panes come with multiple tabs, multiple views, accordion tabs, and even some graphs. All of this is loaded from an HTML file, not an executable.

The richness of the interface is surprising. It's easy to build resizable panes -- something that used to seem impossible to do with HTML, at least to me. In the early years, many of General Interface's customers were pharmaceutical researchers, and the company developed a number of slick tricks for fitting plenty of data into what is still technically just a single Web page. These pages can provide inspiration if you're trying to jam a large amount of data into one dashboard for your clients.

"Web page," however, isn't exactly the right way to describe it because the HTML file is really just a wormhole into another dimension running in the JavaScript interpreter. A few simple script tags start up the main JavaScript library, which loads an XML description of the application. As does competitor Backbase, General Interface uses XML as an intermediate language: The JavaScript code on the local browser turns this XML into the HTML actually displayed. Another competitor, JackBe, stores the application as JavaScript, a technique that avoids XML and the need for parsing it.

Is one approach better than the other? Both seem to work quite well, and there's no noticeable performance differences in the standard-size applications I built. Some may prefer the XML for its relative crispness and harmony with the structure. GUIs are naturally hierarchical, a perfect match for the treelike rigor of XML. I personally like JackBe's JavaScript-only approach, if only because it's a bit simpler, hacker-friendly, and perhaps even a bit more flexible in odd cases.

In any case, many users of Tibco's General Interface won't be spending much time with the underlying XML. Although the IDE kindly offers an "expert" window for editing the XML code, most developers will probably stick with the visual drag-and-drop tools. These offer all of the conveniences of most graphical IDEs, something that will amaze anyone who picked up a bad impression of JavaScript from poorly coded Web sites.

General Interface excels in its power to create graphical views of data. You can write applications that draw graphs or other pictures in Internet Explorer's native VML (Vector Markup Language). None of the other toolkits can do this, although JackBe says it is working on a solution. Part of the problem is cross-platform use. Although it is relatively easy to write cross-browser JavaScript, the only way to generate graphics with Firefox and other browsers is to use the W3C standard, SVG (Scalable Vector Graphics). This may be one of the bigger hurdles keeping Tibco from releasing a cross-browser version of General Interface -- something the company promises will be coming soon. Everything developed on Version 3.1 of the IDE will run on Firefox and IE, eventually.

The Tibco product is also the most developer-friendly tool in the bunch. The main editing pane offers five ways to look at the current project. The first, of course, is the visual designer that shows the layout. The second displays the underlying XML. Many visual applications hide this information or at least make it difficult to see. General Interface brings it forward and even lets you edit it.

Yet another view shows the HTML that will be generated by the JavaScript when it processes the XML layer. This information is invaluable for anyone trying to get the look of the application just right. Even though the application is written in JavaScript, the browser's HTML rendering engine decides on the appearance. Seeing the HTML produced makes it possible to understand what is going on under the hood.

Although this feature is wonderful, it could be better implemented. The HTML comes from an automated algorithm that produces just one long string of tags, without any indenting. Yes, this indenting just gets in the way of the browser's parser, but it would be really handy for the human. A useful solution would be some sort of cross-pane selection. If you highlight one widget on the visual page, the corresponding HTML will be highlighted when you switch pages. This would really make debugging much simpler.

The IDE also includes a step-by-step debugger, but it is one of the few places where the Tibco IDE lags behind traditional development environments. You can't insert a breakpoint by clicking on something with a mouse, the common technique in most IDEs. The solution is to add a new line of JavaScript that invokes the debugger. It's a cute trick, but it's not very visual. Plus, if you want to examine the values in a variable, you need to add print statements that send the values to the system log. It all works, but it isn't as sophisticated as some of the classical environments for creating Java or C++. Competitors, including Backbase, have integrated debugging tools that run on the client itself.

Still, these are minor complaints. It's clear that Tibco General Interface is one of the best ways to put a sophisticated user interface in front of people who use only Internet Explorer. The breadth of the widgets is quite nice, and the structure is solid. This review is based on an early release of Version 3.1, a product that will be the first that Tibco releases at two levels, developer and enterprise. The differences between these levels aren't set yet, but the developer version will be aimed at smaller shops without the need or budget for the standard product. This could bring an entirely new market for the toolkit because it's clear that AJAX will be a dominant part of the Web development world.