Grails is one of the most flexible and most powerful frameworks on The Java Platform. Grails leverages the flexibility offered by the platform in a way that other web frameworks do not. Grails is a fantastic platform for polglot web programming. Part of what makes Grails so compelling is its really powerful plugin system.

The Grails plugin system allows capabilities to be bolted on to applications, including adding support for a variety of programming languages.

The dynamic runtime nature of Groovy is one of the things that sets it apart from standard Java and makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts.

This session will cover the runtime metaprogramming capabilities of Groovy. The session will dive deep into Groovy's Meta Object Protocol (MOP) which implements the incredibly dynamic runtime dispatch mechanism. Come and enjoy a lot of live code demonstrating really powerful runtime features of the language.

One of the major advantages of Groovy is that you can leverage existing Java APIs very easily: you can use them in Groovy just like you would in Java. However, Groovy is a perfect fit for DSLs and it's possible to make those APIs rock: why would you be obliged to use them in a Java fashion if we can build Groovy APIs for them?

It's a web toolkit inspired by Ruby's Sinatra but distinctively JVM. It builds on great foundations such as Netty and Guice while leveraging Gradle and Groovy to make things dead simple.

With plenty of code, strong opinions, examples and a helicopter, we'll be covering Postels law, internal integration, static/ dynamic and why Groovy is among the best languages for enabling large scale development.

Micro Service Architectures have quietly gathered fans and implementations over the past couple of years, as much for their ease of implementation as the incredible adaptability they add to your systems.

The first decision to make is what framework to implement in. If it's HTTP based, there are a plethora of options, if it isn't then you are much more constrained. You assume you will lose the benefits of your investment in Spring and the existing technologies as Spring has historically required a fair amount of setup, what if that weren't the case?

I will show our use of Groovy, together with Dropwizard and Grails, and explain why we decided to integrate our services using Spring Integration and RabbitMq. I will also discuss how we are unit, integration and browser testing our applications using Spock, Spock Spring, Remote Control and Geb. Finally I'll explain why it's all built using Gradle and show how we're using Gradle to setup our IntelliJ project to allow running all types of tests directly from the IDE meaning that we can easily and quickly debug even our integration and browser tests.

It's this time of the year where the Groovy fans gather in London for Groovy Grails eXchange to learn about what's been going on in the Groovy world and ecosystem. In this session, Guillaume will guide you through the latest developments of Groovy, what happened in Groovy 2.2 and what's coming in Groovy 2.3, and beyond, with Groovy 3!

Open Source has been around for a long time, with perhaps it's first formal appearance in the guise of the GNU project in 1983. 30 years later, do we yet understand how open source works? How is it funded? Is it a sustainable model? And how should we as developers approach open source?

These are important questions to answer if we are to gain the benefits of open source and avoid disappointment. You will learn that open source software cannot be treated as simply having no financial cost and that investment reaps rewards. We'll also discuss how to get communities more active and engaged.

Dropwizard is a JVM framework for building fast, ops-friendly high performance RESTful web services. It comes with out-of-the-box support for configuration management, logging and health monitoring.

I will also discuss how DropWizard services fit within a Grails-centric architecture and provide alternatives from the Grails world for many of the niceties provided by DropWizard.

Reactor was recently made public after a two-year incubation, evolving slowly alongside frameworks like Storm, Akka, GPars or Vert.x. Integrated with Grails through events plugin, Reactor takes the best ideas from several asynchronous toolsets and synthesizes them into a coherent framework that supports a variety of runtime topologies and makes it easy for developers to efficiently leverage their cloud or traditional hardware assets.

Reactor is equally at home inside or outside a Spring ApplicationContext and also provides first-class Groovy support in the form of DSLs and language extensions. Special attention has been given to make Reactor easy enough to use to create single-file node.js-like applications, while maintaining a solid asynchronous toolset that works with Data tools like Gemfire, Spring Integration, and Spring Batch.

This talk will discuss how to use Gradle to modernize and customize old build processes that have gotten out of control. How using the power of a declarative system that is not rigid allows you to create an extensible markup system.

One of the biggest changes in data storage has been to go from soley Relational Database Management System (RDBMS) database - web systems, to mix mode systems. Where you can have the web tier plus a traditional RDBS system, and a NoSQL system when performance matters. One of the challenges is determining not only how to lay out the system but also how to write the code with Grails.

Client-side MVC frameworks like AngularJS are getting more popular over time. They represent a big architectural change to what web developers are used to: moving from server-side MVC to a browser based one. I will also do a live demo of a sample web application using AngularJS, Grails, the events-push plugin and MongoDB.

Writing functional tests using Geb in a Grails application is fine for a development team. But when you have QA automation engineers, giving them access to the Grails app might not be the best solution (specially when they belong to a different team). So the same way DevOps allow developers and sysadmins collaborate together, let's talk about DevQA, and make them happy using a framework stack powered by Groovy.

Groovy started life as the dynamic symbiote to Java. In order to achieve this Groovy wasn't totally "duck typing", it supported optional runtime type checking. It was though still very much a dynamic language with a full meta-object protocol, competing with JRuby, Jython and Clojure for market share.

With the additional of @TypeChecked and @CompileStatic and other things, Groovy has entered the realms of being a statically compiled language, competing with Java, Scala, and Kotlin for market share.

Is this the right direction for Groovy to go? Is claiming to be both a static and a dynamic language ruining the Groovy message? Is it ruining Groovy? Is @TypeChecked fundamentally different from @CompileStatic? This session will investigate these questions and may serve as a place to learn about these things or a place to debate the future direction of Groovy.

By improving Grails' convention-over-configuration application design with a message driven architecture, applications can benefit from improved modularity, scalability, and code reusability.

Given that Grails is already a fully loaded Spring application, the content of this presentation will focus on developing message-driven patterns, techniques, and strategies based on Spring Integration. The core of the presentation will focus on developing an application workflow that is amenable to pluggable components and services at given phases in the workflow's lifecycle using Spring Integration.

We often think about Groovy in strict terms as being a programming language, and usually have conversations about it in terms of web development. However, Groovy is also a powerful scripting language, and can be leveraged to build tools to assist in every outlet of system administration.