Case Study: Creating a
Plug-in Architecture

Flexible Sofware Development Using an Iterative Approach

Author: Scott Collins, Synaction Consulting Group

Software development can be a very lucrative business. With the proper processes and development approach, a great business idea can be transformed into a profitable enterprise. However, using a development process that is inflexible and not well suited to the changing demands of developing software can ultimately turn a great idea into a costly failure. This article examines the needs of developing profitable software and examines an alternative to traditional software development processes. This process, called Iterative Development, can greatly reduce the cost of developing software products while increasing the overall chance of success for a software application.

The Software Development Process

The process of developing software consists of several phases:

Requirements Gathering
Design
Development
Quality Testing
Production

Each of these phases can be implemented in different ways, and it is the implementation of these phases that makes up a development process. Some development processes take an approach of strict separation of each of these phases, such as the Waterfall method. Other methods can skip processes completely. This can be referred to as Anarchy. Other processes find a middle ground between Waterfall and Anarchy. The Iterative Development method covers all of the phases mentioned above, but allows for more flexibility than the Waterfall method.

The Waterfall method requires that each phase be completed and receive approval from key stakeholders before the next phase can be started. If new requirements surface during the design or development phase, either the development process must return to the requirements phase, or the new requirements must be put off for a future release. This is a fairly inflexible approach. It looks at the development process in a very optimistic way. It makes the following assumptions about developing software

All possible requirements can be thought of prior to design and development
Requirements do not change
Ideas do not evolve over time

The truth is that developing software is a very complex process. There are many times when requirements surface during the design and development phases of the project. These requirements are often only considered once the developer attempts to write the code to meet the stated requirements. Customers also include new requirements or change their mind about what they originally specified during the requirements gathering stage. And in a worse case scenario, the customer may have specified exactly what they thought that they wanted, but once they receive the final product, they realize that what the specified was not what they wanted.

Although the Waterfall method of development provides an optimistic sense of security in the development process, it is ill-equipped to deal with the most common scenarios that a development group encounter while creating an application. To be successful, another approach must be adopted. This approach must embrace the reality of software development and must be flexible and responsive to changing requirements. This approach is the Iterative Development method.

The Iterative Development Method

Iterative development was designed to handle some problems inherent in the Waterfall method. First, the iterative development process realizes that developing a software product is a very complex task and that it is almost impossible for a developer or group of developers to think about all possible outcomes before writing the code. Iterative development is different than the Waterfall method in that it does not look at the project as a large unit of work. Instead, the functionality is broken up into small units of work that can be completed in no more than 2 weeks. Each unit of work goes through the requirements gathering, design and coding phases. After the small unit is completely coded, it is then reviewed by all interested parties. The major stakeholders can view what the result of the requirements are and they can then make changes. Since the units of work are small, it is not a big deal to make changes to the requirements or even throw it all away and start the unit over. If the work is approved, then the next small unit of work is scoped out and the process starts over again.

The second major issue that Iterative development addresses is that user requirements change over time. More information about what the user is expecting may arise that invalidates prior requirements. In the Waterfall method of development, this can be almost catastrophic. It would require going all the way back to the requirements phase and working back through each design phase until development could begin coding again. Major projects have fallen victim to the faults of this method. The Iterative method of development is different. It embraces the fact that great ideas evolve over time. Since it allows principle stakeholders to review and modify their original assumptions, it allows great ideas to evolve.

Iterative development also goes hand in hand with Test Driven Development. When unit tests are written to make sure that existing code does not break when changes are made, it eliminates the fear of changing code to meet new requirements. If something changes and development has to accommodate new requirements, then the unit tests will ensure that the code that is not changing will not be broken.

Producing Results

When done properly, Iterative Development can have a substantial positive impact on ROI. The nature of Iterative Development requires that the progress of the project must be examined over and over at short intervals, allowing for the project to be molded and redirected in order to provide the very best final product. Without constant monitoring, miscommunications and bad assumptions can lead the project astray. This can ultimately lead to large scale changes when the final product is presented, which can cost a small fortune and can add months to the delivery date.

It also makes sure that the money being invested in development produces exactly what the company wants. With other methods that do not constantly re-examine assumptions, the company may be forced to live with certain decisions that were made early in development. This means the company has invested large amounts of capital to produce something that the principle stakeholders have to live with. With Iterative Development, what is received for the investment is what is actually desired.

Iterative Development is not a magic wand that will solve all of the problems in developing software. When done incorrectly, it can have the same catastrophic effects as other methodologies. But when done correctly, it can greatly reduce development times and produce a product that is far superior and more cost effective than one developed using another technique.