Livegrid extension for GXT/Ext-GWT in the works

There is apparently soon going to be a livegrid implementation for GXT/Ext-GWT, similar to the one that exists for ExtJs, SmartClient/SmartGWT, and ItMill. There is already a demo and all (no source or anything else) – but worth checking out out anyway. And the announcement.

I personally have no idea whether paging is better than live grids for usability – none of the rich UI desktop systems I’ve worked on used paging (10000 or even 100000 rows is not too bad for the user if responsiveness is good and sorting/drilling is organized well), however none of the web apps I’ve developed or used had more than 200 rows per “page”.  I think the key is in the UI organization around the grid and visual responsiveness of components…

SmartGWT portal is getting ready

I’m sure by now the news of the new GWT widget framework – SmartGWT – has reached developer circles. Sanjiv has done a great job bringing out yet another great javascript framework to the java/GWT development world.

There is now also a little portal example that is getting integrated into SmartClient and SmartGWT – here is the forum post announcement and the demo after the break.

Ext-GWT 1.2 is out – drag and drop it all

oh, yeah – GXT 1.2  is out – choke full of new goodies (mostly around Drag and Drop), grid data binding, bug fixes etc. Don’t know about you, but it seems to feel a little snappier with this release, at least on the few individual examples I tried…

GWT asynchronous loader now in trunk

Back from blogging hiatus. Rejoice my fellow geeks! Asynchronous java(script) loading is now part of GWT trunk – post 1.6 it seems. The r3901 merge has done it, and you can now fearlessly start hacking your way through this very early, although looking pretty mature feature. It’s now time to whip out all all of your 1Mb+ GWT modules and break them apart into a thousand 1K pieces 😉

what does the code look like you might ask? Here you go:

GWT.runAsync(new RunAsyncCallback() {

public void onFailure(Throwable caught) {
callback.onFailure(caught);
}

public void onSuccess() {
callback.onSuccess(onInitialize());
}
});

where onInitialize() can have whatever your complex nature desires.

Haven’t tried this particular build yet, but looking forward to, in a few days.

gwt-mosaic project – GWT/incubator/gwt-dnd put together…

There is a new framework on the GWT block – gwt-mosaic – which is basically a cleverly put together collection of widgets from GWT, gwt-incubator, and gwt-dnd. On the surface the showcase of the framework looks very similar to GWT, but soon enough you’ll realize the little but very important things it adds to GWT like more advanced dialogs, additional layouts, tool buttons, treetable, paging scroll table, etc. Since these widgets are based on already available and tested ones from Incubator and gwt-dnd, this new framework even now looks pretty good and is relatively stable.

It’s a very early version right now, but I think is worth following. It’s licensed under Apache 2.0.

Ext-GWT 1.1 is out

There is a new version (1.1) of Ext-GWT library available with all kinds of goodies – Grids, Bean Model/Factory,Web Desktop, Slate theme, Live Combo Box. Slick stuff and definitely a great framework that anyone starting in GWT needs to consider!

One thing I wish for is that Ext-GWT was better interoperable with native GWT widgets/layouts. But maybe it’s just wishful thinking on my part, since I also understand the complexity of getting RIA stuff work smoothly across the browsers and various hacks developers put into place to deal with cross browser issues.

GWT, Maven2, and Eclipse – living happily together (Part 1)

I wanted to post some instructions for getting GWT compiler working with Maven2, at least the I way I use it in some of my gwt development. I hope developers using Maven for their build will find this useful, since unfortunately GWT  doesn’t support maven out of the box. There is a third party Maven2 plugin already available for GWT, however I personally find that using raw GWT compiler is rather more flexible.

GWT wrapper for Dojo (Tatami) v. 1.2 is out

There is a new drop of Tatami project available . Tatami is a GWT wrapper for a famous Dojo javascript library. It looks pretty neat with some newly added widgets: Grid, Spinners, MD5 hash library.

One thing however I don’t understand is the licensing for Tatami project – it’s LGPL – versus typical BSD that Dojo uses or Apache 2.0 license that GWT uses, especially considering the fact that LGPL is really a rather gray area as related to compiled code, such the one that GWT compiler produces.

LombardiSoftware’s Blueprint upgrades to GWT 1.5

good folks at Lombardi Software’s Blueprint team posted their review of the migration to GWT 1.5 and what it means to performance of their project. Here are some interesting nuggets from the post:

• …I was also surprised that converting longs to doubles made as big of an impact as it did.  We don’t have many usages of longs.  Most of them are a couple dozen timer instrumentation points but converting them made a noticeable difference.  The long emulation must be particularly slow…
• …I would say that this shows we’re getting around a 10% reduction in time with a simple upgrade from GWT 1.4 to 1.5 and even an improvement on the Diagram.  This is a simple win as far as we’re concerned….
• …The GWT compile time increased pretty dramatically from 55 seconds to 321 seconds which is almost six times longer.  I’m more than happy with the tradeoff between this and the new features we get with 1.5….
• …The generated OBF code increased in size.  We went from 673,876 bytes to 748,574 bytes (+11%) in uncompressed size on our largest module.  The total application is about 36,000 lines of GWT compiled code (excluding comments and whitespace) and that doesn’t include double counting lines that are reused in multiple modules…

another GWT example – BrightPages.com

“We recently ported the site http://brightpages.com from Struts to GWT. As others have experienced, we had quite a ride porting to GWT framework. Being a public website, we have had to deal with issues like making the site accessible to crawlers and minimize the network traffic. We still have some UI bits rendered from server as GWT’s dynamic UI is not crawlable. But most of the interactive bits turned out good with GWT.

The other issue we dealt with is the size of the javascript output by GWT. The way we got around it using deferred binding to output different JS per page and in some cases, per use case, while using the same GWT module. This bought the size of the uncompressed JS from over 400kb to less than 27kb. I know that the JS is cached by the browser, but the delay in first-time hit was not acceptable.

We tried to switch to GWT 1.5 but the compile time was making the process prohibitive. Looking forward to the final release of 1.5 and the community feedback.”