A waterfall process model is a dominant software development model used by software engineers for the last three decades. This model divides the entire software development process into several independent stages. Further, the developers sequentially carry out these independent stages to obtain the final product (software).
The waterfall model is mostly implemented in the case where the requirements for software are known in advance. In this section, we will be discussing the waterfall model, the phases of the waterfall model, situations in which we can use the waterfall model, and the advantages and disadvantages of the waterfall process model.
Content: Waterfall Process Model
- What is Waterfall Process Model?
- Phases of Waterfall Model
- When to Use Waterfall Model?
- Advantages & Disadvantages
- Key Takeaways
What is Waterfall Process Model?
The waterfall process model has its name waterfall model as each stage constructs a well-defined product or output that is passed onto the next stage as an input, just like a stream of water. Once the stream of water falls down, it cannot flow back up. Similarly, in the waterfall model, when one stage passes its product to the next one, the scenario cannot be reverted.
So, we can say that this entire software development process behaves like a series of tiny waterfalls, and this is why we refer to this model as the ‘waterfall model’.
The waterfall model divides the entire process of software development into a definite number of stages. The developers then carry out these stages in a sequence, one after another. Every stage produces a well-defined product and forwards it as an input to the next stage.
Each stage continues processing until the final product of that stage is obtained before switching to the next stage. The waterfall model does not describe what methodology should be used at each stage, nor does it describe any notation for the products produced at each stage. Let us move towards the phases/stages of the waterfall model.
Phases of Waterfall Model
The waterfall model’s phases/steps/stages vary from author to author & people-to-people, though the overall approach is the same. The phases of the waterfall model that we will study are as follow:
1. Requirement Analysis
Being the first phase at this stage, the software engineer first understands the client’s requirements. What is the client’s problem, and what solution does it require for his problem.
The software engineer documents the client’s requirements in the SRS (Software Requirement Specification) document, which can also be considered a contract between the client and developers. The contract document avoids any dispute between the client and developers in future.
At this stage, the developers schedule the time for modelling, coding, testing & deployment of the software. The developer team also estimate the cost of each phase in this stage. They also plan regarding the hardware requirement, and thus the system architecture is planned at this stage.
In this stage, the software developer analyzes the requirements specified above by the client and transforms the specified requirements into logical models. Then the developer implements this logical model using a programming language.
The developer constructs logical models at the coding stage by developing small programs, which we refer to as units. These small program units are integrated to form the software.
The developed software is tested initially by the software engineers and then by a set of customers. Testing verifies whether the developed software meets the client’s requirement or not. At this stage, it is made sure that the client should not face any problems while installing and using the software.
After final testing, the software is released to the customer or at the market. Along with the software’s deployment, maintenance is also provided to keep the software functional and up to date.
When to Use Waterfall Model?
We must use the waterfall model when the client can specify all his requirements at once, plus his requirements must be stable. The developer team should understand all their client’s requirements at the software development start.
But, this doesn’t happen as it is difficult for anyone to state all the requirements at once. However, a strict waterfall model requires that all the requirements should be specified beforehand as the water once felled from a waterfall cannot go up. Similarly, in a strict waterfall model, we cannot go back once the stage is completed.
A variation in the waterfall model was introduced, known as ‘feedback between the adjoining stages’; it resolves the need for the strict waterfall model.
The feedback between the adjoining stages allows correcting the problem uncovered in the previous stage by taking feedback from the current stage. Like, in the testing stage, if an error is detected in the coding stage, it can be resolved by going back to the coding stage.
So, in reality, there is not an exact sequential flow from communication with the client to the deployment of the product. There is frequent feedback on earlier stages.
Advantages and Disadvantages of the Waterfall Model
Advantages of the Waterfall Model
- The waterfall model divides the entire process of software development into finite independent stages. It makes the controlling of each stage easier.
- Only one stage is processed at a time, and this avoids confusion.
- The waterfall model works best for smaller projects.
- The requirements are stable and known to the developer at the start of the project.
- Client intervention is minimum during software development.
- The waterfall model is simple and easy to implement.
Disadvantages of Waterfall Model
- A strict waterfall model doesn’t allow going back once the stage completes. If developers identify any problem at any stage that discovers the earlier stage’s mistake, it’s too late to rectify it.
- It is difficult to state all the requirements explicitly initially, which causes natural uncertainty at the beginning of the project.
- The client must have patience as he will be able to see the working model only during the deployment stage. If he identifies any problem at that time, it is too late to modify due to the rigidity of the waterfall model.
- The waterfall model is difficult to implement in a complex project.
- As the testing stage comes very late, it becomes difficult to determine the problems uncovered at the early stages.
- For the last three decades, the waterfall model has been a popular software development model.
- The waterfall model divides the entire process of software development into definite independent stages.
- Each stage is well defined and produces a precise output passed on to the next stage as an input.
- The stages of the waterfall model are requirement analysis, planning, modelling, coding, testing & deployment.
- In the requirement analysis, the developer expects the client to specify all the requirements explicitly.
- In the planning stage, the planning is done by scheduling the remaining stages, estimating the cost of each stage, and determining the hardware to be used.
- At the modelling stage, developers design logical models.
- In the coding stage, the developer implements a logical model by developing small integrated programs to form the entire software.
- The software developed is tested in a customer-friendly environment to verify that no flaws remain in the software in the testing stage.
- The product or the software is handed over to the client in the deployment stage.
So this is all about the waterfall model; despite its drawbacks, the waterfall model has been used for years. Implementing the waterfall model in small projects or where the requirements are specified explicitly and are stable is good.
Great content! Super high-quality! Keep it up! 🙂