If you’ve been keeping up on my ramblings on the blog related to RIA development and the various contenders in this space, you have probably read some very positive comments from me regarding Google Web Toolkit – along with the admission that my experience with it has been limited. Last night I decided to give a real application a go and dive into one of their example applications, the DynaTable Example. On the screen it looks pretty slick, and demonstrates some of the cool asynchronous stuff GWT can help you pull off.

But the more I dove into the application and started to change stuff around, the more I started to realize how hard this was to work with when compared to a similar application written in either Flex or OpenLaszlo.  Not being as familiar with GWT as I was with Laszlo or Flex, it took me a little while to figure out where everything was in the application. Eventually, the code made sense to me, as I saw each of the components instantiated and arranged in Java. But for me, the fact that it took me five minutes just to figure out where the buttons were in the application was strike one. Strike two came when I saw how much code was required to create a simple navigation bar:

private class NavBar extends Composite implements ClickListener {

    public final DockPanel bar = new DockPanel();

    public final Button gotoFirst = new Button("<<", this);

    public final Button gotoNext = new Button(">", this);

    public final Button gotoPrev = new Button("<", this);

    public final HTML status = new HTML();

    public NavBar() {

      initWidget(bar);

      bar.setStyleName("navbar");

      status.setStyleName("status");

      HorizontalPanel buttons = new HorizontalPanel();

      buttons.add(gotoFirst);

      buttons.add(gotoPrev);

      buttons.add(gotoNext);

      bar.add(buttons, DockPanel.EAST);

      bar.setCellHorizontalAlignment(buttons, DockPanel.ALIGN_RIGHT);

      bar.add(status, DockPanel.CENTER);

      bar.setVerticalAlignment(DockPanel.ALIGN_MIDDLE);

      bar.setCellHorizontalAlignment(status, HasAlignment.ALIGN_RIGHT);

      bar.setCellVerticalAlignment(status, HasAlignment.ALIGN_MIDDLE);

      bar.setCellWidth(status, "100%");

      // Initialize prev & first button to disabled.

      //

      gotoPrev.setEnabled(false);

      gotoFirst.setEnabled(false);

    }

//Handlers omitted for brevity...

}

Say what?!? That seems a little excessive, don’t you think? The equivalent code in Flex would be something like the following:

<mx:HBox horizontalAlign="right" width="100%">

	<mx:Button label="<<"/>

	<mx:Button label=">" enabled="false"/>

	<mx:Button label="<" enabled="false"/>

</mx:HBox>

This is a shortcoming of GWT I initially glossed over in my evaluation of it. I was so excited at the prospect of turning Java-based tools on user interface logic that I forgot how verbose and complex Java code can be, especially when trying to accomplish certain seemingly simple tasks. OpenLaszlo and Flex employ as their language syntax a combination of XML based markup and scripting, which are much better at creating UI code that is human-readable. XML markup is naturally nested, and as such it is easy to see how components fit together and are going to be arranged on screen. When procedural logic is necessary, you can supplement that markup with scripting. Java is a much more powerful language to do that procedural work, but it really falls flat when you try and arrange a UI.

So it seems that the moral of the story is that the power of Java that GWT offers comes at a price paid in code density and readability, which manifests its self in your organization’s bottom line in developer productivity. Java has the best set of development tools out there, but I can see that I will need to use ALL of them to stay productive writing user interfaces with GWT and Java.