Download pdf - Comparison of the Waterfall, Spiral, and Prototype SDLC Models

Running Head: THE WATERFALL, SPIRAL, AND PROTOTYPE SDLC MODELS 1

A Comparison of the Waterfall, Spiral, and Prototype SDLC Models

Teresa J. Rothaar

Wilmington University

THE WATERFALL, SPIRAL, AND PROTOTYPE SDLC MODELS 2

A Comparison of the Waterfall, Spiral, and Prototype SDLC Models

Introduction

There are numerous software/systems development lifecycle (SDLC) models. According

to Ruparelia (2010), each SDLC model can be classified in one of three categories: linear,

iterative, or a combination of both. Linear models are sequential; each stage automatically leads

into the next, and stages are not revisited or repeated. Iterative models are structured around the

idea that the SDLC is a continuous process, and each stage will be revisited multiple times

during the life of the project. A combined model is an iterative model with a finish line: It

acknowledges that, at some point, there will be no more need to revisit any of the stages (p. 8).

This paper will compare and contrast three popular SDLC models: waterfall, spiral, and

prototype.

The Waterfall Model

The term “waterfall” refers to a methodology as well as a model; software engineers

often use the term interchangeably (C. Seifer, personal communication, March 18, 2015). There

are actually two waterfall models: the traditional, linear model and a newer, iterative model.

Each model has five steps: requirements analysis, design, implementation, testing, and

maintenance (Maheshwari & Jain, 2012, p. 286).

In the traditional waterfall model, each step flows into the other sequentially. While some

“splash back” is permitted, the goal of the model is to move through each phase and onto the

next without repeating, with an “emphasis … on planning, time schedules, target dates, budgets

and implementation of an entire system at one time” (Maheshwari & Jain, 2012, p. 286). This

method is highly structured, with well-defined deliverables and milestones for each phase, which

make it easy to understand. However, the tight structure of the original waterfall model—in


particular, the need to consider and plan for every possible eventuality at the beginning of the

project—has caused it to fall out of favor in today’s dynamic business environment. Often, the

project sponsor may not know exactly what they want at the outset, or, in the case of a large

project being done over a long period of time, something may change in the macro environment

that requires changes to the project (Maheshwari & Jain, 2012, p. 286).

Enter the iterative waterfall model. The steps are the same as in the traditional waterfall

method, but with testing and analysis at the end of each phase, which theoretically provides

valuable feedback when moving into the next phase. Additionally, unlike in the traditional

model, it is expected that phases will be repeated. The advantage of this model is that it is better

suited to the dynamic world of modern software and systems development; however, it lacks the

clear milestones of the original model and, thus, could be difficult to manage (Maheshwari &

Jain, 2012, p. 286-287).

The Spiral Model

Among the most flexible of SDLC models is the spiral model (Saxena & Kaushik, 2013,

p. 118), which is a combination of the traditional waterfall model and the prototype model

(Khurana & Gupta, 2012, p. 1516). It has four phases: requirements planning, risk analysis,

development and testing, and planning the next iteration. At the end of the risk analysis phase, a

prototype is produced, which is coded and tested in the third phase, then evaluated in the fourth

phase; feedback from this iteration is used to plan the next one. The hallmark of the spiral model

is its emphasis on risk analysis and mitigation, which makes it particularly suitable for very

large, costly projects (Khurana & Gupta, 2012, p. 1515-1516).

Figure 1 (Aafrin, 2012) visually demonstrates the similarities and differences between the

traditional waterfall and spiral models. The steps are very similar. However, while each step


“falls” into the next when using waterfall, the spiral method keeps going around the “spiral” as

many times as necessary. While the method is considered iterative, it can be used as a

combination method, as eventually, the project will be finished and there will be no need to go

through further iterations:

Figure 1. A visual representation of the difference between the linear waterfall model and

the iterative spiral model.

The spiral model is not suitable for every project. Saxena and Kaushik (2013) note that,

among other drawbacks, it is very expensive and highly complex; there is no specified “finish

line,” and it can be difficult to determine when to stop going through the iterations; and it

requires that project managers have a high level of expertise in risk management. Thus, they

recommend that it be used only for large, highly complex, risky, and expensive projects (p. 118).

The Prototype Model

According to Maheshwari and Jain (2012), the prototype (or prototyping) model isn’t

solely a standalone model, though it can be used as one; it is an approach that can be

incorporated into any SDLC model (p. 287). For example, as discussed above, prototyping is an


important part of the spiral model. Shukla and Saxena (2013) break the prototype model down

into six steps: requirements gathering; initial designing of the prototype; building the prototype;

having the client evaluate the prototype; refining the prototype; and finally, building the end

product (p. 19). As Figure 2 (ISTQB Exam Certification, 2012) illustrates, prototyping is a linear

method, like waterfall, with a beginning and an end:

Figure 2. A diagram of the prototype model.

Because it requires building a working model (which could end up being discarded), the

prototype model is expensive; however, it’s not as expensive as the spiral model (Shukla &

Saxena, 2013, p. 19). Other advantages include the fact that the client gets to see a working

model early in the project, which makes it easier for the client to make improvement suggestions,

may make it easier to get the project funded, and mitigates risk. However, costs can be high. The

development process can be slow, and as mentioned above, once feedback is received from the

client regarding the initial prototype, it may end up being useless. Additionally, the prototype

model encourages a lot of communication between the client and the developer; while this is

helpful in ensuring the client is happy with the final product, a non-technical client may expect

the moon and become upset when the developer cannot deliver on all requests as quickly and

inexpensively as the client thinks they should (Saxena & Kaushik, 2013, p. 119). Shukla and

Saxena (2013) recommend using this method only for small projects (p. 19).


Conclusion

This paper discussed three popular SDLC models; many more exist. All of them include

phases for gathering requirements, performing a business analysis, designing the system,

implementing the system, and performing QA testing (Mishra & Dubey, 2013, p. 64). There is

no one “correct” model; all of them do the same thing, but use different problem-solving

approaches. The decision to choose one model over the other is dependent on the particular

situation under which an individual project is being developed.


References

Aafrin (2012). Waterfall Model vs. Spiral Model [Online image]. Retrieved from

http://www.aafrin.com/wp-content/uploads/2012/06/waterfall-spiral-model.png

ISTQB Exam Certification (2012). Prototyping Model [Online image]. Retrieved from

http://istqbexamcertification.com/wp-content/uploads/2012/01/Prototype-model.jpg

Khurana, G., & Gupta, S. (2012). Study & Comparison of Software Development Life Cycle

Models. International Journal of Research in Engineering & Applied Sciences, 2(2),

1513-1521. Retrieved from

https://www.academia.edu/8608736/STUDY_and_COMPARISON_OF_SOFTWARE_D

EVELOPMENT_LIFE_CYCLE_MODELS

Maheshwari, S., & Jain, D. C. (2012). A Comparative Analysis of Different Types of Models in

Software Development Life Cycle. International Journal of Advanced Research in

Computer Science and Software Engineering, 2(5), 285-290. Retrieved from

http://www.ijarcsse.com/docs/papers/May2012/Volum2_issue5/V2I500405.pdf

Mishra, A., & Dubey, D. (2013). A Comparative Study of Different Software Development Life

Cycle Models in Different Scenarios. International Journal, 1(5), 64-69. Retrieved from

http://www.ijarcsms.com/docs/paper/volume1/issue5/V1I5-0008.pdf

Ruparelia, N. B. (2010). Software development lifecycle models. ACM SIGSOFT Software

Engineering Notes, 35(3), 8-13. http://dx.doi.org/10.1145/1764810.1764814

Saxena, P., & Kaushik, M. (2013). Advantages and Limitations of Different SDLC Models.

International Journal For Technological Research In Engineering, 1(3), 117-121.

Retrieved from http://www.ijtre.com/manuscript/2013010301.pdf


Shukla, A. K., & Saxena, A. (2013). Which Model is Best for the Software Project? “A

Comparative Analysis of Software Engineering Models.” International Journal of

Computer Applications, 76(11), 18-22. http://dx.doi.org/10.5120/13290-0806