The open source, lightweight Google Web Toolkit (GWT) is a framework that allows Java developers to build Rich Internet Applications (RIA), more recently called Ajax applications, in Java. Typically, writing these applications requires a lot of JavaScript development. However, Java and JavaScript are very distinctively different languages (although the name suggests otherwise), therefore requiring a different development process.

In Beginning Google Web Toolkit: From Novice to Professional, you'll learn to build rich, user-friendly web applications using a popular Java-based Ajax web framework, the Google Web Toolkit. The authors will guide you through the complete development of a GWT front end application with a no-nonsense, down-to-earth approach.

You'll start with the first steps of working with GWT and learn to understand the concepts and consequences of building this kind of application. During the course of the book, all the key aspects of GWT are tackled pragmatically, as you're using them to build a real-world sample application. Unlike many other books, the inner workings of GWT and other unnecessary details are shelved, so you can focus on the stuff that really matters when developing GWT applications.

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 6 Ratings

Examples a bit unclear but a good read - 2009-01-31
Reviewer Rating:
I was looking for a good introductory book on GWT and this fills the bill. I did have some initial trouble with the example code. The sequence that takes you up to running the first example (p.52) fails to to mention that the compile step is required after any changes. Seems obvious but it is not stated. After working through the first real example in the book I could not get the app to run. The GWT error messages were just confusing. An hour of head scratching was followed by the embarrassing realization that I did not compile the project after the most recent change.

So, the book is a good intro to GWT. The examples are nicely staged to take the reader from beginning to simple to fairly complex apps. Just remember to always compile. It would be nice if Apress created a forum for this book.

Ignore the one star rating, Amazon won't let you change a rating after initial submission. I rated the book as three stars.

Beginning Google Web Toolkit - 2009-01-23
Reviewer Rating:
This is a good book that will definitely get you up and running in developing with GWT. It covers basic widget layouts, Ajax and Java 1.5. Generics and annotations are used throughout the accompanying code example. The code example included is added onto in each chapter. It is very good and uses several design patterns such as listeners and builders and is very OO, maybe too much in some places. The code example is meant to scale by its usage of managers, a lot of interfaces, and abstraction.

The server integration chapter will get you started, but doesn't contain a lot of content. This chapter is only fifteen pages or so. Luckily, there's many examples on GWT's site.

Review - 2008-11-11
Reviewer Rating:
I can highly recommand "Beginning Google Web Toolkit" from Apress if you want to start learning GWT.

The nice thing about this book is that it is based on GWT 1.5 and therefore already uses the Java 1.5 language features. The example from the book is building a GWT based Todo List with different categories, something which is actually quite handy to have.

The only negative thing is that I had the feeling that the book repeats itself a bit too often, e.g. it stressed several times how Java programmer can leverage their existing Java knowledge by using GWT.

What I especially liked about the book that it follows a tutorial style building the whole application step-by-step. The book is also very successful in demonstrating how certain conceptional approaches, e.g. separation of concern and testability can be archived with GWT.

Overall a very good book which makes learning the basic GWT very easy.

Written by developers with a knack for simplicity, testibility, and good design - 2008-11-04
Reviewer Rating:
This book stands out as a concise Java developers' introduction to GWT with a fantastic example application and a focus on good design. The example application is built up chapter by chapter and serves as a solid demonstration of how you can pimp your standard web app, GWT-style.

While other GWT book examples are stand-alone doodads that don't look much like webapps, this example really hit the spot. It covers logging in, has a (dynamic) left-side menu, titled modal popups, and a status panel. I actually used this app out-of-the-box as a template for my own first GWT application.

The introduction chapters give a lean overview of what you need to know to get you up and running (with proper browser tooling). It also gives a frank discussion of the advantages and current shortcomings of GWT. By chapter three you're programming using the GWT command line tools.

UI chapters follow and are a definite a strong point thanks to the coherent accompanying example application and an emphasis on good design principles. It's telling that the authors, all members of the pioneering Spring Source inner circle, reference Martin Fowler and Joel Spolsky when discussing these design principles (and pitfalls).

In the spirit of the "Separation of Concerns Principle" and avoiding bidirectional dependencies they advocate an application event structure. I eventually decided not to use it for my small app, but I can see the potential maintenance advantages for a large project.

The Server side chapter introduces GWT RPC, complete with a good exception handling strategy. It also discusses making vanilla HTTP requests for interfacing with any web service and explores using GWT's JSON libraries for communicating complex data structures.

There is a complete chapter on unit and functional testing with extensive coverage of Selenium. The authors correctly point out the drawbacks of GWT testing tools and encourage basic unit testing whenever possible. As a side note, the most advanced (purist) thinking on GWT testing comes from their colleague Rob van Maris[...]

The last chapter covers most everything else you'll need to crank out your GWT app including I18N, browser back support, image upload, and custom javascript inclusion.

The only thing I missed was maven integration, but I found that easily in the GWT docs.

Note: one reader was disappointed that there was no discussion of GWT Spring integration. IMO, Spring integration into GWT doesn't really warrant the complexity it introduces. I certainly use Spring on the server side of my app, but for the client-side (GWT-side) it adds very little. Rest assured that the authors, being from the Spring camp, emphasize similar best practices to the ones you'd encounter in Spring (testability, separation of concerns, 00 design, simplicity).

Command prompt only - 2009-08-23
Reviewer Rating:
This book may walk you through GWT, but it does so only through the command prompt. They casually mention that "you could use an IDE, if you want"; they make a small mention in appendix A on how to run a couple of popular IDE's, but NOTHING on how to set up the IDE for the project -- you must set up the project all from the command prompt and then "add the files to a project in the IDE". What's the purpose of the IDE? Developing from the IDE is FAR superior and MUCH easier to understand for a "beginner". They should take the word "beginner" out of the title of this book: you really need to be an experienced JAVA developer to comprehend the book.

Browse Similar Topics

Top Level Categories:
Internet/Online
Programming

Sub-Categories:
Internet/Online > Web Development
Programming > Ajax
Programming > JavaScript