For the past few months, my sons and I have been working on a different kind of project: We are putting on a conference for developers on Apple platforms, such as iPhone, iPad, and Mac. It’s called CocoaConf.

The first CocoaConf is being held in Columbus OH, on August 12 - 13, 2011. We have an exciting line-up of speakers, including Daniel Steinberg, Bill Dudney, Chris Adamson, Christopher Judd, and Dave Koziol.

We will be having three tracks for the two days; this will include an all day hands-on iPhone workshop on the first day. It's shaping up to be a very exciting event.

The idea for this conference came when my #3 son, Solomon, began learning Mac programming using the book Beginning Mac Programming by Tim Isted. Taking inspiration from my favorite conference series of all time — No Fluff, Just Stuff — we began tossing around ideas. The NFJS events are known for a capped size so that they don't feel crowded, and for a focus on technical content, without the vendor hype and special events that other conferences tend to have. So that's what we are doing for CocoaConf.

I hadn't blogged about CocoaConf here since it has nothing to do with my usual topics, Groovy and Grails (although the CocoaConf site is being developed in Grails). But today I am going ahead with this post, so that I have a place to explain a crazy (but fun) idea.

You see, 26 years ago today, my beautiful wife, Debbie, said “I do.” And today, we are celebrating this 26th anniversary with a one-day-only CocoaConf discount of 26% off the current early-bird rate of $350. That's a $91 savings for today (July 19th) only! So: If you are interested in developing for the iPhone/iPad or Mac and can make it out to Columbus in August, you can now sign up for CocoaConf for only $259 — but only for today, July 19, 2011. Just go to http://cocoaconf.com/register and use the coupon code “ANNIVERSARY”.

I don't know if anyone will take advantage of this deal, but I thought it would be a fun way to celebrate 26 wonderful years of marriage to my amazing wife. She is the second best thing God has ever done for me!

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.

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.

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.

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