Chapter 2

SOFTWARE PROCESSES
A software process is a structured set of activities required to develop a software system.
It involves the following phases:-
 Specification
 Design
 Validation
 Evolution

Software Development Life Cycle Process (SDLC)

SDLC is a process which defines the various stages involved in the development of software for
delivering a high-quality product. SDLC stages cover the complete life cycle of a software i.e.
from inception to retirement of the product. Adhering to the SDLC process leads to the
development of the software in a systematic and disciplined manner.

Planning Stage:-
In any software development project, planning comes first. Before getting started, it is important
to make sure the project has enough people and financial backing. You can have the best idea in
the world, but if you don’t have people or money, moving forward will be a poor business
decision.
Feasibility study: - In feasibility analysis, your team ensures that the project requirements help
the end-user of the system.
Requirement Gathering and Analysis:-
During this phase, all the relevant information is collected from the customer to develop a
product as per their expectation. Any ambiguities must be resolved in this phase only. Business
analyst and Project Manager set up a meeting with the customer to gather all the information like
what the customer wants to build, who will be the end-user, what is the purpose of the product.
Before building a product a core understanding or knowledge of the product is very important.

For Example, A customer wants to have an application which involves money transactions. In
this case, the requirement has to be clear like what kind of transactions will be done, how it will
be done, in which currency it will be done, etc.

Design: - In this phase, the requirement gathered in the SRS document is used as an input and
software architecture that is used for implementing system development is derived.
Implementation or Coding: - Implementation/Coding starts once the developer gets the Design
document. The Software design is translated into source code. All the components of the
software are implemented in this phase.

Testing: - Testing starts once the coding is complete and the modules are released for testing. In
this phase, the developed software is tested thoroughly and any defects found are assigned to
developers to get them fixed. Retesting, regression testing is done until the point at which the
software is as per the customer’s expectation. Testers refer SRS document to make sure that the
software is as per the customer’s standard.

Deployment: - Once the product is tested, it is deployed in the production environment or

first UAT (User Acceptance testing) is done depending on the customer expectation.

In the case of UAT, a replica of the production environment is created and the customer along
with the developers does the testing. If the customer finds the application as expected, then sign
off is provided by the customer to go live.

Maintenance: - After the deployment of a product on the production environment, maintenance

of the product i.e. if any issue comes up and needs to be fixed or any enhancement is to be done
is taken care by the developers.

A software process model is an abstract representation of a process. It presents a description of

a process from some particular perspective.
Software process models (read yourself V-model, prototype model, bing Bang and Agile
model)
Waterfall and Spiral model are described below.
1. The waterfall model: - Separate and distinct phases of specification and development
2. Evolutionary development: - Specification and development are interleaved
3. Formal systems development: - A mathematical system model is formally transformed to an
implementation
4. Reuse-based development: - The system is assembled from existing components

The different phases in water fall model are:-

 Requirements analysis and definition
 System and software design
 Implementation and unit testing
 Integration and system testing
 Operation and maintenance
The drawback of the waterfall model is the difficulty of accommodating change after the process
is underway.
Waterfall model problems
 Inflexible partitioning of the project into distinct stages
 This makes it difficult to respond to changing customer requirements
This model is only appropriate when the requirements are well-understood.
Evolutionary development
There are 2 types:
1. Exploratory development
Objective is to work with customers and to evolve a final system from an initial outline
specification. Should start with well-understood requirements
2. Throw-away prototyping
Objective is to understand the system requirements. Should start with poorly understood
requirements

Problems:-
• Lack of process visibility
•Systems are often poorly structured
•Special skills (e.g. in languages for rapid prototyping) ma y be required
Applicability
•For small or medium-size interactive systems
•For parts of large systems (e.g. the user interface)
•For short-lifetime systems
Formal systems development
It is based on the transformation of a mathematical specification through different
representations to an executable program.
Transformations are correctness-preserving so it is straightforward to show that the program
conforms to its specification.
It is embodied in the Cleanroom approach to software development.

Problems
• Need for specialized skills and training to apply the technique
•Difficult to formally specify some aspects of the system such as the user interface
Applicability
•Critical systems especially those where a safety or security case must be made before the
system is put into operation
Process stages
•Component analysis
• Requirements modification
•System design with reuse
•Development and integration
This approach is becoming more important but still limited experience with it.
Process iteration
System requirements ALWAYS evolve in the course of a project so process iteration where
earlier stages are reworked is always part of the process for large systems.
Iteration can be applied to any of the generic process models.
Two (related) approaches:-
•Incremental development
•Spiral development
Incremental development:-
Rather than deliver the system as a single delivery, the development and delivery is broken
down into increments with each increment delivering part of the required functionality.
 User requirements are prioritized and the highest priority requirements are included in early
increments.
Once the development of an increment is started, the requirements are frozen though
requirements for later increments can continue to evolve.

Advantages
• Customer value can be delivered with each increment so system functionality is available
earlier
• Early increments act as a prototype to help elicit requirements for later increments
• Lower risk of overall project failure
• The highest priority system services tend to receive the most testing
Spiral development (Model)
The spiral model combines the idea of iterative development with the systematic, controlled
aspects of the waterfall model. This Spiral model is a combination of iterative development
process model and sequential linear development model i.e. the waterfall model with a very
high emphasis on risk analysis. It allows incremental releases of the product or incremental
refinement through each iteration around the spiral.

Figure 1: Spiral Model

Software Engineering Layers

Software engineering is a systematic approach used by professionals to develop complex software
end products within a specified time and budget. This approach is often viewed as layered. There
are four layers in general.
Tools: This layer contains automated or semi-automated tools that offer support for the

framework and the method each software engineering project will follow.

Method: This layer contains the methods, the technical knowledge and “how-tos” in order to

develop software.

Process: This layer consists of the framework that must be established for the effective delivery

of software.

A Quality Focus: This layer is the fundamental layer for software engineering. As stated above it

is of great importance to test the end product to see if it meets its specifications. Efficiency,

usability, maintenance and reusability are some of the requirements that need to be met by new

software.

Having Tools, Methods and Processes laid out from the beginning of any software engineering

process makes it an easier task for both developers and project managers to check the quality of

the end product and deliver a more complex software on time by staying on budget.
Prototype
The Software Prototyping refers to building software application prototypes which displays the
functionality of the product under development, but may not actually hold the exact logic of the
original software.
Software prototyping is becoming very popular as a software development model, as it enables
to understand customer requirements at an early stage of development. It helps get valuable
feedback from the customer and helps software designers and developers understand about what
exactly is expected from the product under development.

What is Software Prototyping?

Prototype is a working model of software with some limited functionality. The prototype does
not always hold the exact logic used in the actual software application and is an extra effort to be
considered under effort estimation.
Prototyping is used to allow the users evaluate developer proposals and try them out before
implementation. It also helps understand the requirements which are user specific and may not
have been considered by the developer during product design.
Following is a stepwise approach explained to design a software prototype.

Basic Requirement Identification

This step involves understanding the very basics product requirements especially in terms of user
interface. The more intricate details of the internal design and external aspects like performance
and security can be ignored at this stage.

Developing the initial Prototype

The initial Prototype is developed in this stage, where the very basic requirements are showcased
and user interfaces are provided. These features may not exactly work in the same manner
internally in the actual software developed. While, the workarounds are used to give the same
look and feel to the customer in the prototype developed.
The prototype developed is then presented to the customer and the other important stakeholders
in the project. The feedback is collected in an organized manner and used for further
enhancements in the product under development.
The feedback and the review comments are discussed during this stage and some negotiations
happen with the customer based on factors like – time and budget constraints and technical
feasibility of the actual implementation. The changes accepted are again incorporated in the new
Prototype developed and the cycle repeats until the customer expectations are met.
Prototypes can have horizontal or vertical dimensions. A Horizontal prototype displays the user
interface for the product and gives a broader view of the entire system, without concentrating on
internal functions. A Vertical prototype on the other side is a detailed elaboration of a specific
function or a sub system in the product.
The purpose of both horizontal and vertical prototype is different. Horizontal prototypes are used
to get more information on the user interface level and the business requirements. It can even be
presented in the sales demos to get business in the market. Vertical prototypes are technical in
nature and are used to get details of the exact functioning of the sub systems. For example,
database requirements, interaction and data processing loads in a given sub system.

Types of Software Prototyping

There are different types of software prototypes used in the industry. Following are the major
software prototyping types used widely −

Throwaway/Rapid Prototyping

Throwaway prototyping is also called as rapid or close ended prototyping. This type of
prototyping uses very little efforts with minimum requirement analysis to build a prototype. Once
the actual requirements are understood, the prototype is discarded and the actual system is
developed with a much clear understanding of user requirements.

Evolutionary Prototyping

Evolutionary prototyping also called as breadboard prototyping is based on building actual

functional prototypes with minimal functionality in the beginning. The prototype developed
forms the heart of the future prototypes on top of which the entire system is built. By using
evolutionary prototyping, the well-understood requirements are included in the prototype and the
requirements are added as and when they are understood.

Incremental Prototyping

Incremental prototyping refers to building multiple functional prototypes of the various sub-
systems and then integrating all the available prototypes to form a complete system.

Extreme Prototyping

Extreme prototyping is used in the web development domain. It consists of three sequential
phases. First, a basic prototype with all the existing pages is presented in the HTML format. Then
the data processing is simulated using a prototype services layer. Finally, the services are
implemented and integrated to the final prototype. This process is called Extreme Prototyping
used to draw attention to the second phase of the process, where a fully functional UI is developed
with very little regard to the actual services.

Software Prototyping - Application

Software Prototyping is most useful in development of systems having high level of user
interactions such as online systems. Systems which need users to fill out forms or go through
various screens before data is processed can use prototyping very effectively to give the exact
look and feel even before the actual software is developed.
Software that involves too much of data processing and most of the functionality is internal with
very little user interface does not usually benefit from prototyping. Prototype development could
be an extra overhead in such projects and may need lot of extra efforts.

Software Prototyping - Pros and Cons

Software prototyping is used in typical cases and the decision should be taken very carefully so
that the efforts spent in building the prototype add considerable value to the final software
developed. The model has its own pros and cons discussed as follows.
The advantages of the Prototyping Model are as follows −
 Increased user involvement in the product even before its implementation.
 Since a working model of the system is displayed, the users get a better understanding of
the system being developed.
 Reduces time and cost as the defects can be detected much earlier.
 Quicker user feedback is available leading to better solutions.
 Missing functionality can be identified easily.
 Confusing or difficult functions can be identified.
The Disadvantages of the Prototyping Model are as follows −
 Risk of insufficient requirement analysis owing to too much dependency on the prototype.
 Users may get confused in the prototypes and actual systems.
 Practically, this methodology may increase the complexity of the system as scope of the
system may expand beyond original plans.
 Developers may try to reuse the existing prototypes to build the actual system, even when
it is not technically feasible.
 The effort invested in building prototypes may be too much if it is not monitored properly.