then:
        configurationCache.assertStateStored()
        outputContains("Groovy compilation avoidance is an incubating feature")

        when:
        configurationCacheRun("compileGroovy", "--rerun-tasks")

        then:
        configurationCache.assertStateLoaded()
        outputContains("Groovy compilation avoidance is an incubating feature")
    }

[[task_configuration_avoidance]]
= Avoiding Unnecessary Task Configuration

As of Gradle 5.1, we recommend that the configuration avoidance APIs be used whenever tasks are created.

image::writing-tasks-4.png[]

[[sec:how_does_it_work_config_api]]
== Task configuration avoidance API
The configuration avoidance API avoids configuring tasks if they will not be used for a build, which can significantly impact total configuration time.

class TaskAvoidancePerformanceTest extends AbstractCrossBuildPerformanceTest {

    def "help with lazy and eager tasks"() {
        given:
        runner.testGroup = "configuration avoidance"
        runner.buildSpec {
            displayName("lazy")
            invocation {
                tasksToRun("help")
            }
        }
        runner.baseline {
            displayName("eager")

        .withSourceFiles(50000)
        .withSubProjects(0)
        .withDaemonMemory('3g')
        .withCompilerMemory('6g')
        .withSystemProperties(['org.gradle.groovy.compilation.avoidance': 'true'])
        .withFeaturePreviews('GROOVY_COMPILATION_AVOIDANCE')
        .assembleChangeFile(-1)
        .testChangeFile(-1).create()),

--

[[configuration-avoidance]]
== Configuration avoidance

Gradle 4.9 introduced a new API for creating and configuring tasks in build scripts and plugins. The intent is for this new API to eventually replace the existing API.

[quote]
____

val codenarcVersion = if (isGroovy4) "3.1.0-groovy-4.0" else "3.1.0"
val spockVersion = if (isGroovy4) "2.2-groovy-4.0" else "2.2-groovy-3.0"
val asmVersion = "9.7"
// To try out better kotlin compilation avoidance and incremental compilation
// with -Pkotlin.incremental.useClasspathSnapshot=true
val kotlinVersion = providers.gradleProperty("buildKotlinVersion")
    .getOrElse(embeddedKotlinVersion)

dependencies {

It is important to note that while `task1` was configured and executed, `task2` was not.
This is called _task configuration avoidance_ and prevents unnecessary work.

Task configuration avoidance is when Gradle avoids configuring `task2` when `task1` was called and `task1` does NOT depend. on `task2`.

[.text-right]

* Increased compile avoidance - Reducing the number of transitive dependencies leaked from a project also reduces the likelihood that an ABI change will trigger recompilation of consumers. Gradle will also spend less time indexing the dependencies for its up-to-date checks.

For example, on `tasks` they are of type `TaskProvider<T>` and provide a lazy reference and lazy configuration of the underlying task.
Here are some examples that illustrate the situations in which configuration avoidance applies:

[source,kotlin]
----
tasks.test {
    // lazy configuration
}

	"collisionCount":         "Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision.",
	"conditions":             "Represents the latest available observations of a DaemonSet's current state.",
}