Welcome

As your GR8 Conference host, I would like to welcome you to this years edition of GR8 Conference Europe. 

In this short introduction, I will tell you a little about the conference agenda, our speakers and other practical stuff.

Groovy on the way to success

The European Patent Office (EPO) is the official patent granting authority of Europe, founded on the European Patent Convention, an agreement between 36 countries. EPO’s main responsibility is to examine patent applications and grant European patents, processing more than 140,000 patent applications per year.

EPO’s Data Resources Department is responsible for collecting patent-related data, which involves interfacing with about 100 patent offices all over the world. In order to replace its Cobol/Mainframe-based data flows EPO Data Resources has developed the Data Flow Platform, an enterprise application to streamline operations for all the data collection processes. In addition, EPO has developed a Data Flow Language (DFL, a Groovy domain specific language) to leverage similarities in the processes for communicating with each individual country’s patent office, and transform them into a single, universal process.
 
In this session you will learn:

• why Groovy was chosen as the preferred technology to write processes
• how Groovy makes it easier for business and IT to communicate
• why a Domain Specific Language is a key feature
• how the DSL interacts with a Business Rules Engine
• how the combination of Groovy and Agile methodology helps answer business needs in a timely manner and with higher quality

Grails Update

Grails provides a dynamic and agile development framework for web applications that is based on the most stable and productive open source libraries, including the Spring
framework.

This session will describe the latest features available in the new Grails 1.2 release and will describe the roadmap for upcoming releases.

Outline

• What’s new in Grails 1.2
• Preview of what’s coming in 1.3 and beyond
   

Grails Internals - Demystifying the Magic

In this talk Graeme Rocher, project lead of Grails, will walk you through the internals of Grails, demonstrating how the underpinnings of the framework fit together.

Grails is built on Spring and Hibernate, and is quite simply an abstraction layer built on top of these popular frameworks. In this advanced talk Graeme will show how to debug into
Grails internals and understand how Grails interfaces with Spring and Hibernate.

Graeme will also cover how other aspects of Grails function, such as class loading and the build system

Gaelyk, a lightweight Groovy toolkit for Google App Engine

Guillaume will present Gaelyk, a lightweight toolkit for easily developing Groovy applications to be deployed on Google App Engine Java. We'll learn more about what the toolkit provides, how to leverage it for your own needs through some demos.

Flying with Griffon

Building a desktop application is a hard task, there are some many things to keep track of that many projects simply fail to meet their goals.

Setting up the project structure keeping each artifact on a well identified location given its responsibility and type, defining the base schema for managing the application's life cycle, making sure the build is properly setup, and more. These are recurring tasks that should be handled by a tool or better yet, a framework.

Griffon is such a framework. Inspired by the Grails framework Griffon aims to bring the same productivity gains to desktop development.

Faster Groovy in 1.8

Groovy's speed is a reoccurring theme in discussion. For most people Groovy is fast enough, others are satisfied with using for example Java at the very small critical parts. But there is also a group of people that does not want to do polyglot programming and that feels Groovy should handle all their needs.

In Groovy 1.6 we did already invest great efforts to make Groovy faster eliminating the method selection overhead. But still some things like integer math is much slower in Groovy than in Java.

Here I will talk about what in the runtime has to be improved and what the compiler could optimize without changing the language in essential parts.

Gradle - A Better Way To Build

Gradle is an enterprise-grade build system. Gradle allows you to describe your build using a rich, extensible build language based on Groovy. It comes with build-by-convention support for Java, Groovy, Scala, OSGi, and web projects. Gradle provides exciting solutions for the big pain points that exist with current build systems.

Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks.

With its Deep API Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior.

Gradle has a particular focus on enterprise builds. It comes with many optimization strategies for building fast and yet reliable. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories.

In this session you will first learn about the philosophy and concepts of Gradle. After that we will go through a couple of live demos to see Gradle in action. You will see how easy and elegant you can do amazing things with Gradle.

The demos will span dependency management, test result analysis, code sharing, parallelizing, incremental builds, importing Ant/Maven projects and more.

Mobile web applications with Grails

Mobile web applications is an exciting and growing marketplace and Grails is a unique environment for riding this wave.

In this talk Sébastien, developer of the iWebkit plugin, will show how building mobile web applications with Grails is as easy as pie (the food, not the calculation). Sébastien will describe the anatomy of a mobile web app and then dive into the functionnalities of the plugin.

The presentation will be interrupted with small demos which will give a concrete idea of what is possible to do with mobile web development using grails.

Hackergarten on Tour

Hackergarten is a craftmen's workshop, classroom, a laboratory, a social circle, a writing group, a playground, and an artist's studio. 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. Membership is open to anyone willing to contribution their time.

What to Expect - You'll meet some great people, write some great code, and contribute directly to the Groovy community. Expect to leave Hackergarten knowing a Groovy framework or project a lot better, knowing how to create and submit a patch to an open source project, and meeting some new friends. There is no better way to learn about the GR8 technologies than to spend a few hours coding side by side with the project leaders and members.

What to Bring - Bring yourself. If you have one, bring a laptop. Expect to pair program. If you don't have a laptop then someone else will.

Our History - Hackergarten meets once a month in Basel Switzerland at the Canoo Engineering AG offices. In the past we have written the Gradle Announce Plugin for version 0.9, and three plugins for the Griffon framework. Let's see what we can create in Copenhagen!

Hackergarten is brought to Denmark by Canoo Engineering AG. They will sponsor the pizza's and the drinks at this event.

Groovy Goodness – Exploring the Gems in Groovy

Groovy has a lot of features we don't come across every day. But knowing these features can make our development efforts much easier.

We take a road trip into the more advanced Groovy features and look for the little treasures hidden in Groovy. We learn about Groovy's extensions to Java classes in the GDK, the advanced collection features, the dynamic capabilities of Groovy and more.

After our journey we have extended our Groovy toolset and knowledge and we are ready to use them in our every day development life.

Quickie: Groovy IntelliJ IDEA

In this hands-on presentation, we’ll investigate how a modern Java IDE can add value to Groovy and Grails developers by helping them create and maintain dynamic code, mix it with Java or other languages, create tests and analyze code from different angles or define IDE support for your custom DSLs. We'll go through several coding examples using IntelliJ IDEA, showing the various aspects of the available support that makes development even groovier.

Groovy: to Infinity and Beyond!

In "Groovy, to infinity and beyond!", Guillaume Laforge will keynote on Groovy's past, present and future. First, we'll do a quick review of Groovy 1.6 features: multiple assignment and option return in if/else and try/catch blocks, AST transformations with @Delegate, @Lazy, @Immutable, @Mixin and friends, the Grape dependency module, metaprogramming enhancements, JSR-223, JMX and OSGi support built-in. Then we'll dive into Groovy 1.7, especially how to simplify the creation of AST transformations, and we'll discover the upcoming features in Groovy 1.8, for instance how to extend annotations beyond Java 5, potential new features such as structural pattern matching, parser combinators, actors, and more.

Quickie: Groovy actors and concurrent dataflow with GPars

Low-level concurrency handling is usually hard to get right. And it's not much fun either. Now, when parallel systems are the norm in the mainstream, it has become obvious that the common shared-memory multithreading causes more troubles than it solves.

In this hands-on session we will go through the concurrency options that GPars (http://gpars.codehaus.org), an open-source concurrency library for Groovy, gives to your Groovy applications. We'll cover parallel collection processing, map/reduce, fork/join, asynchronous closures, actors, dataflow concurrency and other concepts, which aim to make your Groovy code concurrent with little effort.

If you want to learn how to safely harness all the cores in modern processors, this session is for you.

Groovy Compiler Metaprogramming

A language should have access to its own abstract syntax' John McCarthy, Father of Lisp.

Well, now Groovy does! This talk is about why AST transformations are important, what you can do with them, and where the language world is headed.

We'll dive into some of the useful Groovy annotations and libraries being written that harness AST transformations, see how to write our own, and work with the AST tools that are available today or being currently developed by the Groovy team.

Smarter Testing with Spock

For many years, developer testing on the JVM was intrinsically linked to JUnit. But as the JVM becomes more polyglot, several new kids on the block are competing to advance the state of the art. One of them is Spock, a Groovy-based testing and specification framework for Java and Groovy applications.

In the first part of this session, you will learn how Spock's beautiful and expressive domain-specific language simplifies state-based, behavior-based, and data-driven testing. After covering the fundamentals, we will explore several of Spock's extensions (including the Spring and Grails extensions), and write an extension of our own. Finally, we will take a short look under the covers and reveal how Spock pushes Groovy's meta-programming capabilities to their limits. Along the way, expect to see lots of code and live demos.