Loading...

June 11, 2012

Gr8Conf 2012 Conference Report: Day One

After the university day the conference now really starts with a lot of sessions. Aside from the first session all sessions are in parallel tracks. This means you sometimes have to make though choises. Luckely a lot of the presentations or code from the presentation is online. If we go to the Gr8Conf website and look at the Presentations page we can go directly to a presentation. On that page we see more about the subject and the speaker, but also the presentation itself is included or a link is available.

Søren Berg Glasius started the day and gave us a very big welcome to the 4-th Gr8Conf Europe. Guillaume Laforge presented the first session Groovy Update: What's New in 1.8 and What's Coming in 2.0?. First he gave a short recap off all the features that were added in Groovy 1.8. But quickly we got to see what is in store for Groovy 2.0, which is just around the corner. First of all Groovy will be more modular. This means we don't need to have a big JAR file to work with Groovy, but we can decided which parts of Groovy we need. The core itself will be small and we have modules like console, XML, templates and more. Also Groovy 2 will have JDK 7 alignments. It will use invokeDynamic which is in JDK 7 to improve performance. And finally we get static type checking and static compilation.

After a small coffee break it was for my session Grails Hidden Gems. I showed with live coding many features of Grails. It is stuff you probably read about or used before, but somehow forgot it was there. Or maybe you didn't even know that it was possible with Grails. The small code snippets I used are available on GitHub. Mean while at the other room of the conference Andres Almiray released Griffon 1.0! Would have loved to be there and celebrate the moment, but that is what Gr8Conf is about: making though choices (or you need to present, while in the other room there is a great session).

Next I went to the Testing with Geb session. I already read some stuff about Geb, but I never got around to use it in my projects. After a great presenation by Luke Daley I am convinced I really need to do this in my projects. Geb has a very concise syntax to define tests or specifications. It can be used in JUnit tests or Spock specifications. Also we can abstract pages and use variable definitions with closures to define constraints and behaviour for a page. And with a jQuery like syntax we can traverse the generated HTML structure and use that for simulating user behaviour. To simulate a browser Geb uses Webdriver, the successor to Selenium. This is very flexible and allows to simulate for example Firefox, Chrome or Internet Explorer. We can even do mobile browsing.

After a good lunch Graeme Rocher presented the Grails Update session. He showed all the cool features that were added in Grails 2.0. Then he showed what is happening for the Grails 2.1 release. A lot of effort is put into the Maven plugin. It turned out developers working on Grails projects wanted or needed to support Maven for the company's build system. So that way a Grails application can be part of a bigger suite of applications and with proper Maven support it would be fully supported by their build systems. Also the cache plugin is updated in Grails 2.1. There is now an API, which is independent of the underlying implementation. Plugin authors should use this API and the Grails developers can configure the underlying caching mechanism for their application. In Grails 2.2 we may expect that Groovy 2 will be supported.

Next up was my Groovy Hiden Gems session. In this session I went to a lot of the cool features of Groovy with live coding. All mentioned samples are already described in my blog. So this was a subset of those blog posts showing off how Groovy can make your development live easier.

In the Gradle in the Enterprise session presenter Luke Daley showed how Gradle can be used in enterprise projects. Enterprise means big, a lot of dependencies between many projects, legacy projects and a heterogeneous environment. Gradle is really suited for this scenario as Luke showed. We can even define a company configured Gradle build and put it up in one location. We can define which scripts need to be executed for a Gradle build. The incremental build support really speeds up the build process, so even for big projects the build will be fast. Also we can create a specific build DSL for our projects, so we use the same 'language' in our build system as we would use when we talk about it in person. At the end of the presentation Peter Niederwieser showed how well Gradle already integrates with Eclipse (via STS). Gradle exposes a tools API, which is invoked by the Eclipse plugin. People from Gradle are developing the tools API, but the people at SpringSource are writing the Eclipse/STS plugin.

The last session of the day I attended was Keeping your Grails code clean. Andreas Aredal showed how we can apply the Clean Code rules of Uncle Bob to a Grails application. He gave pointers on how we can reduce the amount of repetition in our code base. Also how we can use informative method names and the like. It was interesting to see how we can apply good developer's craftmanship to a Grails application.

The day ended with a nice BBQ where we could mingle and speek to all speakers and attendees.