June 11, 2012

Gr8Conf 2012 Conference Report: Day Two

The final day of Gr8Conf 2012 in Copenhagen. The first conference day was really inspring, so I was ready for my second day and learn a lot from all the great presenters. The day started half an hour earlier than the day before, but it seemed not everybody knew this. During the first session a lot of people arrived and had to sneek in while the session was already on the way.

The first session I went to was Grails EE. The title might suggest that Grails will be part of Java EE, but it was a presentation about a real big Grails project and the lessons learned from the project. Ivo Houbrechts did a good job explaining the nice things Grails added to the project, but also pitfalls. I really like the parts where he showed how they achieved a lot of code reduction by implementation AST transformations. The code really looked much beter after this redesign and also the repetitive code blocks were gone. Also the addition and use of UI components was great. Cleaning your code and applying the DRY principle also needs to apply to the view layer in the application. On the project several specific project plugins and some are also available for use like the GSP taglib plugin and Rich Domain plugin. I got some very good ideas from the presentation.

Next up for me was the GPars session presented by Russel Winder. This was a fun session. Russel is a great presenter and capable of explaining complex subjects with humor and make it understandable. GPars is a library part of Groovy (but can be used standalone with Java apps as well) to support parallelism. Now a days the computer power of a single CPU core is limited. To improve performance we should use parallelism, so use multiple processors, to execute our code. Threads are something we shouldn't care about in our applications. They are part of infrastructure and we shouldn't manage them. With several examples we saw how different models of parallelism can influence the outcome and performance. There is no one-model-to-rule-them-all, we need choices. And GPars provides these choices with actors, dataflow and Communicating Sequential Processes (CSP). The nice thing is that all these models are developed somewhere in the sixties and seventies of the previous century. You can read more at Russel Winder's website.

After a coffee break I attended the Hacking the Spring Security Plugin presented by THE Burt Beckwith. Burt is a great presenter and how showed us all the different parts that make up the Spring Security plugin. We can pick and choose a lot of the components/filters and reconfigure them in our own application. The plugin is very flexible (as is the underlying Spring Security) and we can reconfigure parts easily. In the end there is a lot of Spring stuff underneath and we can reconfigure it by overriding components or setting properties.

Peter Ledbrook presented the Asynchronous IO on the JVM: Vert.x session. Vert.x is like Node.js, but we can use Groovy! Writing Vert.x code is very easy as Peter showed us. We write modules that will interact via an event bus. We don't have to worry about the event bus, it can run in a single JVM, but can also spawn multiple JVMs on different computers. Scaling a Vert.x application is very easy. With a concrete example we saw how easy it was to see real-time logging from a Grails application in a Javascript application running in the browser.

After lunch it was time for my final session on this Gr8Conf: Gradle Hidden Gems. I showed with several examples how we can work with Gradle build files. Different command-line options, task configuration and more were covered. During the talk I made the classic Gradle mistake to create a new task and leaving out the leftShift operator (<<), which would only configure the task. But the nice thing about live coding is that the audience will always help and try to find out what went wrong.

Next I went to Luke Daley's session Releasing Software with Gradle. He showed with a lot of example code how we can use Gradle for a project that we want to deploy to Maven Central repository. All steps necessarry were covered. Like creating a correct POM, signing the JAR file and uploading multiple artifacts to a Maven repositories. Very insightful and showed there is no excuse not to use Gradle. Luke also put the code on GitHub as reference.

I couldn't attend the last two sessions of the day, because I had to catch my plane back home. Which was unfortunate, because in the last two sessions interesting Spock things were covered and also Betamax, a tool to interact with HTTP services in tests.

Gr8Conf 2012 Europe was packed with interesting sessions. If you are developing Grails applications, work with Gradle, write test code with Spock or Geb, or use any other Gr8 technology, you should really attend this conference. Everybody is really approachable and it is great to meet the people behind all the projects. Mostly we know their names, but it is good to meet them in real life. Copenhagen is a great city with friendly people that speak English easily and ready to help. The conference takes place at the IT University and has nice auditoria to follow the session, while you can use your laptop to immediatelly try things from the session. The organizers did a great job organizing the conference (they even went through the "trouble" of brewing a special conference beer!). Thank you very much and hopefully see you all next year!