Groovy / Grails User Groups

Technology user groups benefit both a technology (with the companies behind it) and its users. Java user groups around the world played a big role in the adoption and advance of the Java language and platform. Even now that Java is in its old age (or on its deathbed, depending on who you talk to), JUGs are actively promoting educational and community-building initiatives.

The Groovy community is benefiting similarly from a growing number of user groups. There are currently a few dozen groups around the world, and more are forming every day.

Now there is a website that can help you find a group in your area or help you get one started. G2Groups.net has a list of active Groovy user groups, with links to their sites. If you can't find one in your area, you can propose one. The site will post a link to your proposal on Twitter; you can retweet this to help get the word out. Then when others are interested in your idea, you'll get emailed about it, and you're off and running!

Once you get a few likeminded (and by "likeminded," I of course mean "brilliant") people together and get a group started, send me a note, and I'll invite you to the Groovy User Group Leaders list on Google Groups. This list is a great way to get support and ideas from other Groovy/Grails/Griffon/Gaelyk/Gradle/Getc. group leaders.

I've always said that the best feature of Groovy and Grails is the community. User groups are a big part of that. So if you're not already involved in a G2Group, get plugged in. You'll be glad you did.

JavaOne Has Been Replaced

I just got back from SpringOne/2GX. It was an excellent experience. The enthusiasm and interest level of the attendees was great. The content, both on the Spring side and (of course) the Groovy and Grails side, was top-notch. There were nine tracks loaded with sessions that covered all kinds of topics related to software development in the Java ecosystem. There were long breaks with plenty of stimulating hallway conversations. Even the keynotes were informative. At most conferences, I skip the keynotes. I've become so used to them being just sales pitches from people who don't even use the tools they're talking about. That wasn't the case here. One of the highlights of the show was Graeme Rocher's keynote demo of the new NoSQL DB support in GORM.

As excellent as it was, I'm not saying that SpringOne/2GX has replaced JavaOne.

The week before SpringOne/2GX, I took two of my sons to the StrangeLoop conference in St. Louis. This conference covered several important areas of software development. There was good coverage of Java and alternate JVM languages and frameworks, along with a bunch of other languages and technologies. It wasn't held in a big conference center or a nice hotel, but in three different buildings, each with a unique atmosphere. This “small” midwest conference featured industry luminaries that you might have expected to see only in the Moscone Center. To see them on the stage of a St. Louis night club was something else!

Just this afternoon, after opening registration less than 4 days ago, the CodeMash conference in Sandusky, OH, sold out. This conference, like StrangeLoop, covers a broad range of technologies. Though there is a bit more .NET than I would like to see, :-) it is another excellent event, bringing speakers from across the country and attendees from across the globe.

I could go on. There is the Silicon Valley Code Camp, the Houston TechFest, and so many more. But you get the picture.

For several years now, JavaOne has been turning into more of a vehicle for pushing a certain technology (coughJavaFXcough). The attendance has been gradually dropping. As developers stopped going to JavaOne, they began to find other events to meet the need that JavaOne was not filling. Or they started their own.

The Oracle acquisition and the subsequent decision to make JavaOne an afterthought to Oracle's annual event didn't help, but JavaOne was already on its way out. It was destroyed the way so many companies are: by pushing what it wanted its customers to have rather than providing what its customers wanted.

So I can't point to a single conference that will be the new JavaOne (although Über Conf comes close). But I can look out at all the technical gatherings happening around the world—Devoxx, JAOO, the JAX events, the GR8 events, and so many more. And then I can look closer to home and see all the “small” conferences that are providing big benefits to attendees and speakers, and I can say it without a doubt. JavaOne has been replaced.

Move On In Peace

As long as we measure the success of a movement by adoption numbers, any successful movement will eventually become compromised and diluted. This is a cycle that has repeated itself time and again. It happens in all areas of human interaction: politics, religion, science, entertainment, business, and technology, to name a few.

When this cycle occurs, the founders and early adopters often begin to feel bitter about where things have gone. They long for the “early days.” They begin to lash out at the masses that have morphed their creation into something less than what they had in mind. They may even make a concerted effort to reform the movement, and to bring it back to its roots. This is understandable, but it is not practical. I cannot think of a single instance where it has worked.

I've been thinking of a more sane and peaceful path: Founders and early members of a movement could, at the first sign of success, begin to plan their next move. Learn from what has been done before. Keep the essence of it, and start over. If the original idea was good, reuse and rebrand it. If those unwashed masses did bring a little value after all, borrow it and build on it. Or scrap the whole mess and reinvent the wheel. (Round does get boring after a while. :) )

Just be willing to let go of what was, and let those who have come run with it. Don't whine about it. Don't attack the newcomers. Just move on. If you miss the “good old days,” you can always start some new ones.

GroovyMag Plugin Corner: JavaScript Validation Plugin

The following post is a reprint of the Plugin Corner article for the April 2009 issue of GroovyMag. You can find this and other past issues at http://groovymag.com.

Grails provides powerful and easy-to-use constraint validation. With a few short lines in a simple DSL, you can ensure that required fields are filled in or that numeric field values are within a specified range. If you take advantage of Grails’ scaffolding, error reporting is also handled for you. The only catch is that it’s server-side only. If you want this type of validation without a round-trip to the server, you’re on your own — unless you use Peter Delahunty’s brand new JavaScript Validation plugin.

Peter released the Javascript Validation plugin earlier in March and then went right to work improving it. At the time of this writing it is at version 0.7 and is working quite well. Let’s see how easy it can be adding client side validation to our Grails applications. We’ll start by installing the plugin:

> grails install-plugin javascript-validation

We’ll need to make a couple changes to the views that we want validation on, but first let’s look at the domain class that we’ll be working with.

class Book {
   String title
   String author
   Integer pages
   static constraints = {
       title(blank:false)
       author(blank:false)
       pages(range:10..1000)                                                         
   }
}

This simple Book class (bet you never saw that in an article before) has three constraints. We will use the JavaScript Validation plugin to check those constraints without a trip to the server.

Open grails-app/views/book/create.gsp and take a look at the <g:form> declaration. It should look something like this:

<g:form action=”save” method=”post” >

The Validation plugin requires that our form contain a name attribute and an onSubmit attribute that calls the validateForm JavaScript function. So, let’s modify our form declaration to look more like this:

<g:form name=”bookCreate”

        onsubmit=”return validateForm(this);”

        action=”save” method=”post” >

Finally, we need to add the following line to the <head> section of our page:

<jv:generateValidation domain=”book” form=”bookCreate”/>

Here we’re just using the minimum required attributes for the <jv:generateValidation> tag. The domain attribute takes the domain class name, but with the first letter lowercase. The form attribute takes the same value that we assigned to the name attribute of our <g:form> tag. That’s all it takes to start using this plugin.

Now if we go to create a new Book and leave out the author’s name for some dumb reason, we’ll see something like the screenshot in Figure 1.



Not bad for a couple lines of code. That’s just the basics. The <jv:generateValidation> tag has ten more attributes that we can use to add more vigor and vim to our validations.

There is support for both domain classes and command objects. Errors can be displayed in a JavaScript alert (as shown in Figure 1), which is the default, or they can be shown in a list placed in a page element of our choosing, or we can even create custom error handling.

Currently only the following constraints are supported by the plugin:

• blank


• nullable


• email


• creditCard


• matches


• range

This list is considerably shorter than the list of constraints that Grails provides, but as we can see by the 6 updates since its creation a few weeks ago, this plugin is being actively enhanced, so I wouldn’t be surprised to see more constraints supported soon.

Oh, and lest I forget, the Javascript Validation plugin works with Grails internationalization. So with a minor tweak to our messages.properties file, we can customize our error messages as shown in Figure 2.



This plugin has great potential. It will already save significant development time in setting up client-side validation, and I’m sure it’s going to keep getting better. Stop by the Grails Plugin Portal and check it out. You can leave a comment with enhancement suggestions, or, if you’ve tried it out, let others know what you think with a rating. I’m giving it 5 stars!

Resources

Grails Plugin Portal page:
http://grails.org/plugin/javascript-validator

Peter Delahunty’s Blog:
http://blog.peterdelahunty.com

ÜberConf - Exceeding Expectations

ÜberConf kicked off yesterday with the pre-conference iPhone/iPad workshop. The workshop was completely full, with just over 90 people. The view from the front of the room was pretty impressive -- all those glowing apples. ;-)

Later, the conference proper got going with a great dinner and a keynote by industry luminary Cliff Click. At the time when a normal No Fluff, Just Stuff event would wrap up for the day, there was an opening reception with more food and drinks and a roving magician. A great time was had by all.

This morning, the sessions are going in full swing. I'm actually skipping one right now to finish up my sample project for the Grails workshop tomorrow. But the rest of the week is packed with great technical sessions, and not a marketing person in sight!

I caught Keith Donald's Spring MVC session this morning and plan on making it to a session by Ted Neward this afternoon. The content choices are amazing. You've got Java Collections, Functional Java, Groovy, Grails, Wicket, Camel, Hadoop, NoSQL, Agile Architecture, JRuby, TDD, and on and on. In fact, it's hard to think of a buzz word in the Java ecosystem that isn't covered here.

And the attendees are the best part. I've met folks from all over the country and beyond. I even ran into members of CapJUG and the Gateway Groovy Users. Seeing so many old friends and meeting so many new ones is definitely the best part of a conference like this. And with the longer breaks, receptions, etc., you actually get time to visit with folks without missing the tech sessions.

With all due respect to the many great folks who make the pilgrimage to San Francisco every year, this is what JavaOne should have been.

Recording of Grails / Terracotta webinar

In case you missed it and in case you're interested, Terracotta has posted a recording of the webinar that Mike Allen and I held a couple weeks ago. You can catch it in all of its glory (or lack thereof :) at http://bit.ly/scaling_grails.

During the demo I mentioned a blog post coming to the GQuick blog where we would add Quartz scheduling to TekDays (the sample app from GQuick), well that post ended up here instead.

Once again I'd like to thank the folks at Terracotta for their cool technology and for their support of the Grails community.

Quartz and Grails: A Quick-Start Guide

Terracotta's Quartz scheduler has always played a key role in Grails development. Originally it was built into the framework; now it is a core plugin. Quartz allows us to have code executed at regular intervals. This a great way to have batch processes or system checks performed at off hours.

The Quartz plugin provides three different mechanisms (triggers) to determine the timing of job execution: Simple, Cron, and Custom. With a simple trigger, we can set the amount of time to wait before initial job execution, an interval to wait between repeated executions, and the number of times the job should be executed. The cron trigger also allows us to set a start delay. Then it takes a cron expression, which we can use to set a wide range of schedules. With a custom trigger – well, you can use your imagination.

In our TekDays application, we have lists of tasks that need to be done to organize a technical event. These tasks have due dates, but we currently have no way of reminding event organizers and volunteers when they have tasks that are overdue. That's where Quartz comes in. In this post, we'll create a Quartz job to check for overdue tasks and send a reminder email to the person assigned to that task.

First, we'll install the Quartz plugin:

> grails install-plugin quartz

The plugin provides us with a new Grails script, create-job. We'll use this script to create our TaskReminderJob.

> grails create-job TaskReminder

The create-job script will create a stubbed out TaskReminderJob.groovy that looks like this:

class TaskReminderJob {
   def timeout = 5000l // execute job once in 5 seconds

   def execute() {
       // execute task
   }
}

We'll replace the timeout property with a triggers closure in a moment, but first let's look at the execute method. This method will be called at the intervals that we determine with the triggers. We can put any code we want in this method, but the most common practice, and the one we'll follow, is to call a method of a service class.

For triggering the call to our service method we'll use the cron expression: "0 0 2 ? * MON-FRI", which will execute every weekday at 2:00AM. This is how our new TaskReminderJob looks:

class TaskReminderJob {
   def taskService
   static triggers = {
       cron name: 'cronTrigger', cronExpression: "0 0 2 ? * MON-FRI"
   }

   def execute() {
       taskService.sendTaskReminders()
       log.info("Task reminders sent on ${new Date()}")
   }
}

Now we need to add the sendTaskReminders() method to our TaskService. This method will use the Mail plugin (which you can find more about at http://grails.org/plugin/mail), so we'll add that to TaskService too. Something like this:

class TaskService {
   def mailService

   //...

   def sendTaskReminders(){
       def tasks = Task.findAllByDueDateLessThan(new Date())
       tasks.each{task ->
           def recipient
           if (task.assignedTo)
               recipient task.assignedTo.email
           else
               task.event.organizer.email
   
           mailService.sendMail {
       to recipient
       from "admin@tekdays.com"
       subject "Task Reminder"
       body """The following task is overdue:
      ${task.title}"""
           }    
       }
   }
}

That's all there is to it. We now have the confidence of knowing that event organizers and volunteers will be kept informed of the tasks they need to do. And based on the experience of some people I know who recently put on a tech conference, this is important.

Now, something that in days past might have required us developers to climb tall mountains to make supplication to sysadmins wearing robes and conical hats has been made almost trivial by Quartz and the Quartz plugin. I, for one, am impressed and grateful. (I'm getting way too old for mountain climbing.)

But wait (as they say) – there's more. As TekDays gets more and more traffic (which we know will happen with all the new and exciting technologies coming out these days), we will want to take advantage of the power of Terracotta and cluster our Quartz jobs. To do this, we just need to create the property file: grails-app/conf/quartz.properties. Then enter the following values in this file:

org.quartz.jobStore.class = org.terracotta.quartz.TerracottaJobStore
org.quartz.jobStore.tcConfigUrl = localhost:9510
org.quartz.scheduler.instanceName = TekDaysScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.jmx.export = true

Finally, we'll copy quartz-terracotta-1.1.0.jar in our lib folder. The quartz-terracotta jar comes in the Terracotta download, which can be found at http://www.terracotta.org/dl/oss-download-catalog.

Now, if we've clustered our TekDays application as described in an earlier post, our scheduled jobs will be spread out across all the nodes. Not too shabby.

There is still some room for improvement in the Grails / Terracotta integration story, but I continue to be amazed at just how low the barrier of entry is to these powerful products.