Archives

Some noteworthy Ajax Framework releases have come out in the last few weeks, along with some other news of interest:

• Ext JS 2.1 and Ext GWT 1.0 Beta – Better performance, new Slider, StatusBar components. REST support (support for other HTTP methods beyond POST and GET). The Ext GWT 1.0 Beta consummates the love affair between GWT (Google Web Toolkit) and Ext that was started by gwt-ext and MyGWT, but provides the comfort of knowing that it is supported by the Ext JS folks. Note: Ext GWT is pure GWT, not an Ext JS wrapper.
• Dojo 1.1 – First off, API compatibility between 1.0 and 1.1. Unified timing loop (ala Scriptaculous) for animation effects, with increased performance. Syntactic improvements to dojo.query. Unification of XHR functionality into dojo.xhr() function.
• Backbase Enterprise Ajax 4.2 – Backbase has been in the commercial framework game longer than almost anyone. Among the new features: hierarchical data bindings and improved performance. If you’ve wanted data binding for tree widgets, have a look.
• Google Search, Feed and Translation API – I opined a while back that Google discontinued their SOAP search API because they didn’t want people reordering or otherwise manipulating their search results. Looking at the terms of use of the new REST service, you can see that this continues to be a concern:  You agree that you will not, and you will not permit your users or other third parties to: (a) modify or replace the text, images, or other content of the Google Search Results, including by (i) changing the order in which the Google Search Results appear…
• Google App Engine – it only runs Python apps right now, and it’s a preview release available to a select few, but you can already see that this is Google’s challenge to Amazon’s EC2 compute cloud. In at most a year, unless you are security sensitive — health care, financial services — or running on Windows, you won’t be building and maintaining data centers. The capital requirements for launching sophisticated and scalable online services is about to change.
• Echo3 (beta) – it’s getting close. Superior performance to Echo2. Easier development of new components. Automatic serialization of objects between client and server. All HTML rendering now done on client. Overall the JavaScript client code is now of a design quality on par with the server code.

Lots of exciting developments for Ajax developers and Web 2.0 entrepreneurs. I, for one, can’t wait to see how the Google App Engine compares to EC2 for deploying and scaling Facebook applications.

Technorati Tags: ajax, dojo, google app engine, gwt, ext js, backbase, echo3, google search

I’ve long been a proponent of server-side Ajax frameworks — frameworks that store state on the server and use an Ajax engine in the browser to drive the display. The advantages: state and control logic stay on the server, so security compromises that exploit client-side state and logic are more difficult to pull off; developers can work in one language and, for the most part, ignore the fact they are writing a web application. The disadvantages: the server retains a large amount of state, so scaling your application can be problematic.

There’s one other large disadvantage to these open source server-side frameworks: for every 100 Java developers who use the framework, there is only 1 of them that can do serious JavaScript development. That means that the lifeblood of these frameworks — the development of new and cool JavaScript widgets — is sluggish at best. That has certainly been the case with the best known 3 frameworks: Echo2, ZK and ThinWire (though ZK does wrap a number of Ajax widget libraries, such as Dojo).

Echo3 is showing a few more signs of life. Since my update last month on some early details of Echo3, the pace has picked up. No alpha release, but already there are two forums, one especially for folks looking to contribute to Echo3 development. Also, a few other things worth mentioning about Echo3:

• The SVN repository can be found at svn://svn.nextapp.com/echo3/trunk (Echo3Extras are at svn://svn.nextapp.com/echo3extras/trunk).
• If you just want the binaries (or binaries with source), the Echo3Go project is handy.
• Initial performance numbers of Echo2 vs Echo3 show a more than 2x improvement in performance.

Further, a more detailed description of the new features, design principles and ideas behind Echo3 can be found on the wiki. Two items that are especially interesting for those looking to write their own components:

• Automatic Serialization: Data objects sent between client and server can be automatically serialized between Java, XML, and JavaScript. The serialization architecture is extensible–serialization code for new object types may be added by the developer.
• Simplified Client/Server Synchronization Peers: Serializing components and commands between client and server is performed automatically using the built-in serialization architecture. The component developer only need specify which properties should be sent (for components, all local style properties are automatically sent).

Serializing and deserializing data between client and server can be one of the more timeconsuming and error prone parts of developing Ajax apps. Packaging this into the framework with improve productivity at the very least.

Technorati Tags: ajax, echo3, echo2

Some hopeful news on Echo3:

• First, it is close to a release.
• Second, there are more developers working on it.
• Next, they have a new web container architecture:

In Echo2, we used the client as a remote “canvas”, upon which to “render” the state of an application that was running on a server. We sometimes did this by sending down blocks of XHTML code, instructing the client to add the new code to its DOM. We sometimes did this by sending XML directives that would invoke JavaScript code to render an HTML representation of a component on the client. In both cases, the client did not have any real information about what components were being rendered to it. It was simply used as a display.

[...]

With Echo3, the client gets smart. The first step was to create a version of Echo that ran entirely on the client, that is, a JavaScript version of Echo. This has been done to such an extent that, if desired, Echo 3.0 applications can be developed in client-side JavaScript without the need for a server at all (this topic will be discussed at length later).

The mission of Echo 3.x is still to enable advanced web-based application development in server-side Java code, just as it was with 2.x. Just like in 2.x, the developer is not required to write any client-side JavaScript. From the end-developer’s perspective, this still works in 3.x in the same way it did with 2.x. You still write server-side, object-oriented and event-driven Java code, and the application state magically appears on the client. Behind the scenes though, the process by which application state is synchronized between the client and server is quite a bit different.

In Echo3, we serialize the state of an application between client and server. As we now have the application framework running on the client as well, this is quite easy to do.

As another poster observed, it should be possible to write Echo3 apps in other languages besides Java on the server side, plus it looks like writing components will be much simplified.

I’m still waiting to hear, though, how the community will be able to contribute to Echo3, rather than the current wandering wiki/forum zip file.

Time to update and extend the tutorial.

Technorati Tags: ajax, echo2, echo3

Aejaks, a Tcl/Tk style framework built on top of Echo2, has a new version out: 0.5, now considered Beta. What’s in the new release?

• Echo2 Extras widgets – MenuBar, Drag/Drop, TabPane, TransitionPane, etc.
• Echo2 Chart widget
• Echo2 FileTransfer widget & Download command
• TaskQueue command – update widgets asynchronously
• Nuvola icon set -3,700+ high quality icons ready to use
• Updated widget_tour demo to show off all new widgets
• Download packages now split between exe and src; separate war file can also be downloaded which runs the widget_tour demo.

Check out the project news page and the 0.5 CHANGELOG.

Technorati Tags: ajax, echo2, aejaks, tcl, tk

We can see the beginnings of IDE support for Echo2 in NetBeans. This isn’t close to the commercial plugin for Eclipse provided by NextApp, which, among other things, provides a widget tree and property editor that eases UI assembly. But the nbecho2support module does a couple of useful things for you. First, it will create an Echo2 webapp project for you with Echo2, Echo2Extras and the EchoPointNG libraries already included. Also, the web.xml file is already configured (though you will have to edit the default index.jsp to redirect to the /app url).

The one Echo2 specific filetype that can be created is the Echo2 style sheet, default to blank. So, definitely a useful module for those who want to work with NetBeans, with plenty of room for improvement.

Technorati Tags: ajax, netbeans, echo2

Just stumbled across this not quite ready Google Maps component for Echo2 over at Sourceforge. Hacim Bengalis over at his blog has taken this work and presents the code changes necessary to getting it to work with Echo2. Basically, he registers his own service (i.e. the stuff that gets run at start time for an Echo2 session, as I recall) that injects the Google Maps Javascript include into the page.

    /* add google maps api */
    baseDoc.addJavaScriptInclude("js/googleload.js");

If you read French, then this fellow claims to have done it without having to register his own services, i.e. with a stock Echo2.

The solution use the component HttpPaneEx from EchoPointNG (I guess this is standard library for most Echo2 users). This component creates an HTML Iframe in which you can display any HTML pages : even one using GoogleMaps. Next, you need to interact with it. The trick is to use method enqueueCommand and JavaScriptInclude and JavaScriptEval object from Echo2 to trigger javascript from Echo2.

I recall that when I tried this with Echo2 2.0.x, I had issues with the Echo2 client engine capturing events and making the Google maps component do weird things. His tutorial looks extensive; anybody feel up to translating some French?

Technorati Tags: ajax, echo2, google maps

Will Gilbert has contributed a handful of validating form field components. Take RegExTextField, for instance. It will take a regex and, surprise, validate the input against it. Maybe not earth shattering, but handy nonetheless.

Technorati Tags: ajax, echo2, components

Kenneth Riggio has put together an Echo2 sample app — a single player Blackjack game.

He was kind enough to put up his source code and even gave a hat tip to my getting started tutorial.

Technorati Tags: ajax, echo2, games, examples

Tod Liebeck dropped some tantalizing hints on the future direction of Echo2. First, it won’t be Echo2, but Echo3! Sounds like the development of custom components will be a touch easier too.

The next version isn’t 2.2, it’s worth of a full version number change. We’re almost ready to do the initial announcement on this one.

The Echo 2.x method of rendering component state to the client is all gone, component state is automatically serialized to the client for you (and changed properties on the client are automatically serialized back).

Another result of the Echo2/Cooee fork? You decide.

Technorati Tags: ajax, echo2, echo3