Kotlin, one language to build them all!

Rodrigo Oliveira & Paul Merlin

gradle.github.io/imaginate

video - pdf - sources

Agenda

Imaginate 🖼: An imaginary image generator
Gradle & Kotlin ❤: Build logic
Speed-up Loop Bonus 🚀: Configuration cache

Who are we?

🧑‍💻 🧑‍💻


speaker {
    name = "Paul Merlin"
    company = "Gradle"
    joined = 2015
    position = "Kotlin DSL Project Lead, again \o/"
    previously = "Configuration Cache Project Lead"
    github = "eskatos"
    mastodon = "@eskatos@mastodon.social"
}


speaker {
    name = "Rodrigo B. de Oliveira"
    company = "Gradle"
    joined = 2015
    position = "Configuration Team Lead"
    previously = "Kotlin DSL Project Lead"
    github = "bamboo"
    mastodon = "@rbo@mastodon.social"
}

Gradle

Since 2008, our mission is to
accelerate developer productivity.

Apache licenced sofware build tool

With 30M+ monthly downloads, this is one of the top 20 popular open source projects according to TechCrunch.

Gradle Enterprise, commercial product, is the first Developer Productivity Engineering (DPE) integrated solution.

Gradle

Android

Maven

Bazel

Scala (2023)

Developer Productivity Engineering

DPE is an emerging software practice that relies on acceleration technologies and data analysis to improve developer productivity.

dpe handbook dpe maturity model

gradle.com/developer-productivity-engineering

dpesummit.com

DPE Lowdown - Youtube Playlist
DPE Showdown - Youtube Playlist

Build Scans

A permanent record
of what happens during a build.

Gradle & Maven build speed challenge

Get some swag :)

We recruit!

If what we’re going to talk about Today is of interest to you, come work with us!

gradle.com/careers

Imaginate 🖼

An imaginary image generator

Imaginate - Demo

Imaginate - Exploration

gradle/imaginate#DesktopMain.kt

Imaginate - Overview

Gradle & Kotlin ❤

Build logic

Build logic - Kotlin!

Gradle’s Kotlin DSL

Kotlin DSL on top of Gradle’s Java API
Low ceremony thanks to Kotlin Scripting
Official Kotlin compiler plugins
IDE assistance, code navigation etc…

Build logic - Structure

A composite build bringing 4 included builds together.

Build logic - Slides

"capital letter K. elephant. pop art."

"elephant in the Kotlin island. caravaggio."

Build logic - Overview

settings.gradle.kts


includeBuild("image-generation")
includeBuild("slides")

include("shared-resources")
include("shared-logic")
include("shared-ui")
include("desktop-app")
include("android-app")
include("ios-app")
include("web-app")

for (project in rootProject.children) {
    project.projectDir = file("applications/${project.name}")
}

buildSrc/settings.gradle.kts


includeBuild("../image-generation")

Build logic - Exploration

gradle/imaginate#ImageGenerator.kt

open ImageGenerator
find usages of ImageGenerator.generate()
navigate to build logic
"we are in a WorkAction, this is Gradle, and this is still kotlin"
quick scrolling on what constitutes a Gradle task
inputs/outputs/action
show directory tree
"we are in buildSrc`", build logic shared by subprojects there are some other tasks for image processing, regular `.kt files
show DrawAndroidImage
explain caching annotations, local and remote cache
explain workerClasspath input, isolation, using Gradle’s Worker API
find usages of workerClasspath input
navigate to shared-resources convention plugin, a .gradle.kts file
explain Gradle’s plugin mechanism
convention plugin vs. project script
complex logic vs. declarative configuration
find usages of svgToDrawableClasspath
configurations for external tools dependencies used in the tasks
isolation worker api
navigate to registerDependencyBucket
explain helpers in buildSrc, .kt files
navigate back to shared-resources convention plugin
three tasks registration, inputs/output wiring
scroll to the :generateBitmaps task registration
this task uses a shared build service
used to represent external resources in a build
navigate to imageGenerationSemaphore
external api concurrency control
still in shared-resources convention plugin
this plugin exposes a custom DSL
for projects to declare what images they produce
show DSL extension registration a container of ImageSpec
let’s see how this custom DSL is used by a project open :shared-resources project script file shared-resources/build.gradle.kts
convention plugin vs. project script
complex logic vs. declarative configuration
explain Kotlin DSL features using this project script
generated accessor to the custom DSL extension
sam-with-receiver, Action + HasImplicitReceiver
assignment operator overload
"how are these resources consumed by other projects?"
open :web-app project script file web-app/build.gradle.kts
dependency on shared resources
using generated accessors
convention plugin vs. project script
complex logic vs. declarative configuration
search in files "shared-resources-consumer" navigate to shared-resources-consumer convention plugin
registers configurations for declaration of dependencies on shared resources
bitmap vs. drawable
"this plugin for consuming shared resources is for example applied to :web-app
go back to :web-app project script file web-app/build.gradle.kts
convention plugin vs. project script
complex logic vs. declarative configuration

Build logic - Kotlin DSL

Gradle plugins contribute to a dynamic model

Kotlin DSL provides static accessors

extensions and tasks
projects and version catalogs

IDE assistance, code navigation etc…

applications/web-app/build.gradle.kts


plugins {
  id("web-app")
}

dependencies {
  // Configuration defined in the
  // `shared-resources-consumer` convention plugin
  sharedBitmaps(projects.sharedResources)
}

kotlin {
  sourceSets {
    // Source set defined in `web-app` convention plugin
    jsMain {
      dependencies {
        // Static project accessor
        implementation(projects.sharedLogic)
        // Static version catalog accessors
        implementation(libs.imaginate.imageGeneration)
      }
    }
  }
}

Build logic - Building blocks

Convention plugins

Put .gradle.kts files in buildSrc/src/main/kotlin
Apply them in project build scripts

Custom DSL

Use Gradle extensions and containers

Helpers

Put .kt files in buildSrc/src/main/kotlin
Prefer internal visibility

Custom Tasks

Use the Worker API for isolation and parallelism

Build logic - `buildSrc`

Keep imperative logic out of project build scripts.
Expose declarative DSL from convention plugins instead.

applications/android-app/build.gradle.kts


plugins {
    id("android-app")
}

android {
    namespace = "imaginate.android"
}

dependencies {
    implementation(projects.sharedLogic)
}

Build logic - `buildSrc`?

buildSrc vs includeBuild for build logic

buildSrc

Everything is made available in the owner build’s project scripts.

You can directly use anything.

includeBuild

Nothing is made available by default.

You have to declare dependencies.

Convention plugins

plugins {
    id("my-convention-plugin")
}

From buildSrc

dependencies {
    implementation("my:included-build:latest")
}

Since Gradle 8.0, buildSrc is much more like included builds
docs.gradle.org/8.0/release-notes.html#improvements-for-buildsrc-builds

Build logic - `buildSrc` first

Start with buildSrc,
move to included builds when you need to

share logic between builds,
isolate a portion of build logic.

Transition is simple
if you only use convention plugins

Publish your convention plugins for sharing them across repositories

Build logic - Learn more

Gradle’s Kotlin DSL
- Documentation
- DSL Reference
Build organization
- Structuring individual builds
- Structuring software products
- Jendrik’s Understanding Gradle videos
- Tony's and Cédric's blog posts

Speed-up Loop Bonus 🚀

Configuration cache

Significantly improves build performance
by caching the result of the configuration phase
and reusing this for subsequent builds.

Configuration cache - How does it work?

First run

Subsequent runs

Configuration cache - What are the benefits?

Configuration time becomes work graph loading time
Increased parallelism
Reduced memory consumption

Configuration cache - Turn it on!

Stable in Gradle 8.1
docs.gradle.org/8.1/release-notes.html

On the command line


./gradlew --configuration-cache build

Persistently in gradle.properties


org.gradle.configuration-cache=true

What’s next?

Usability

Simpler container DSL
Kotlin and Kotlin DSL version management
DSL reference improvements
And more…

Performance

Script compilation avoidance
plugins {} block interpreter
Faster precompiled script plugins build
K2
Quicker first-use
Configuration cache by default for Android
Project Isolation

We recruit!

If what we talked about Today is of interest to you, come work with us!

gradle.com/careers

Thank you!

Don’t forget to vote!

Kotlin, one language to build them all!

Agenda

Who are we?

Gradle

Developer Productivity Engineering

Build Scans

We recruit!

Imaginate 🖼

Imaginate - Demo

Imaginate - Exploration

Imaginate - Overview

Gradle & Kotlin ❤

Build logic - Kotlin!

Build logic - Structure

Build logic - Slides

Build logic - Overview

Build logic - Exploration

Build logic - Kotlin DSL

Build logic - Building blocks

Build logic - buildSrc

Build logic - buildSrc?

Build logic - buildSrc first

Build logic - Learn more

Speed-up Loop Bonus 🚀

Configuration cache

Configuration cache - How does it work?

Configuration cache - What are the benefits?

Configuration cache - Turn it on!

What’s next?

We recruit!

Thank you!

Build logic - `buildSrc`

Build logic - `buildSrc`?

Build logic - `buildSrc` first