How to select the best build automation tool?

An organization needs to select an appropriate build automation tool to optimize costs, save time, and achieve the best possible outcome.
The identification of a suitable build automation tool, therefore, comprises of the following steps:

Step 1:

Identifying all relevant requirements

Step 2:

Categorizing the requirements (basic, technical, business, feature)

Step 3:

Creating a list of suitable tools against basic requirements

Step 4:

Shortlisting the tools against other requirements

Step 5:

Creating a chart for comparison

Step 6:

Generating a final scorecard and zeroing in on the tool

The initial step is to collect all the requirements that are needed for delivering the project. This is followed by a clear categorization of the requirements, often into:

Basic Requirements, covering with the basic needs of the project like what type of product or application is to be built, and the ease of execution.

Technical Requirements, consisting of the language preference, system requirements, the platform used, and the skills of the team.

Business Requirements, concentrating on the cost, budget, time, and project deadline.

Feature Requirements, covering what kind of feature we are looking for like UI, integration, Reporting and so on.

Subsequently, the tools have to be mapped with the identified requirements to make sure whether they are satisfying all the necessary considerations.

Finally, a comparison chart has to be plotted using all the details, which leads to a scorecard on which tool is best suited for the project.

Based on the analysis performed, the team has identified three open source and multi-language, multi-module supported tools – Gradle, Maven, and Bazel. In the following pages, we present an in-depth view into the framework and the specification of each of the tools to understand their feasibility and applicability across projects.

Maven:

Maven is an open-source Java-based build automation tool, used mostly for the creation of Java projects. The tool was created by Jason Van Zyl in 2002, with its first release on July 13, 2004 by the Apache Software Foundation.

The tool can also be used to build and manage projects in other languages such as Ruby, Scala and C# respectively. The working mechanism of Maven consists of usage of declarative speech approach, where the project structure and the contents are described in the form of the project object model.

Maven attempts to apply patterns to any project’s build structure thereby, promoting comprehension and productivity through providing a fine path to make use of the best practices. It helps as a management tool in managing the documentation, builds and dependencies.

Project Creation in Maven:

Step 1:

Download the Maven software from the official website. https://maven.apache.org/download.cgi

Step 2:

Install the software by changing the appropriate environment variables.

Step 3:

Set path in the root directory or directory of your choice.

Step 4:

Check for successful installation using the command maven -v.

Figure 1: Project creation process in Maven (Source: geeksforgeeks.org)

Maven Build Phases

Maven build lifecycle goes through a series of stages, called as default build phases – validate, compile, test, package, verify, install and deploy. These phases executed sequentially when we run a maven build command.

We can build a java project using maven in two alternate ways.
1. Using Command Prompt
2. Using Eclipse

In eclipse, we have to create a maven project and then check for the POM file which is very important in this automation.
In the POM file, we have to add the dependencies. As mentioned in Figure 1 we can take the dependencies from the system which we are using or we can use online repositories.
All the java projects use the test frames like junit or testng, we can use any test frame of our choice.

<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.4.0</version>
<scope>test</scope>
</dependency>

A sample of the POM file

Figure 1a: Adding dependencies to the POM file

Java file compilation in Eclipse using Maven

Figure 1c: Project build compilation in eclipse using Maven

Java file compilation with Maven using command prompt

The Project can also be built successfully using command prompt. For that, one needs to go to the folder in which the project is saved, and then use the maven test command.

Figure 1d: Project build compilation in command prompt using Maven

Gradle:

Gradle began as an open-source project led by Hans Docker and Adam Murdoch. The initial success of the Gradle build tool project paved the way for the establishment of the Gradle Enterprise in 2017.

As a build automation tool, Gradle supports multiple-language software development.
The tool controls various processes involved in the software development processes and automates processes such as the tasks of compilation, packaging, testing, deployment and publishing as well. The languages supported by the Gradle build automation tool, include:

Java
Kotlin
Groovy
Scala
C/C++ and
JavaScript

The working mechanism of the Gradle tool consists of inclusion of directed acyclic graph to detect the order in which the each of the tasks is been running, and also provides dependency management. The tool operates by leveraging certain series of build tasks which can run either serially or in parallelly. Builds which are of incremental types are supported by knowing the updated parts of the build tree, and any of the tasks are dependent only on those parts of the tree, that does not need to be repeated at any another time. Gradle supports cache conflicts and dependency management of the builds. It also supports multi-project organization.

Project Creation in Gradle:

Step 1:

Download the Gradle software from the official website. https://gradle.org/install/

Step 2:

Install the software by changing the appropriate environment variables.

Step 3:

Set path in the root directory or directory of your choice.

Step 4:

Check for successful installation using the command gradle -version.

Step 5:

Once details of Gradle version is displayed, create a build using the gradle init command.

Step 6:

On pressing enter, select the language of your choice for project creation.

Step 7:

Project starts generated corresponding to the program in the build. gradle file.

Step 8:

Project is successfully created in Gradle.

The overall build process includes compiling, linking, and packaging the code, and is supported mostly for a groovy-based domain. Gradle therefore provides a seamless building, testing, and software deployment experience for different project sizes. With its focus on maintenance, performance, and flexibility it is widely adopted across teams.

Figure 2: Project creation process structure in Gradle (source: vaadin.com)

Gradle Build Phases

A Gradle build has three distinct phases.

1. Initialization:

Gradle supports single and multi-project builds. During the initialization phase, Gradle determines which projects are going to take part in the build, and creates a Project instance for each of these projects.

2. Configuration:

During this phase the project objects are configured. The build scripts of all projects which are part of the build are executed.

3. Execution:

Gradle determines the subset of the tasks, created, and configured during the configuration phase, to be executed. The subset is determined by the task name arguments passed to the Gradle command and the current directory. Gradle then executes each of the selected tasks.

Figure 2a: Project build compilation in eclipse using Gradle

Gradle project creation is performed using eclipse and the results are as shown in the above picture. The process to build the application using Gradle is almost the same as Maven, with the only difference being that a Maven Project will be built only after modifying the POM file, while in Gradle, the application is built just after the creation of the project.

Gradle has many options in the command prompt to select the project details and all other requirements to start the build process.

The command used to start the build process in Gradle is “Gradle init.” After entering this command in the command prompt, it will initialize the task and starts showing all the options one by one and we have to select what are the requirements needed to build the application.

Figure 2b: Options display to build a process in Gradle tool

Figure 2c: Complete testing of compilation process and build creation in Gradle tool

Figure 2d: Complete testing of compilation process and build creation in Gradle tool.

The build compilation time in Gradle may be more than Maven in the command prompt, due to the extra time consumed while opting for the requirements and automatic cache cleaning function of Gradle when a new application is started.

However, while using the Eclipse IDE, it was observed that the build time of Gradle was significantly less as compared to Maven.

Bazel:

Bazel is an open-source version of Google’s internal solution, Blaze, which is used for automating software processes within the search engine giant. The tool, an anagram of Blaze was launched in March 2015.

In terms of build automation tools, Bazel is similar to Apache Maven and Apache Ant. It provides complete automation in build and testing of the software, across platforms. The working mechanism consists of building of software applications from the source-code by following a certain a set of rules. These rules are created in Starlark Language which serves as dialect of the Python programming language.

The software application packages produced by Bazel capable of being integrated with Android and iOS platforms, thereby paving way for real-time applications. Built-in rules are present in Bazel for building software applications with various types of language support namely: C++, Java, Go, Python, Objective-C and Bourne Shell script respectively.

Bazel leverages parallelization techniques to speed up the process of build and software application package creation as well. New build rules can be written in Bazel so as enhance cross-platform integration. The tool also provides plugin-in support IDEs including IntelliJ, Android Studio, and CLion.

Project Creation in Bazel:

Step 1:

Download the Bazel software from the official website. https://docs.bazel.build/versions/main/ install-windows.html

Step 2:

Install the software by changing the appropriate environment variables.

Step 3:

Set path in the root directory or directory of your choice.

Step 4:

Check for successful installation using the command bazel -v.

Step 5:

Once details of Bazel version is displayed, create a build file with sub file called planning.java.

Step 6:

Create a sub-directory with a java file as source.java

Step 7:

Once build is created test the builds.

Step 8:

Project is successfully created in Bazel.

Figure 3: Project structure in Bazel

Bazel Build Phases

In Bazel, a build occurs in three distinct phases:

1. Loading Phase:

The first is loading during which all the necessary BUILD files for the initial targets, and their transitive closure of dependencies, are loaded, parsed, evaluated and cached. Errors reported during this phase include: package not found, target not found, lexical and grammatical errors in a BUILD file, and evaluation errors.

2. Analysis Phase:

The second phase, analysis, involves the semantic analysis and validation of each build rule, the construction of a build dependency graph, and the determination of exactly what work is to be done in each step of the build. Errors reported at this stage include: inappropriate dependencies, invalid inputs to a rule, and all rule-specific error messages.

3. Execution Phase:

This phase ensures that the outputs of each step in the build are consistent with its inputs, re-running compilation/linking/etc. tools as necessary. Errors reported during this phase include: missing source files, errors in a tool executed by some build action, or failure of a tool to produce the expected set of outputs.

Step-1: Installation of the Bazel tool

Figure 3a: Step1: Installing the Bazel software.

Step-2: Checking for successful compilation of the Bazel tool

Figure 3b: Step 2: Checking for complete compilation process of Bazel tool.