Archives

With the release of IT Mill Toolkit 5.3.0, the server-side RIA framework is now ready for production. I announced the initial release of 5.0 back in December of 2007. Since that time, IT Mill 5 has gone through several revisions and the release of GWT 1.5 (which means you can use Java 5 now on both the client and the server). As a reminder, server-side RIA frameworks let you write your app completely in the server and uses a client-side Ajax engine to render the interface. The nice wrinkle with IT Mill is that both the server side and the client side are written in Java, so if you want to add a component, you don’t have to break out the JavaScript (see the extensive and high quality reference manual for details on how to develop your own custom components in GWT). If you’re a Java shop, that’s got to be a good thing.

At Pathfinder we do a fair amount of desktop style development — iPhone/Cocoa, WebForms, Swing — and web application development — Grails, Rails, JSP, ASP.NET, etc., etc.. In the last two years we, like a lot of other software development shops, have experienced a convergence in our efforts. The web is coming to the desktop in the form of Air and the Desktop is coming to the web in the form of RIA’s. Now web MVC, which used to be a pretty benign pattern mostly concerned with app flow and validation, is starting to resemble desktop MVC, which has to deal with document-centric models and long lived views and all of the plumbing that requires.

So we recently had a powwow between all the different parties to talk about MVC and this convergence. With the exception of the insufferable Mac and iPhone developers and their disgustingly mature Cocoa framework, we all agreed it would be nice to have an application level MVC framework for each platform. We also agreed that Swing is a great example of what happens when the vendor doesn’t provide such a thing — spaghetti code that relies on component level MVC and hard wiring at the application level. There are a few MVC frameworks for Swing, such as TikeSwing and Spring Rich Client (soon to be superseded by Spring Desktop), but for every Swing app that has this sort of design, there are hundreds that are just a mess.

When you’re developing a desktop or GWT application you’re going to go through a bunch of iterations, tweaking the UI, adding components, etc. Sometimes in all of that work it is very tempting to take a shortcut and update a view directly from a controller (label.setText(model.messsageString)). That way lies madness. Before long you’ve got your view code strewn across the length and breadth of your application. Change the view or some aspect of the model and you’re on a refactoring of biblical proportions.

In fact there’s never a good time to break out of MVC, but sometimes you just don’t know what sort of Observable your model should be. Will you be using a table, a tree, some custom component? In those situations I try to preserve MVC while punting the hard decision until later. To this end, I’ve written a little set of utility classes called SimpleModel. How do you use SimpleModel?

Many times open source projects are mute — they have insufficient documentation. Good technical blogs can function as a sort of ad-hoc documentation. That’s what I’ve tried to do, most recently with my series of posts on GWT and OpenSocial. Vinay, over at Web Technology I/O, often does the same. He’s got a great post about Ray Cromwell’s GwtQuery (JQuery-like syntax in GWT) and how to make it work.

I’ve been tinkering with this tool as well and am going to do my own writeup, but thought I’d give you all the heads up. BTW, according to Vinay, the compiled GWT JavaScript for GwtQuery clocks in at 712 bytes!! So much for GWT bloat.

Note: It is assumed that you know your way around GWT and Eclipse for purposes of this tutorial.

While developing OpenSocial applications can be a bit tricky, getting set up to develop can be a real pain in the neck. For this installment of OpenSocial and GWT, I’m going to go through the basics of setting up a simple Hello World gadget with iGoogle. We’ll get into the details of signing up for other OpenSocial containers, testing, and so on, later. Right now we’re just going to do the basics.

So, what do you need to build a Google Gadget with GWT for iGoogle? You need the following:

1. The Google Web Toolkit
2. The GWT Google Gadget API
3. An account on iGoogle
4. Access to the iGoogle sandbox
5. Some public server space so you can serve up your gadget to iGoogle

It’s not quite done (the game notation looks like crap in IE), but I thought I’d give a taste of my latest labor of love, a chess game viewer in GWT. This is the sort of thing that is usually implemented as a Java Applet. A few others have already built chess viewers in GWT, but as they say in Full Metal Jacket, “this one is mine.”

As I blogged a few weeks ago, I ported the Java chess library ChessPresso into GWT, which was a blast and an example of how you can leverage existing Java libraries to write browser-based apps.

In the example, I’ve pulled the eleven games of the recently completed world championship between Anand and Kramnik in a single page. The GWT app identifies all of the relevant tags, reads the PGN (Portable Game Notation) in those tags, then inserts a game viewer widget into the page.

What isn’t working yet:

• Doesn’t look so good in IE (a little CSS work)
• The notation pane isn’t hooked in so you can click on a move and jump to the position

Anyhow, have a look and let me know what you think.

Update: OK, the notation panel is hooked up to allow clicking on moves to navigate aroung the game. Still looks like crap in IE, though.

Update: for those interested in some of my very few games that make me look good.

Update: Another set of tweaks to display a collection of games, one 41 games PGN chunk and a 250 or so chunk.

I’ve been developing with GWT, OpenSocial and Orkut, using the gwt-google-apis project on Google Code (specifically the gadgets subproject). It’s a nice enough api that makes it relatively painless to build gadgets in GWT.

This is a bit different from Didier’s gOpenSocial library, which was an early success at building OpenSocial gadgets with GWT. But the google gadget library isn’t really quite ready for OpenSocial. I’ve skinned my knee here and there, so I thought I’d give others the benefit of my experience.

So, first thing, how the heck do I get GWT to generate the

line into my manifest?

The JSON utility library for GWT that I blogged about last week is now up on google code.

To recap, the idea is that you can write code like this

JSONValue root = JSONParser.parse(json);
JSONWrapper obj = new JSONWrapper(root);
String result = obj.get("map").get(1).stringValue();

when dealing with JSONValue objects.

As it’s only one class, you could just include it in your source tree as code instead of using the jar.

I’ve been using GWT to resurface interfaces of a variety of legacy applications — J2EE, PHP, Rails — and more often than not that means working with JSON returned from the server. One thing that I’ve found is that GWT’s JSON support is kind of chatty. That is, you have to write a bunch of code like this:

JSONValue root = JSONParser.parse(json);
JSONObject obj = root.isObject();
if (obj != null) {
    JSONValue map = obj.get("map");
    if (map != null) {
        JSONArray arr = map.isArray();
        if (arr != null) {
            if (arr.size() > 1) {
                JSONValue strval = arr.get(1);
                if (strval != null) {
                    JSONString str = strval.isString();
                    if (str != null) {
                        String s = str.stringValue();
                        // do something with the string
                    }
                }
            }
        }
    }
}

Yikes! Just to get the string in the second array item in the “map” key of the top level object. Truth is, most of the JSON I’m getting back is fairly predictable. And if it’s not in that predictable form, it’s an error that the client code can’t recover from. I’d like to be able to write something like String result = obj.get("map").get(1).stringValue() without having to worry about NullPointerException‘s cropping up all over the place.

Shalk Neethling has written up a nice, streamlined tutorial on how to build a model in GWT using the GWTx project’s support for java.beans.PropertyChangeSupport.

The basic idea here is that while the browser is the View and the server side is the Model and Controller in MVC, you really should structure your browser side code as an MVC itself where only the Model interacts with the server.

Well worth a read.