Customer Reviews

The Definitive Guide to Grails (Expert's Voice in Web Development)

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

 

 

This book is OK. But since it is written to grails 1.1, it is way out of date. The online resources are more accurate.

The Definitive Guide to Grails, Second Edition (aka DGG2) is no doubt the best Java book I've ever read, and for what it's worth mentioning I read it from cover to cover. It was not only because it was about Grails I meant to get skilled at, but also for its comprehensive English language. I took the liberty of writing complete reviews of each chapter on my blog, so it kept me busy almost 3 months to digest all the Grails goodies Graeme and James collected in their book. Although it was my second book about Grails (after "Beginning Groovy and Grails: From Novice to Professional") I couldn't stop reading it. The more I read the often I asked myself why it took me so long to appreciate Grails features. The book covers the features of Grails 1.1 which was in beta while the book was written yet the material didn't get outdated with its final release. The authors made all the efforts to ensure the book is complete and up-to-date even though Grails 1.1 was not available at that time yet.

I don't want to spoil your reading of the book and its unique style of explaining Grails features by its authors, so if you're like me chasing the simplicity of Grails and trying it out in your projects that's definitely a book you have to read. There are almost 650 pages divided into 17 chapters and one appendix about Groovy - the language of Grails. You shouldn't afford yourself just to read it once - you might easily fail to notice all the gems presented in this book. There are so many that even reading it twice might not be enough. I had a pleasure to read it once, underline all the stuff I considered useful and used it in the reviews afterwards. All in all I think I read it a couple of times and I always found something new I'd missed earlier. I must admit that after a few weeks I was even completely fed up with Grails as there were too much to digest. It reminded me of reading a science book with lots of equations, examples and their explanations - even if I enjoyed it and could read it over night, the best bet to not get swamped was to read it chapter by chapter or even section by section and do the samples myself. DGG2 was not different. It contains the gory details of Grails presented by its project lead and its project member, so who else could bring you the latest stuff right and in details?

It's definitely a definitive guide to Grails. I don't think Grails could have been presented better than what you can find in the book. I'm sure many could share my view that one can't call himself a Grails expert unless (s)he has read the book. You can't simply let yourself miss the pleasure of reading the book. It's like you never programmed with Java IDE and be once presented with its features one by one in a very organized manner. You'll surely get astonished how much you missed for so long. So will happen to you after reading this book. No matter whether you're a Grails developer now or want to become one soon, you'll come across many ground-breaking solutions of Grails in this book. It is highly recommended for anyone who keeps looking for the Holy Grail of the web application frameworks. It could just be Grails after all.

This is one of the best-written programming books I've come across. It covers every aspect of creating a Grails application. Although this is a thick book, and not a "put together a Grails app in a few hours" book, it nonetheless manages to keep a brisk pace, conveying plenty of useful information without getting mired in detail.

As a bonus, the book features an appendix that covers the basics of the Groovy programming language. However, if you plan to develop in Groovy on a regular basis, you might want to consider adding Groovy in Action to your library.

[Edit: Grails 1.1 has been released since this book came out. The changes to the API are pretty minor, so this book still stands out as an excellent introduction. However, Grails in Action (which I haven't read yet) promises to be a more up-to-date primer.]

The book is thorough, and detailed in terms of its revealing the structure of Grails framework. The more important part to me, however, is its detailed explanation of integration of Grails to Spring, which is lacking in other Grails books (they have their own merits of course). In addtion to many parts of the book that relate to Spring, one whole chapter (chapter 16) is devoted to Grails as related to Spring. "Spring is the engine that underpins Grails."(p.487). "all Grails objects are essentially Spring beans that have been configured for autowiring by name" (p.489). Thus, in the place where Spring as a a dependency injection container uses XML (other format too) to configure and wire together dependencies,"Grails makes some decisions based on the conventions in the project and automatically configures Spring using sensible defaults.(p.489). Grails stands on the shoulder of the giant by using conventions over configurations. Grails uses groovy's dynamic features to dynamically inject dependencies.

Then the books goes into details about "The BeanBuilder DSL", about how to define spring beans, and how to overrite Spring beans, and finally present a case of "Spring in Action" on Integrating JMS with Spring JMS.

If there is any complaints, I would say that the chapter on Spring is too late and too brief on Spring itself. If we all agree that Grails is a dynamic version of Spring, then readers without training in Spring would benefit a lot from a more detailed presentation of the spirit of Spring - a framework that manages an oceans of objects by going beyong concepts of classes, concepts of interfacts and ending up with a combination of interfaces combined with factory patterns. To this effect, I think it's good to learn something from Pro Spring 2.5 where a simple Hello World program is used to reveal the overwhelming beauty of Spring the famework.

Very good book!
It covers lot of good details, and cover a lot of Grails topics & features through many pages in the book. The MVC and Web Services chapters are great! The GORM chapter should go more into detailed about the one-to-many and many-to-many with how the indices are linked together from tables to tables. Also there should be some discussion about the Grails/Groovy performance in general and GORM performance in doing different types of queries. Besides the myth that we can develop applications with just couple hours, designing a workable and reasonablly comprehensive web portal, would actually still take weeks or months of design, development and testing. But yes, coming from C, C++, and Java background, I do appreciate the DSL MVC framework that Grails and RoR have done. I say it does save 60% of my development time, especially I can pull in so many open-source libraries as well as my useful tool libraries that I have develop over the years at no times at all. I would not want to do anything in Java or C that I think I can do in Groovy & Grails (I prefer Groovy-n-Grails over RoR).
The only remaining issue is the performance aspect of it. I think Groovy/Grails need to have a very good performance, something close to Java, to make it a dominant choice for all, not just for applications that don't concern about performance. At the end of the day, the performance will be a big consideration factor for any reasonable commercial deployment.

We are working on some big Grails projects and one of the references we continue to use is this book.
This is not a 5 star book, because Grails is not yet a 5 star framework because Groovy is just a slow/trainee 'junior' programming language.
Definitely Grails as a framework continues to improve over time but still has GORM performance problems and especially big unpredictability in releases, release after release. The book does not speak about these problems, probably because it is written by some of the core committers of the framework.
Except these "hidden secrets" of the framework the book is excellent and a must have for every pioneer that thinks the classical way of building robust, speedy and prove to be scalable java web application is over and wants to try this new way.
The book covers all you can expect: what is grails, a nice getting started better compared to the one on Grails site, whole chapters dedicated to Domains, Controllers and Views (wow, looks like we never had these before Grails), how to map URLs , how easy is to localize and internationalize an application (nothing new, but useful to remember).
What about GORM? Well, GORM has its own full chapters. At the end of reading this chapter if you are a junior in software you might say: "how lucky I don't need to learn SQL" and if you are an advanced programmer you might say "is this true?". Well, it's not, my advice is to continue to learn SQL and eventually for some simple mapping use Hibernate if you really want to be in the software fashion industry. But you prepare your web application to be the next super complicated "lot of joins" application, forget about GORM.
There are other chapters dedicated to Security, Web Services or how to write plugins. Nothing special here.

My rate is only 4 star not because the book is written wrong but because in this moment the framework , especially how it is maintained from version to version and how slow it works in production does not deserve a better score.

Good luck Grails, shame on your Groovy :).

I already had the first edition of this book and upgraded to the second edition because of the 250 additional pages.
My team is working on a Grails application and this book helped me/us a lot.
Both Grails and this book deserve the 5 starts.

I've been a Java developer for over 10 years and I'm extremely impressed with the design philosophy and possibilities of Grails. I have the 2nd edition ebook version of this title and I'm a third of the way through it. So far I'm impressed and I recommend this book.

This is a great book to get up to speed on Java's ruby on rails clone. It is well written, which made it a quick read. Grails is quickly evolving and the latest version may require some minor tweaks to the examples presented. This is a must have for those getting started with Grails.

I started to read this book on a business trip. As such I made it to Chapter 6 without turning on a computer. Having a background in Rails I found many similarities with the added benefit of a tighter integration to Java. Both of these facts were positives to me.

However, when I returned home and attempted to work through the examples I could not get through Chapter 2's simple scaffolding examples.

The scaffolding did not work as described in the book and to add to the excitement, the test created for StoreController in Chapter 1 (yeah - Ch.1) inherits from a different class than the one shown in the book (GrailsUnitTestCase in beta as opposed to ControllerUnitTestCase in the book).

(update) I was eventually able to make Ch 1 and 2 work after some time hunting around the Grails mailing list archives on Nabble. Seems that scaffolding has been through some changes in 1.0.4 / 1.1 and the Grails team is addressing.

If you want to see where Grails 1.1 is heading this may be a good book but until Grails goes "final" and we get updated code examples I would tred carefully with this book.