*/
    CompositeBuildParticipantBuildState includeBuild(IncludedBuildSpec includedBuildSpec);

    /**
     * Registers an included plugin build of the current build. An included plugin build may provide plugins to this build only. In contrast to {@link #includeBuild(IncludedBuildSpec)},

    </a>
</div>
++++

Build engineers that are ready to configure custom build logic and write their own plugins should start here.

To get started engineering Gradle builds:

1. Read the <<gradle_author_intro,build basics chapters>>.
2. Follow the <<author_tutorial,tutorial>> for a hands-on approach.

[[gradle_author_intro]]
== 1. Authoring Gradle Builds Basics

1. **<<sharing_build_logic_between_subprojects.adoc#sec:using_buildsrc,Multi-Project Builds using buildSrc>>** - where `buildSrc` is a subproject-like directory at the Gradle project root containing all the build logic.
2. **<<composite_builds.adoc#composite_builds,Composite Builds>>** - a build that includes other builds where `build-logic` is a build directory at the Gradle project root containing reusable build logic.

    private final List<BuildDisplayInfo> builds;

    private final List<CrossBuildPerformanceResults> newestFirst;
    private final PerformanceExperiment experiment;

    public CrossBuildPerformanceTestHistory(PerformanceExperiment experiment, List<BuildDisplayInfo> builds, List<CrossBuildPerformanceResults> newestFirst) {
        this.experiment = experiment;
        this.builds = builds;
        this.newestFirst = newestFirst;
    }

# This is important for reproducing native builds with cross-compiled builds.
go build -o x.a text/template
! grep 'GOROOT\\' x.a
! grep 'text\\template' x.a
! grep 'c:\\' x.a

# executables should use slash-separated paths even on windows
# This is important for reproducing native builds with cross-compiled builds.
go build -o hello.exe hello.go
! grep 'GOROOT\\' hello.exe
! grep '\\runtime' hello.exe

        // Block until second build has produced blue things
        def build2 = executer.withTasks("redThings", "blueThings", "block2").start()
        block2.waitForAllPendingCalls()

        // Finish up first build while second build is still running
        block1.releaseAll()
        def result1 = build1.waitForFinish()

        block2.releaseAll()
        def result2 = build2.waitForFinish()

        then:

Develocity may help you with fulfilling these requirements while still using the build cache for all your builds.
It allows you to easily find out which build produced an artifact coming from the build cache via build scans.

[.screenshot]
image::build-cache/from-cache-origin.png[]

== Accelerate developer builds by reusing CI results

    void waitForBuildToWait(buildNum = 0) {
        run {
            poll(BUILD_EXECUTION_TIMEOUT) { assert builds[buildNum].standardOutput.contains("waiting for stop file") }
        }
    }

    void waitForDaemonExpiration(buildNum = 0) {
        run {
            poll(BUILD_EXECUTION_TIMEOUT) { assert builds[buildNum].standardOutput.contains(DaemonStateCoordinator.DAEMON_WILL_STOP_MESSAGE) }
        }
    }

     */
    ProjectBuildingResult build(org.apache.maven.api.services.ModelSource modelSource, ProjectBuildingRequest request)
            throws ProjectBuildingException;

    /**
     * Builds the projects for the specified POM files and optionally their children.
     *
     * @param pomFiles The POM files to build, must not be {@code null}.

        build1.includedBuilds() >> [includedBuild2]
        build1.parent >> rootBuild

        includedBuildState1.mutableModel >> build1

        includedBuildState2.projects >> projects2
        includedBuildState2.buildRootDir >> dir2
        includedBuildState2.importableBuild >> true

        build2.includedBuilds() >> []
        build2.parent >> rootBuild