2GX Schedule

By Guillaume LaForge

Let's talk about all the new features of Groovy 2.1!

With 1.7 million downloads last year, Groovy continues leading the pack of alternative languages for the JVM. Groovy 2.0 was released almost a year ago, introducing its modularity, its JDK 7 support with "Project Coin" syntax enhancements and usage of "Invoke Dynamic", and proposing static type checking and static compilation support.

With Groovy 2.1, the "Invoke Dynamic" support was completed for even more performance. A new annotation for helping documenting your Domain-Specific Languages, helping IDEs with auto-completion, and the static type checker to understand the DSL. A meta-annotation facility was created to let you group together and configure several annotations into one to escape from annotation hell. Last but not least, some additional customizations are possible to further configure the Groovy compiler.

Fasten your seat belt, ready for take-off with Groovy 2.1!

By Jeff Scott Brown

Grails brings the powerful "coding by convention" paradigm to Groovy and Java. Grails is not just another flavor in the pool of web development frameworks for Java. Grails leverages the powerful dynamic features of Groovy while taking advantage of best of breed technologies like Hibernate, Spring and Sitemesh to make web application development both fun and easy.

This session will demonstrate how easy it is to get a simple application up and running with very little effort and then evolve that application by adding features to really show off the power of the Grails framework. Topics include:

• Grails Quick Start
• The Grails Command Line Tools
• GORM and Hibernate
• Groovy Server Pages (GSP)
• Spring Integration

By Peter Ledbrook

Java is a good all-purpose programming language, but does that mean it's the best tool for all jobs? In this talk, you'll see how Groovy can scratch itches you didn't even know you had. From scripts, to writing unit tests, to building projects, we'll take you through use cases that highlight the advantages of having a second language in your toolbox.

We'll also discuss an approach to introducing the language into Java teams that doesn't hit too much resistance and allows time for teams to become comfortable with it. Dictatorial approaches typically don't work well!

By Kenneth Kousen

Watch Preview Video

The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.

In this presentation, we'll look at several examples of Spock tests and review most of its capabilities, including mock objects and integration with Spring.

By Graeme Rocher

In this talk Grails project lead, Graeme Rocher, will talk through the latest and greatest happenings in the world of Grails including a walk through of the features included Grails 2.3 and upcoming in Grails 3.0

Join Us!

By Bobby Warner

APIs open up our application data and functionality to other clients like mobile applications, JavaScript clients and even potentially other companies. The most prominent way of implementing them is by using the REST architectural style and it is now almost expected for all web developers to know how to build good RESTful APIs. As Grails developers, we have a few options readily available to us to simplify this task and Grails 2.3 included lots of new REST support.

This talk will cover these options as well as discuss some of the pros and cons with each approach so you can successfully build APIs using the new REST features in Grails 2.3 for your next project.

By Baruch Sadogursky

Grails is awesome! agreed? Good!

Now, search and testing facilities have become such a basic commodity in applications that it's almost taken for granted.

But as a Grails developer you face limitations and concerns: is the library well maintained? Does it fit the framework's paradigm?

After nominating the winners, we’ll show you the advantages of our tools of choice and take a deep dive into the juicy details.

This talk will provide short overviews and comparisons in the search for 2 pieces of the holy grail - good search and testing facilities.

By Kenneth Kousen

Watch Preview Video

The Spring framework has always had a friendly relationship with dynamic languages. In this presentation, we'll look at all the ways you can add Groovy to Spring to make development easier, ranging from simplifying your configuration files to deploying refreshable beans to using Spock tests in the Spring test context and more.

Groovy works comfortably with existing Java infrastructure, and Spring has special capabilities designed specifically for scripting languages. The combination is very powerful and is an easy way to take advantage of Groovy code simplification.

By Kenneth Kousen

The JAX-RS 2.0 specification is part of Java EE 7, but can be used now. It contains the expected annotations for the HTTP verbs (@GET, @POST, and so on) and mechanisms for retrieving variables, but only a few methods for doing hypermedia. This presentation will review those techniques by adding both structural and transitional links to resource representations. Groovy is used to simplify the code and also to implement a MessageBodyWriter for JSON data.

In addition to simplifying the implementation classes, Groovy also supplies a RESTful client class from the HttpBuilder project. That will be used, as well as the native client implementation classes in JAX-RS 2.0, to build Spock tests for RESTful services.

Prerequisite: Some knowledge of Groovy would be helpful

By Jeff Scott Brown

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 Part 1 of 2 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. The session will include a lot of live code demonstrating really powerful runtime features of the language.

This session is focused specifically on Groovy's runtime metaprogramming capabilities. Part 2 of 2 will cover Groovy's compile time metaprogramming capabilities.

By John Thompson

Everyone knows controllers can be tricky little buggers to test. Spring MVC Test brought some exciting testing capabilities to Spring 3.2, but it you're left on your own for mocking the service layer in your controllers.

We'll take a look at the Groovy approach of using Spock to unit test your controller interactions with the service layer and Spring MVC Test to unit test controller interactions with the web layer.

By Burt Beckwith

Grails plugins are a great way to reuse and share common code, and to modularize an application. In this talk we'll look at the general process for creating a plugin.

In addition, we'll look at the different types of plugins, how to deploy and release, and options for various testing approaches.

By Burt Beckwith

When you think about securing a Grails application, you probably think of the Spring Security and Shiro plugins. But these plugins only control access to your pages and objects – what about guarding agains cross-site scripting (XSS), cross-site request forgery (CSRF) and SQL injection attacks? The OWASP project maintains a list of the top 10 web application security risks.

In this talk we’ll look at these risks and what libraries and plugins are available to make your applications resistant to these types of attacks.

By Venkat Subramaniam

Everyday coding involves taking care of so many things that much time can get wasted writing over and over code to deal with the basics of programming. Not so in Groovy, thanks to the annotations that transform your code to synthesize the cruft.

In this presentation we will explore, using some live examples, various Groovy annotations, their purpose, and take a peek at what they actually do internally.

By Venkat Subramaniam

You can program higher order functions in Groovy quite easily using closures. But the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures.

In this presentation, we will unlock that treasure and explore ways in which we can design applications using Groovy closures, to apply different design patterns, to create fluent interfaces, and even program asynchrony.

By Venkat Subramaniam

When I got into Java I had a "Wow, look how easy it is to implement these patterns." When I got into Groovy, I had the same reaction, but only better. The dynamic nature of Groovy makes it easier to implement some common patterns. What's better, there are some patterns that you can exploit in Groovy that are not so easy in Java. In this section, you will learn how to implement some traditional patters in Groovy, and also other patterns you are simply not used to in Java.

This presentation will go far beyond the Gang-of-four (GOF) patterns. You will learn how to implement some GOF patterns, but also some patterns that will allow you to exploit dynamic nature of Groovy and the elegance of Groovy closures.

By Peter Ledbrook

Grails is geared towards an MVC architecture with a database back-end and a service layer. But is this the only way to write Grails applications? What other architectures are possible and what is required to implement them?

In this talk we'll answer those questions by looking at several different architectures in the context of Grails. From single-page apps to event based back-ends, you'll get a good overview of just what is possible and you'll be able to make an informed decision on how to implement your next project.

By Joe Sondow

Asgard is a free and open source Grails application built and used by Netflix to deploy code changes and to manage resources in the Amazon cloud at large scale.

In this talk we'll delve into how Asgard works, covering topics such as:

• Open source motivation, presence, and support.
• Tour of the user interface.
• Customizing Asgard for your own company.
• How Netflix philosophies drive Asgard's design.
• The Netflix Cloud Model.
• Easy large deployments and fast rollback.
• Caching the cloud with Groovy.
• Visual language for the cloud.
• Publishing a REST API.
• Mocking AWS for offline testing.
• Comparison with the AWS Management Console.

By Daniel Woods

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

This presentation will demonstrate and discuss architecture design patterns for implementing a message-driven architecture in Grails to allow for better 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.

By Burt Beckwith

Properly performing multiple data updates requires a transaction, but how do we do this in Grails? Services are the best option, but there are different approaches that can be used.

We'll look at how to effectively use transactions and how to customize transaction attributes such as isolation and propagation levels. We'll also look at using two-phase commit (2PC) when using multiple datasources, or when combining database updates with JMS messaging. And we'll also look at testing to ensure your code is properly transactional.

By Jeff Scott Brown

Getting started building web applications for the Java platform is easy. Following that through to rich interactive applications that solve the business needs is more tricky. Grails 2 goes the whole way to address pain points not only for simple applications but of real enterprise applications with real demands. This session steps through many of the advanced features of Grails 2 that help get your applications through that last 20% that teams often struggle with. This session is not the standard hello world CRUD introduction to Grails.

Grails has long made web application development both fun and easy. This session dives beyond the basics to cover a lot of the advanced features introduced in Grails 2.

By Jeff Scott Brown

The dynamic runtime nature of Groovy is really powerful and really flexible. The runtime capabilities of the language allow for a lot of capabilities that are not possible with less dynamic languages. Those runtime capabilities are really powerful but are not the whole story of Groovy's dynamic capabilities. Groovy also allows for a lot of dynamic behavior to be introduced at compile time. Participating in the compilation process isn't something that application developers are generally used to doing, but Groovy makes it somewhat easy to jump into that process without having to write a whole compiler of your own. This session will dive deep into the features of Groovy that allow for you to participate in the compilation process to control what the compiler emits. You will learn to add methods to classes, modify existing and more, all at compile time.

This session is focused specifically on Groovy's compile time metaprogramming capabilities. Part 1 of 2 will cover Groovy's runtime metaprogramming capabilities.

By Mark Johnson

Real-time analytics is the process of monitoring and often reacting to web based events or machine-to-machine communication and then quickly deliver the appropriate response to an end-user or machine process. The challenge though is how can we modify the analytics algorithms and reference data without shutting down the data feeds.

In this session we will demonstrate architectural and implementation patterns utilizing Spring Integration Framework, HBase, and of course Groovy to illustrate how it is possible to dynamically change your enterprise’s real-time algorithms without a system restart.

By Graeme Rocher

In this talk Grails project lead, Graeme Rocher, will talk through the latest Async features offered by Grails and how they can be used to create elegant non-blocking REST APIs.

Join Us!

By Stephane Maldini

Grails 2.3 is coming with new asynchronous and eventing features, driven by the same usability that shapes the Grails success amid developers. That means the framework now supports the modern definition of "realtime".

In fact, Platform-core plugin currently helps developers at writing Event-Driven Architectures and pushes the boundaries to the Browser with its Events-Push extension. Scalability might also be an outcome of such architecture, since multiple Grails applications can now easily work together. Eventually, with events propagated across server(s) and browsers, a new set of patterns emerges and HTML5 web applications have rarely been so pleasant to write.

We'll see in this session how we address few spotted today's and tomorrow's concerns: Scrolling large data sets without blocking, streaming to the browser, scale Grails in the cloud...

By Clay McCoy

Some of the most difficult problems in applications today involve coordinating and distributing work in a resilient way. Use cases include communicating with unreliable remote services, parallelization, scheduling critical timers, being immune to server failures... Even if you handle these concerns how do you test this sort of orchestration glue-code? Groovy's powerful metaprogramming capabilities and AWS's robust Simple Workflow Service can be used to solve these problems.

In this talk you will see real world pragmatic examples that can be used even if your business logic is not running in the cloud.

By Baruch Sadogursky

It is often beneficial to allow users extend your software with their own logic. With the rise of dynamic languages on the JVM it is also much more easier to do than ever before. In this session we will share our experience in creating Groovy authored user plugins interface.

After a brief introduction to domain specific languages (DSLs), their relevance to user plugins and how they can be easily implemented in Groovy, we’ll look at more user-friendly, but developer-challenging type of DSLs, which support plugins written both in Groovy or Java.

Good public API design is another very important aspect - while the APIs have to be broad enough to allow interesting functionality, internals should stay close to allow changes and further development. Exposing APIs to the world come with great responsibility - once ublished they can’t be changed without a price, so it is important keep backwards compatibility in mind.

Another very important aspect is security - you let strangers into your chambers, and you better be ready. Leveraging security mechanisms is essential to establish proper sandboxing and protect your application from malicious or faulty plugins.

Finally, we will cover another very important and nontrivial aspect of user plugins exposure - the classpath isolation when your plugins require dependencies. We will compare different solutions like establishing classpath hierarchies, OSGi, JBoss modules and the long-awaited Project Jigsaw.

By Kenneth Kousen

Watch Preview Video

Groovy isn't designed to replace Java -- it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.

Topics will include building and testing applications, accessing both relational and NoSQL databases, working with web services, and more.

By Venkat Subramaniam

The ability to navigate and even alter the abstract syntax tree of your code is very powerful and yet under utilized. Quite a few tools have exploited this capability in Groovy. These techniques can be useful to create fluent syntax and validate DSLs.

In this presentation we will explore the key features and strengths of Groovy AST transformation API and techniques. Learn how to use compile-time metaprogramming with Groovy AST transformation.

By Ryan Vanderwerf

This talk will cover how to get your application running on AWS VPC and related services.

We will go over some related services like RDS, autoscaling, s3, cloudfront, s3fs, ebs, elastic beanstalk, etc and how your Grails application can benefit from using these. The networking can also be confusing with your application so we'll cover the basics here as well.

By Colin Harrington

JSON (JavaScript Object Notation) is now the lingua franca of data interchange. Most platforms such as browsers, phones, client and embedded applications have support for consuming/producing JSON. Native Browser compatibility makes it especially convenient for our modern web architecture.

In this session we'll walk through several patterns for delivering JSON to our clients. We'll explore the built-in converters, profiles, and look at creating your own JSON view layer for more in-depth structures.

Grails has some good tooling built-in but we'll explore both the Spring Layer and plugin ecosystem's various tools to find the right tool for your job.

By Colin Harrington

Testing is built into grails, but many Grails apps go untested. We'll cover how to test many different artefacts as well cover many principles that have helped lead to succesfully tested Grails application.s

Testing is built into grails, but many Grails apps go untested. We'll cover how to test many different artefacts as well cover many principles that have helped lead to succesfully tested Grails application.

Adapted from a talk called "Testing the Crap out of your Grails application" We'll go beyond the basics and talk about my experiences in the 10+ Grails codebases and tems that I've had the opportunity to work with.

By Paul King

Groovy has excellent support for the creation of Domain Specific Languages (DSLs). Such DSLs can be particularly useful when writing business rules. Rules can be written in English-like phrases which are straight-forward to read or write (by non-developers) yet can be fully executable code corresponding to a layer over the top of a traditional logic solving API. This talk illustrates various DSLs, highlights several logic solving APIs and looks at the pros and cons of the various approaches (including tool support, flexibility, lock-in).

Whilst Groovy is the language of choice for this talk, the techniques and principles are not specific to Groovy and apply readily to your favourite modern scripting language. The "logic solving" APIs being highlighted are primarily Choco, Drools Expert and Drools Planner but again these are just illustrative of the logic APIs that you can use when writing a DSL layer. We look at the benefits and costs when writing such DSL layers, numerous real-world examples and the all-important aspects of tooling; covering what non-developer, developer and cloud tooling is available with this kind of approach.

To give a flavour of the talk, here is a snippet from one of the code examples (Einstein’s riddle):

the Briton has a red house the owner of the green house drinks coffee the owner of the yellow house plays baseball the person known to play football keeps birds the man known to play tennis drinks beer the green house is on the left side of the white house the man known to play volleyball lives next to the one who keeps cats the Norwegian lives next to the blue house

When discussing this example, we look at how you create and debug such code, illustrate how several APIs can be used underneath this DSL layer, discuss the costs involved in creating the above DSL in its basic form and in more complex forms that allow type checking, code completion etc. and options for parallelism and cloud deployment.

By Paul King

This talk reviews the features in Groovy which make it easy to work with databases. It reviews the features of Groovy SQL including Groovy's LINQ-like lazy evaluation technology called datasets. In addition, it looks at working with a couple of NoSQL databases: MongoDB (using GMongo) and Neo4J (using it's Java api and via Gremlin support).

This talk looks at accessing relational databases using raw JDBC, Groovy's lazy LINQ-like datasets and briefly using hibernate, caching, and spring-data technologies. It also looks at the approaches that can be used to access NOSQL databases.

The talk covers Groovy-SQL in some depth and then briefly examines the other technologies mentioned to give you a feel for your options. For Groovy SQL, we look at how to do the basic CRUD operations and then examine a few more advanced features like working with transactions, batches, chunking, stored procedures and database metadata. Example code will be provided on github (under development) so that attendees can dive deeper into the examples if they wish.

By Guillaume LaForge and Paul King

In this presentation, Guillaume, Paul, and Andrew will show you how to leverage Groovy to build a Domain-Specific Language (DSL) used to control a rover on Mars! Various metaprogramming techniques and integration mechanisms will be demonstrated. But the language itself is only the first part of the story. Developers cannot be expected to properly use a DSL without first-class IDE support and documentation.

The presentation will start by building the DSL from scratch, using the power of Groovy to create a concise and readable mini-language, and showing how to secure its integration. The second part of the presentation will demonstrate how to integrate the DSL into Groovy-Eclipse with custom content assist, navigation, searching, and inline documentation.

By Cedric Champeau

Since Groovy 2.0, the Groovy language offers the ability to type check your code at compile time. Type checking is a nice feature for people who come from a strongly typed language world and do not feel comfortable with dynamic typing. On the other hand, Groovy is also a perfect match when it comes to writing DSLs. It becomes even more interesting if you know that you can combine strategies in order to provide the user with a statically checked DSLs.

In this session, we will introduce the type checking mechanism of Groovy and demonstrate some techniques that you can use to make your DSL compatible with the type checker.

By Cedric Champeau

The Groovy language has always been promoted as an excellent companion to the Java language, but also as a lightweight platform for building DSLs on the JVM. In practice, Groovy offers a wide range of options to integrate with Java: plain application then use it as a jar dependency, cross-compilation, GroovyScriptEngine, GroovyShell, ... Furthermore, each of those solutions have benefits or disavantages that you might not be aware of.

In this talk, we will discuss those options, show examples of integration and demonstrate how you can leverage the rich configuration options of Groovy to make the experience very smooth. If you ever dreamt of sneaky throwing Groovy into your heavyweight application, you may end up with new ideas to do so!

By Venkat Subramaniam

Java - Groovy integration just works, for most part. Calling into Java code from Groovy is pretty straight forward. Calling into Groovy from Java is easier than you may think (and that\\'s the hard part!). There are a few rough edges you will run into when you try to call from Groovy into other languages.

In this presentation, we will take a look at integration mechanisms and how to work around the few challenges you may run into.

By Brian Kotek

Page-based web applications were once the norm, but times have changed. Users increasingly expect rich, desktop-like experiences from their browser-based applications. They demand apps that adhere to common standards, without the need for special plugins. Finally, they want to use them on any device, from smartphone to flat-screen.

It's a daunting task, but help is on the way. Grails provides an awesome foundation for HTML-based Rich Internet Applications. In this session, we'll see how Grails can make HTML RIAs a snap.

JavaScript is the language of the web, but it has its warts. Grails plugins allow us to easily leverage intermediary languages like CoffeeScript or TypeScript to help create large-scale client-side code. Libraries like ExtJS or Dojo offer expansive UI toolkits that hook perfectly into Grails REST APIs. JSON and GSON are excellent data exchange formats, as long as you properly plan out their structure. And GORM is incredibly powerful, but without careful thought you can inadvertently send huge amounts of unnecessary data to the client.

We'll dig into each of these areas, and more. Come see just how much power and productivity Grails brings to the HTML RIA table.

By Joe Rinehart

Grails makes it easy to dive right in and build an application, but that's the tip of a very large iceberg. Joe Rinehart's spent years working in highly secured environments and been the subject of many top-to-bottom, OS-to-Web audits. Join him as he introduces publicly available security guidelines for Java/Grails applications made available by some of the strictest clients in the world, showing how Grails can often make life much easier.

"STIGing." It's a phrase that makes even seasoned secured application developers wince.

What's a STIG? It's a "Security Technical Implementation Guide" - a grammar fail only the U.S. Government could manage. It's usually a product-specific, hundred-plus page PDF or XML document describing applicable security controls.

These are not thrilling reads.

Their content, however, is fantastic: from obvious XSS issues to nuances of running Tomcat within an application security manager, they present a holistic approach to technical application security.

Join Joe as he walks through the essential security topics for Grails (and Java) Web applications, showing how Grails can often lighten your load and the pitfalls of attempting to secure highly dynamic code.

By Kenneth Kousen

Watch Preview Video

Groovy has a very easy learning curve for Java developers, so many people become Groovy users without realizing all it can do. This presentation will examine features of Groovy that can make your life easier once you're past the initial adoption stage.

Examples will include closure coercion, mixins, simple runtime metaprogramming, operator overloading, drop and take, a tour through some of the overlooked methods in the Groovy JDK, and more.

Prerequisite: Some Groovy knowledge

By Paul King

Groovy doesn't claim to be a fully-fledged functional programming language but it does provide the Java or Groovy developer with a whole toolbox of features for doing functional style programs. This talk looks at the key Groovy features which support a functional style. Topics covered include using closures, currying and partial evaluation, closure composition, useful functional-centric AST macros, useful functional-centric runtime meta-programming tricks, trampolining, using Java functional libraries, immutable data structures, lazy and infinite lists, using Groovy 2's static typing and approaches for moving beyond Java's type system.

There are many advantages to using a functional style in your programs. Learn what can be done to leverage functional style while retaining many of the productivity gains of the Groovy programming language.

By Greg Turnquist

We all know how to code various patterns of behavior. But when your app needs to be used in the Real World(tm), there are certain things that are key.

In this talk, we'll walk through a production-grade Grails application that includes the following characteristics:

By Joe Rinehart

Somehow I've gained a reputation for applications that users think look good and are easy to use. I think my code's sometimes pretty, but please don't ask me to center something in CSS or Photoshop my way to fame and fortune. Recently, all the credit really goes to Twitter's Bootstrap UI library.

Join me for a bit as I take you through the basics of integrating Bootstrap into a Grails application, its semantics, the "whoa, that just works!" controls it provides, where to find nice add-ons such as Bootstrappish icons, and how you can leverage the Grails framework to make your Bootstrapped life even easier.

By Daniel Woods

Groovy provides flexible and dynamic capabilities for developing modular, maintainable code. With Groovy's extension framework, developers can modularize common application utility functions. Leveraging Groovy's dynamic nature can allow developers to create powerful, easy-to-follow business components. Employing Groovy categories and mixins can help localize and simplify transformation and adaptation logic that would otherwise be verbose and difficult to maintain.

This talk will focus on leveraging the strengths and flexibilities in Groovy to employ a powerful, maintainable, and simple application architecture.

By Peter Niederwieser

So you already know and love Spock, the Enterprise ready testing framework, but want to know how to make the most of it and take your testing to the next level? Then this talk is for you. Even if you're new to Spock, but are interested in making your testing more effective this talk is for you.

Spock has many hidden gems which we'll be going through in this session. We'll also be looking at some of the upcoming features in Spock 0.7 including; functionality and contract mixins, improved configurability, and several new lumps of syntax sugar.

By Peter Niederwieser

Getting software from a developer's machine to a production environment without a fully automated process is time-consuming and error-prone. Continuous Delivery enables building, testing and deploying of software through build pipelines with well-defined quality gates.

In this session, we will discuss how to build an exemplary pipeline with the help of Gradle and Jenkins.

By Hans Dockter

The Gradle development team have not been taking it easy since the release of Gradle 1.0. New features and innovations are constantly being added, rough edges are being smoothed and the platform continues to expand. In this session we’ll explore the most notable additions to Gradle since the release of 1.0 and preview some of the new and exciting features just over the horizon with Gradle founder and Gradleware CEO Hans Dockter and Gradle core developer Peter Niederwieser.

Gradle continues to evolve with a high velocity to gain new capabilities, features and increased build performance.

We’ll dig into to some of the features incorporated since the 1.0 release, such as:

• Maven import and archetype support
• Parallel task execution
• Improved Dependency Reporting
• Dependency management improvements that make Grade the best dependency system out there.
• Additions to the task model like soft dependencies and finalizer tasks.
• Gradle Android and C/C++ Support
• Improvements to the Tooling API (i.e. embedded Gradle)
• Better scalability for large scale enterprise builds
• Using Jenkins slaves for distributed test execution.
• Deep integration with Arquillian for deploying to web and JEE servers.

We’ll also take a sneak peak at some of the upcoming features that will soon be available in Gradle.

By Hans Dockter

Discussions around Builds and Buildsystems haven't been treated for many years with the conceptual depth and principles they deserve and require. The lack of this is even more painful today as modern builds form a crucial part of a continuous delivery pipeline far away from the simple copy, compile and archive of the past. We will discuss the concepts of declarative and imperative builds, standardization of your build process, the executional model of a build system and dependency management. We will shed a lot of light into the dark with surprising results that are crucial to understand when deciding for a build system.

You will learn in this session :

• What are declarative and imperative build and build systems? Followed by an in-depth discussion about advantages and dangers of their approaches.
• Why Maven is more imperative than you might think.
• The sweet spot in between standardization, declarativeness and necessary flexibility.
• Gradle’s state of the art declarative approach shown by example of the new Gradle based Android build system.
• Why and what it means that builds should focus as much on developer productivity as on enforcing the software factory.
• Why also smaller projects should care about build system concepts (the larger ones don’t really have a choice.)
• The importance of a rich execution model for build systems.
• The problems with POM based dependency management and solutions to this.

This talk is driven by many examples from Gradle, Maven and Ant builds.

By Andrey Cheptsov

When it comes to productivity, what counts is reliable and smart support from your IDE for the frameworks in your project. IntelliJ IDEA’s support for Groovy, Grails and Spring has been going strong for the last few years, expanding and refining its features with each new release.

Let’s explore the most tricky features of the IDE that help developers to be more productive.

By Kenneth Kousen

Grails 2.3 makes it much easier to build RESTful web services from your domain classes, and even includes hypermedia capabilities. This presentation will demonstrate those capabilities and then add a JavaScript client-side framework like AngularJS. The Ratpack framework will also be used as an alternative server-side implementation.

Tests and build files will be included in a GitHub repository.

By Jeff Scott Brown

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. All of the major programming languages available on the JVM are supported by The Grails Framework. These include Java, Groovy, Scala, Clojure and others.

This session will dive in to that aspect of the framework with a focus on Scala and Clojure and will demonstrate what is involved in adding support for new languages.