I received a free review copy of Grails 1.1 Web Application Development from Packt Press. They asked me to provide a review for it. Unfortunately, this review will be less than glowing ( sorry Packt ).
It’s refreshing to see more introduction books to come into the Grails market in the last few months. When I started working with Grails a year ago, there were few references other than the Definitive Guide to Grails. Today, Apress, Manning, Packt and other individual publishers have really seen the need for good reference books. It’s also nice to see that specialized books such as Robert Fischer’s Grails Persistence with GORM and GSQL, Bashal Abdul-Jawad’s Groovy and Grails Recipes or books in other languages such as Nacho Brito’s Spanish language Manual de desarrollo web con Grails.
About the Book
This book is an introduction to web development with Grails. It competes in the same space with Apress’ Beginning Groovy and Grails and Manning’s recently published Grails in Action. I would say that it’s geared towards beginners who want to learn more about the platform, and does contain a robust example of a web application being developed – a team communication portal.
Things I liked about this book:
- Content-wise, the book is sufficient. If you have never heard about Grails and want to sit through a good tutorial – and can get this book for cheap – it’s a welcome addition to any library. It covers all you would expect from a Grails book. Unfortunately, I think it’s done better elsewhere.
- The example application here is relatable, in the form of a team communication project.
- The author does cover Grails 1.1. features such as template namespaces and RESTful mappings, but unfortunately does not do so consistently across the entire book. I would have liked to see features like database password encryption mentioned in the database chapter, for example.
- I like the reference to the rich plugin infrastructure of Grails. In the testing chapter, he mentions Marc Palmer’s excellent Functional Testing plugin, for example.
- The file sharing ( not p2p ) chapter was very interesting. It is perhaps the one strength of this book. It’s something that is not well covered by the documentation, and the author provides a clear concise implementation here that answers a lot of the questions.
Things I didn’t like:
- I am not sure who Jon Dickinson is, which is unfortunate. A lot of the other books in this space have been written by people who have contributed plugins or are known in the mailing lists. When I pick up Robert Fischer’s book, for example, I can associate in my mind the autobase and liquibase plugins. Glen Smith, one of the authors of Grails in Action, is the host of the grails podcast and has written groovyblogs. Peter Ledbrook, the other author of Grails in Action works for SpringSource and wrote the JSecurity plugin referenced in this book. They are people known in the community for their reputation. But I couldn’t find a blog or any info bearing his name.
I get a sense by reading the book that Jon is more of a backend developer, dealing heavily with the business logic side of things. I think this book would have benefited from another author that deals more with front-end technogies that would have helped fleshed out the book more. It feels like some of the chapters are straight out rehashes of the user manual. Which is not a good thing. You don’t hear about things like the ui-performance plugin, xTemplates or other really nice tools that make developing frontends with Grails a joy. There is also no mention of the OpenLaszlo, Flex or GraniteDS plugins in the RIA chapter. Which is a shame.
- The writing is a little dry. Grails in Action has a chapter called Advanced GORM Kung Fu and another one called Grails in a Hurry. The enthusiasm for the technology is apparent in that book. The writing here is very matter of fact and purposeful. But to me it’s hard to see the benefits of reading this against the excellent Grails Reference Manual.
- The chapter organization was very strange. Groovy, the programming language used in Grails, has always been at the first or second chapters of all the other intro books. To me, it sets the stage for understanding the code in the rest of the books. Here, Groovy is introduced in chapter 4. After a long talk about setting up the application and scaffolding. It didn’t make sense to me.
- Then there is lax terminology. To give you an example, the author lists ‘Less configuration’ as one of the advantages of Grails. I wish the author would have stuck with the more popular term ‘Convention over Configuration’, which is an actual software pattern – so that users reading the book can take note of this and google this if they wanted.
- The way code is presented in the book is horrid:
code code code
line in bold
code code code
In Grails in Action, there are cueballs that the authors then reference. This makes it feel more like ‘hey look at this part of code’. The way code is laid out in this book makes it feel lazy and I wish more attention would have been paid to the typesetting of this book.
- The plugin chapter is weak compared to other books. While it’s nice to put your code into plugins, the author misses the fact that the plugin system allows for integration with other libraries, making Grails the perfect glue language. I recommend watching Russ Miles’ grails plugins podcast
- It’s $40.
If this was a cheap book, I would recommend it as an extra resource to your library. It has some gems, but nothing you could not find documented on the grails.org site or the reference manual. If this book was available a year ago, it would have done really well. But today, do not waste your money on it as your primary reference. Instead, try to get a copy of either Graeme Rocher and Jeff Brown’s excellent Definitive Guide to Grails ( 2nd edition ), or Peter Ledbrook and Glen Smith’s Grails in Action.