Table of Contents
Abuild is a system designed to build large software projects or related families of software projects that are divided into a potentially large number of components. It is specifically designed for software projects that are continually evolving and that may span multiple languages and platforms. The basic idea behind abuild is simple: when building a single component (module, unit, etc.) of a software package, the developer should be able to focus on that component exclusively. Abuild requires each component developer to declare, by name, the list of other components on which his or her component depends. It is then abuild's responsibility to provide whatever is needed to the build environment to make other required items visible.
You might want to think of abuild as an object-oriented build system. When working with abuild, the fundamental unit is the build item. A build item is essentially a single collection of code, usually contained within one directory, that is built as a unit. A build item may produce one or more products (libraries, executables, JAR files, etc.) that other build items may want to use. It is the responsibility of each build item to provide information about its products that may be used by other items that depend on it. This information is provided by a build item in its abuild interface. In this way, knowledge about how to use a build item is encapsulated within that build item rather than being spread around throughout the other components of a system.
To implement this core functionality, abuild provides its own system for managing build items as well as the dependencies and relationships among them. It also provides various build rules implemented with underlying tools, specifically GNU Make and Apache Ant accessed using the Groovy programming language, to perform the actual build steps. We refer to these underlying tools as backends. Although the bulk of the functionality and sophistication of abuild comes from its own core capabilities rather than the build rules, the rules have rich functionality as well. Abuild is intended to be your build system. It is not intended, as some other tools are, to wrap around your existing build system. [1]
Support for compilation in multiple programming languages and on
multiple platforms, including embedded platforms, is central to
abuild's design. Abuild is designed to allow build items to
be built on multiple platforms simultaneously. An important way
in which abuild achieves this functionality is to do all of its
work inside of an output directory. When
abuild performs the actual build, it always creates an output
directory named
abuild-
.
When abuild invokes make, it does so
in that directory. By actually invoking the backend in the
output directory, abuild avoids the situation of temporary
files conflicting with each other on multiple simultaneous builds
of a given build item on multiple platforms. For ant-based
builds (using either the supported Groovy backend or the
deprecated xml-based ant backend), each build is given a private
ant platform
Project
object whose
basedir
is set to the output directory.
Abuild is designed to never create or remove any output files
outside of its output directories. This enables abuild's
cleanup operation to simply remove all output directories created
by any instance of abuild, and also reduces the likelihood of
unintentionally mixing generated products with version-controlled
sources.
[1] Abuild can, however, interoperate with other build systems as needed, which may be useful while transitioning a software development effort to using abuild.