Beginning Groovy and Grails: From Novice to Professional
and over one million other books are available for Amazon Kindle .
Learn more
| |||||||||||||||
 Trade In this Item for up to £9.45
Trade in Beginning Groovy & Grails: From Novice to Professional (Expert's Voice in Open Source) for an Amazon.co.uk gift card of up to £9.45, which you can then spend on millions of items across the site. Plus, get an extra £5 when you trade in books worth £10 or more until June 30, 2012. Trade-in values may vary (terms apply). Find more products eligible for trade-in.
|
Frequently Bought Together
Product details
|
More About the Author
Product Description
Product 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.
Inside This Book
(Learn More)
Tags Customers Associate with This Product(What's this?)Click on a tag to find related items, discussions, and people.
|
What Other Items Do Customers Buy After Viewing This Item?
Customer Reviews
Most Helpful Customer Reviews
1 of 2 people found the following review helpful
Format:Paperback
The book tries to cover a lot of ground, but does it at too high a level, and with three authors, the result is noticeably and frustratingly variable in style.
The Groovy section really isn't enough to teach you how to use the language, yet includes details without explanation. Eg a table of regex constructs is included without explaining the difference between the identical quantifiers listed under greedy, reluctant or possesive. At best, the Groovy section could be used as a refresher for people who already know Groovy.
The Grails sections are obviously the reason for the book - but there are numerous errors and many times where particular conventions are not explained but merely used. The level of assumed intelligence and knowledge of the reader is incredibly variable. Some examples or code listings are only different in the most minute way from previous examples, and yet at other times other frameworks (eg Rails) are referenced in a way as to suggest the author assumes the reader is familiar. Further more the obvious things, such as being able to simply use named closures in controller for actions, are left for the reader to deduce from the examples, rather than stating it up front.
If you know Java, then Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers) is a great book.
If you know Groovy, then the Grails documentation, including the user guides, available for free from the Grails site, are much better.
The Groovy section really isn't enough to teach you how to use the language, yet includes details without explanation. Eg a table of regex constructs is included without explaining the difference between the identical quantifiers listed under greedy, reluctant or possesive. At best, the Groovy section could be used as a refresher for people who already know Groovy.
The Grails sections are obviously the reason for the book - but there are numerous errors and many times where particular conventions are not explained but merely used. The level of assumed intelligence and knowledge of the reader is incredibly variable. Some examples or code listings are only different in the most minute way from previous examples, and yet at other times other frameworks (eg Rails) are referenced in a way as to suggest the author assumes the reader is familiar. Further more the obvious things, such as being able to simply use named closures in controller for actions, are left for the reader to deduce from the examples, rather than stating it up front.
If you know Java, then Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers) is a great book.
If you know Groovy, then the Grails documentation, including the user guides, available for free from the Grails site, are much better.
1 of 2 people found the following review helpful
Format:Paperback
It starts out covering Groovy.
* Basically Groovy gives Java a facelift, making for a more terse syntax and includes closures and meta programming capabilities to facilitiate "builders" which make doing component construct for things like Swing and XML document manipulation a snap.
* For a more in depth I'd recommend Dierk Koenig's Groovy in Action, but there is enough here to get you up and running.
Grails is a web framework that uses Spring & Hibernate under the covers. * It has it's own Object Relational Mapping technology known as GORM that is described quite well.
* I think Id have preferred if the book had taken a full on explanation rather than a small amount early on (Ch 4) then take a step back and elaborate on this (Ch6).
** The early chapters made me questioning how to model a Person domain object with two self reference for mother/father or currency exchange rates with double reference to a currency say.
** But it gets covered eventually in chapter 6.
The book uses a "to-do list" domain model.
* Three client are created: Web, Swing and command line and they interact with RESTful web services.
** Third party libraries used for Swing include SwingXBuilder, Glazed Lists and JGoodies. There are passing references to JideBuilder and SWTBuilder too.
*** I would have liked to have seen the JGoodies syntax elaborated on a bit here. But the external links were provided.
** JLine gets used for the command line interface.
* The web client is Ajaxified with Scriptaculous for showcasing 'edit in place' and 'auto complete' features.
* JasperReports are integrated into the solution and integrated with the Open Symphony Quartz scheduler to fire off "to-do" reports via email.
* Gant gets a brief mention in Chapter 12.
** Groovy version of Ant. You don't need Ant Contrib to do conditional/loop processing.
** This gets covered in more depth in Groovy in Action.
* Chapter 7 covers security.
** This chapter seems to deviate from the rest of the book. The topics covered don't seem to integrate as harmoniously as the other topics in the book.
** JSecurity, CAS and Acegi security get a brief mention.
** But there's not enough meat on the bone to sink your teeth into here. Acegi gets the lions share of coverage.
Overall though the book made for a thoroughyly engaging read and is one which I highly recommend.
I've recently tried to use some of the Grails code from this book and as the reader below indicated, it is rather buggy. The tests also seem fabricated. So, although the book gives you a fair overview, the precision in the details lets it down. Dave Kleins book is better for Grails as is the Jon Dickinson book. Consequently I've downgraded this review from 5 to 3 stars.
* Basically Groovy gives Java a facelift, making for a more terse syntax and includes closures and meta programming capabilities to facilitiate "builders" which make doing component construct for things like Swing and XML document manipulation a snap.
* For a more in depth I'd recommend Dierk Koenig's Groovy in Action, but there is enough here to get you up and running.
Grails is a web framework that uses Spring & Hibernate under the covers. * It has it's own Object Relational Mapping technology known as GORM that is described quite well.
* I think Id have preferred if the book had taken a full on explanation rather than a small amount early on (Ch 4) then take a step back and elaborate on this (Ch6).
** The early chapters made me questioning how to model a Person domain object with two self reference for mother/father or currency exchange rates with double reference to a currency say.
** But it gets covered eventually in chapter 6.
The book uses a "to-do list" domain model.
* Three client are created: Web, Swing and command line and they interact with RESTful web services.
** Third party libraries used for Swing include SwingXBuilder, Glazed Lists and JGoodies. There are passing references to JideBuilder and SWTBuilder too.
*** I would have liked to have seen the JGoodies syntax elaborated on a bit here. But the external links were provided.
** JLine gets used for the command line interface.
* The web client is Ajaxified with Scriptaculous for showcasing 'edit in place' and 'auto complete' features.
* JasperReports are integrated into the solution and integrated with the Open Symphony Quartz scheduler to fire off "to-do" reports via email.
* Gant gets a brief mention in Chapter 12.
** Groovy version of Ant. You don't need Ant Contrib to do conditional/loop processing.
** This gets covered in more depth in Groovy in Action.
* Chapter 7 covers security.
** This chapter seems to deviate from the rest of the book. The topics covered don't seem to integrate as harmoniously as the other topics in the book.
** JSecurity, CAS and Acegi security get a brief mention.
** But there's not enough meat on the bone to sink your teeth into here. Acegi gets the lions share of coverage.
Overall though the book made for a thoroughyly engaging read and is one which I highly recommend.
I've recently tried to use some of the Grails code from this book and as the reader below indicated, it is rather buggy. The tests also seem fabricated. So, although the book gives you a fair overview, the precision in the details lets it down. Dave Kleins book is better for Grails as is the Jon Dickinson book. Consequently I've downgraded this review from 5 to 3 stars.
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com:
20 reviews
11 of 11 people found the following review helpful
Beginning?? Says Who?
17 Aug 2008
Format:Paperback
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.
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 people found the following review helpful
Great Start to a great solution
28 Jun 2008
Format:Paperback|Amazon Verified Purchase
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.
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 people found the following review helpful
Get the Definitive Guide
27 April 2009
Format:Paperback|Amazon Verified Purchase
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.
Were these reviews helpful?
Let us know
Listmania!
|
|
Look for similar items by category
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
|
