Customer Reviews

Developing with ExtGWT: Enterprise RIA Development

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

 

 

Apress really lets us down with this one! This feels more like a pamphlet than a book. I found almost nothing new in here.

1) It is only 140 pages.
2) Large useless pictures fill up many pages.
3) Large top and bottom margins waste tons of space.
4) Large font, font spacing, and header sections break up everything.
5) The examples are less helpful than what is available on the EXT GWT website.
6) The book only covers really obvious stuff. Things most commonly discussed in an intro.
7) The book has no index!

To quote directly from the last page of the book

"GXT has many other aspects that just couldn't be explored within the pages of this book."

If you are a developer you most likely can do without this. I have been developing GWT and GXT for about two months before reading this. So if this book will be your first GXT experience maybe it will help you.

This book is intended for Java developers who want to quickly develop a rich web application using GWT-Ext library.

The particularity of this collection is to follow technological developments as closely as possible. This book is not an exception to the rule and uses GWT and GWT-Ext in their latest versions (GWT is 1.6 and GWT-Ext is 2.0). If you plan to buy, so this is the moment !

This book has a didactic style, it begins with an overview, how to install this library, introduces the simple and advanced components and ends with a concrete example.

The first chapter describes both GWT-Ext and GWT. Since the topic of this book is Ext-GWT, author begins with it. We can see that this library is a layer of GWT because the author has much more to say about general GWT. If this presentation of GWT does not replace a book dedicated, it remains a good summary.

The second chapter is a useful tutorial that explains how to configure a development environment GWT-Ext in Eclipse and how to start a first application. The author seems to prefer the didactic GWT batches to the simplicity of the GWT Eclipse-plugin.

The third and fourth chapters gradually introduces the components of the library, from the simplest to the more advanced one. The presentation is progressive and easy reading. Some screenshots and code examples complement the explanations.

The fifth chapter describes the GWT-Ext components which link the graphical widgets to the server components. As the library does, the author decided to follow a "full GWT" way and therefore does only cover the GWT RPC mode. Do not try to find in this book an example of data exchange with XML or JSON, you won't find any !

The sixth and final section provides a concrete example which aims to sumamarize all the things presented in previous chapters. Although synthetic, it also provides some additional information needed to build a real application.

Before reading this book, I had built GWT-Ext applications, using all the Ext components. The benefit to you is that I could write a better review with respect to what is said or not by the author! The downside for me is that suddenly, I'm left wanting more ... Must believe that I am not the target !

What is great in this book is all the comments, tips and tricks it contains. I was pleasantly surprised to see that it gives all the traps in which I fall myself. I therefore recommend mainly to those who want to write their first application with GWT-Ext.

I just began coding GXT and found that without an understanding of the basic concepts of this environment the learning curve can be quite steep. Coming from a Swing background GXT's MVC programming pattern isn't entirely foreign but there are sufficient differences, introduced partially by the client-server nature of the code, to give me reason to scratch my head. Stores? Loaders? Models are a familiar SWT and Swing concept but GXT adds it's own quirks. Beanmodels?

I needed a way to be brought up to speed, to get a handle on just enough of GXT to 'take it from there'. Let's face it: GWT and Ext-GWT are technologies that are in rapid flux. It is almost impossible to keep up with it with literature. A work that is up-to-date today can be obsolete six months from now and I believe the book wisely understood that it could only get you started and did not intend to provide the reader with an indepth review of all the intracies of GXT. You won't find any highly detailed descriptions of classes and methods here - material that could not survive a year of usability. Instead, the author has focused on clarifying the basics that need understanding if the programmer even wants to begin to interpret the many source code examples GXT shows both online or the downloads. It intends to provide a mere foundation, to explain the principles behind GXT, the way it hangs together. Do not expect highly detailed examples - after all, they would be mere reproductions of the GXT examples.

The book attempts to provide the reader with answers to the most obvious questions a novice will have when studying GXT code - and after all, this *is* how you are going to learn to code using this framework and do not expect to find a comprehensive work on it like you would on Swing. It certainly got me jumpstarted and writing exploratory code in very little time until I found myself delving deeper after 'having gotten something to work'. And this is after all what the book wants you to empower to do: To be able to ask the right questions.

It will certainly not answer your question for a *specific* programming answer for this or that problem with specific twists to it. That you will likely have to take to the forums or a few hours of reading code. However, it will get you coding with GXT in a short amout of time and that was invaluable to me.

I was a bit disappointed at the brevity of the piece (it is quite short with 140 pages). It sometimes simply points out the existence of different concepts without so much as even elaborating on a complete code path from a to b. That is something I feel is worthwhile correcting and I feel the book would have fared better with another 70 pages or so - just to cover the basics.

Still, I was happy I bought it, particularly in light of the fact that there is almost no literature available on the subject matter.

If you're a GWT or GXT developer, avoid this book. It has no code at all. Nor does it explain how to do anything with GXT; no examples of how to do anything. Just a bunch of medical pictures and how to style your GUIs to present complex medical information. What a waste of money! Even the cover is a lie, it explains nothing to do with GXT technology. If I could get my money back I would. Sorry Grant, you might have meant well; but this book certainly doesn't say anything about Developing with Ext GWT. I tried to give it no stars, but that's not acceptable.

If you are at all advanced this is not the book for you. If I had spent much more on it I would have been very upset. However, I took a calculated gamble that I might find something useful from it. Unfortunately I didn't find anything that I could not find in the Ext GWT examples but as I said, it was a gamble which unfortunately did not pan out.