SDLC - Waterfall Model in Software Engineering
The Waterfall model in software engineering is the first SDLC model to be used for software development and is also known as the linear-sequential life cycle model. Winston Royce first debuted it in 1970. This classical model is very straightforward - the next phase follows each phase sequentially and linearly without overlaps. Though it was formerly widely utilized, this model is now relatively uncommon. However, it is critical because all other software development life cycle models are built on the traditional waterfall approach. Let us see how the waterfall model works, dive deeper into its phases, and learn about its pros and cons.
What is the Waterfall Model in Software Engineering?
The waterfall model in software engineering divides project activities into linear sequential phases that are handed down to each other, with each phase relying on the deliverables of the preceding one to get its corresponding task done. This method is common in many areas of engineering design. However, it is one of the least iterative and flexible methodologies in software development since progress flows mostly in one direction ("downwards" like a waterfall) through the SDLC phases.
Sequential Phases of the Classical Waterfall Model
The classical waterfall model in software engineering divides the life cycle into phases. This concept assumes that one phase can begin after the previous phase is completed. That is, the output of one phase becomes the input of the next. As a result, the development process can be viewed as a sequential flow in a waterfall. The phases do not overlap in this case. The following diagram depicts the several consecutive phases of the classical waterfall model in software engineering:
Requirements Analysis and Specification Phase
The purpose of the requirement analysis and specification phase is to precisely document the customer's specific needs. First, all software needs are gathered from the client, and then they are assessed. The purpose of this analysis is to eliminate inconsistencies and incompleteness. Therefore, all aspects of the actual requirements should be included, and no part of the requirements should contradict some other part. A software requirement specification (SRS) document is used to document the output of this phase.
This phase's purpose is to translate the requirements obtained from the SRS into a format that can be programmed in a programming language. It consists of both high-level and detailed design, as well as overall software architecture. In addition, it includes discussions like programming language selection, database selection, redundant backup, failover capabilities, etc. The work of this phase is documented in a Software Design Document (SDD).
Implementation and Unit Testing
Design is executed during this phase. If the SDD is comprehensive, the implementation or coding phase goes smoothly since the SDD contains all the information software engineers require. The code is extensively scrutinized and updated throughout testing. Small modules are initially evaluated in isolation. These modules are then tested by adding some extra code to verify their interaction and the flow of intermediate output.
Integration and System Testing
This step is crucial since the effectiveness of the testing defines the final product's quality. High-quality deliverable means happier customers, cheaper maintenance costs, and more accurate results. Unit testing is used to measure the efficiency of individual modules. However, the interactions of the modules or components with one another and with the system are tested at this stage. They are embedded into a module or system for various tests. This is known as system testing. It comprises three types of testing activities, detailed below:
- Alpha testing: The development team does system testing, known as alpha testing.
- Beta testing: is the process of having a group of amiable users test a system.
- Acceptance testing: After the program is delivered, the customer conducts acceptance testing to decide if they should accept or reject the product.
Operation and Maintenance Phase
The most important component of any software product development cycle is assisting your customers through frequent maintenance and checks. It is a critical stage in the software development life cycle. Maintenance typically accounts for 60% of the overall effort required to construct a whole product. There are three types of maintenance :
- Corrective maintenance: It is performed to repair faults that were not found during the product development process.
- Perfective Maintenance: This sort of maintenance is performed to improve the system's functionality depending on the customer's request.
- Adaptive Maintenance: When porting software to a new environment, adaptive maintenance is frequently necessary.
When to Use SDLC Waterfall Model?
The waterfall model in software engineering can be deployed for software development in the following scenarios:
- The clients have a crystal clear understanding of what they want.
- The requirements are significantly less likely to change during the execution of the project.
- The software product being developed is not complicated.
- The tools and technologies to be used for developing the software will not change dynamically.
- The resources required are predictable, and the resources are available to use.
Advantages of the Waterfall Model
Here are some advantages of the Waterfall model in software engineering:
- The model is very easy to understand and simple to implement.
- Each stage is very well defined. The start and end points are fixed, and there is no overlap.
- Process and results are well documented.
- It reinforces positive habits such as define-before-design and design-before-code.
- Progress is easy to track as the milestones are easily perceivable.
- Because of the model's rigidity, it is simple to manage. Each phase includes its own set of deliverables and a review process.
- The final cost and release date of the project can be determined in the beginning.
Disadvantages of the Waterfall Model
Now, let us look at some disadvantages of the waterfall model in software engineering:
- Working software is produced only towards the end of the life cycle.
- It cannot accommodate changing requirements.
- The waterfall model is not suitable for complex projects.
- There is no feedback system. As a waterfall, the model demonstrates the progression of software from one phase to the next. It is believed that no mistakes occur during the development process. As a result, it lacks any method for mistake correction.
- It does not allow overlapping phases, and this aspect may not be suitable for the real world because it may be beneficial to overlap the phases in terms of efficiency and costs.
- The classic Waterfall model is simple, linear, sequential, and rigid.
- This model works very well for small projects where requirements are very well understood and do not change frequently.
- This approach requires that all prior phases be finished before going on to the next, which is why it is rarely used for large software development projects.