// Copyright 2018 the original author or authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

[[what_is_gradle]]
= What is Gradle?

[[gradle_overview]]
== Overview

Gradle is an open-source https://en.wikipedia.org/wiki/Build_automation[build automation] tool that is designed to be flexible enough to build almost any type of software. The following is a high-level overview of some of its most important features:

High performance::
Gradle avoids unnecessary work by only running the tasks that need to run because their inputs or outputs have changed. You can also use a build cache to enable the reuse of task outputs from previous runs or even from a different machine (with a shared build cache).
+
There are many other optimizations that Gradle implements and the development team continually work to improve Gradle's performance.
JVM foundation::
Gradle runs on the JVM and you must have a Java Development Kit (JDK) installed to use it. This is a bonus for users familiar with the Java platform as you can use the standard Java APIs in your build logic, such as custom task types and plugins. It also makes it easy to run Gradle on different platforms.
+
Note that Gradle isn't limited to building just JVM projects, and it even comes packaged with support for building native projects.
Conventions::
Gradle takes a leaf out of Maven's book and makes common types of projects — such as Java projects — easy to build by implementing conventions. Apply the appropriate plugins and you can easily end up with slim build scripts for many projects. But these conventions don't limit you: Gradle allows you to override them, add your own tasks, and make many other customizations to your convention-based builds.
Extensibility::
You can readily extend Gradle to provide your own task types or even build model. See the Android build support for an example of this: it adds many new build concepts such as flavors and build types.
IDE support::
Several major IDEs allow you to import Gradle builds and interact with them: Android Studio, IntelliJ IDEA, Eclipse, and NetBeans. Gradle also has support for generating the solution files required to load a project into Visual Studio.
Insight::
https://scans.gradle.com/[Build scans] provide extensive information about a build run that you can use to identify build issues. They are particularly good at helping you to identify problems with a build's performance. You can also share build scans with others, which is particularly useful if you need to ask for advice in fixing an issue with the build.

[[five_things]]
== Five things you need to know about Gradle

Gradle is a flexible and powerful build tool that can easily feel intimidating when you first start. However, understanding the following core principles will make Gradle much more approachable and you will become adept with the tool before you know it.

=== 1. Gradle is a general-purpose build tool

Gradle allows you to build any software, because it makes few assumptions about what you're trying to build or how it should be done. The most notable restriction is that dependency management currently only supports Maven- and Ivy-compatible repositories and the filesystem.

This doesn't mean you have to do a lot of work to create a build. Gradle makes it easy to build common types of project — say Java libraries — by adding a layer of conventions and prebuilt functionality through <<plugins#plugins,_plugins_>>. You can even create and publish custom plugins to encapsulate your own conventions and build functionality.

[[the_core_model_is_based_on_tasks]]
=== 2. The core model is based on tasks

Gradle models its builds as Directed Acyclic Graphs (DAGs) of tasks (units of work). What this means is that a build essentially configures a set of tasks and wires them together — based on their dependencies — to create that DAG. Once the task graph has been created, Gradle determines which tasks need to be run in which order and then proceeds to execute them.

This diagram shows two example task graphs, one abstract and the other concrete, with the dependencies between the tasks represented as arrows:

.Two examples of Gradle task graphs
image::task-dag-examples.png[Example task graphs]

Almost any build process can be modeled as a graph of tasks in this way, which is one of the reasons why Gradle is so flexible. And that task graph can be defined by both plugins and your own build scripts, with tasks linked together via the <<tutorial_using_tasks#sec:task_dependencies,task dependency mechanism>>.

Tasks themselves consist of:

 * Actions — pieces of work that do something, like copy files or compile source
 * Inputs — values, files and directories that the actions use or operate on
 * Outputs — files and directories that the actions modify or generate

In fact, all of the above are optional depending on what the task needs to do. Some tasks — such as the <<base_plugin#sec:base_tasks,standard lifecycle tasks>> — don't even have any actions. They simply aggregate multiple tasks together as a convenience.

NOTE: You choose which task to run. Save time by specifying the task that does what you need, but no more than that. If you just want to run the unit tests, choose the task that does that — typically `test`. If you want to package an application, most builds have an `assemble` task for that.

One last thing: Gradle's <<more_about_tasks#sec:up_to_date_checks,incremental build>> support is robust and reliable, so keep your builds running fast by avoiding the `clean` task unless you actually do want to perform a clean.

=== 3. Gradle has several fixed build phases

It's important to understand that Gradle evaluates and executes build scripts in three phases:

 1. Initialization
+
Sets up the environment for the build and determine which projects will take part in it.

 2. Configuration
+
Constructs and configures the task graph for the build and then determines which tasks need to run and in which order, based on the task the user wants to run.

 3. Execution
+
Runs the tasks selected at the end of the configuration phase.

These phases form Gradle's <<build_lifecycle#build_lifecycle,Build Lifecycle>>.

[NOTE]
.Comparison to Apache Maven terminology
====
Gradle's build phases are not like Maven's phases. Maven uses its phases to divide the build execution into multiple stages. They serve a similar role to Gradle's task graph, although less flexibly.

Maven's concept of a build lifecycle is loosely similar to Gradle's <<base_plugin#sec:base_tasks,lifecycle tasks>>.
====

Well-designed build scripts consist mostly of <<authoring_maintainable_build_scripts#sec:avoid_imperative_logic_in_scripts,declarative configuration rather than imperative logic>>. That configuration is understandably evaluated during the configuration phase. Even so, many such builds also have task actions — for example via `doLast {}` and `doFirst {}` blocks — which are evaluated during the execution phase. This is important because code evaluated during the configuration phase won't see changes that happen during the execution phase.

Another important aspect of the configuration phase is that everything involved in it is evaluated _every time the build runs_. That is why it's best practice to <<authoring_maintainable_build_scripts#sec:minimize_logic_executed_configuration_phase,avoid expensive work during the configuration phase>>. https://scans.gradle.com/[Build scans] can help you identify such hotspots, among other things.

=== 4. Gradle is extensible in more ways than one

It would be great if you could build your project using only the build logic bundled with Gradle, but that's rarely possible. Most builds have some special requirements that mean you need to add custom build logic.

Gradle provides several mechanisms that allow you to extend it, such as:

 * <<custom_tasks#,Custom task types>>.
+
When you want the build to do some work that an existing task can't do, you can simply write your own task type. It's typically best to put the source file for a custom task type in the <<organizing_gradle_projects#sec:build_sources,_buildSrc_>> directory or in a packaged plugin. Then you can use the custom task type just like any of the Gradle-provided ones.

 * Custom task actions.
+
You can attach custom build logic that executes before or after a task via the link:{groovyDslPath}/org.gradle.api.Task.html#org.gradle.api.Task:doFirst(org.gradle.api.Action)[Task.doFirst()] and link:{groovyDslPath}/org.gradle.api.Task.html#org.gradle.api.Task:doLast(org.gradle.api.Action)[Task.doLast()] methods.

 * <<writing_build_scripts#sec:extra_properties,Extra properties>> on projects and tasks.
+
These allows you to add your own properties to a project or task that you can then use from your own custom actions or any other build logic. Extra properties can even be applied to tasks that aren't explicitly created by you, such as those created by Gradle's core plugins.

 * Custom conventions.
+
Conventions are a powerful way to simplify builds so that users can understand and use them more easily. This can be seen with builds that use standard project structures and naming conventions, such as <<building_java_projects#building_java_projects,Java builds>>. You can write your own plugins that provide conventions — they just need to configure default values for the relevant aspects of a build.

 * {guidesUrl}/implementing-gradle-plugins/#modeling_dsl_like_apis[A custom model].
+
Gradle allows you to introduce new concepts into a build beyond tasks, files and dependency configurations. You can see this with most language plugins, which add the concept of <<building_java_projects#sec:java_source_sets,_source sets_>> to a build. Appropriate modeling of a build process can greatly improve a build's ease of use and its efficiency.


=== 5. Build scripts operate against an API

It's easy to view Gradle's build scripts as executable code, because that's what they are. But that's an implementation detail: well-designed build scripts describe _what_ steps are needed to build the software, not _how_ those steps should do the work. That's a job for custom task types and plugins.

[NOTE]
====
There is a common misconception that Gradle's power and flexibility come from the fact that its build scripts are code. This couldn't be further from the truth. It's the underlying model and API that provide the power. As we recommend in our best practices, you should <<authoring_maintainable_build_scripts#sec:avoid_imperative_logic_in_scripts,avoid putting much, if any, imperative logic in your build scripts>>.
====

Yet there is one area in which it is useful to view a build script as executable code: in understanding how the syntax of the build script maps to Gradle's API. The API documentation — formed of the link:{groovyDslPath}/[Groovy DSL Reference] and the link:{javadocPath}/[Javadocs] — lists methods and properties, and refers to closures and actions. What do these mean within the context of a build script? Check out the <<groovy_build_script_primer#groovy_build_script_primer,Groovy Build Script Primer>> to learn the answer to that question so that you can make effective use of the API documentation.

NOTE: As Gradle runs on the JVM, build scripts can also use the standard {javaApi}[Java API]. Groovy build scripts can additionally use the Groovy APIs, while Kotlin build scripts can use the Kotlin ones.

