Software Engineering: UNIT-2
Software Engineering: UNIT-2
Software Engineering: UNIT-2
UNIT-2
software product.
Several process models have been developed so far for the efficient
Software process
developers.
The simplest process model is the waterfall model, which states that
But all other life cycle models are essentially derived from the
Classical waterfall model divides the life cycle into the following
Design
The purpose of the coding and unit testing phase (sometimes called the
implementation phase) of software development is to translate the
software design into source code. Each component of the design is
implemented as a program module. The end-product of this phase is a set
of program modules that have been individually tested.
During this phase, each module is unit tested to determine the correct
working of all the individual modules. It involves testing each module in
isolation as this is the most efficient way to debug the errors identified at
this stage.
Integration and System Testing
The waterfall model, although widely used, has some strong limitations.
Some of the key limitations are:
1. It assumes that the requirements of a system can be frozen (i.e.,
baselined) before the design begins. This is possible for small systems.
But for large systems, determining the requirements is difficult as the
user does not even know the requirements.
2. Freezing the requirements usually requires choosing the hardware. A
large project might take few years to complete. If the hardware is selected
early, then due to the speed at which hardware technology is changing, it
is likely that the final software will use a hardware that becomes obsolete.
This is clearly not desirable for such expensive software systems.
3. It follows the “big bang” approach—the entire software is delivered in one
shot at the end. This entails heavy risks, as the user does not know until
the end what they are getting. Furthermore, if the project runs out of
money in the middle, then there will be no software. That is, it has the “all
or nothing” value proposition.
4. It encourages “requirements bloating”. Since all requirements must be
specified at the start, it encourages the users and other stakeholders to add
unnecessary requirements (which they think that they are needed but, may
not be used finally).
5. It is a document-driven process that requires formal documents at the
end of each phase.
When to use the Waterfall Model?
Requirements are well known and stable
Technology is understood
Development team have experience with similar projects
For small projects
2.2 Prototyping
Advantages
Provides a working model to the user early in the process, so, it increases
user's confidence.
The developer gains experience and insight by developing a prototype
that results better implementation of requirements.
The prototyping model serves to clarify requirements which are not
clear; hence, it reduces ambiguity and improves communication between
the developers and users.
There is a great involvement of users in software development. Hence,
the requirements of the users are met to the greatest extent.
Helps in reducing risks associated with the software.
Dis-Advantages
If the user is not satisfied by the developed prototype, then a new
prototype is developed. This process goes on until a perfect prototype is
developed. Thus, this model is time consuming and expensive.
The developer loses focus of the real purpose of prototype and hence, may
compromise with the quality of the software.
For eg, Developers may use some inefficient algorithms or inappropriate
programming languages while developing the prototype.
Prototyping can lead to false expectations.
For eg, a situation may be created where the user believes that the
development of the system is finished when it is not.
Where to Use Prototype Model?
The Iterative Development Process Model counters the third and fourth
limitations of the waterfall model and tries to combine the benefits of
both prototyping and the waterfall model.
The basic idea is that the software should be developed in increments,
each increment adding some functionality to the system until the full
system is implemented.
There are two approaches in iterative model.
The first approach called the iterative enhancement model works as
follows;
A simple initial implementation is done for a subset of requirements that
are assumed to be important for the customer.
A project control list is created that contains, in order, all the tasks
that must be performed to obtain the final implementation.
Each step consists of removing the next task from the list, designing the
implementation for the selected task, coding and testing the
implementation, and performing an analysis of the partial system obtained.
These three phases are called the design phase, implementation phase,
and analysis phase.
The process is iterated until the project control list is empty, at which
time the final implementation of the system will be available. The iterative
enhancement model is shown below.
Iterative Enhancement Model
In today’s world clients do not want to invest too much money without
seeing returns. The iterative model permits this after each iteration some
working software is delivered.
It reduces the rework.
It has no all-or-nothing risk.
New requirements can be added easily.
Dis-Advantages
Rational Unified Process (RUP) is another iterative process model that was
designed by Rational Software, now part of IBM.
It was primarily designed for object-oriented development.
In this, software development is divided into cycles where each cycle
consists of four phases;
Inception phase
Elaboration phase
Construction phase
Transition phase
Inception Phase
To overcome the shortcomings of the waterfall model of, Agile process
model was proposed in mid 1990s.
The agile model was primarily designed to help projects to adapt to
change requests.
Agile approaches are based on some common principles, some of
which are;
Working software is the key measure of progress in a project.
Software should be developed and delivered rapidly in small
increments.
Even late changes in the requirements should be entertained.
Face-to-face communication is preferred over documentation.
Continuous feedback and involvement of customer is necessary for
developing good-quality software.
Simple design which evolves and improves with time is a better approach
than doing an elaborate design for handling all possible scenarios.
The delivery dates are decided by empowered teams of talented
individuals.
Some popular agile methodologies are XP (Extreme Programming),Scrum,
Unified Process, Crystal, DSDM (Dynamic System Development Method) and
Lean.
Extreme Programming (XP) is an agile software development framework
that aims to produce higher quality software, and higher quality of life for the
development team.
Extreme programming (XP)
At a time, only one user story is planned, developed and tested using
acceptance testing.
An iteration may not add significant functionality but, still a new
developers.
Can be misinterpreted…
Difficult to get external review.
When project is complete, and team disperses, maintenance becomes
difficult.
XP, and other agile methods, are suitable for situations where the
volume and pace of requirements change is high, and where requirement
risks are considerable.
It works well when the customer is willing to involve heavily during
the entire development, working as a team member.
Assignment-Cum-Tutorial Questions