Book Review: Grails 1.1 Web Application Development

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 ).

The book’s website is here, you can order from Amazon here, and there is a free sample chapter here.

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:

  1. 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.
  2. The example application here is relatable, in the form of a team communication project.
  3. 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.
  4. 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.
  5. 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:

  1. 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.

  2. 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.
  3. 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.
  4. 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.
  5. 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.

  6. 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
  7. It’s $40.

Conclusion

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.

10 thoughts on “Book Review: Grails 1.1 Web Application Development

  1. Burt Beckwith

    Similarly I received a copy of a Packt Spring/AOP book to do a review of, probably the same outreach as this. I guess I hadn’t read a Packt book before because I was very surprised at how uncomfortable the format was. The author had clearly done some good work but the structure and order of the book, the layout of the code, and the lack of editing made it a pretty unpleasant experience. It made me appreciate even more the excellent support that the Manning folks provided to Glen and Peter that I saw when doing the technical edits for Grails in Action.

    Reply
  2. Michael Kimsal

    I have a copy of this which I’ll be doing a review of. I share some of your concerns, although I’m not sure I’ll come to the exact same conclusion.

    I liked the black bold lines which were then referenced in the text below. Sure, it could have been done another way, but I think it’s pretty usable as is.

    If this book had come out 6 months ago, and just dealt with 1.0, it would have been *great*. I do think that the recent set of books that have come out since last fall have taken some of the utility out of this one, but it’s not *bad*. I appreciated the section on ‘services’ which seem to have been glossed over in most other books. I don’t recall much in DGGv2 on it, and nothing in the Recipes book referenced above. A bit more on the ‘when and why’ of how to use the Services approach would have been appreciated in this book, but it’s better than nothing. Lack of any detail on services was, for me, one of the only flaws of the Judd book from last year (Apress).

    A hardcopy of this book at, say $20, would have been a no-brainer to recommend. At $40, it is a bit of a stretch to recommend, but I suspect there will be Amazon discounts, and eventually used copies for cheaper. Similarly, if the ebook PDF prices was, say $15-$20, I’d recommend this to people easily, as it’s good as a “build a site tutorial” book.

    Reply
  3. rzezeski

    I recently read Learning ExtJS from Packt, and lets just say I wasn’t surprised to read your lackluster review of “Grails 1.1 Web Application Development.”

    “Learning ExtJS,” while adequate as an introduction, was very rough around the edges. Many typos, confusing references to code examples, dry reading in a lot of places. The authors know the framework, but the book just didn’t meet my expectations. It felt more like a glorified tutorial, rather than a well written technical book.

    After reading your review, it makes me wonder if all Packt books have this feel, or if it’s just a coincidence?

    Reply
  4. Jeremy Flowers

    Hey Tomas.
    I too had similar experience with Packt books. One on learning YUI. With that code download and book didn’t tally. Author Dan Wellman was great help though.
    I had heard of Jon Dickinson through the Grails Podcasts/devx.
    Check out episode 52 &
    http://www.devx.com/Java/Article/37487
    http://www.devx.com/Java/Article/37640
    http://www.devx.com/DevX/contentByAuthor/38240?author_id=1918&num_items=5
    He’s a UK based guy. Hereford. Surprised we haven’t bumped into him at GGUG/Skills Matter.

    Reply

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s