Andres Almiray

Learn all about the wonders of Groovy's AST transformations! Tweaking the AST at compile time is a very powerful tool however some developers may find this task a bit daunting as knowledge of the compiler internals must be attained before hand. But Groovy offers an alternative in the form of AST transformations. These set of classes will enhance your code at compile time without you having to write the modifying code by hand.

In this session we will explore the set of predefined AST transformations that come bundled in the standard Groovy distribution, and perhaps we can cover some additional ones found in other projects.

One of the biggest impediments to overall developer productivity and the overall success of the software organization is inefficient processes. Without the right tooling to get to the root of the problem, debugging build and test failures is incredibly frustrating and leads to delays in shipping software.

In this workshop, you’ll work through examples using Maven, Gradle, and Gradle Enterprise on our real data and that of some popular open source projects. You'll learn how to measure build speed and reliability, which metrics are important, how to apply these analyses to your own builds, and how to use build caching to make those builds dramatically faster enabling your team to achieve better developer productivity.

Despite of all the buzz and hype around webapps over the last 8 years fact is that desktop applications are still found in many places, specially in the enterprise. However the legends are true: building desktop applications is a hard job. But it does not have to be. Enter Griffon.

Griffon aims to bring back the fun and productivity to desktop application development in the same way Grails did it (and continues to do so) on the web. Griffon is rooted in the JVM but has Grails in its DNA. This means you'll find yourself right at home if you're a Java veteran, same goes for all of you that made the jump to Grails.

In this session we'll cover the basics to get you started with Griffon. How applications are structured and built. Then we'll switch gears into high speed and cover topics like threading, testing, deploying, handling of legacy code and even network and database integration.

The Java language boasts one of the biggest software ecosystems: You will find libraries, components and servers of all sizes, types, colors and flavors - which have made it the choice language for many. However the JVM is open enough to let other languages live in it, these languages provide new features and concepts that the Java language does not have. Some of these languages are even Java friendly.

In this session we'll discover the benefits of adding a bit of spice to your Java development skills by exploring Groovy's metaprogramming techniques, Scala's functional side and Clojure's approach to managing concurrency.

Groovy is the fastest growing JVM language out there. It might be because it is so easy for Java developers to pick it up, but also because there's an increasing number of projects and libraries that make use of Groovy as the starting point.

In this session we'll cover frameworks, tools and libraries rooted in the Groovy language that can make your daily work a much more enjoyable experience.

• Frameworks
  Grails, Griffon, Gaelyk
• Build Systems
  Gant, Gradle
• Testing
  Easyb, Spock
• Code Quality
  CodeNarc, GMetrics
• Libraries
  GPars, GContracts

With large tech companies such as Google famously touting the advantages of their monorepo strategy and other top tech companies talking about their equally impressive multirepo solutions, it can be difficult to decide which strategy is best for you and your team. Luckily, Gradle has plenty of experience helping organizations of all sizes and build tools through monorepo and multirepo transitions.

In this session, we hope to share our expertise no matter your build tool of choice. We’ll cover all the important decisions of both the monorepo and multirepo paths so that you can leave prepared for the path you choose and confident that you won’t end up abandoning the transition or stuck in the worst of both worlds.

These topics include how to:

work with and not against your organizational structure
select a new source code repository or modify an existing one
help geographically distributed teams
setup language and platform agnostic infrastructure
model the repository structure onto CI pipelines
factor performance and reliability tradeoffs into build tool choice