// Serialize an inner child here so that the BaseObject.childrenTracking is non null
        Build build = model.getBuild();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(build);
        }

        Build build2;
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

The build is then included in the root project's _settings_ file as seen in the above snippet.
For more details about included builds, see link:{userManualPath}/composite_builds.html[Composing Builds] chapter.

The `myproject.java-conventions` plugin is then applied to the `buildSrc` build:
====
include::sample[dir="kotlin",files="buildSrc/build.gradle.kts[tags=plugins]"]

    doLast {
        fileCollection.files
    }
}
"""
        // Ensure build scripts compiled
        run("help")

        when:
        def build1 = executer.withTasks("redThings").withArgument("-Dcrash=true").start()
        build1.waitForFailure()

        run("redThings")

        then:
        output.count("Transforming") == 1

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 * </p>
 * <strong>Note:</strong> This interface is part of work in progress and can be changed or removed without notice.
 */
public interface Builder {
    //

== Step 1. Understanding Incremental Builds
It's important to know that Gradle optimizes your build in a variety of ways.
One such optimization is called _incremental builds_.

An _incremental build_ is a build that avoids running tasks whose inputs did not change since the previous build, making the execution of such tasks unnecessary.

// If the command fails, Run reports the error using Errorf.
func Run(cmdargs ...any) {
	cmdline := str.StringList(cmdargs...)
	if cfg.BuildN || cfg.BuildX {
		fmt.Printf("%s\n", strings.Join(cmdline, " "))
		if cfg.BuildN {
			return
		}
	}

	cmd := exec.Command(cmdline[0], cmdline[1:]...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {

used by debuggers, to reduce build time. To include debugger information in
the binary, use 'go build'.

The exit status of Run is not the exit status of the compiled binary.

For more about build flags, see 'go help build'.
For more about specifying packages, see 'go help packages'.

See also: go build.
	`,
}

func init() {
	CmdRun.Run = runRun // break init loop

A. Unique TensorFlower <******@****.***> 1703041221 -0800

A. Unique TensorFlower <******@****.***> 1711560469 +0000

A. Unique TensorFlower <******@****.***> 1711560469 +0000