It was great to have an active crowd as well, and I hope that everyone that attended was able to take away something from the evening. Scott and Venkat started with an agenda for the evening, but we quickly pulled them off track and wandered. I’m working from memory, but we roughly covered the following:

• Groovy is Java, except when it isn’t! Search for “Groovy the blue pill” or “Groovy the red pill” to see what that means.
• We saw several perfectly valid Java classes become elegantly simple Groovy classes
• Examples of Groovy metaprogramming and AST transformations (@Immutable, @Delegate and @Newify)
• What tools and IDEs might be considered for Groovy and Grails programming
• We learned that Venkat only uses a web browser that works with EMACS-like commands (it is Conkeror in case you are wondering)
• We were reminded of the evil lurking in Java with precision issues in double and float, and how Groovy avoided this issue

There were many more little bits of information, but suffice to say we covered a lot of ground. Thanks again to Scott and Venkat, and thanks to all that attended our first meet-up.

Please watch the meet-up group site for more information about our next meet-up.

                          

I also want to be sure that everyone goes to the Philly GGUG official site at http://www.phillygroovy.org and join the email list so that you can be a part of our future events. I am hoping to have Philly GGUG meet-ups every two months, so look for another meet-up in June.

                          

if( !book.save() ) {
   book.errors.each {
        println it
   }
}

In Grails 1.2 a feature was added to allow the option of forcing save to throw a grails.validation.ValidationException by using the failOnError argument.

try {
     book.save(failOnError:true)
} catch(ValidationException e) {
   // handle
}

If you prefer to make failing on validation errors the default, you can update Config.groovy in your Grails project to set the following property.

grails.gorm.failOnError=true

Thanks to Jeff Brown for reminding me of this when replying to a recent thread on the Grails user email list.

                          

Examples:

• ‘grails schema-export’ : generates the DDL for the development environment into the default file ddl.sql
• ‘grails prod schema-export’ : generates the DDL for the production environment to the default file ddl.sql
• ‘grails schema-export export’ : generates the export DDL (drop then create)
• ‘grails schema-export stdout’ : generates the DDL and sends it to starndard out

                          

This will be a 90 minute tutorial targeted at beginners of Grails. We plan to cover the following:

1. Overview of Grails

2. GORM

• Properties and Validation
• Associations and Composition

3. Configuring Grails with PostgreSQL

• Environments: Dev, Test, and Production
• Using DataSource.groovy

If you happen to be at the talk, be sure to introduce yourself and say hello!

                          

class User {
  String login
  String password
  String email
  Integer age

  static constraints = {
    login(size:5..15, blank:false, unique:true)
    password(size:5..15, blank:false)
    email(email:true, blank:false)
    age(min:18, nullable:false)
  }
}

Constraints are syntactically formatted as method calls with the name of the method matching the name of the property the constraint is to be associated with. The method parameters are named parameters specifying the constraint. On User we have defined a constraint for each property. This was my decision to constrain each property, there is not a requirement to name a constraint for all properties in a domain class.

So far so good, but now I want to verify my constraints work the way I expect. The easiest way to test constraints is as part of a unit test. Grails provides mocking support in unit tests, so to setup a mock domain class for constraint testing I would create the following test class.

import grails.test.*

class UserTests extends GrailsUnitTestCase {

  protected void setUp() {
    super.setUp()
    mockForConstraintsTests(User)
  }

  protected void tearDown() {
    super.tearDown()
  }

  void testValidation() {
    def user = new User(login:'jdoe', password:'passw0rd',email:'jdoe@foo.com',age:32)
    assertTrue user.validate()
  }
}

That is it. One item of note, I recently found out that it is possible to pass a list of property names to the valdiate() method indicating that the validation should only be run on those properties. For example, if I only want to validate the login and password properties on an instance of User then I would do the following.

user.validate(['login','password'])

This trick, however, does not work in unit tests as it appears the validate method provided by the mock does not accept any parameters. Still, this will come in handy when I know that I don’t have a fully populated domain POGO, but want to validate what I have. Say, for example, in a UI wizard where each step sets a partial set of properties on the domain class.

                          

• Google news including GDrive and a primer on Google Go
• Maven’s switch to Guice and a demo of Maven POM files in Groovy
• Dependency injection annotations JSR-330 and JSR-299 released with JavaEE 6
• Flex, OSGi, and Gremlin

If you have suggestions on topics we should cover in the future, you can tag related news items on Delicious with the tag devnewsideas and we will consider your story for the podcast.

While you are checking out the DevNews, be sure to catch podcasts with Venkat Subramaniam and Jeremy Grelle. Both of these guests will be speakers at the Emerging Technologies for the Enterprise Conference being held in Philadelphia on April 8-9, 2010. In the interest of full disclosure, this conference is hosted and presented by Chariot Solutions – my employer. This is the 5th year this conference will be presented, and it just keeps getting better. We have a great list of speakers and topics lined up, so check it out and be sure to register soon to get the early bird discount.

                          

It started last week with two Groovy related announcements. First, we were treated to Groovy 1.7 RC2 and found out that we have every reason to expect Groovy 1.7 GA before Christmas.

See: Groovy 1.7-RC-2 out there

Also, last week the Groovy-Eclipse team quietly released 2.0M2 of the Groovy Eclipse plug-in. They claim to have addressed over 100 issues, which includes a better inference engine, better refactoring support, task tag support, and content assist in GStrings. All in all, it looks like some nice improvements.

See: Groovy-Eclipse 2.0.0M2 New and Noteworthy

Then today there was an explosion of news all starting with the release of Spring Framework 3.0. There is a lot of good new stuff in there, and I’ll leave it to Juergen Hoeller to lay it all out for you.

See: Spring Framework 3.0 goes GA

This was followed very closely with the release of Grails 1.2 RC2 which includes the new Spring Framework 3.0 GA.

See: Grails 1.2-RC2 Release Notes

Finally, Guillaume Laforge posted an update on the modularity work that is being done as part of the Groovy 1.8 effort. This gist of this is to modularize Groovy into smaller pieces rather than having one, large groovy-all.jar distribution. Part of this effort will include replacing the current Ant based build with Gradle. This is a nice feather in the cap for Gradle.

See: Groovy 1.8 modularization

I am very excited to see what is to come in 2010 for the Groovy and Grails community. Judging by the activities of just the past month, there is a lot to be excited about for the year to come.

                          

Groovy on Grails seminar downloads: http://www.chariotsolutions.com/events/groovy

If you also head over to the Chariot Solutions team blog, you will see some video testimonials (including one from me) taken at the event. The team blog is also a great resource to follow for news about other upcoming events, like the Emerging Technologies for the Enterprise conference in April 2010. There should be some more great Groovy and Grails talks at this conference, so watch the site as speakers and topics are announced.

Chariot Solutions team blog: http://chariotsolutions.blogspot.com/
Emerging Technologies for the Enterprise: http://www.phillyemergingtech.com/