Q:

Hands-on study plan for learning Grails

I'm a Java developer trying to learn Grails, and I'd like to get exposure to as many parts of the Grails framework as possible.  Preferably doing so by solving small real-world problems using the "Grails way to do it" (DRY, convention-over-configuration, and so on). 
Three example could be:

Learn about GORM by creating a few classes (say Movie, Actor, etc.)  and relations/mappings between them (1:1, 1:N, N:N, etc.). 
Learn about the layout support (sitemesh) by using it to generate headers and footers common to all GSP:s on the site. 
Learn about the filter support by using it to make sure all accesses to a certain controller comes from authenticated users. 

My question goes to all Grails developers out there - what would you include in a "Grails curriculum" and in what order? 
All input appreciated! 

A:

Here's some examples, but be warned that they're fairly trivial and don't really show you how the system works together.   One of the strengths of Grails is that the different parts all combine to reduce your code complexity and speed development.   I recommend doing a single project of moderate size (like blogging software or a photo gallery) that forces you to touch virtually everything.   I'm currently working on a ticket management application, and I've had to learn basically everything in the framework.   It's really not that much material, actually. 
That being said, here's my list of "must study", along with some examples:

Groovy, especially closures, maps, and properties.   If you're coming from Java, closures might seem a little strange at first.   However, once you wrap your head around them, it'll be hard to go back to a language that doesn't use them.   Maps and properties use ideas that might be familiar, but the syntax and usage is different enough that it's worth studying them closely.   Grails uses these three things ALL THE TIME, all throughout the framework.   For a good example, examine the "BeanBuilder" that instantiates the Spring beans defined in resources.groovy.   Also, run through the Groovy documentation at groovy.codehaus.org.   A couple of hours there will save you DAYS down the road. 
MVC programming.   The "MVC" model in Grails pretty closely matches the one used in Rails, but it's significantly different than the "MVC" model used in Java desktop applications.   Basically, all incoming URL requests are a message to a controller, which returns a view.   Domain objects are the data that you want to store, view, and manipulate through views and controllers.   Do an input form that validates the user's input using constraints, and then manipulates it somehow using a controller.   Something like a page that takes in your birthday, and returns your Zodiac sign and Chinese Zodiac animal.  See if you can get it to return errors to the user when bad input is given. 
GORM.   GORM is super-important, but you'll be forced to learn it with virtually any project you pick.   Give the documentation a once-over, just so you know what its' capabilities are. 
Filters and Services.   These are "the grails way" to do a lot of DRY programming.   Authentication is a canonical example, and it's perfect for learning filters.   For services, write something that will send out email.   There's a great example of a simple emailer service on the Grails website. 
Groovy Server Pages.   If you've worked with a templating engine before, then this should seem familiar.   Get to know the GSP tag library, it's a huge help.   Practical examples include:  virtually anything.   Every application needs a front-end.   Try and make it pretty.   NOTE:  This spills into a lot of stuff that isn't Grails-specific, like JavaScript, CSS, etc.   Unless you have that knowledge already, prepare for a bit of a learning curve.  
Your "conf" directory.   Get to know every file in there, especially UrlMappings.groovy.   Play with UrlMappings so that you have an app that takes meaningful information from the URL.   Something like /myapp/calculate/36/times/145, where the app returns an answer. 

I'd say those are the basics, but there's a lot of other topics like webflows, i18n, testing, session handling, and so on.   The best way to learn those is by building a decent sized project.   While you're doing that, you'll probably find yourself thinking, "Gosh, I wish that Grails did ____".   Read through the excellent documentation on Grails.org, and you'll probably find a built-in capability or plugin that does what you want.   The reference PDF lives on my desktop, and I've found it invaluable during my learning experience. 
Oh, and look at the scaffolding code that Grails generates.   You'll probably end up pitching it all out, but it'll give you a good idea of how the system works. 
Have fun, and happy hacking!