Generic Software Process Model:The waterfall model

A software process is a set of activities that leads to the production of a software product. These activities may involve the development of software from scratch in a standard programming language like JAVA or C.  A software process model is an abstract representation of a software process. Each process model represents a process from a particular perspective, and thus provides only partial information about that process.

            The generic software process models are not definitive descriptions of software processes. Rather, they are abstractions of the process that can be used to explain different approaches to software development. We can think of them as process frameworks that may be extended and adapted to create more specific software engineering processes.

1.      The waterfall model
This takes the fundamental process activities of specification, development, validation and evolution and represents them as separate process phases such as requirements specification, software design, implementation, testing and so on.

Fig: Waterfall Model

The waterfall model derives its name due to the cascading effect from one phase to the. In this model each phase well defined starting and ending point, with identifiable deliveries to the next phase. This model is sometimes referred to as the linear sequential model or the software life cycle.

The model consists of six distinct stages, namely:

1.1     In the requirements definitions phase:

(a)    The problem is specified along with the desired service objectives (goals)

(b)   The constraints are identified

They are then defined in detail and serve as a system specification.

            1.2 System & Software design phase:

The system design process partitions the requirements to either hardware or software systems. It establishes overall system architecture. Software design involves identifying and describing the fundamental software system abstractions and their relationships.

            1.3 Implementation and unit testing phase:

In this stage, the software design is realized as a set of programs or program units. Unit testing involves verifying that each unit meets its specification.

            1.4 Integration and system testing phase:

The individual program units or programs are integrated and tested as a complete system to ensure that the software requirements have been met. After testing, the software system is delivered to the customer.

            1.5 Operation and maintenance phase:

This is the longest phase. The system is installed and put into practical use. Maintenance involves correcting errors which were not discovered in earlier stages of the life cycle, improving the implementation of system units and enhancing the system's services as new requirements are discovered.

The Waterfall method is expensive and is very time consuming because it was designed to minimize the use of very expensive computing resources. The Waterfall model describes a process of stepwise refinement.  It is widely used in military and aerospace industries.

            Advantages

·        Testing is inherent to every phase of the waterfall model

·        It is an enforced disciplined approach

·        It is documentation driven, that is, documentation is produced at every stage

 

 Disadvantages

  The waterfall model is the oldest and the most widely used paradigm. However, many projects rarely follow its sequential flow. This is due to the inherent problems associated with its rigid format. Namely:

·        It only incorporates iteration indirectly, thus changes may cause considerable confusion as the project progresses. 

·        As The client usually only has a vague idea of exactly what is required from the software product, this WM has difficulty accommodating the natural uncertainty that exists at the beginning of the project.

·        The customer only sees a working version of the product after it has been coded. This may result in disaster any undetected problems are precipitated to this stage.

·        Inflexible partioning of the project into distinct stages makes it difficult to respond to changing customer requirements.

·    Only appropriate when the requirements are well-understood and changes will be fairly limited during the design process.

·        Mostly used for large systems engineering projects where a system is developed at several sites.