The progressive, adaptive, iterative approach is founded on the following principles:
- Proceed in small steps, continuing steadily by increments.
- The plans must adapt to the project’s changing circumstances.
- The characteristics that distinguish the product or service must be progressively elaborated.
- They should be broadly defined early in the project and made more explicit and detailed as a better understanding of the project emerges.
- Large projects must be broken up into smaller projects.
- Requirements errors can be 100 times more costly to fix after deployment than at requirements time.
- Initial estimates have a large margin of error—most waterfall projects cost two to three times what was initially predicted.
- The first one never works; always develop things at least twice.
- Initial designs will be flawed.
- Requirements must evolve alongside demonstrable versions of the product.
- Teams need to own and be accountable for their achievements and plans.
- You should believe the project results, not the project plan.
- Detailed planning should be limited to the next milestone.
- Projects should adopt an active and aggressive approach to addressing project risk.
Progressive, iterative processes were developed in response to the problems inherent in the waterfall approach. Instead of developing the whole system in one go, an increment is selected and developed, then another increment, and so on. The selection of the contents of the first increment is based on risk, addressing the highest-priority risks first. To address the selected risk(s), select a subset of the requirements to be implemented and tested. Develop the minimal set of functionality that enables objective verification (through a set of executable tests) that the risks have been successfully addressed. Then select the next highest risks to be addressed in the next iteration, and so on.
One of the great ironies of modern software development is that in the paper that led to the popularity of the waterfall approach to software development, Winston Royce argued that projects should always go through at least two development cycles because the first version never works. He was actually arguing that projects should take a more incremental approach, not that they should adopt a prescriptive waterfall development approach. Progressive, iterative approaches take this principle one step further by splitting the lifecycle up into many smaller increments, each explicitly addressing the project’s major risks.