CSC/ECE 517 Fall 2012/ch2a 2w2 ab
The Waterfall Model
The linear sequential process of software development described by Winston W. Royce in 1970 is popularly known as the Waterfall Model of Software Development. Also referred to as the classic life cycle, the linear sequential model presents a systematic approach that is based on progression from one stage to another namely requirement analysis, design, implementation, testing and finally support. Even after the adaptation of many new methodologies such as prototyping and agile, the classic approach presents a very strong case for scenarios where the requirements are fixed and generally helps in understanding the evolution of software engineering processes. The approach is very similar to one followed in many other engineering disciplines such as manufacturing and construction.
Analysis and Requirement Gathering
This is the first and foremost phase in the Waterfall model or Linear Sequential Model for Software Development. This phase includes meeting with the customer and gathering all requirements specific to the project. This can be considered as the most important phase of the model, because if there is any misinterpretation during this phase then it can lead to validation issues later. The gathered requirements have to be unambiguous. Gathering the correct requirements is very important so that the customer is satisfied with the final product that is built[1]. This stage basically deals with gathering both the functional and the non functional requirements of the project. Functional requirements are those requirements which are the actual features for which the project is being made. Non-functional requirements are those implicit requirements that all the projects are expected to have such as Scalability, Maintainability etc. The Waterfall model works very closely with deliverables. Hence, the deliverables that this stage produces is Software requirement specification(SRS), Acceptance Test Plan and the System Test Plan. After the requirements are collected accurately, we move on to the next phase which is the Design phase.
Design
Designing a software is a process of deriving at the high level solution of the problem that the software aims to solve.The design considers the requirements gathered from in the Requirement analysis phase and build a solution based on the given constraints. The design encompasses the definition of the basic properties of the software solution such as data structures, software architecture, interface representations and algorithmic detail. All the elements of the solution are described along with the relationship among them. Software re-use decisions are also taken at this stage. If some components are eligible for reuse they must be described and incorporated in the design. The deliverable of this phase consists of the High Level Design Document (HLD), the Detailed Design Documents (DLD) along with unit test cases and integration tests. The HLD gives an overview of the system and its various components. A separate DLD is made for all such individual components detailing the design considerations for each. Test cases are also written in the design phase so that the verification and validation of the design can be done on the implementation of the solution.
Implementation
This is the third phase in the waterfall model. After we have a thorough design phase, we can go ahead with the implementation phase. In this phase the design is converted into machine readable form. Actual coding is done in this phase and Programs are created. If Design is done sufficiently then implementation can be done with a greater degree of accuracy. In this phase we divide the Software Module into individual units. A unit is a logically separable part of the software. In this phase, along with the code generation part, Unit testing of individual units is also carried out. Unit testing is performed by the developer itself [2], as he is the best person who knows the code and can judge it whether it is meeting the specification or not. The deliverable that we get at the end of this phase is a Unit Tested Code.
Testing
Most of the unit testing is done by the programmers while coding their individual components. In the testing phase, the integration and system testing is carried out. The integration tests focus on the interoperability of the independently developed components of the software. The primary focus is on making sure that they are able to function together. Once that is done, the system testing is carried out. The test cases and plans are based on the System Requirement Specification (SRS).Here the software is tested against the originally expected requirements and behaviors. Whenever an expectation is not met, a flaw is recorded. System testing includes the validation of the software based on parameters such as usability, security, accessibility and reliability. The functional and non-functional requirements must be tested and the focus is on uncovering maximum numbers of errors and bugs before the system is handed over the customer.
Deployment and Support
This is the final phase of the Waterfall model. When we reach this phase, we already have a completely functioning and fully tested system on our hand. What needs to be done in this phase is that we need to install the system on the user’s environment. After it is successfully installed, we need to train the customer on how to use the system. After the customer is satisfied with the system, we need to take the approval that the project is officially complete and it is meeting all the requirements that were made in the first phase of the model. In terms of deliverable for this phase, we have to generate a user manual for the user which he can refer if he has any problem understanding the system. This phase does not end here. If in future the customer has some problems with the system, then it is the responsibility of the developers to get the system up and running if it is down due to some errors. The errors can be introduced due to many reasons. Some of which can be exceptions in the embedded software, or changes in the external environment in which it was deployed or even if the customer wants some additional features in the system.