Week 1 : Waterfall and Iterative Approaches to Software

Development

Iterative Development

Although managers of the 1970's and 1980's loved the waterfall model because of its logical
flow, in the 1990's a new form of software development called Iterative Development came
to prominence.

With iterative development, some requirements could lead to some design which would lead
to some implementation, etc. While a team would be implementing a particular subset of the
project, requirements could still continue on another subset, and so on.

If you want to compare iterative development to the waterfall model, let's apply each
approach to building a doghouse.

In the waterfall method, the team would gather all requirements, make a design, build the
house completely, test it, and then show it to the client. Delivering everything (the finished
doghouse) to the client at the end of the project characterizes the waterfall model.

Rather than one delivery, the iterative approach would have several cycles. At the end of
each cycle, something of value would be delivered to the client. For example, imagine that
your doghouse project was broken up into three iterations:

 Iteration 1: Create a frame outline of the dog house in wood.

 Iteration 2: Add the roof and walls to the wooden frame.

 Iteration 3: Paint the house and add decorations, including the dog's name
above the door.

The value of iterative product development becomes even more obvious if you look
more closely at each iteration. Let's start the first iteration:
 Figure 1 : Iteration 1: The wood frame

Imagine you've finished the wooden frame and you test it, only to find out that your
dog doesn't fit in comfortably (or perhaps, in the meantime, you've adopted a slightly
bigger dog �). Once you put the frame in your small backyard, you will see how
much space it takes up and decide that you want a smaller doghouse (but one that
the dog still fits in). With iteration development, your team provides a deliverable to
the client who then reacts to what has been delivered.

Now imagine that you are happy with the frame and you move on to the second iteration
phase. You instruct the team to build the walls and roof. Now that the team knows that the
size of the frame won't change, they can start with more confidence. Their focus is now on
the walls and roof that they will deliver at the end of the phase.

Figure 2 : Iteration 2: Walls and roof

During this process, let's say that the team discovers a problem with the roof. The
interior of the doghouse is wet after a night of rain. In that case, the roof is leaky and
must be replaced. Or, the team uncovers a different issue: adding the roof increases
the width of the doghouse and the doghouse no longer fits into the intended location
in the backyard. With the iterative method, the issue can be fixed right away.

Figure 3 : Iteration 3: Paint and decorate

The third iteration phase can begin because you know that the shape of the doghouse is
good (Iteration 1 feedback) and the walls and roof are acceptable (Iteration 2 feedback). Now
you are ready to varnish and paint the wood, treat the roof, add the dog's name, and even a
toy bone above the door!

The beauty of the iterative approach is that you learn from each iteration and take
that learning to the next. This ability to absorb learning means that you can adapt to
misunderstandings, change of context, or new knowledge in a productive way.

The Birth of Agile Software Development

The popularity of iterative software/product development in the 1990's, in turn,

motivated a new set of methodologies such as Extreme Programming (XP), SCRUM,
and Kanban. These new methodologies were iterative in nature but added additional
elements. They became recognized as effective approaches to building software and
products that customers loved.

in 2002, some visionaries in the field of software development condensed what they
had learned into a set of principles called the Agile Manifesto, which crystallized the
arrival of Agile development practices into the world. In the next few chapters, we will
look at the Agile Manifesto, discuss the principles of Agile development, take a quick
look at Kanban, and then spend most of the rest of this course looking in-depth at
SCRUM, which is one of the more popular agile methodologies.

Summary

 In the 1970's, the waterfall model of software development was popular. It

prescribed building in a set of phases (Requirements Analysis, Design,
Implementation, Testing & Maintenance) and only moving to the next phase
when the current phase was complete.

 During the 1990's, iterative product development was born out of a frustration
with the waterfall model and in particular, its need to define all requirements
up-front as well as the inability to manage changing requirements. Iterative
product development breaks a project up into iterations and delivers
something of value to the client at the end of each phase.

 In the 1990's and 2000,s, Agile methodologies (all iterative such as SCRUM,
Kanban, and XP) were built on this principle and are very popular today.