If you’ve been programming in Grails for a year (give or take) and are ready to go deeper than the tutorials and docs usually take you, then Burt Beckwith’s book — Programming Grails (O’Reilly, 2013) — is going to feel like just what the doctor ordered. If asked to sum it up as a pithy one-liner, I’d describe it as a guided tour of the framework’s guts by one of the field’s seasoned experts. He goes beyond the basics, and dives headlong into those dark corners for (as he puts it) “developers who want to dig deeper into the architecture and understand more about how Grails works its magic”.
If Beckwith’s name is familiar, then you’ve probably been around the Grails block once or twice. He curates the This Week in Grails blog series and at least half the time seems to be the author of the accepted answer to that Grails question you found on StackOverflow. In other words: this is a guy that knows his way around the the framework.
Having worked in, with, around, over, under, and through Grails over the past couple of years, this book was exactly what I was looking for at this point in my relationship with the framework. Beckwith is specifically targeting developers that have gone past simply snapping together applications along the happy-path; this one is for the developers that find themselves regularly battling with some dark and thorny corner or rough edge of the framework. Beckwith does a fantastic job of introducing these “hidden” and “magical” parts of Grails, and breaking them down into easily-digestible sections. It’s like a series of miniature epiphanies — one right after the other. (The opening chapter on Groovy alone is worth the price of admission.)
There were a couple of things that could have made this one better. Most of them were small to the point of being ridiculous (e.g., I could have used a more specific definition for the purpose behind
BootStrap.groovy), while others were arguably out of scope (e.g., an in-depth discussion of Groovy’s metaclasses is… probably more appropriate for a book dedicated to Groovy). Then there was the chapter on plugin development which — although I learned something on almost every page — I found myself wondering: (1) why not discuss how to run with inline plugins right from start? (2) why wait so long to mention `settings.groovy`? (3) why not a better example of CLI tests?
(As you can see: even my “legitimate gripes” are little more than nit-picks. But I suppose the nit-picks add up?)
Would I recommend this one? In heartbeat. I’ll continue to recommend Grails in Action as the best place to start,1 but Programming Grails is required reading for anyone with six months or more of non-trivial Grails development under their belt.
Disclosure: I received an electronic copy of this book from the publisher in exchange for writing this review.
- Though I’ll post-script that with the caveat: “…as soon as the second edition comes out…” Because (let’s face) it, though good, that first edition is showing its age. [↩]