Google Web Toolkit
, by Ryan Dewsbury, is an excellent book for those looking to use GWT
to good advantage, covering most areas of GWT functionality in exceptional detail. It covers software engineering, server integration, custom component composition, CSS, and various methods of RPC via some good sample applications.
The first chapter walks through your first steps with GWT, including defining programmer backgrounds and the challenges associated with them - for example, if you're a traditional web application developer, the book suggests that you're in for a change in user interface paradigm, closer to AWT. Desktop application developers will have the smoothest transition, although they'll have to get used to working within the browser-based sandbox.
The second chapter gives an overview of the user interface library: static widgets, form widgets, complex widgets (trees and menubars), layout panels, container panels, and event interfaces. In general, it covers the widgets well, discussing various points about them one might not expect - for example, the PushButton documentation is quite detailed, showing the hierarchy of images one can replace on display, and showing CSS styles. The RichTextArea discussion is also quite good.
However, the FileUpload widget discussion is lacking - it says that FileUpload requires a FormPanel in order to work (which is true) and promises a deeper discussion when FormPanel is documented - but FormPanel's discussion focuses on the way to manage the "normal" widgets being submitted, and doesn't cover file uploads at all. Considering that file uploads are probably the trickiest fields to manage from a web page, this is rather disappointing.
The third chapter is on server integration techniques, including the use of traditional server-side technologies such as PHP or Ruby. XML and JSON are discussed well, in addition to documentation of HTTP proxies, calling third-party services, and stateful services.
The fourth chapter is on software engineering: installing a JDK, debugging GWT, using JUnit, sharing modules (i.e., extending GWT with custom components), and deploying GWT applications to servlet containers. This is a very useful chapter, although it seems out of place somewhat. If it were the second chapter, where it might fit more logically, it would be too much information at the beginning of the learning curve; however, here, it feels like it covers information that the developer should already have in hand, given the depth of the content provided in the previous chapters. That said, it contains crucial information on using GWT extensions (also covered in chapter five) and testing.
Chapter five, "Using the toolkit effectively," is another excellent chapter. It discusses elegant user interfaces with CSS, toolkit extension, internationalization, generating code, and performance improvement. It'd be really nice if more framework books would include a "best practices" section like this, to try to fill in the holes beyond "here's what it can do" with "here's what you should do."
The code generation discussion is fascinating. One strength of GWT is that it combines multiple images into a single image, breaking them into pieces on the client side, to reduce server traffic (i.e., one HTTP request for fifteen images, instead of fifteen requests.) The "generating code" section discusses how this is done, and it also shows you how you can write your own generators - including a short example in this chapter and a much longer, in-depth example in the database editor example at the end of the book.
Chapters six through ten contain example applications: a gadget desktop application, similar to http://igoogle.com
, including drag and drop, stored user preferences, use of Google Gears and other storage mechanisms. A multi-search application - which submits search requests to multiple search engines - is next, including integration with Yahoo!, Google, and Flickr.
Chapter nine is an instant messenger application, building a collaborative application with asynchronous events - including the ability to update the messages without polling. It then goes one step further, by documenting the use of COMET (server push) on Tomcat, and continuations on Jetty. It'd be nice if there was a standard mechanism for COMET in servlet containers - but this is a start, and it's much welcomed.
Chapter ten provides a database editor for a fictional web site similar to Digg, including PHP and Ruby integration, and a very indepth discussion of using generators to make management very easy. This sample is probably the most esoteric of the set, but it's also the most impressive - the information here is presented concisely, and replicating the functionality would be difficult without the techniques presented here.
Altogether, Google Web Toolkit Applications is an excellent book, well worth the list price of $49.99 (USD) if you're doing any serious GWT development. It's well written, very much in depth, and shows application patterns that will be very useful for anyone using GWT, in many cases showing concepts that are very difficult to find elsewhere. It's also available as an eBook
for $39.99 USD, if that interests you instead - and the print version offers a free trial Safari subscription.