Continuous Integration
Traditional software development methods don't dictate how frequently or regularly
you integrate all of the source on a project. Programmers can work separately for hours,
days, or even weeks on the same source without realizing how many conflicts (and perhaps bugs)
they are generating. Agile teams, because they are producing robust code each iteration, typically
find that they are slowed down by the long diff-resolution and debugging sessions that often occur
at the end of long integration cycles. The more programmers are sharing the code, the more problematic
this is. For these reasons, agile teams often therefore choose to use Continuous Integration.
Continuous Integration (CI) involves producing a clean build of the system several times per day,
usually with a tool like CruiseControl, which uses
Ant and various source-control systems. Agile teams typically configure CI to include automated
compilation, unit test execution, and source control integration. Sometimes CI also includes
automatically running automated acceptance tests such as those developed using
FitNesse. In effect, CI means that the build is nearly
always clean.
Continuous Integration Technique, Tools, and Policy
There are several specific practices that CI seems to require to work well. On his site,
Martin Fowler provides a
long, detailed description of what Continuous Integration is and how to make it work.
One popular CI rule states that programmers never leave anything
unintegrated at the end of the day. The build should never spend the night in a broken state. This
imposes some task planning discipline on programming teams. Furthermore, if the team's rule is that
whoever breaks the build at check-in has to fix it again, there is a natural incentive to check code
in frequently during the day.
Benefits of Continuous Integration
When CI works well, it helps the code stay robust enough that customers and other stakeholders
can play with the code whenever they like. This speeds the flow of development work overall; as
Fowler points out, it has a very different feel to it. It also encourages more feedback between
programmers and customers, which helps the team get things right before iteration deadlines. Like
refactoring, continuous integration works well if you have an exhaustive suite of automated unit
tests that ensure that you are not committing buggy code.
Skillful CI means that integration is never a headache, because your work reflects only slight
divergence from the codebase. If the team must regularly deal with small-scale divergences, they
never have to deal with truly scary ones. They also get the opportunity to discuss different design
approaches on the day that they arise, because integrating that day brings them to the entire team's
attention. |
