Not to be too much of a self-apologist, but let me preface this review by indicating that my frustration (and hence my lower rating) comes largely from gaps in my own knowledge. But as a result of those gaps, I wasn't able to reap this book's full benefits. So first, what was my impression:
Grails in Action is a fast-paced overview of the Grails platform, with an even quicker overview of the Java-based Groovy language that powers it, and some at-a-glance discussions of some other underlying frameworks and technologies (e.g., Spring, Hibernate, SiteMesh). The book's approach is to take you through the platform in a learn-by-doing approach, walking you through the major language features by building an application in Grails that takes advantage of all (or at least most of) its major features. By building the application alongside the authors' text, you get yourself familiar with those features, their syntax, and the philosophy behind it all.
Sounds great; but, a brief segue on why I didn't reap the full benefits:
So why the disappointment? Grails in Action wasn't really written for front-end developers. I suppose I could have figured this out if I'd taken a look at the pedigrees of either of the authors--there's a lot of Groovy and Java there. But that colors the approach, and when they say "previous experience with Java web development is an advantage"--they mean it. Not knowing Java--and/or not doing much work on the band end--will slow down your understanding.
With that out of the way, what were the good and the bad?
(1) I agree that the "learn by doing" approach is the best way to go. Nothing helps it "stick" quite like getting your hands dirty. That said, this particular learn-by-doing was a strange mix of hand-holding (e.g., "Right, OK that was obvious.") followed by cavalier glossings-over of other aspects (e.g., "Wait--what?--where did that come from?").
(2) Part 1 ("Introducing Grails") and Part 2 ("Core Grails") are fantastic overviews of the core "90% of your time" features in the Grails platforms. There are some outstanding and very clear explanations of those features, the philosophies that guided the implementations of those features, and how best to apply them in a given context. By the end of Chapter 6, you'll be in a decent position to start banging away on your own apps.
(3) The chapters on build systems, writing your own Grails scripts, and plugin development are very informative and show the kind of real power that lives under the Grails covers.
And/or, the critiques both big and small, and a few other things that couldn't be helped:
(1) The Grails community is moving fast, and though I would not call the book "out of date", there were some quirky differences between Grails 1.1 (the current version when they wrote it) and 1.3.5 (the version I had installed during my reading). One example that came up during the first chapter: their exercise on pages 19-20 said to type "new Quote" when what was really needed was the namespaced version ("new qotd.Quote").
(3) There's an awful lot of time given to writing tests and testing. OK, I get it--testing is important and can help you save yourself from yourself. But there were quite a few features of the language that got not-as-much (e.g., "At what point is UrlMappings.groovy parsed? processed? How does that work?") or else not-at-all (e.g., "What's supposed to go in that 'src' directory?") coverage that would have been nice to see instead of that whole chapter on testing.
(4) Plugins, plugins, plugins... Again: "OK, I get it..." As a platform, Grails is all about plugins--it's a conglomeration of plugins to start with, and it has a vibrant community of plugin writers. And that is marvelous. But once plugins are introduced (in (surprise!) the chapter on tests and testing), every chapter after that includes a line that reads "grails install-plugin name-of-plugin". Perhaps that is (shall we say) idiomatic Grails development, and perhaps the implied take-away is "install the plugin and examine its source code", but that time might have been better spent discussing the problem and the "how" of the solution instead of just dropping one in.
I would stand by Grails in Action as an excellent primer on the major features of Grails, and its hands-on approach should help you get comfortable with the key features quickly. But if you're a front-end developer looking to get started with Grails, this probably is not the best introduction. It seems to skip over some aspects of the platform or else give only cursory explanations, but then it spends a lot of time talking about and working with domain classes and the technologies behind them. Again, this is probably fine if you're already a seasoned Java or Groovy programmer on the back-end, or already fancy yourself an adept full-stack developer--but if you've spent most of your time in the browser, you may find it tough to wade through some of what's in here.
For my money, I'm still looking for that good introductory book on Grails. Grails in Action was worth the read, but I think I'll need to give it a second pass after I've found my feet.