Details of Iterative Software Development

Iterative software development is based on developing a software system incrementally. This allows the people involved to learn from learnings of the previous steps. With each iteration, more subsets of the overall specification are developed, and clarity in specifications and design from previous iterations are plugged in. This way, the system moves towards being closer to the overall customer need, rather than trying to meet the initial need that was defined in the initial stages, at a time when the customer themselves did not have full clarity about the specifications. This clarity typically comes when the customer has had a chance to look at some designs and some prototypes.
Think of the need for an iterative system like this: Many activities are involved in developing a solution to a problem. We need to understand the problem, gather requirements for a potential solution, translate those requirements into a design, build the solution, and test it. This order is fairly natural and generally correct. Problems creep in, however, when we try to scale this approach up—that is, when we try to gather all requirements, then do all design, then all development, and then all testing in a strictly linear fashion.
Now, if we undertsand the need for an iterative system, we need to understand the procedure. The Procedure itself consists of the Initialization step, the Iteration step, and the Project Control List. The initialization step creates a base version of the system. The goal for this initial implementation is to create a product to which the user can react. It should offer a sampling of the key aspects of the problem and provide a solution that is simple enough to understand and implement easily. To guide the iteration process, a project control list is created that contains a record of all tasks that need to be performed. It includes such items as new features to be implemented and areas of redesign of the existing solution. The control list is constantly being revised as a result of the analysis phase.
Or, to put it another way, The iterative development cycle is a spiral that passes repeatedly through four phases:
- Plan. In this phase, you are trying to understand your users and their needs, as well as how you want to address those needs.
- Implement. During implementation, you build a prototype to test the solutions you developed during the planning phase.
- Measure. Now it’s time to see how users react. How long does it take them to understand your solution? How long does it take them to do their work? What problems do they encounter? It is important to understand that measurements must be both objective and subjective; time on task is important, but if a user takes more time because the tools enable him or her to do a superior job, then you must be able to weigh improved quality of work against increased time on task.
- Learn. This is the analysis phase, where you decide which parts of your prototype are doing well, and which parts are not. There can be many reasons that a prototype does not achieve its goals. Sometimes these will be implementation issues, but more often the problem will be an incorrect or insufficient understanding of the users or the work they need to accomplish. As you make the transition back to planning, this fresh look–from a real user’s perspective, derived from user testing in the measurement phase–is essential!