| | |  | Software Engineering | Home » » » Beginning Groovy and Grails: From Novice to Professional | | | | | | | Product Promotions: | | | | | Description: | | Web frameworks are playing a major role in the creation of today's most compelling web applications, because they automate many of the tedious tasks, allowing developers to instead focus on providing users with creative and powerful features. Java developers have been particularly fortunate in this area, having been able to take advantage of Grails, an open source framework that supercharges productivity when building Java–driven web sites. Grails is based on Groovy, which is a very popular and growing dynamic scripting language for Java developers and was inspired by Python, Ruby, and Smalltalk. Beginning Groovy and Grails is the first introductory book on the Groovy language and its primary web framework, Grails. This book gets you started with Groovy and Grails and culminates in the example and possible application of some real–world projects. You follow along with the development of each project, implementing and running each application while learning new features along the way. What you’ll learn - Understand the fundamentals of the open source, dynamic Groovy scripting language and the Grails web framework.
- Capitalize upon Grails’ well–defined framework architecture to build web applications faster than ever before.
- Improve your web application with cutting–edge interface enhancements using Ajax.
- Use Grails’ object–relational mapping solution, GORM, to manage your data store more effectively than ever before.
- Take advantage of Groovy to create reporting services, implement batch processing, and create alternative client interfaces.
- Deploy and upgrade your Grails–driven applications with expertise and ease.
- Discover an alternative client in Groovy as well.
Who this book is for Java and web developers looking to learn and embrace the power and flexibility offered by the Grails framework and Groovy scripting language. | | | Features: | |
• ISBN13: 9781430210450
• Condition: New
• Notes: BRAND NEW FROM PUBLISHER! 100% Satisfaction Guarantee. Tracking provided on most orders. Buy with Confidence! Millions of books sold!
| | | Product Details: | | | Author:
| Christopher M. Judd | | Paperback:
| 440 pages | | Publisher:
| Apress | | Publication Date:
| June 23, 2008 | | Language:
| English | | ISBN:
| 1430210451 | | Product Length:
| 9.21 inches | | Product Width:
| 7.05 inches | | Product Height:
| 0.92 inches | | Product Weight:
| 1.27 pounds | | Package Length:
| 9.1 inches | | Package Width:
| 7.0 inches | | Package Height:
| 1.1 inches | | Package Weight:
| 1.28 pounds | | Average Customer Rating:
|  based on 20 reviews |
| | | | Customer Reviews: | |
Average Customer Review:
 ( 20 customer reviews )
Write an online review and share your thoughts with other customers.
Most Helpful Customer Reviews
11 of 11 found the following review helpful:
 Beginning?? Says Who?Aug 17, 2008
By Scott Davis
Let me start by saying "Beginning Groovy and Grails" is the book that the Grails community has been clamoring for. Two very good books kicked off the Grails revolution ("Definitive Guide to Grails" and "Getting Started with Grails"), but both predate the 1.x version of Grails by many dot-versions and many years (as of the time of this review, August 2008). BGG will certainly have worthy competition on the bookshelf before long, but right now it is the book that we all have been waiting for. Luckily, it easily lives up to the heightened expectations.
After reading BGG cover to cover, it seems to break naturally into three sections: Core Groovy, Core Grails, and Ancillary Grails. This division is mine, not the authors; the table of contents lists 13 chapters with no explicit section breaks. (Whether the three sections correspond to the three authors is an interesting question -- the tone of voice and writing style is consistent across the entire book.)
The first three chapters do an admirable job of covering the Groovy language from the basics to advanced topics. Groovy offers lots of syntactic sugar that might initially catch a Java programmer off-guard. These features, once you've seen them, dramatically reduce the lines of code you have to write. But more than that, there are some fundamentally new features in Groovy that don't have an easy match in Java. Builders, Expandos, metaprogramming, and DSLs are all discussed in these early chapters. While you don't have to use these features yourself to be successful in Grails, it certainly helps the reader understand how much of the Grails "magic" occurs under the covers.
The next three chapters (Introduction to Grails, Building the User Interface, and Building Domains and Services) hit the Core Grails features hard. These 150 pages do a great job of walking you through the basics of getting a Grails application up and running with a minimum of effort. They also make testing feel like a natural part of the development process (which it should be!). Rather than having a single chapter dedicated to testing, each new topic organically includes testing as a way to validate that the new code does what it promises to do.
The remaining chapters (Security, Ajax, REST, Reporting, Batch Processing, Deploying, and Alternative Clients) make up close to half the book. Each chapter covers the subject material as advertised, including working sample code. Not every Grails application will use every feature discussed here, but I still found a clever snippet of code here or a nice explanation of a general concept that rewarded me for reading every chapter.
Overall, "Beginning Groovy and Grails" delivers on its title -- if you are new to either (or both) technologies, you will be up and running before you know it. But don't be fooled by the title; even though it has "Beginning" in it, this book doesn't shy away from the advanced topics, either. This isn't a completist volume. Rather, it is a broad survey of the Groovy and Grails ecosystem. Christopher, Joseph, and Jim covered a lot of ground in an easy, readable way. I highly recommend it.
7 of 8 found the following review helpful:
Great Start to a great solutionJun 28, 2008
By Donald 'Donnie' Demuth
I come from a strong Django background and when I recently inherited the role of Lead Developer I had the power to make decisions for a small start-up. There were two requirements for the product the customer needed: database independence and it must be based on a java framework. Additionally, the team would be fairly small and we would have less than 4 month to deploy. Needless to say I felt Grails would make my life livable.
This book does a wonderful job introducing you to the Grails framework. To be honest, its hard to pick up Grails based on the documentation out on the net unless you already have experience with a similar framework. I had several members on my team that failed miserably with Grails who came from a Spring/Struts background. However, those who had Rails and Django experience could hit the ground running.
If this book came out earlier, I'm sure the 'other' developers could've had less headaches. The book holds you hand and introduces you to the simplicity this technology offers. Give Grails a shot and get this book! Yes, the framework and language isn't quite mature yet and does have a number of 'gotchas.' But with its glowing community I can see it easily improve and become a very popular choice in the job market.
2 of 2 found the following review helpful:
 Get the Definitive GuideApr 27, 2009
By Nick D
"Nick D"
the intro to Groovy is good, but the Definitive Guide is a better book since it's written with a more recent version of Grails. In my opinion it's also a better beginning tutorial.
2 of 2 found the following review helpful:
Great for Development ManagersDec 16, 2008
By Charles Boecking
Used this book to create a prototype website in Grails. This book seemed tailor-made for the job. This book helped a small development team design, build and deploy a proof-of-concept retail site in one weekend. Our team had lots of Java experience and virtually no Groovy and Grails experience.
2 of 2 found the following review helpful:
A very well-written tutorial but the demo source code falls a little short at timesNov 14, 2008
By Jeremy Leipzig
"Bioinformatics Programmer"
This is a well-organized and comprehensive introduction to Grails. The reader will come away with a lot of exposure to the Grails way of doing things, which was kind of a shock for a hack like me who is used to mixing sql queries with html and changing entire schemas at a whim. The authors do not assume you know MVC or even Groovy, so I think it would be a good book for anyone with a bit of Java coding under their belt.
The source code presents some difficulties, although some of these might be attributed to Grails and Jetty. One problem is that all the collab-todo examples are called "collab-todo", which seems innocuous enough but it causes several problems as you proceed through the book. Often Grails leaves all sorts of artifacts in GRAILS_HOME that corrupts different versions of collab-todo. I found myself having to run rm -rf ~/.grails/1.0.3/projects/* before things would work properly for the next chapter. Secondly, I found it impossible to deploy multiple demo chapters at the same time, which would have been useful to see how the author edited various files to achieve increasing customization. Even when the application.properties file was altered to give the deployments different names, the lightweight jetty app server would display a "port already in use error". If I chose a new port for new deployments, there were still deployments files that were still using the directory name "collab-todo" instead of "collab-todo4", my renamed app.name, which caused all sorts of weird runtime errors. The authors and testers really should have foreseen this problem.
Another albeit smaller problem is that the .project files used for Eclipse or IntelliJ are missing for chapters 6 and 8 and I don't think those are really finished demo freezes - I'm not sure if this was intentional or not. I suspect they were not meant to be deployed. If that is the case they should put that in the README. The unfortunate things about chap 6 is that it would have been good for a working MySQL example. There is no formal introduction into using a different backend database until chapter 12, an example so complex it threw all sorts of Hibernate errors in prod mode.
I think the collab-todo project is a decent model for the average web application. However, in some sense a lot of the quick webapps that would have previously been done in Visual Basic or FileMaker Pro can now be handled by Rails/Grails, so a migration example starting from a poorly maintained Excel spreadsheet with no normalization and no keys might have been useful.
After banging my head against JSF for a few months I was happy to see a framework that has proper respect for GET and for a developer's need to have control over any element of a web application without question. I just didn't want to bang my head to get some of these Grails demos to work. Still, this is a decent read and well worth the money.
See all 20 customer reviews on Amazon.com
| | |
|
