The Waterfall Model was the primary Process Model to be introduced. It is very simple to understand and use. In Waterfall, each phase must be completed before the subsequent phase can begin and there’s no overlapping within the phases. The waterfall model is the earliest SDLC approach that was used for software development.
In the “The Waterfall” approach, the entire process of software development is split into separate phases. The outcome of 1 phase acts because of the input for the subsequent phase sequentially. This means that any introduce the event process begins as long as the previous phase is complete. The waterfall model may be a sequential design process during which progress is seen as flowing steadily downwards (like a waterfall) through the phases of Conception, Initiation, Analysis, Design, Construction, Testing, Production/Implementation, and Maintenance.
As the Waterfall Model illustrates the software development process during a linear sequential flow; hence it’s also mentioned as a Linear-Sequential Life Cycle Model. The waterfall model is the basic software development life cycle model. It is very simple but idealistic. Earlier this model was very fashionable but nowadays it’s not used. But it’s vital because all the opposite software development life cycle models are supported by the classical waterfall model.
The classical waterfall model divides the life cycle into a group of phases. This model considers that one phase is often started after completion of the previous phase. That is the output of 1 phase is going to be the input to the subsequent phase. Thus the event process is often considered as a sequential flow within the waterfall. Here the phases don’t overlap with one another.
The waterfall model was introduced by Winston Royce introduced in 1970. This model has five phases: Requirements analysis and specification, design, implementation, and unit testing, integration and system testing, and operation and maintenance. The steps always follow during this order and don’t overlap. The developer must complete every phase before the subsequent phase begins. This model is known as the “Waterfall Model” because its diagrammatic representation resembles a cascade of waterfalls.
Phases of the model:
1. Feasibility Study:
The main goal of this phase is to work out whether it might be financially and technically feasible to develop the software. The feasibility study involves understanding the matter then determine the varied possible strategies to unravel the matter. These different identified solutions are analyzed supported their benefits and disadvantages, the simplest solution is chosen and every one the opposite phases are administered as per this solution strategy.
2. Requirements analysis and specification:
The aim of the need analysis and specification phase is to know the precise requirements of the customer and document them properly. This phase consists of two different activities.
• Requirement gathering and analysis:
Firstly all the wants regarding the software are gathered from the customer then the gathered requirements are analyzed. The goal of the analysis part is to get rid of incompleteness (an incomplete requirement is one during which some parts of the particular requirements are omitted) and inconsistencies (inconsistent requirement is one during which some a part of the need contradicts with another part).
• Requirement specification:
During this first phase, the potential requirements of the appliance are methodically analyzed and written down during a specification document that is the idea for all future development. The result’s typically a requirements document that defines what the appliance should do, but not how it should roll in the hay. These analyzed requirements are documented during a software requirement specification (SRS) document. SRS document is a contract between the development team and customers. Any future dispute between the purchasers and therefore the developers are often settled by examining the SRS document.
This stage largely covers technical design requirements, like programing language, data layers, services, etc. A design specification will typically be created that outlines how precisely the business logic covered in the analysis is going to be technically implemented. The aim of the planning phase is to rework the wants laid out in the SRS document into a structure that’s suitable for implementation in some programing language.
4. Coding and Unit testing:
In coding phase software design is translated into an ASCII text file using any suitable programing language. Thus each designed module is coded. The aim of the unit testing phase is to see whether each module is functioning properly or not. The actual ASCII text file is finally written during this fourth stage, implementing all models, business logic, and repair integrations that were laid out in the prior stages.
The integration of various modules is undertaken soon after they need to be been coded and unit tested. The integration of varied modules is administered incrementally over a variety of steps. During each integration step, previously planned modules are added to the partially integrated system and therefore the resultant system is tested. Finally, in any case, the modules are successfully integrated and tested, the complete working system is obtained and system testing is administered on this.
System testing consists of three different sorts of testing activities as described below:
Alpha testing: Alpha testing is that the system testing performed by the event team.
Beta testing: Beta testing is that the system testing performed by a friendly set of consumers.
Acceptance testing: After the software has been delivered, the customer performed the acceptance testing to work out whether to simply accept the delivered software or to reject it.
Maintenance is the most vital phase of a software life cycle. The effort spent on maintenance is that 60% of the entire effort spent to develop full software.
There are basically three types of maintenance:
• Corrective Maintenance: This type of maintenance is carried out to correct errors that were not discovered during the product development phase.
• Perfective Maintenance: This type of maintenance is carried out to enhance the functionalities of the system based on the customer’s request.
• Adaptive Maintenance: Adaptive maintenance is usually required for porting the software to work in a new environment such as work on a new computer platform or with a new operating system.
Waterfall Model Application:
Every software developed is different and requires an appropriate SDLC approach to be followed supported the interior and external factors.
Some situations where the utilization of the Waterfall model is most appropriate are;
• Requirements are very well documented, clear and fixed.
• The Product definition is stable.
• Technology is understood and is not dynamic.
• There are no ambiguous requirements.
• Ample resources with the required expertise are available to support the product.
• The project is short.
The Advantages of the Waterfall Model:
While the waterfall model has seen a slow phasing call in recent years in favor of more agile methods, it can still provide a variety of advantages, particularly for larger projects and organizations that need the stringent stages and deadlines available within these cool, cascading waters.
• Adapts to Shifting Teams:
While not necessarily specific to the waterfall model only, employing a waterfall method does allow the project as an entire to take care of a more detailed, robust scope and style structure due to all the upfront planning and documentation stages. This is particularly compatible with large teams that will see members come and go throughout the life cycle of the project, allowing the burden of design to be placed on the core documentation and fewer on a person team member.
• Forces Structured Organization:
While some may argue this is a burden rather than a benefit, the fact remains that the waterfall model forces the project, and even the organization building said project, to be extraordinarily disciplined in its design and structure. Most sizable projects will, by necessity, include detailed procedures to manage every aspect of the project, from design and development to testing and implementation.
• Allows for Early Design Changes:
While it is often difficult to form design changes later within the process, the waterfall approach lends itself well to alterations early within the life cycle. This is great when fleshing out the specification documents within the first couple stages with the event team and clients, as alterations are often made immediately and with minimal effort, since no coding or implementation has actually taken place up thereto point.
• Suited for Milestone-Focused Development:
Due to the inherent linear structure of a waterfall project, such applications are always well-suited for organizations or teams that employ well under a milestone- and data-focused paradigm. With clear, concrete, and well-understood stages that everybody on the team can understand and steel oneself against, it’s relatively simple to develop a timeline for the whole process and assign particular markers and milestones for every stage and even completion. This isn’t to suggest software development isn’t often rife with delays (since it is), but the waterfall is befitting the type of project that needs deadlines.
The Disadvantages of the Waterfall Model:
While some things in software development never really change, many others often fall by the wayside. While Dr. Royce’s initial proposal of what’s now referred to as the waterfall model was groundbreaking when first published back in 1970, over four decades later, a variety of cracks are showing within the armor of this once heralded model.
• Non-adaptive Design Constraints:
While arguably an entire book might be written on this subject alone, the foremost damning aspect of the waterfall model is its inherent lack of adaptability across all stages of the development life cycle. When a test in stage five reveals a fundamental flaw within the design of the system, it not only requires a dramatic leap backward piecemeal of the method but in some cases, is often causing a devastating realization regarding the legitimacy of the whole system. While most experienced teams and developers would (rightfully) argue that such revelations shouldn’t occur if the system was properly designed within the first place, not every possibility is often accounted for, especially when stages are so often delayed until the top of the method.
• Ignores Mid-Process User/Client Feedback:
Due to the strict step-by-step process that the waterfall model enforces, another particularly difficult issue to urge around is that user or client feedback that’s provided late into the development cycle can often be insufficient, too late. While project managers can obviously enforce a process to step back to a previous stage thanks to an unforeseen requirement or change coming from a client, it’ll be both costly and time-consuming, for both the development team and the client.
• Delayed Testing Period:
While most of the more modern SDLC models attempt to integrate testing as a fundamental and always-present process throughout development, the waterfall model largely shies away from testing until quite late into the life cycle. This not only means that most bugs or even design issues won’t be discovered until very late into the process, but it also encourages lackadaisical coding practices since testing is only an afterthought.
Some more specific takes on SDLC include:
- Rapid Application Development
- Iterative Model
- Agile Model
- Big Bang Model V-Model
- Spiral Model
1. Iterative model:
The iterative process starts with easy implementation of a subset of the software requirements and iteratively enhances the evolving versions until the complete system is implemented. At each iteration, design modifications are made and new functional capabilities are added. The basic idea behind this method is to develop a system through repeated cycles (iterative) and in smaller portions at a time (incremental).
2. Spiral model:
The spiral model has four phases. A software project repeatedly passes through these phases in iterations called Spirals.
- Constructor build
3. Big bang model:
The Big Bang model is an SDLC model where we don’t follow any specific process. The development just starts with the specified money and efforts because the input, and therefore the output is that the software developed which can or might not be as per customer requirement. This explosion Model doesn’t follow a process/procedure and there’s really little planning required. Even the customer isn’t sure about what exactly he wants and therefore the requirements are implemented on the fly without much analysis.
4. Agile model:
Agile SDLC model may be a combination of iterative and incremental process models with specializing in process adaptability and customer satisfaction by rapid delivery of working software package. Agile Methods break the merchandise into small incremental builds. These builds are provided in iterations. Each iteration typically lasts from about one to 3 weeks. Every iteration involves cross-functional teams working simultaneously on various areas like;
- Requirements Analysis
- Unit Testing and
- Acceptance Testing
5. Rapid application development:
The RAD (Rapid Application Development) model is predicated on prototyping and iterative development with no specific planning involved. The process of writing the software itself involves the design required for developing the merchandise.
Rapid Application Development focuses on gathering customer requirements through workshops or focus groups, early testing of the prototypes by the customer using the iterative concept, reuse of the prevailing prototypes (components), continuous integration and rapid delivery.