import static org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps.GeneratedResource.Location.SOURCE_OUTPUT;

/**
 * A helper class to handle incremental compilation after a failure: it makes moving files around easier and reverting state easier.
 */
public class CompileTransaction {

    private static final Logger LOG = LoggerFactory.getLogger(CompileTransaction.class);

    private final Deleter deleter;

#   GOLDFLAGS: Extra linking flags passed to 'go' when building.
#   GOGCFLAGS: Additional go compile flags passed to 'go' when building.
#   DBG: If set to "1", build with optimizations disabled for easier
#     debugging.  Any other value is ignored.
#
# Example:
#   make
#   make all
#   make all WHAT=cmd/kubelet GOFLAGS=-v
#   make all DBG=1

// This just makes it easier to catch all actions that has a name; instead of hard-coding all request that has it associated
type actionWithName interface {
	core.Action
	GetName() string
}

// actionWithObject is the generic interface for an action that has an object associated with it

.Using the `tasks` container API for eager configuration
====
include::sample[dir="snippets/kotlinDsl/configuring-tasks-basics/kotlin",files="build.gradle.kts[tags=using-eager-api]"]
include::sample[dir="snippets/kotlinDsl/configuring-tasks-basics/groovy",files="build.gradle[tags=using-eager-api]"]
====

 * An idiomatic Gradle build
+
If you want to future proof your build, this is where you want to end up.
Making use of Gradle's conventions and plugins will result in a smaller, easier-to-maintain build, with a structure that is familiar to many Java developers.
You will also find it easier to take advantage of Gradle's power features to improve build performance.
+

== Understanding which plugins you don't need

It's worth remembering that Gradle builds are typically easier to extend and customize than Maven ones.
In this context, that means you may not need a Gradle plugin to replace a Maven one.
For example, the Maven Enforcer plugin allows you to control dependency versions and environmental factors, but these things can easily be configured in a normal Gradle build script.


[[migmvn:custom_plugins]]

		prec = f.wid
		if negative || f.plus || f.space {
			prec-- // leave room for sign
		}
	}

	// Because printing is easier right-to-left: format u into buf, ending at buf[i].
	// We could make things marginally faster by splitting the 32-bit case out
	// into a separate block but it's not worth the duplication, so u has 64 bits.
	i := len(buf)

= Using Ant from Gradle

Gradle provides integration with Ant.

Gradle integrates with Ant, allowing you to use individual Ant tasks or entire Ant builds in your Gradle builds.
Using Ant tasks in a Gradle build script is often easier and more powerful than using Ant's XML format.
Gradle can also be used as a powerful Ant task scripting tool.

Ant can be divided into two layers:

                    languageVersion = JavaLanguageVersion.of(8)
                }
            }

            // Even though we're using a JDK8 toolchain, we compile down to Java 6 bytecode.
            // This makes it easier to run these tests locally since most developers have Java 8
            // installed. We still try to run the Gradle build with Java 6/7, but we skip those tests
            // when Java 6/7 are not installed.

====

[[sec:subkeys]]
=== Using OpenPGP subkeys

OpenPGP supports subkeys, which are like the normal keys, except they're bound to a master key pair. One feature of OpenPGP subkeys is that they can be revoked independently of the master keys which makes key management easier. A practical case study of how subkeys can be leveraged in software development can be read on the https://wiki.debian.org/Subkeys[Debian wiki].