Gradle eXchange 2013

The larger and more diverse your technology organization, the greater the value you can realize in standardizing your build and delivery process. Internal build standards make it easier for people to switch between teams, allowing you to more readily adjust your staffing to meet changing business needs.

In this session we’ll walk through examples of leveraging Gradle’s extensibility and plugin mechanisms to develop standards, enforce compliance and deliver tailored out of the box functionality. We will also look at how to provision such customisations throughout your enterprise in a controllable way.

Gradle's flexibility combined with its support for conventions, including your conventions, provides the ability to solve your automation challenges effectively in a centralised fashion.

One of Gradle's attractive features is that plugins are extremely simple to write and can do anything. Gradle plugins can add new functionality, enhance existing functionality or even remove undesired functionality. If you've ever wanted to write a Gradle plugin, or are interested in the deep details of plugins, then this session is for you.

In this session we'll explore some fundamental concepts that can be used as guidelines when developing plugins and new Gradle functionality, and the role of plugins and how they can be used.

We'll look at issues such as; how to implement flexible tasks, how to support convention over configuration while maintaining flexibility, how to structure plugin stacks, building and distributing plugins and testing your plugins. We'll be developing a sample plugin during the session and discussing other real world example plugins.

What a better way to start the Gradle eXchange 2013, than by joining the talk of the creator of Gradle? Hans Docter will talk about:

• A short history of the Gradle project.

• The current position of Gradle in the continuous delivery ecosystem.

• The role of the Gradle community and Gradleware.

• The strategic roadmap for the next 12 months.

When your software project grows into the 100s and 1000s of sub-projects within a single project tree you shouldn't have to compromise on build performance, and the Gradle team has been working hard on optimizing for this high end of enterprise software builds. If you're involved in large projects and are looking for ways to keep the developer experience a happy one with the build, this session is for you.

We will look into unique Gradle features that improve building and developing large applications and how they have helped some large projects stay productive at scale. While new Gradle features can help you achieve faster builds, there are also considerations, optimizations and performance traps that you should know about when working in the very large that we will cover. Finally, we will look at what's in the Gradle development pipeline to improve the experience for those working on extra large software stacks.

Effective companies and teams do more with less, and automation is a vital ingredient to this. As developers we are accustomed to the idea of build automation through build & continuous integration systems that compile, test & deploy our software. However, the production of software is typically only one of the concerns of a team or company. There are many auxiliary processes that can equally benefit from the rigour, repeatability and cheap labour of automation.

Gradleware - the company behind the Gradle build automation tool - has automation in its DNA, and applies it to everything that it does. In this session, we'll discuss and showcase different examples of the kind of automation the team @Gradleware have developed to support the development of Gradle and its documentation, the online presence, user support, business processes and other aspects. The ideas discussed will invigorate participants to see new opportunities for automation in their endevours.

What has Gradle, Node.js, Play and martial arts have in common?

As it turns out, a lot, depending on how you approach them. Automating Node.js CI processes is not as easy as it sounds and I tried several approaches before settling on Gradle as a key component in a combination of tools. So in this session I’ll provide you insights into lessons learnt during my one-year long Node.js journey and demonstrate solutions developed along the way.

Following this I'll talk about "Polyglot Gradle" concept, what it means for me, why I find it a useful and how far (or whether) you should consider it. Come to learn from my experience and make your automations a real breeze! Above all, let’s have a good discussion about new ways to develop Gradle plugins in the future.

One of the key aspects of a well oiled development workflow is the effective integration of different fit-for-purpose tools. While Gradle offers a lot out of the box, there are many great tools out there that can help you and your team at build time with many different kinds of tasks. Fortunately, Gradle is an extensible kit and offers many ways for you to leverage such tools easily.

We'll look at the techniques and APIs available for integrating tools such as code generators, web browsers, language runtimes, and even other build systems. Using embedded libraries, external processes, external Java processes, Ant tasks and even forked workers, you'll learn how you can extend Gradle by integrating your favorite tools.

One of the biggest challenges in build automation is creating builds that span multiple languages and platforms. When it comes to native applications we have an interesting situation, tools like autoconf and Make are mature, but they are difficult to integrate with other pieces of a large multi-language build automation platform. What Gradleware plans to do with our C/C++ support is bring the same approach we’ve applied to Java, Scala, Groovy, and Android to native applications giving C and C++ first-class support in Gradle.

Other build tools hack native support into a model that was designed for Java. Instead of providing a rich DSL for declaring dependencies and configuration information in a way that is tailored to native applications you have to dance around a system that thinks build automation ends at “build my jar”. It doesn’t, and Gradle is aiming for something different. We don’t just want to make native builds better for people creating multi-language builds. We want Gradle to be a contender for stand-alone native builds.

This session will cover the following topics:

• Gradle’s unique features for C/C++ builds. What can Gradle do that other build systems cannot?

• Learn how to use Gradle to build binaries from C/C++, how to test them, and how to share them with other teams.

• Find out about how Gradleware plans to solve some of the interesting challenges of building things from C/C++ and other native languages.

Come along and hear why you should use Gradle for your C/C++ projects.

The "golden" times of 100% Java are gone - even on the JVM! These days, Java code is increasingly mixed with Groovy, Scala, and other languages. Join us to learn what Gradle has in store for them.

Using the right language for the job feels great. Using a different build tool for each language - not so much. In this session, we are going to explore Gradle's support for Java, Groovy, Scala, and other languages.

We will cover topics such as language tasks and plugins, joint compilation, incremental compilation, and targeting multiple language versions. Last but not least, we will give an outlook on what to expect from Polyglot Gradle in the future. If you are a language nerd, then this session is for you. Make sure to bring your favorite language!

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.

With Jenkins as the centerpiece of our build pipeline, we'll model our way from build to deployment. We'll start by introducing a case study application and learn how to build it with Gradle. Step by step, we will touch on topics like developing unit, integration and functional tests, incorporating popular OSS code quality tools as well as packaging, publishing and deploying the deliverable.

Come hear Johannes and Thorsten present a case study of a migration process to convert an old development process based on ANT with thousands of lines of XML to a modern Gradle based environment! In this talk Johannes and Thorsten present how they made the switch to Gradle and what pitfalls they had to avoid.

Creation of a new DSL for internal deployment will be covered as well as tweaking external systems like nexus to achieve a highly flexible release cycle.