* supersource for this class contains a field of type {@code C}.
 *
 * <p>For details about this hack, see {@code GwtSerializationDependencies}, which takes the same
 * approach but with a subclass rather than a superclass.
 *
 * <p>TODO(cpovirk): Consider applying this subclass approach to our other types.
 */
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@GwtCompatible(emulated = true)

 * supersource for this class contains a field of type {@code C}.
 *
 * <p>For details about this hack, see {@code GwtSerializationDependencies}, which takes the same
 * approach but with a subclass rather than a superclass.
 *
 * <p>TODO(cpovirk): Consider applying this subclass approach to our other types.
 */
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@GwtCompatible(emulated = true)

	// 	doesn't provide any ways to retrieve the current TCP keep-alive settings, therefore
	// 	we're not able to run the test suite similar to Unix-like OS's on Windows.
	//  Try to find another proper approach to test the keep-alive settings on old Windows.
	if !windows.SupportTCPKeepAliveIdle() || !windows.SupportTCPKeepAliveInterval() || !windows.SupportTCPKeepAliveCount() {
		t.Skip("skipping on windows")
	}

For now we just have this global repository of ADRs.
If we see fit, we can break these out to per-platform ones, or keep a hybrid approach to having global and platform-specific ADSs.

Our aim is to keep the process lightweight and approachable.

        // Configures the majority of the infrastructure required for resolving dependencies.
        // This is the dependency-injection-less approach to obtain a `RepositorySystem`.
        // Maven generally recommends using Eclipse Sisu and Guice for DI, however this approach is also supported.
        RepositorySystem repoSystem = new RepositorySystemSupplier().get()

// even in simple programs like gofmt when they parallelize walking
// a file tree.
//
// After a long discussion on go.dev/issue/46279, we decided the
// best approach was for Go to raise the limit unconditionally for itself,
// and then leave old software to set the limit back as needed.
// Code that really wants Go to leave the limit alone can set the hard limit,

 *
 * Each isolated action is re-created through Configuration Cache serialization before it is applied to a target.
 * This approach ensures that sharing mutable state across targets via any means
 * (including {@link org.gradle.api.services.BuildService}, which are not supported) is prevented.

makes it easier to keep plugin versions consistent across projects within a build. The approach also improves the performance of the build.

The <<plugins#sec:subprojects_plugins_dsl,Using Gradle plugins>> chapter explains how you can declare plugins in the root project build script with a version and then apply them to the appropriate subprojects' build scripts. What follows is an example of this approach using three subprojects and three plugins. Note how the root build script only declares...

What are the main benefits you are looking for?

To better understand, consider the following opposing scenarios:

 * An imported build via <<ant#sec:import_ant_build,`ant.importBuild()`>>
+
This approach is quick, simple, and works for many Ant-based builds.
You end up with a build that is effectively identical to the original Ant build, except your Ant targets become Gradle tasks.
Even the dependencies between targets are retained.

Everyone has to start somewhere, and if you're new to Gradle, this is where to begin.

To get started using Gradle:

1. Read the <<gradle_intro,core concepts chapters>>.
2. Follow the <<getting_started,tutorial>> for a hands-on approach.

[[gradle_intro]]
== 1. Gradle Core Concepts