Last week I sat down with the gang at the Grails Podcast and talked shop for about 45 minutes. We talked about a lot of different topics such as Groovy, Lean software, Spock, Groovy in Action, and of course Hackergarten. Check out the full audio and shownotes over at Grails Podcast Episode 125.

Hackergarten is on tour again, and in the next few days we have an all day coding event at GeeCON in Krakow (Saturday 14th May) and all night event at GR8 in Copenhagen (Tuesday 17th May). So what is Hackergarten anyway?

Hackergarten is a group of people that come together to write open source code. If you come to Hackergarten, then expect to do some pair programming, learn better how to write code, and make a contribution to the open source world. The idea of the event is to create a hands-on user group, where you don’t sit an listen to a presentation, but instead you learn through doing and creating. Conferences give people tons of energy and excitement, and here’s a way to continue your conference experience and make a positive impact on the world while you’re still amped up from the conference.

Here’s a run-down of some important aspects of hackergarten:

• there will be coding – most of your the time is spent pair programming on a small task for an existing project
• you will submit a patch – your goal is to write a feature or fix for a project and then submit the patch (or make a commit)
• there is no agenda – the session starts with chaos as people suggest coding ideas and naturally from into small teams and groups
• you don’t need a laptop – If you have a computer then please bring it! If you don’t then come anyway and don’t worry about it
• you don’t need specific skills – All skills and backgrounds are welcome: beginner to expert, assembler to Scala, and everything in between
• you can recruit for your open source project – got an OS project of your own? Come to Hackergarten and convince other people to work on it with you

There will be some Hackergarten veterans to help out with the event. We have our own project ideas and can lead some teams if you want.

Andres Almiray – Andres is the lead on the Griffon Framework (among other things) and he’s always ready to lead people through contributing
Rene Groeschke – Rene is a frequent plugin contributor to the Gradle build system and will to help people with working on Gradle
Hamlet D’Arcy – I am a committer on CodeNarc (static analysis for Groovy) and the Groovy language. I have a ton of static analysis rules that are ready to be implemented for Groovy, and just need some help from you.
You – Got your own project? Please show up and help people contribute!

There is one last important thing: drinks and food are provided. Canoo sponsors Hackergarten (thanks Canoo!), so you’ll at least be fed and watered.

See you soon!

If you are reading this then you are quite likely a Jazoon 2010 attendee looking for more information about the mysterious “Hackergarten Jazoon” session blocked in your Wednesday night conference schedule. Welcome Aboard! Here is what you can expect:

1. A room will be announced when we know it
2. Drinks and food will be provided by Canoo
3. During the evening, everyone will try to contribute in some way to an open source software project.

Here are some of the contributions we made at past Hackergartens:

• A Twitter plugin for the Gradle build system
• A Growl/Notification plugin for Gradle
• Several Swing related plugins for the Griffon application framework
• A Grails Elastic Search plugin
• An inhancement to the Groovy language to aid logging

We have several ideas for projects to work on, but please feel free to show up with your own or leave a comment here with your idea. The past events have been Groovy focused, but Java, Scala, Clojure or whatever are all perfect. A few of the speakers have said they would attend and Griffon project lead Andres Almiray will be there. Pairing with an expert is a wonderful way to learn.

As people show up we Canooies will help you find other people with similar interests. Once you have 2-6 people in your group then it is up to you to start working. In the past, the most effective project groups are around 5-6 people, which creates 2 or 3 pair programming teams. Any larger than that and you spend too much time organizing yourselves. Near the end of the night you should wrap up your work and submit a patch to the project. Canooies are around to help you with patches, version control, tools, expertise, or anything else you might need.

Here are some of our project ideas, but please leave a comment here with your own! And remember, you have at most 4 hours so think small. There is no project too small… a 2 line patch is the Open Source developer’s equivalent of a CHF 10 bottle of wine. It might not be appropriate to the current meal, but it is almost always appreciated.

• Griffon-Hudson Plugin similar to the Grails plugin
• Griffon Substance Look and Feel Plugin
• Groovy Static Analysis Rules – Similar to Find Bugs but for Groovy
• Groovy @Log Transformation extensions – There is some small work to do in Groovy Core
• Find Bugs statis analysis rules for Java
• Gradle Find Bugs plugin
• Gradle JavaNCSS plugin

Post your ideas below, and see you on Wednesday.

Last week was the European GR8 Conference for Groovy, Grails, Griffon, and other GR8 technologies. Besides sending four attendees, Canoo had two speakers: Andres Almiray for “Flying with Griffon” and Hamlet D’Arcy for “Code Generation in Groovy“. As if that weren’t enough, Canoo also sponsored a Hackergarten night, where patches to Groovy, Grails, Griffon, and Gradle were all created. At the end of the event, a few of us Canooies got together and wrote about our favorite parts, the parts that impressed us most.

Detlef Brendle

Spock – Smarter Testing with Spock by Peter Niederwieser

Peter presented the Spock Framework. Inspired by Junit and other testing framework, Spock brings the strength of Groovy into testing. A groovy DSL lets test cases be more human readable and more structured. It can even help in discussions with non-techie project members such as business analysts or managers. Also, data-driven test specifications let developers inject a data table (loaded from any data source such as an excel file, a db table or others) into tests in order to separate the test from its data. Spock testcases are Junit tests and therefore nothing special needs to be done within the IDE or within the CI build system. If a test case fails Spock provides a much better reporting output than Junit. It gives a developer hints what have went wrong. Conclusion: The Spock Framework is something to consider on our next project.

Groovy: to Infinity and Beyond! by Guillaume Laforge

Sven Ehrke

Guillaume presented the most interesting bits in the evolution of Groovy from version 1.5 up to the current 1.7.x and what they would like to put in the future versions of Groovy. Especially for Groovy newbies it was interesting to see what Groovy provided in it’s first version like generated getters and setters for bean properties and how each version provided new value such as support for Java 5 features like annotations, generics and enums in Groovy 1.5. Then in 1.6 we got AST transformations such as @Immutable and @Delegate, parallel assignments, Grape and improved performance. 1.7 brought anonymous inner and nested classes, power asserts and ASTBuilder.

One of the latest additions is that annotations can take a closure as argument laying the foundation for fantastic things like GContracts, Design by Contract (TM) for Groovy, which arose big interest. Unfortunately there was no exclusive session about gcontract, but Hamlet D’Arcy came to the rescue and explained the most important things about it in his very interesting and enjoyable sesssion ‘Groovy Code Generation’. Guillaume also gave an outlook about potential new features in version 1.8 such as annotations beyond Java 5, structural pattern matching and parser combinators. The intersting thing I found was when we discovered that ‘withDefault()’ of a Map actually modifies the map even when it is made immutable:

  def m = [:].withDefault { k -> 'default'}.asImmutable()
  assert m.size() == 0
  m.get(1)
  assert m.size() == 1

Groovy Goodness – Exploring the Gems in Groovy by Mr. Haki

Hamlet D'Arcy

Mr. Haki, aka Hubert K. Ikkink, stood in front of the audience for a 90 minute live coding session that wowed everyone. I filled a page of my notebook with new Groovy idioms that I did not know existed. For example, did you know you can use Lists as a replacement for constructors:

  URL url = ['http', 'www.mrhaki.com', 80, '/'] as URL

It’s great to see a live coding session and Mr. Haki did it with almost no written notes. Bravo. As a Groovy developer, the Groovy Goodness blog is a great resource that I use all the time for reference. It was fun and informative to see it live.

Gradle – A better way to Build by Hans Dockter

Detlef Brendle

Hans talked about his baby Gradle and how Gradle can help to ease the build system of any Java Project. The strength of Gradle is its declarative way of defining the ‘What’ to do in order to build and leave the ‘How’ to the build system itself. Even things like task dependencies (e.g. to execute Tests the sources must have been built before) are left to Gradle. Parallel Test execution is also a built-in feature. This will soon be extended to parallel build execution for multi project builds.

Build system sessions can sometimes be boring, but Hans spent nearly all the session writing build scripts live, showing how quickly new build requirements can be incorporated into an existing build. His focus was on showing how a rich project domain model and a good front end scripting language enable you to get the build you need, not the build some other team has dictated to you.

Conclusion : It is definately something to keep in mind when thinking about changing to a new build tool.

Groovy on the way to success by Philippe Delebarre, Raffaele Cigni, European Patent Office

Sven Ehrke

In the keynote Philippe and Raffaele gave an overview on how the European Patent Office works and explained the difficulties of processing 140,000 patent applications per year. Since patent applications have an unstructured format it is very challenging to process them in an automated way. Currently this is done by a legacy system mainly consisting of HOST components and REXX scripts. Two attempts to migrate the old system with a new one failed. The latest attempt with a so called Data Flow Platform, a process server, was sucessful. With DFP and openrules business rules are implemented using a groovy based DSL. This is done by a business person together with a developer based upon the users’s and the business’s needs.

An eye opener for me was how a business oriented DSL opens up completely new perspectives on pair programming (a BA and a developer pairing together) and thus can contribute so much to the success of a project. In this project this was the way to bring Business and IT in direct contact which is so difficult in many larger companies. Philippe and Raffaele made the experience that this led to a much faster development cycle and in addition they rose the interest of other business domains in the European Patent Office to use this approach.

Flying with Griffon by Andres Almiray

Hamlet D'Arcy

If you think including a co-worker’s Grails-like RIA framework session in the “best of” wrap up is unfair, then you must not have seen the session! Andres built a full Twitter client live starting with nothing and using only Griffon and the standard plugins. It was runnable as an applet, a JNLP webstart, or a traditional desktop application. It had a rich data grid that competes evenly with the FlashVM alternatives, and the business/component widgets are top notch.

The time when Griffon really impressed was during the extended question and answer. Every question was answered with a “yes, there is a plugin for that” and a live demo. Need an executable installer or a Mac .dmg file? Andes typed:

  griffon install-plugin installer

  griffon install-plugin css-builder

Once again a group of Canooies and Friends joined together on a Friday night to write open source code and contribute back to the software community. By any measure, the April Hackergarten was a large success!

The group developed and released 3 Plugins to the Griffon Framework, an open source Groovy and Swing desktop application framework. The plugins were:

• JTreeMap – An interesting take on tree visualizations based around the JTreeMap component.
• Notify – A perennial hackergarten favorite, this adds nice alpha blended desktop announcements to Ubuntu, Windows, and MacOSX.
• Oxbow – A mature project to standardize common task dialogs, an area Microsoft excels in but Java is just catching up with.

We also got a good start on a 4th plugin (DockingFrames), but there was just too much work to do and we’ll try to finish and release in the next few weeks.

Griffon Project Lead (and Canooie) Andres Almiray already blogged his thoughts about the night. Here is what some other participants are saying:

I learned a lot about Griffon plugin system. never thought how easy plugin developement for Griffon is. Also learned some more stuff about git and about using Intellij IDEA with griffon.
Rene Groeschke

At Hackergarten I learned how easy and fun the development of a standalone application can be using Griffon. In just a few steps you are able to get something working, avoiding the painful process of setting up a build tool. I liked the use of the pomodoro technique during the evening, when used in team it helps avoiding that only one developer is doing all the steering.
Francesco Durbin

It’s amazing to see what you can achieve spending just a few hours in hackergarten: Before the last event Griffon was completely unknown to me – now I am an official contributor of that project. And besides that I had a great evening with beer and pizza and some nice people.
Christoph Lipp

The second Hackergarten was great! Not only did I learn Griffon, I had the best teacher in the world, project lead Andres Almiray himself! Working together with such talented people, as Hackergarten brings together, is sheer joy. Actually contributing to the open source community, seeing your stuff used by others, is just cream on top! I can’t wait until the next Hackergarten!
Per Junel

The next two Hackergarten nights are on the road. If you’d like to join the fun then swing by or join the mailing list:

• 19 May – GR8 Conference Copenhagen
• 2 June – Jazoon Conference Zurich