The "build tree state" holds the state for the entire build definition for a single build execution within a session.

The build tree state is managed by the `BuildTreeState` class.
An instance is created at the start of a build execution and discarded at the end of the execution.

### Build state

The "build state" holds the state for a build within the build definition for a single build execution, and is contained by the build tree state.

singleProjectSampleLanguages.forEach { language ->
    setupGeneratorTask(language, "library", ModularizationOption.SINGLE_PROJECT)
    setupGeneratorTask(language, "application", ModularizationOption.SINGLE_PROJECT)
}

multiProjectApplicationSampleLanguages.forEach { language ->
    setupGeneratorTask(language, "application", ModularizationOption.WITH_LIBRARY_PROJECTS)
}

Should and should not do's.

## Error messages and suggestions

Traditionally, if an error occurred, the error message and the possible solution were provided to the console via a single String in the corresponding exception.
That meant possible solutions for Problems could be scattered all over the console output.
To improve the user experience, we introduced a new way to provide suggestions.

            val destFile = rootBuildDir.resolve("report$projectPathName-${it.name}.zip")
            zip(destFile, it)
        }

        // Zip all files in project build directory into a single zip file to avoid publishing too many tiny files
        reports.filter { it.isFile && it.toPath().startsWith(projectBuildDirPath) }
            .map { projectBuildDirPath.relativize(it.toPath()).toString() to it }

checkstyle {
    toolVersion = "8.12"
    config = configFile("checkstyle.xml")
    val projectDirectory = layout.projectDirectory
    configDirectory = rules.elements.map {
        projectDirectory.dir(it.single().asFile.absolutePath).dir("checkstyle")
    }
}

plugins.withType<GroovyBasePlugin> {
    the<SourceSetContainer>().all {
        tasks.register<Checkstyle>(getTaskName("checkstyle", "groovy")) {

        parallelization: (Int) -> ParallelizationMethod
    ): List<SmallSubprojectBucket> {
        // splitIntoBuckets() method expects us to split large element into N elements,
        // but we want to have a single bucket with N batches.
        // As a workaround, we repeat the bucket N times, and deduplicate the result at the end
        val resultIncludingDuplicates = splitIntoBuckets(
            LinkedList(subProjectTestClassTimes),

        }

        val comments = descriptor.generateWithExternalComments(groovyDslSettings)
        descriptor.generateWithExternalComments(kotlinDslSettings)

        if (modularization == ModularizationOption.SINGLE_PROJECT) {
            generateSingleProjectReadme(specificContentId, templateFolder, groovyDslSettings, comments, descriptor, projectLayoutSetupRegistry)
        } else {

* Keep commits discrete. Avoid including multiple unrelated changes in a single commit.
* Keep commits self-contained. Avoid spreading a single change across multiple commits. A single commit should make sense in isolation.

### Testing changes

After making changes, you can test your code in 2 ways:

1. Run tests.

            .first()!!
            .text()

    private
    fun DocumentBuilderFactory.fetchNightlyVersion(mavenMetadataUrl: String): String =
        fetchVersionsFromMavenMetadata(mavenMetadataUrl)
            .single()
}


internal
fun DocumentBuilderFactory.fetchVersionsFromMavenMetadata(url: String): List<String> =
    newDocumentBuilder()
        .parse(url)
        .getElementsByTagName("version").let { versions ->

author:
  using_gitstream: {{ (pr.author | isEnabledUser ) }}

# Perhaps a task could generate this list from the CODEOWNERS, or both this and CODEOWNERS could be generated from different single source of truth?
# Keys like `- build_infrastructure:` do not mean anything, they just need to be unique
# The `name:` field specifies the platform label, e.g. `name: build_infrastructure` => `platform:build_infrastructure` label