A lot has happened in the years between then and now, and it was cool to see that TIBCO has taken General Interface and donated it to the Dojo Foundation. GI is a very cool tool indeed and in many ways was probably ahead of its time as a browser based rich tool.

Dylan has talked about how the Dojo foundation was happy to bring in a great tool so people don’t have to reinvent the wheel. Over time, we should see nice integration within and outside of Dojo the toolkit itself.

When we posted the last podcast on Aptana Jaxer, someone commented on the fact that Kevin Hakman was there, and “Doesn’t Kevin Hakman work for Tibco? What does he have to do with Aptana?”.

Aptana has now come out with the news that they have hired Kevin:

We are excited to announce that Kevin Hakman has joined Aptana to head up marketing and developer community programs. Kevin is a recognized leader in the Ajax community. Long before the term “Ajax” was coined, Kevin was pioneering single page web application concepts via the company he co-founded, General Interface Corp., one of the first enterprise Ajax libraries and visual development tools companies. General Interface Corp. went on to be acquired by TIBCO Software in 2004 as a compliment the company’s service-oriented architecture (SOA) products. Today TIBCO General Interface is used by many Fortune-scale companies for rapid Web application development and deployment atop their XML and SOAP data sources.

In addition to his historic role on the steering committee of the OpenAjax Alliance, Kevin currently chairs the organization’s integrated development environment working group. The OpenAjax Alliance IDE Working Group which includes Adobe, Aptana, the Eclipse Foundation, IBM, Microsoft, Sun, TIBCO and others is now close to delivering a draft specification for a uniform way to describe Ajax libraries and controls and thus streamline the ability to use Ajax libraries within your development tools of choice. Kevin is a frequent speaker at Ajax industry events and is an author to many published articles on Ajax in the enterprise.

I asked Kevin a couple of questions about his move, comparisons between the companies, and the industry in general.

What similarities / differences do you see between pioneering heavy JavaScript on the client w/ GI and JavaScript on the server with Aptana

GI and Aptana’s primary application models are different to serve different purposes similar to the way that Java has multiple presentation tier architectures for differents kinds of apps: Swing, SWT, AWT for application GUIs and JSP, JSF for generating web pages. With GI, the concept in 2001 when we deployed some of the first “Ajax” apps pretty much evolved from a need to migrate software-style GUIs to the Web and a technical approach summarized as “we like Java Swing, but not the JRE dependency, so let’s do something Swing-like in JavaScript with a JavaScript VM of sorts and get data as XML / SOAP via the XML HTTP Request Object — an oh yeah, make it Visual Basic-like easy to visually develop too”. That led to what I call a “Client-Services” architecture where you have a full fledged JavaScript application running in a web page talking to back-end data services plus the WYSIWYG rapid development tools for which GI has been recognized as best in class in enterprise IT journals. With GI, you never really interact with the HTML page or its DOM. Instead there’s a higher abstraction of application concepts and a model of the GUI, called “dual DOM” by some. The result is that the JavaScript applications are deployed into a webpage more like an applet, (except it’s all in the same JavaScript memory space and there’s no JRE dependency of course). This “Client-Services” architecture has been a great fit for many enterprises pursuing service-oriented architecture strategies.

Aptana Studio is clearly among the best-in class for the predominant model of Ajax development called “single DOM” where you work directly in the HTML DOM to describe elements within a page, then apply Ajax and CSS concepts to bring that page to life with interactive features. Aptana Studio meets the needs of Ajax developers working in this model extremely well. Whereas tools for web page development have historically focused on layout, image placement, styling, and JavaScript for roll-over and simple navigational assists, Aptana saw that with Ajax and the popularity of all the single-DOM model Ajax libraries like dojo, Ext, prototype, MooTools, and jQuery, the page was becoming increasingly programmatic in the client and needed tooling optimized for the programmatic page.

What excites you about Aptana

Aptana Jaxer is a very cool concept for all the JavaScript developers out there because they can now go boldly where no JavaScript developer has gone before–to the server-side. Sure Netscape had LiveWire back in the day, but remember there was no real DOM, no real CSS and certainly no XHR object at that time. Aptana Jaxer’s genius is that is takes the same Mozilla engine we know and love in the browser, and puts it inside a server along with a bunch of handy Jaxer methods and properties to do server-side things like interact with databases, web services, session concepts, sockets and more. I personally love the ability to write a script that runs on the server, but call it from the client as if it were running on the client. In this case Jaxer handles all the sync or async communications for you transparently, and soon will provide end-to-end debug capabilities as well. We’re also now working with Joe Walker of the DWR project to extend this kind of capability to remote Java objects as well through Jaxer. We’re also investigating how to best interoperate with Microsoft’s .NET platform.

To some, JavaScript is not a preferred language and that’s where things like GWT and DWR come in real handy. At the same time there’s millions of developers who like the ease and mutability of JavaScript. Aptana Studio, with its JavaScript debug and type inference capabilities, and Aptana Jaxer with its server-side power enable all JavaScript developers to do much more, more quickly in the language we love to work with — JavaScript! Thinking beyond the solid JavaScript programming tools in Aptana Studio today, things like visual WYSIWYG GUI composition and data-binding are clearly natural extensions. Not many people know that the Aptana team contributed to much of the Eclipse Monkey code which enables JavaScript to run within and communicate with Eclipse’s APIs. This means that Aptana is extraordinarily well positioned to execute a first-class solution for WYSIWYG editing — and further streamline the creation of Ajax web pages and full-featured Ajax applications.

Now you have been around JavaScript for awhile, what are you likes and dislikes, and do you have any thoughts on JavaScript 2?

Having been part of Ajax projects where we had single HTML pages running for 9 hours sessions with over 180 separate application modules you could load/unload during that time (and that was in 2001), the GI core team (Luke Birdeau, Michel Peachey, Jessee Costello Good, and myself) has had loads of experience in what it means to make highly scalable, full featured apps in JavaScript. Much of what we had to invent and implement in JS1.5 for the TIBCO GI Framework, things like object orientation for example and better memory management, is on the horizon for future releases of JavaScript. The primary pain of JS though, until recently, has been lack of great debugging, type inference, and code assist capabilities. What few people realize about Aptana Studio is that it not only code assists on the Ajax libraries you’ve loaded, it assist with the Ajax objects, classes, packages, functions and properties that you create too — again a concept borrowed from the Java community, but with less programmatic overhead since its JavaScript.

gi.js is a library to help integrate DWR with TIBCO GI. It is due for official release with DWR 3.0, however it is reasonably stable now, and will probably only undergo performance tweaking before the official 3.0 release.

Since it doesn't have any dependencies on DWR, it can be used without waiting for an official release. The best place to download it is either via a milestone release of DWR (see the java.net download page), or through the FishEye view of the DWR CVS repository. See this direct link to gi.js.

The article walks through a simple example integrating with a fake social network backend:

• How long did it take that service to respond?
• How long did it take for that component to render?
• How long did it take that data to parse?
• How long did it take for that function to execute?

Check out the Craigslist example which uses three Ajax libraries: TIBCO General Interface, dojo for offline capabilities, and Google Maps.

When you setup tests, you do so with a simple DSL:

To get started you first pick a locale, then a category, then do a search. You can also add multiple regions and categories too.

Here is a quick demonstration of the app in action:

Your components must:

• Must use General Interfaceâ„¢ v3.4.1, an open source Ajax toolkit from TIBCO with over 100 Ajax components and a suite of visual tools.

• You may also include other Ajax components and libraries if you wish.

Ben and I will be helping out as judges, so we are interested to see what creative ideas come in.

The open source home page features the full downloadable source online (SVN and SVN Web), an online bug tracking system (JIRA), and build tools to make it far easier for you to extend GI and create optimized GI libraries for your Ajax application projects.

Download the latest release, or view the releast notes (pdf).

TIBCO GI has released a new test automation kit:

To further support rapid Ajax application development cycles in the enterprise, TIBCO has released TIBCO General Interface Test Automation Kit, a free, open source kit optimized for functional, unit and regression testing of solutions built with its TIBCO General Interface Ajax toolkit. The testing suite extends the popular Selenium TestRunner open source project with additional libraries and features that streamline the testing cycles for Ajax applications, components, and portlets.

It is a very smart move to take Selenium and add features on top of that, instead of starting from scratch.

In this article you will learn how to create a new Ajax RIA front end to an existing Apache Struts2 .jsp application using TIBCO General Interface (GI), an open source Ajax toolkit with a MVC architecture similar to that of Java Swing. GI is optimized for creating business productivity applications and communicating with XML, SOAP, JSON and other types of services in a SOA.

Specifically we’ll extend the Struts2 CRUD (create, retrieve, update, delete) sample that comes with its installation to expose XML data services optimized for GI interoperation and create the Ajax application that connects the end user with those services though a rich graphical user interface. The intent behind this approach is to demonstrate how you can make incremental changes to existing applications rather than having to rewrite from scratch.

Due to its history, many of the TIBCO GI deployments are behind corporate firewalls, but Xignite is showcasing its financial web services with a great TIBCO GI example. The source code for the Ajax app is availableand it shows what it means to build a full-fledged Ajax application (as opposed to enrich HTML pages with Ajax features).

A side effect feature is also interesting in its own right. You will notice the smart tour guide that can take you for a ride, or watch what you are doing and give you some information. This could be a nice learning tool for your application, as long as you do go as far as Clippy.

With a traditional request/response model, DWR (and Lightstreamer) would be calling GI routines to update. With the pub/sub model the distinction between client and server is gone because the UI publishes things it's interested in back to the hub. There's no reason the UI has to be GI even: any UI that groks the OpenAjax hub can play. We could even have several UI components listening to the same messages on one page.

The OpenAjax Hub is getting close to a 1.0 release, and I'm hoping that DWR will have a server-side version of the OpenAjax hub soon after. This would allow you to transparently co-ordinate remote hubs, and even allow publishing of messages from one browser to another.

I've put the DWR version live so anyone can have a play. It's not exciting, but you can see it in action. Just click on an "Industry Sector" to see messages published to that sector. See the DWR/OpenAjax/GI demo. I hope to move where it is hosted soon, and this is definitely something of a test, so don't be surprised if you get a 404. I hope we can get a demo of the Lightstreamer version live soon too.

Ajax RIA + Portal + SOA = Success for H&R Block

H&R Block Sr. Systems Architect, Dan Cahoon, shares how H&R Block delivered SOA-connected Ajax portlets to its more than 12,000 branch offices to deliver composite workspaces streamlining the staffing operations for the nation's largest seasonal employer. Dan shares his learning from the project and discusses the successful pattern they are reusing to get more solutions to market quickly.

How to Deploy Ajax Portlets to JSR-168 and Other Portlet Containers

Howard Weingram, Sr. Architect for TIBCO PortalBuilder, shows you how to deploy rich Ajax portlets to JSR-168 and other types of portlet containers and more...

The Role of the Proxy in Creating Ajax Mashups within Portals

The role of a proxy in accessing data across hosts and domains.

An Ajax "PageBus" for Client-Side Pub/Sub in Ajax & Portlets

How to architect for modular applications that publish and subscribe to events and message using an Ajax PageBus architecture.

The new release adds support for IE7 and Firefox 2 and boosts performance to caching, application init times, and large data set rendering.

TIBCO GI 3.3 contains:

• 100+ Ajax Components for Ajax GUI, Data, Communication, & System objects
• Visual Tools
• All Open Source BSD Licensed

This is good news for both parties:

• TIBCO GI users will have a new way to integrate with Java web applications
• DWR: The integration work between DWR and TIBCO GI will probably help integrate with other frameworks. Changes made to DWR to work with GI will be exposed for other work. For example, the DWR team will look at automating the currently-hand written server-side version of Scriptaculous Effects.

JBI users may get some tighter integration too, making your life easier. We are excited to see what comes of this.

More details (from the Press Releases)

TIBCO will work with DWR founder, Joe Walker, to provide ready-made integration points between DWR and TIBCO General Interface™, TIBCO’s Ajax Rich Internet Application toolkit for creating rich graphical GUIs in a browser. Additionally, the collaboration will seek to extend DWR so that it can function as a Java Business Integration (JBI) standard service engine and be deployed on TIBCO ActiveMatrix™, the industry’s first service virtualization platform. The complementary components of DWR and General Interface™ will ultimately enable businesses to expand their uses of message and event-based service-oriented architectures.

“We are excited to be working with TIBCO to push adoption of DWR further into the enterprise,” said Joe Walker, DWR founder. “DWR has been a leading Ajax framework for some time but working with TIBCO will help take DWR further into the realm of full Ajax Rich Internet Applications being deployed alongside message and event-driven service platforms.”

With substantial application modernization efforts underway and a continued trend towards SOA in business, the combined Ajax libraries of General Interface and DWR will provide capabilities that deliver rich user features such as editable grids, real-time events and notifications, and streaming data. By running on Internet technology rather than operating or runtime environment dependent technologies, businesses will experience much lower costs of ownership.

“DWR is a rapid way for Java developers to expose Java objects as simple Ajax services without the need for additional configuration or transformation. We have many customers already using DWR with the General Interface Ajax library,” said Kevin Hakman, director product marketing, TIBCO General Interface. “With DWR’s reverse Ajax capability, messages and events can be pushed from the server to the browser so that Web applications can also have real-time notification and streaming data features.”

Read Joe Walker's thoughts

In Episode 19 (~28MB, MP3 format), we discuss:

• What happens to the price of your product now that its open source?
• Why are you open sourcing TIBCO GI now? Did you fail in the marketplace?
• Just to be clear, can I use TIBCO GI to create something like Flickr, put it on-line, and never pay you anything?
• What's in the new 3.2 release?
• What motivated your port to Firefox?
• How hard was it?
• What other browsers do you support?
• How well did the VML code port to SVG?
• How does the performance of TIBCO GI apps differ on Firefox versus IE?
• What were some of the key shortcomings preventing Safari support?
• How much of an impact will Firefox's upcoming JIT make on your product's performance?
• You used SVG instead of Canvas to render your charts in Firefox; why?
• TIBCO GI's IDE environment is in the browser itself; why did you make that decision?
• How does GI fit into the Ajax ecosystem? Why use it instead of one of the other Ajax frameworks?
• How easy could I add Scriptaculous or Dojo to a GI app today?
• How many different UI widgets do you have? What are some of the funnest widgets you've done?
• What is the architecture of TIBCO GI app like What
  server-side platforms easily integrate with a TIBCO GI view?
• Is GI meant to build desktop apps that happen to run in a browser, or
  to build web apps?
• Do you support Comet-style architectures?
• How extensible is TIBCO GI? Can I start creating my own widgets and incorporating them into the IDE?
• How is the open source project being run? Who are the committers? To whom would I submit patches?
• How good is your project's documentation?
• You mentioned "pixel-perfect" fidelity between IE and Firefox with TIBCO GI apps; does GI give you full pixel-level control?

We recorded the podcast at the same time we did the screencast that we released earlier.

The intent behind that release was to enable developers to use and deploy the product at no cost under the terms of the BSD license.

Now TIBCO has taken the next step, bundling the fully commented and unobfuscated JavaScript source with the product download so that it can serve as a reference to those that really want to get in under the hood and see what makes GI tick.

TIBCO also states on the GI download page that implementing a full open source eco-system will occur in phases.

• Phase 1: Source code is provided with the download for use as a reference. The product and its source are free to use under a BSD license; Full support, warranty, and more is offered under separate TIBCO agreements.
• Phase 2: Source compilation, compression and obfuscation tools will be provided so that you can generate optimized runtime code for multiple platforms from your modifications to the source.
• Phase 3: Community contributions under separate contributor agreements for those that want to contribute their good stuff.

Developers wanting to create modifications and extensions to the GI libraries can now do so more easily with access to the fully commented source. However close inspection of the source will reveal that the raw JavaScript source can also be run through a “pre-compiler” that compresses, obfuscates, and generates separate runtimes for each of the supported browsers—and that pre-compiler will not be out until Phase 2 of the open source implementation process. In effect the source code has forks in it for various browser types, but the pre-compiler generates optimized code for a single browser, thus increasing performance and shrinking the footprint while packing in lots of capabilities.

With over 100 Ajax components, it’s pretty amazing all the features the GI team can get into such a small footprint. Taking a peek through the source reveals some of the ways the GI team whose been in the Ajax business for 5 years now, has architected the product to do so much with so little.

You can download GI and its fully-commented JavaScript source @ developer.tibco.com.

• Open Source License. Yes, GI is open source!
• Firefox support

There are many other items of interest too, such as SVG charting, and the load time optimizations.Ben and I got to sit down with Luke Birdeau, the Lead Engineer of TIBCO General Interface. We got to interview him, and also did a screencast with him to get a better understanding of the TIBCO GI toolkit.

The screencast covers:

• The TIBCO GI interface. Loading up your dev environment in Firefox
• Using the new to 3.2 Matrix component that slices and dices
• Using the drag and drop interface to quickly put together an Ajax component or application
• Using rich trees (as part of the Matrix) and some of the more advanced abilities
• Using a datamapper to bring in data via any service endpoint (XML over HTTP, JSON, WSDL, etc)

It is really worth checking out this short screencast as it shows you what a pow
erful tool GI is, and we are constantly surprised at how fast and feature full i
t is. Sometimes we get excited at a new Foo components for Prototype, and then
we remember that GI has hundreds of components :)

The answers are interesting so we wanted to get the entire community into the loop:

Q. Can you explain the license options? When do you need enterprise etc?

The two editions provide a variation on the familiar "dual license" model that many open source products have pursued. The primary idea is
to provide the software under terms that make it free for any use, then offer value added benefits such as access to TIBCO's enterprise-grade
support services and stronger license terms with warranties and intellectual property protections through a separate license and support agreement for organizations that want those things for their more critical development and deployment cycles.

What were the challenges with the Firefox 1.5 port?

Firstly there's just so much in TIBCO General Interface. There's now
over 100 ready made components plus the whole visual toolset that goes
along with them.

When I was discussing our progress on Firefox with Alex Russell of the
Dojo Foundation early this year, telling him that we had most of the
communications and data and other components in place, he correctly
predicted that the cross-browser GUI stuff would be the more difficult.

TIBCO General Interface is known for it's "dual-DOM" architecture--
developers interact with a higher-level applications concepts in a DOM
of widows, dialogs, sliders, editable data grids, charts and data series
as opposed to the SPANs and DIVs in the primary rendering DOM, then in
an MVC architecture that high level DOM gets rendered into SPANs and
DIVs and VML/SVG and JavaScript. The net effect of the 2nd DOM is an
abstraction layer that allows the GI libraries to more easily handle the
rendering differences between the browsers (and lots of other things
like further automating garbage collection for long running sessions).

At the baseline, even rendering a rectangular region in IE and FX has
differing behaviors. Getting the rectangular region to render is easy.
It's the behaviors for that rectangular region of the screen that get
tricky -- namely with resizing. So we wrote an intermediary
jsx3.gui.Block class that adds managed resizing and dynamic layout to
the rendering of DIVs in Firefox to that there was parity with what we
had out of the box through Internet Explorer.

What went easy? Porting the GI vector charting package to FX was a feat
too. Again the abstraction model make this easier than we though it
would be. We did hit one hiccup along the way that required the
containing HTML page to be XHTML for the SVG to render, but Alex and
Dylan at Dojo were kind enough to point us in a direction that overcame
that issue -- so use the charts in any context now. No longer an XHTML
restriction.

What about support for Firefox 2.x?

Like IE7, FF2 is in pre-release states, so we're looking at those as
they mature and come to their general releases.

What other features are snuck in there that get dwarfed by the big
announcement?

There's a new Swiss army knife of a component we've added in 3.2 called
"Matrix" (jsx3.gui.Matrix). This single class supports list, grid,
tree, tree-list, and tree-grid, and categorized-list and
categorized-grid views of data. It handles both two dimensional and
hierarchical data sets and includes built in lazy-data display modes for
various pagination models including scrolling to the end of your 20,000
item list and seeing the last X rows, and heuristically scrolling
through large data sets such that the data you need before you scroll to
it is gathered and rendered in anticipation of where you're scrolling
to. There's also more than a dozen new editable data cell prototypes
built upon a simplified and easier to expend model for creating editable
cell types of your own through the jsx3.gui.MatrixColumn class.

The initial footprint and thus load time is smaller. Classes now load
as needed rather than the kitchen sink all up front.

There are enhancements to the jsx3.util.Logger class, a development time
and runtime logging utility based on Apache's Log4j project.

We're still in beta, so full docs and more resources are forthcoming as
you can imagine. However one change in this area is that there's a new
TIBCO Developer Network site @ developer.tibco.com, that's wide open to
public access. Previously you had to fill out a form and provide your
mother's maiden name to get access to the software and its developer
resources. Not any more.

For people just getting started with TIBCO GI, version 3.1 of the
product has more docs including video tutorials. Viewing those would be
a useful quick start, but reading the 3.2 release notes and the 3.1 to
3.2 migration guide would be essential to understand the differences
between 3.1 and 3.2 (with the added benefit of understating what else
was packed into this release.)

All that said, it's important to remember that TIBCO General Interface
is primarily for building business productivity solutions that connect
to point services (using what ever server tech you want) we well as
enterprise SOA service buses. We're not trying to be all things AJAX to
all people. But we do want to make GI the best thing out there for
making Web apps and components that look and feel like desktop GUIs.
The addition of Firefox enables us to reach nearly every business users'
desktop -- a place where IE or FX are pretty much ubiquitously present.
Plus as we showed at JavaOne earlier this year and will again at The
AJAX Experience, you can actually use Dojo and other AJAX components
within GI. We're continuing this work with Dojo and others through the
OpenAjax Alliance to make Ajax libraries increasingly interoperable.

There are also other new features such as:

• New Matrix control: Grids and Lists, Trees, Tree-Grids and Tree-Lists, Built-in incremental data acquisition and display features. Many new column types including date, time, dialog, slider, color, and pretty much anything you could put in a block
• Smaller initial footprint and enhanced package loading times
• Configurable development time, and runtime deployment paths
• Chart package implemented in SVG
• API and visual tooling enhancements throughout

Read more:

• TIBCO GI 3.2 Release Notes
• Press Release
• TIBCO GI Resource Center

We just heard that the support is available in a beta: TIBCO General Interfaceâ„¢ 3.2 Beta 1 with support for Firefox 1.5 is now available and also includes the following features:

• New Matrix control combines Tree, List and Grid capabilities and adds built-in support for large data set scrolling and pagination
• Chart package implemented in SVG to enable execution in Firefox without a plug-in
• Load-time optimizations with automated fine-grain and deferred class loading
• Deployment path flexibility
• API and visual tooling enhancements throughout
• Plus lots more as described in the release notes

NOTE: The TIBCO team will be at The Ajax Experience in Boston on October 23-25.