AGILE IN ACTION: Iterative and incremental development

Sunday, July 03, 2005

Iterative and incremental development

Typically agile software development combines incremental and iterative techniques to deliver functionality early and often. Many people believe that iterative development is the same as incremental development. In fact, they are different but entirely complementary practices for developing software.

Iterative development

iterate - verb perform repeatedly. Make repeated application of a procedure, applying it each time to the result of the previous application.

Iterative development refactors code repeatedly, making progress through successive refinement. On any given day, a developer repeatedly performs a little modeling, a little coding, a little testing, a little integration using the practice of test-driven development. The completion of each cycle provides feedback for the next cycle.

Using a book-writing analogy (taken from http://www.c2.com/cgi/wiki?IterativeVsIncremental) to demonstrate iterative development. As an author:

I write an initial draft chapter that's not well organised.
I review the draft discarding irrelevant and superfluous text, expanding on the important topics, clarifying confusing or poorly explained topics, and sorting out the overall structure and formatting.
I review again and start to see a shape emerge. I continue to resolve issues.
I review yet again, etc, until the draft chapter can be considered good enough.

Incremental development

increment - noun an increase or addition.

Incremental development builds and delivers software to a production environment as a series of small and regular releases with expanding functionality. An application is therefore delivered in incremental releases over time, where each release adds new functionality to the previous release.

Again, using the book-writing analogy to demonstrate incremental development. As an author:

I write the first chapter
I write the second chapter
I write the third chapter
And so on until the book is finished

In Extreme Programming, the term 'iteration' defines a time-box. An iteration can be considered a mini-project whose goal is to produce an increment of functionality with stable, integrated production-quality code. An increment does not have to be a release, i.e. delivered to a production environment. In some circumstances it may not make sense to deploy an increment to production, e.g. the increment may require other software, that will only be developed in the next iteration, for it to be usable by the end-user. Arguably an 'iteration' should've been called an 'increment'.

Note: My previous post Slicing the cake described how to evolve the functionality of a user story through multiple increments. In this context, an increment is not a release nor the output of an iteration. An increment is simply an incarnation of the user story functionality at a point in time. Within an iteration, the demonstrable functionality of a user story will proceed through many increments as the developer completes the engineering tasks. This is an entirely separate concept to iterative development, which of course, the developer is practicing as he refactors the code to improve its legibility, design and structure.

Combining iterative and incremental development

Agile software development employs both iterative and incremental development techniques but also applies feedback across releases or increments, or to use Extreme Programming terminology, iterations. Effectively, incremental development becomes evolutionary, where the previous iteration guides the next iteration.

In any iteration, you should focus only on the functionality described by the user stories in that iteration. You should pay no attention to other user stories, not yet scheduled, which may impact how you choose to implement the current user stories. In practice, during the coding of an iteration, you often need to change or refactor code from previous iterations to accommodate new functionality.

Interesting links:
Iterative and Incremental Development: A Brief History, Craig Larman and Victor R Basili