The Waterfall Model is the most well known software lifecycle development model. The waterfall model was given its name because the effort cascades down a single line of steps that many view as the essential components of the software development. It is also called as "Classical Lifecycle" or the "Linear Sequential Model,” which suggests a systematic, sequential approach to software development.
The first formal description of the waterfall model through a paper was published in 1970 by Winston Royce. The Waterfall model originated from highly structured sequential software development process that progresses through various software design and development phases in linear order. The model recommends total and correct completion and documentation of each phase before moving on to the next. As such, it emphasizes that requirements are frozen and the design phase is complete before proceeding to the coding phase. This saves time and effort in the construction, integration and testing phases of the software development process and reduces the risk of schedule slippage and cost overruns.
Like in a waterfall, the water progressively falls from one altitude to the lower, in a similar way, the production cycle progresses sequentially, from one stage to the other (illustrated by a waterfall model diagram).
Waterfall Model Phases
The waterfall model phases of software development are as follows:
1. Software Requirement Specifications
2. Software Design.
3. Implementation / Coding
4. Integration and System Testing.
5. Operation and Maintenance.
1. SRS (Software Requirement Specifications):
This is the most crucial phase for the whole project. All requirements of the system which has to be developed are collected in this step. The project team chalks out the functionality and limitations (if there are any) of the software they are developing in detail. The document which contains all this information is called SRS.
2. System Design and Software Design:
Using SRS as input, system design is done. System Design is important because it describes what is going to get developed in the next phase. It is assured that risk factor is very high in a project where there is poor design or no design. System design included designing of software and hardware i.e. functionality of hardware and software is separated out. After separation design of software modules is done, the design process translates requirements into representation of the software that can be assessed for quality before generation of code begins. At the same time test plan is prepared, test plan describes the various tests which will be carried out on the system after completion of development.
3. Implementation and Unit testing:
It refers to the realization of business requirements and design specifications into a concrete executable program, database, website, or software component through programming and deployment. This phase is where the real code is written and compiled into an operational application, and where the database and text files are created. Software modules are now further divided into units. A unit is a logically separable part of the software. Testing of units can be done separately. In this phase unit testing is done by the developer itself, to ensure that there are no defects.
4. Integration and System Testing:
Now the units of the software are integrated together and a system is built. So we have complete software at hand which is tested to check if it meets the functional and performance requirements of the customer. Testing is done, as per the steps defined in the test plan, to ensure defined input produces actual results which agree with the required results. A test report is generated which contains test results. After successfully integration including the related tests, the complete system has to be tested against its initial requirements. This will include the original hardware and environment, whereas the previous integration and testing phase may still be performed in a different environment or on a test bench.
5. Operation and Maintenance:
It is the process of modifying a software solution after delivery and deployment to refine output, correct errors, and improve performance and quality. The maintenance phase ensures that the software or system works as intended. For modern project teams, this phase can become a project of its own based on the development contract terms with the customer. The system is handed over to the customer and will be used the first time by him. Naturally the customer will check if his requirements were implemented as expected but he will also validate if the correct requirements have been set up in the beginning. This phase goes on till the software is retired.
Advantages of the Waterfall Model
• A waterfall model is easy to follow.
• A waterfall model helps to find problems earlier on which can cost a business less than if it was found later on.
• It allows for departmentalization and managerial control.
• Easy to manage due to the rigidity of the model – each phase has specific deliverables and a review process.
• Stable project requirements.
• As everything is documented, a new team member can easily understand what's to be done.
• Works well for smaller projects where requirements are very well understood.
• Each phase of development proceeds in strict order.
Disadvantages of the Waterfall Model
• Time consuming.
• If requirements may change the Waterfall model may not work.
• There is not much room for iterative development or revisions to take place. As a result, once an application reaches the testing stage, it can be very cost prohibitive for project teams to revisit earlier stages of the development process.
• Software is delivered late in project, delays discovery of serious errors.
• Difficult to estimate time and cost for each stage of the development process.
Waterfall software development model may be applicable to projects where:
• Software requirements clearly defined and known.
• Development projects, which involve development of new products or major enhancements to existing software products.
• New version of the existing software system is created.
• Development of programs those are already stable. That is, their design does not need a major makeover. In situations where the designers of software can accurately predict the flaws that may arise can be developed through a waterfall model.