What do you think?
Rate this book
Programming Grails: Best Practices for Experienced Grails Developers
Dig deeper into Grails architecture and discover how this application framework works its magic. Written by a core developer on the Grails team, this practical guide takes you behind the curtain to reveal the inner workings of its 2.0 feature set. You’ll learn best practices for building and deploying Grails applications, including performance, security, scaling, tuning, debugging, and monitoring. Understand how Grails integrates with Groovy, Spring, Hibernate, and other JVM technologies, and learn how to create and use plugins to augment your application’s functionality. Once you know how Grails adds behavior by convention, you can solve problems more easily and develop applications more intuitively.
364 pages, Paperback
First published October 22, 2012
4 people are currently reading
18 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 4 of 4 reviews
May 13, 2013
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 (with the caveat: "as soon as the second edition comes out..."), but Programming Grails is required reading for anyone with six months or more of non-trivial Grails development under their belt.
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 (with the caveat: "as soon as the second edition comes out..."), but Programming Grails is required reading for anyone with six months or more of non-trivial Grails development under their belt.
July 29, 2014
Exactly the kind of book I was looking for. I've been working with Grails for a few years, and frequently finding myself wanting to understand the internals well enough to make alterations and do some wizardry/magic, pushing stuff to the limits to make our grails codebases cleaner.
This book is extremely well-written, interesting, and very technical. This is not an intro to grails book, I wouldn't recommend it to anyone except people who are very familiar with grails already, who I would recommend it to wholeheartedly.
I highlighted stuff on about 40 pages from this book while reading it on a family trip, and started doing some stuff based on those notes as soon as I got back to work. Lots of cool stuff going on here, I learned a ton and feel like some kind of Grails superguru now. Great stuff.
This book is extremely well-written, interesting, and very technical. This is not an intro to grails book, I wouldn't recommend it to anyone except people who are very familiar with grails already, who I would recommend it to wholeheartedly.
I highlighted stuff on about 40 pages from this book while reading it on a family trip, and started doing some stuff based on those notes as soon as I got back to work. Lots of cool stuff going on here, I learned a ton and feel like some kind of Grails superguru now. Great stuff.
January 5, 2015
Nice walk-through across Grails main features by the hand of one of its most prolific and active contributors. This is not actually a reference manual so the level of detail is not so thorough. Sadly, as Grails is a continuously evolving framework, and it's evolving real fast, this kind of treatise gets outdated too soon.
November 21, 2016
Good book for the more experienced developers who want to understand deeper what is happening behind the scenes and how Grails works its magic. Also as a nice surprise it contains a chapter on Groovy language itself which for me was more than welcomed.
Displaying 1 - 4 of 4 reviews