Community Developed Builds for the Agile Developer


Agile development is a process methodology where, at its core, is the ability for developers to share and test changes in software as rapidly as possible in an efficient but disciplined approach. The Continuous Build process is based on manual scripting and therefore is highly redundant and non-adaptive. Continuous Builds that rely on redundant scripts become road blocks for agile teams when attempting to move quickly from code to deployment. Agile developers must recognize the problems of manual scripting and begin moving toward a non-redundant Community Developed approach to managing the Continuous Build. 

Development tools have become highly efficient. From the introduction of IDEs and Service Oriented Architecture, developers have the tools they need to build upon Agile methodologies and improve the overall development process. Source code is generated and reused across teams. Redundant tasks are identified and removed. This is not the case with the build process. It remains a redundant manual scripting process that can cause big problems for teams attempting to streamline their development process from development to deployment.

Rigid Manual Builds
The basic description of Agile development simply does not apply to manually scripted builds. Agile development implies an iterative development methodology. {sidebar id=1} The basic concept is that you build and deploy applications quickly and on a frequent basis. These mini, iterative releases allow for each developer's coding change to be compiled into a complete application on a continuous basis, called a quot;Continuous Build.quot;
The static Continuous Build is problematic for agile developers because agile development results in an application that is changing at a rapid pace. This quickly changing application development process forces updates in the build itself. The agile development process stops while the build scripts are manually updated. The problem is clear. The agile development process is highly adaptive and dynamic. However, the Continuous Build, relies on a non adaptive manual process.
Build scripts are executable documents. Because they are manually written there is redundancy within the scripts themselves. Redundancies are found at multiple layers. Each developer may maintain a local script as well as a shared script that executes the Continuous Build, QA Build and Production Build (see Figure 1). In addition, scripts may be copied so that one set executes with quot;debugquot; turned on and another with quot;debugquot; turned off. Because of the static nature of build scripts, this type of redundancy is unpreventable.

Figure 1: Script Redundancies

Agile development is highly adaptive but build scripting is not. The Continuous Build relies on non-adaptive manual scripts causing the agile process to be less iterative. A good example of this is the inability for most manual scripts to perform accurate quot;incremental builds.quot; An incremental build is a build that is intelligent enough to recompile only the objects that are out of date, versus the entire application. If the entire application takes one hour to compile, then there can only be a limited number of builds completed in a day. To solve this problem developers attempt to build the application over several machines performing a quot;distributedquot; build. But the problem is not the speed of the build, it is the script's inability to simply re-build the one or two modules that need to be updated.
The non-adaptive nature of build script is out of sync with the highly adaptive natures of development IDEs. For example, code and package re-factoring can cause names of object to change. A developer has the option to easily re-factor code inside of the development IDE such as Eclipse. However, the script itself is not aware of these name changes. The scripts and have no connection to the IDE. What is done dynamically in the IDE must be done manually outside the IDE. Code and package re-factoring tasks can require developers to re-visit multiple scripts to finish the job.
A Build Paradigm Shift
Agile developers are beginning to recognize the high cost of redundant, non-adaptive build scripts. Developers who are successful in defining and working within an Agile development process understand the importance of the build step. Most importantly, they understand the importance of a centralized, Community Developed build process.
There are three primary characteristics of a Community Developed build process:

About the author

AgileConnection is a TechWell community.

Through conferences, training, consulting, and online resources, TechWell helps you develop and deliver great software every day.