Customer Reviews

GWT in Practice

5 star:		(11)
4 star:		(2)
3 star:		(1)
2 star:		(2)
1 star:		(3)

 

 

I am surprised to hear so much lofty praise for this book. It is mediocre at best, and the editing is quite horrible. Here the advice I would give the authors and in particular the editors:

- I hate having to flip from one chapter to the previous one in order to find a particular snippet being referenced. If you are starting a project, all the source for that needs to be close to each other. I dislike being told 'Go find table 1.1, (with no page number given) and use the code from there.
- The code examples given clearly have NEVER been through the compiler. There are missing methods in examples, and silly typos that are quite unacceptable since it leads me to question the effort put into creating the book. (see page 52, listing 2.12 for example, - Private is NOT the same as private. setInitDisplay is never defined. )
- My preference - and probably for a number of other people - is to use the well defined hello world approach, rather than a discourse on how configuration is to be set up. Eclipse should be introduced earlier. I'm sure others would disagree, but getting a HelloWorld going gets my blood flowing
- The section on design patterns is a TOTAL waste. Please dont introduce examples that focus on MVC, not GWT. I am not reading GWT to understand how MVC works. Make simpler examples that gets rid of this fluff, and focusses on GWT.
- How exactly does showing what StringBuffer looks like in pretty & obfuscated mode help the user? It looks like an attempt to pad the size of the book

Manning books are always a hit and miss. THis is a clear miss. Really, the editors need to pull up their socks and get things out right, not get it out quick.

For starters: I am one of the pilot developers in my company (a large Fortune 100 Financial Institution) doing GWT development. We are about to release our first product to the business. So I've spent the last 18 months or so learning and beating my way through GWT. In the process, I've bought all the GWT books that are out there. Straight to the point: this is the best one out there. Period. Cooper & Collins have produced an excellent book on User Interface development for the next generation....and you get an outstanding understanding of basic and advanced principles in GWT. Plenty of good stuff for the beginner as well as someone who claims to be fairly advanced. GWT in Action by Rob Hanson used to be my favorite...it still has a soft spot for being the first real GWT book, and a great reference book. Collins & Cooper have managed have the same energy that David Geary has in GWT Solutions (which is lofty praise if you've ever seen David speak about GWT!). I really like Dewsbury's GWT Applications, but GWT in Practice is actually better. There are 3 other GWT books (can't remember their names because they're at home), the 2 black and yellow ones and the flower book...I really like GWT in Action better. I've used gwittir, which is a binding framework from Cooper & Collins, so when I saw that they had written a book, I was psyched. In this day and age when book sales gotta be tough because of all the info on the internet, I was glad to see a book that I didn't think was just a rehashing of what's out there online. Good stuff guys...crank out a new version when GWT 1.5 is fully baked and I'll buy it!

My first thought upon reading the first few chapeters of this book was "Where was this thing when I started to use GWT a few months ago?" The authors have done an excellent job really showing how to use the Google Web Toolkit. My eternal fear when I read these books is that there won't be any content outside of what the product already ships with. Not so in this case at all.

The authors cover the GWT basics, to be sure, but more importantly, they demonstrate a way to really use GWT. They hit upon one of my thoughts when first trying to get my head around GWT: GWT is not a framework; it is a platform at best. They recognize this and help you work with the power and around the limitations of GWT.
The authors demonstrate common patterns and practices in the "language" of GWT. It was extremely satisfying to finally, with the help of this book, be able to articulate and execute all the patterns that I've been using in other systems, (e.g. MVC, PropertyListeners, etc.)

The authors also demonstrate how to use GWT in a variety of environments and build system. These concepts were useful, but I found myself skimming over pages at a time to get back to the "good stuff." (This was my primary knock in not giving it five stars.)

All in all, I highly recommend and I'll be ensuring that my team each learn the concepts presented.

Some of the code examples use the GWT Maven plugin. Bad idea for two reasons: 1) It complicates the GWT application creation process, which doesn't need any more complications and 2) The GWT Maven plugin is ALREADY outdated and not compiled. Meaning you can use the old source from the GWT-Maven plugin, try to compile it, try to integrate it with Cooper/Collin's source code, try to get the projects to build...do ya see where I'm going with this? I'm not saying the GWT is a bad project, nor that Maven is a bad project. But when you start piling frameworks on top of frameworks when you're trying to learn something it becomes this big mess.

GWT in practice covers the Google Web Toolkit at a level few books on this subject matter go into. The book is well written and also approachable for someone who is new to GWT. I particularly found useful the chapter on deployment which also covers deployment using Maven with the GWT-Maven plug-in, and the chapter on CI which covered Hudson. IMHO it is worth buying the book for these chapters alone as this information is hard to find anywhere else.

The samples used in this are so outdated that they are utterly useless. You would have to modify them to get them to work with the new GWT, which wouldn't be bad but they are a far departure from the new GWT. GWT has changed so much since this was printed that you would have to unlearn much of this. Many of the samples use deprecated methods. The whole structure of how a project is put together has changed. This references executables within the toolkit that are simply not used any more and not included. You would think that the author would at least have the courtesy to update the samples on the website, but there are no updates there. I wasted my money on this book. I would suggest using the online resources offered by Google. They are much more useful and will get you moving much faster. The PDF version of the book that is included with the book is a great idea, but this information is too outdated to be of any real value.

The beginning of the book is a good introduction to GWT but then there is too much technical discussion to get started. Probably useful for supporting complex environments but way beyond my need. I'm looking at GWT and Google App Engine. Their tutorials worked better.

I bought this book based on its high ranking, but after reading through it I realized what a mistake it was. This book is super light on details and presents only basic concepts you can easily find on google. One specific instance was on file uploads where the book briefly mentions some basic template code on the client side. No mention of the server handling, nothing. Luckily I bought this book used or else I would have really been kicking myself. This used book goes for 4 bucks, tells you much just by the price. Don't be fooled.

I don't have to work with java as part of my job. However I like to check out new things happening to the language and technologies based on it. When GWT came out, I started playing with it and though the tutorials at their website were good enough to get you started, if you are developing more complex applications you need to understand more about how GWT works. You need to know how to integrate GWT with the existing javascript and java based tools. Since GWT allows you to develop applications that have characteristics of a standalone desktop application (e.g. Swing) and also characteristics of a server based application (e.g. JSF), the way you implement the MVC pattern with GWT will be slightly different. So not only do you need to know MVC you also have to know how to implement the pattern using GWT. You need to know how to do unit tests and code coverage with GWT.

This book covers all of the above aspects and much more. I wish more programming books were written the way this book is written. According to some survey that I read recently, 70% of programmers working with J2EE have no clue about J2EE. After reading this book I felt that if there were J2EE books written in this style, where the focus is not on showing a 'hello world' example and presenting compilable code but on explaining why something is done in the context of design patterns, maybe just maybe we might have better Java programmers.

Though this book is based on an older version of GWT, I could follow the topics and play with a variation of the exercises with the version of GWT I am using (2.0). All the code used in the examples is also hosted at [...]. The authors use different IDEs (and also no IDE!) in different examples in book. This helps in setting up your IDE to work with GWT.

Overall a very well written book. It certainly helped a novice like me to be productive with GWT.

Gets right into coding reusable GWT applications. Recommend this book to get feet wet with learning GWT.