Next Saturday, 3rd December, Canoo is sponsoring the Swiss installment of the Global Day of Code Retreat. It’s being held in Lugano, which is easily reachable from Switzerland or Northern Italy. The event is free, lunch is provided, and you’ll get a chance to practice your programming skills while taking part in a world-wide event that criss-crosses the globe. Sound fun? It will be. Here’s what you need to know:

A code retreat is a day long event where programmers get to practice and hone their craft. The format was created three years ago and has been used and improved regularly since then. During the day we’ll use Conway’s Game of Life to practice our design, testing, and pair programming skills. The event has a predefined format and will be facilitated by Canooie Hamlet D’Arcy. This is quite different from our Hackergartens, so you may want to read up on the format so you know what to expect. Michael Hunger has an excellent synopsis of Code Retreat up on the InfoQ website.

The originator of the idea is Corey Haines and he will be facilitating the first code retreat of the day in Australia and then flying to Hawaii to also facilitate the last retreat of the day. There is most likely a code retreat in your area, just in case you can’t make it to Lugano. Check out the map to see where you can go.

There are several sponsors for the Code Retreat in Lugano: Canoo, Ex Machina, and JetBrains to name a few. If you show up then expect to leave with some goodies as well as the free lunch. And please, if you plan on coming then be sure to register on the website so we can provide enough food and coffee.

See you Saturday!

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!

Another month has past and it is once again time for Hackergarten.

Last month we came together and managed to write 4 new static analysis rules for the CodeNarc project, a static analysis tool for Groovy similar to FindBugs for Java. We learned a lot about Groovy AST and had a great time. You should have come by!

This month there are two groups:

• Gradle – At the very first Hackergarten we released the “Announce” Plugin for Gradle. Now that Twitter has updated their security layer, we need to rework the plugin to use OAUTH. If you want to learn about Gradle or OAUTH then come by and lend a hand. Show up with your laptop (or don’t)
• Mockito and Spock – Mockito is a mock object framework for Java, and Spock is a testing framework for Groovy. We’re going to compare the two projects against each other and create some new “developer cheatsheets” for both projects. We aren’t fully decided, but it will probably be a quick reference that other developers can hang by their monitor as a guide to the projects.
• Your Project – Got an idea? Bring it. We need project ideas: Java, Groovy, .NET, JVM, whatever.

Lastly:

• Halloween – There is a bar in Heuwaage giving free drinks to those in costume celebrating Halloween. I am bringing my sumo wrestler outfit, and I encourage you to bring your costume. Surely we will break by 10 PM to go celebrate, possibly earlier.

See you Friday!

Two weeks ago I spoke at the Chech Java User Group (CZJUG) on the topic of “Code Generation on the JVM”. Some of the technologies covered are Lombok, Groovy, GContracts, Spock, AST Transformations, Spring Roo, and other fun stuff.

The slides are available at: http://github.com/HamletDRC/presentations/blob/master/asttransformations/asttransforms_czjug.pdf

As a fun aside: my Ubuntu laptop went crazy the night before and I spent all day before the JUG reloading Linux on my vacation. In the end, I had to switch to my wife’s Mac to do the presentation and live coding. I got the Macintosh fully configured and, during the 1st presenter, realized that I had no VGA output on the Macintosh. Oh geez. The final solution was to share my desktop, have an audience member VNC to my wife’s machine, and project the desktop from the audience. It worked and I’m glad I didn’t have to give the whole talk in chalk on the blackboard (although that would have been a fun challenge).

Enjoy the video!

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

This year’s JAX.de conference hosted many great Java thought leaders, including one of my personal favorites Gilad Bracha. If anyone has the authority to critique Java and the Java platform then surely it is Gilad who spent years working for Sun on the language and platform tools. If you haven’t followed him recently, I recommend reading his papers on Pluggable Type Systems and Objects as Software Services. Lucky for me, my “Code Generation on the JVM” talk was sandwiched between his “Java: A Post Mortem” and “Newspeak: A Principled, Dynamic Language”. It was surreal to see my name next to someone I’ve revered for many years, and I felt a bit like the rookie professional athlete who has to play his first game against someone they grew up watching on TV.

As expected, his talks were good mix of humor, strong opinion, and thoughtful analysis. Here are my favorite bits:

If you can’t abstract over it then it doesn’t belong there.
An original sin of Java was constructors. They are static methods that commit to returning a concrete implementation. Remember the design mandate “program to interfaces”? Constuctors subvert this and gave rise to a cottage industry of Dependency Injection frameworks to get around the issue (as long as you consider VMWare a cottage industry!). You wouldn’t need DI if your language supported proper inversion of control in the first place. The next generation of languages hopefully won’t have this limitation.

Class initialization is absurd. There should be none.
Static state is bad, bad, bad and read Gilad’s great blog post if you aren’t persuaded. Without static state there is no need for class initialization. We’ve all heard that the JVM start up times are slow, but that is a bit of a myth. The problem is that through class initialization we’re asking the JVM to do millions of operations that could be avoided without static state. A Lambourgini isn’t slow, but it sure seems that way if you try to drive it to the Moon. Likewise the JVM.

Why should a high level language need a memory model in the first place?
The original Java memory model was incoherent, the revised memory model is understood by only five people in the world, and the actors for concurrency idea existed since the Gulati paper of 1970. Bracha’s point wasn’t that we need a better Java memory model, it is that we should have made a language that did not need to expose a memory model to the developers. As with many of the Java original sins, Threads were the wrong level of abstraction and something better like Actors should have been chosen.

Java is going to stay but it is going to stay where you don’t want to look
Everyone wants to predict the demise of Java, don’t they? But few people offer a real, long-term alternative. There is enough risk with any of the other JVM languages to persude Enterprises that sticking with Java is the best choice. The evening’s speaker panel agreed (mostly) that the real successor to Java didn’t exist today. So where will the next big lanugage come from? Who can monetize a programming language? Microsoft has somehow done it with .NET, but show me the Oracle business plan that details how to get rich from writing a programming language. Or any other company for that matter. Here is my prediction: all this language innovation results in the best ideas making it into libraries and frameworks available for the Java language, and Java remains number one on our beloved TIOBE index, clunky syntax and all.

Webapps make you reboot. It is called “session expired”
Newspeak was funded to solve the problem of always on, always updated software. Quick question: what version of Google do you use? I’ve never in my life seen a version number at Google.com and that is a deployment success story. All software should work this way. I’m unclear how Newspeak is going to solve the session state problem but I’m also certain that I do <i>not</i> fully grasp the Newspeak vision.

If you want a static language you should look at Egyptian heiroglyphics because it hasn’t changed in a long time
And another quote from Brian Hurt: “Demand that you not have to learn something new to learn new languages, and then wonder why languages don’t improve much”. Newspeak is a bold change, and people are going to be very resistent. Incremental changes like Groovy are much easier to sell than big sweeping language changes. And an always changing language can hardly be adopted by the masses. I left the session wondering if Newspeak is an experiment meant to fuel language innovation or a real alternative as a mainstream programming language.

Complicated is not a sign that you’re clever. It is a sign that you failed.
Simple solutions can be achieved with a low number of non-overlapping concepts. If you need something more complicated then build it by composing the simpler pieces together. Special cases like primitive types are the road to ruin. Or the road to massive popularity and success as is the case with Java. In my humble opinion: success is an accident, much better to aim for happiness.

Language development has moved away from professional language writer and into the hands of hobbiest developers
As a hobbiest developer working on the Groovy language, I have averaged a mere 2-3 hours a week of work over the last 12 months. The good news: I’m clearing my schedule after the GR8 Conference to work on Groovy’s GEP-4. The bad news, I am and will remain a non-professional hobbiest developer hacking on a language in my spare time. Life couldn’t be better.

A few weeks ago on a Friday evening, Canoo opened its doors to the public and hosted a new programming user group called Hackergarten. The goal of the group is different from other user groups: instead of learning from listening to a presentation they want to learn by writing code. In their own words:

Our goal is to create something that others can use; whether it be working software, improved documentation, or better educational materials. Our intent is to end each meeting with a patch or similar contribution submitted to an open and public project.

We’re excited to say that their contribution to the Gradle build system was accepted last week! The next release of Gradle 0.9 contains an “Announce” plugin that can notify you and your customers of build events using Twitter, Snarl, or the Ubuntu notification system. You can notify yourself of local build failures or notify your customers of successful formal build releases. It was a long Friday night, but the group of over 10 developers are all happy to see their work accepted. As the group sponsor, Canoo is happy to have kept them caffeinated and well fed.

The next Hackergarten is this Friday, 30 April 2010. The group plans to write some Griffon plugins, a desktop application framework written in Java and Groovy. The Griffon Project Lead (and Canoo employee)Andres Almiray will be present to help guide the group. If you are anywhere near the Basel area this Friday, then please stop by Canoo and come join the fun. Don’t worry if you’ve never seen Groovy or Griffon before, the point is to learn new skills and meet new people.

You can find out more information on the Hackergarten mailing list or follow @Hackergarten to stay up to date.

Come join the fun. Here’s what people are saying about the last event:

.

The first Hackergarten was a great event, not only because there was free pizza, but primarily because it was a true team event with everyone actively contributing. Submitting a patch for a new Gradle plugin at the end of the night was our goal which we reached successfully. I look forward to learning more about Griffon at the next Hackergarten.

Etienne Stuber

.

I learned how easy and powerful Gradle is. The fact: with a little group and in a little time, we wrote a worth-making contribution to an open source project. Did I have fun? Definitely, it was like meeting with friends but for a beer but enjoying coding at the same time. In the future I am interested in writing Grails or Griffon plugins.

Alberto Mijares

.

At Hackergarten I learned about the Pomodoro technique and how to use groovy closures to do exception handling in a smart way. And yes, I had a lot of fun! For future events I am interested in anything with new technologies but especially with testing different approaches on how to program in teams.

Christoph Sperle