SE

UNIT 1

Introduction to Software Engineering & its

history, Software Development Life Cycles

1.1 Software Engineering and its history

Software engineering works with a variety of software production

methods. It accompanies software product development using
well-defined scientific principles, methods and processes. The
result of software engineering is an efficient and reliable software
product.

The term software engineering is coined with the addition of

'software + Engineering'.

Software is more than just program code. The program is a usable

code, which serves a specific calculation purpose. Software is
considered a collection of effective editing code, compatible
libraries and texts. Software, when required for a specific
purpose, is called product software.

Engineering, on the other hand, is about making products, using

well-defined scientific principles and methods.

There are some definitions of software engineering provided by

some famous authors:

(1) The use of a systematic, directed, unparalleled approach to

software development, operation and maintenance; that is, the
use of engineering in software. [By IEEE]

(2) German computer scientist Fritz Bauer described software

engineering as: “Software engineering is the development and
application of sound engineering principles to provide reliable and
efficient software for real machines”

1.2 Software crisis & Evolution of Programming System

Product
The difficulty of writing the code for a computer program which is
correct and understandable is referred to as software crisis. The
term software crisis revolves around three concepts: complexity,
change and the expectations. This term was given by F. L. Bauer
at the first NATO Software Engineering Conference in 1968 at
Garmisch, Germany. Current System design approach is
exceedingly empirical. It is unable to cope with increasing
systems complexity. A number of problems in software
development were identified in 1960s, 1970s, and 1980s. The
problems that software projects encountered were: the projects
ran over-budget, caused damage to property even to life. Despite
our rapid progress, the software industry is considered by many
to be in a crisis. Some 40 years ago, the term “Software Crisis”
emerged to describe the software industry’s inability to provide
customers with high quality products on schedule.

“The major cause of the software crisis is] that the machines have
become several orders of magnitude more powerful! To put it
quite bluntly: as long as there were no machines, programming
was no problem at all; when we had a few weak computers,
programming became a mild problem, and now we have gigantic
computers, programming has become an equally gigantic
problem.” – Edsger Dijkstra
Software Evolution is a term which refers to the process of
developing software initially, then timely updating it for various
reasons, i.e., to add new features or to remove obsolete
functionalities etc. The evolution process includes fundamental
activities of change analysis, release planning, system
implementation and releasing a system to customers.

The cost an impact of these changes are accessed to see how

much system is affected by the change and how much it might
cost to implement the change. If the proposed changes are
accepted, a new release of the software system is planned.
During release planning, all the proposed changes (fault repair,
adaptation, and new functionality) are considered.

A design is then made on which changes to implement in the next

version of the system. The process of change implementation is
an iteration of the development process where the revisions to
the system are designed, implemented and tested.

Laws used for Software Evolution:

 Law of continuing change:

This law states that any software system that represents some
real-world reality undergoes continuous change or become
progressively less useful in that environment.
 Law of increasing complexity:
As an evolving program changes, its structure becomes more
complex unless effective efforts are made to avoid this
phenomenon.
 Law of conservation of organization stability:
Over the lifetime of a program, the rate of development of that
program is approximately constant and independent of the
resource devoted to system development.
 Law of conservation of familiarity:
This law states that during the active lifetime of the program,
changes made in the successive release are almost constant.

1.3 Characteristics of Software and some Software Myth

Software is treated as a good software by the means of different

factors. A software product is concluded as a good software by
what it offers and how well it can be used. The factors that decide
the software properties are divided into three categories:
Operational, Transitional, and Maintenance. These are explained
as following below.
1. Operational:
In operational categories, the factors that decide the software
performance in operations. It can be measured on:
 Budget Functionality
 Usability Dependability
 Efficiency Security
 Correctness Safety

2. Transitional:
When the software is moved from one platform to another, the
factors deciding the software quality:
 Portability
 Interoperability
 Reusability
 Adaptability

3. Maintenance:
In this categories all factors are included that describes about
how well a software has the capabilities to maintain itself in the
ever changing environment:
 Modularity
 Maintainability
 Flexibility
 Scalability

Myths About Software Development

There are many myths and false assumptions that continue to

loom around software development. Even though the first
programming language, Fortran, was created in 1957 and the
World Wide Web has eclipsed the quarter-century mark, software
development is still viewed as some sort of dark magic, thus
making people hesitant to embrace new technology. There are
also lots of myths out there which prevent us from fully
comprehending how business processes can be automated or
improved by top quality programming which can lead to
significant time and cost savings.
 Software Development Comes with a Hefty Price Tag

It is because of this myth companies do not harness the potential

that custom software can provide which can improve their
organization’s efficiency. Instead, they opt for purchasing some
“one size fits all” solution which, of course, doesn’t fit their
requirements and they have to find other means to work around
it.

2. Users Have No Idea what they Know what they Want

Even though there conversely exists a myth that customers have

no idea what they want until you show them, regardless, software
companies need to be both product oriented and customer
oriented as long as they consider the speed of delivery to be
important. Wise businesses don’t simply focus on creating a top-
notch, most innovative product on the market, but they also
strive to deliver the best solution to the consumer, that provides
market success. Doing no market research and not listening to
your customers is simply not an option

3. The Waterfall Method Still Works

You would be amazed at the number of people who still believe

that a system can be specified in detail, before you even build it.
Not only is this almost impossible, but it is also inefficient to
execute the development process in a sequence.

4. The More, the Merrier

Unfortunately, a myth exists that adding people to a development
team makes it better and speeds up delivery. However, adding
more people to a project tends to prolong the project’s timeframe
and causes friction due to issues in training and collaboration.
5. Software Development has a Fixed Cost and Strict Timeframe
Going back to the Waterfall approach, it is simply not possible to
detail out the software before building it. Even though a lot of
companies are lured in by the fixed price model, they must also
remember that there are some hidden costs associated with it in
terms of quality and additional costs incurred as the project goes
beyond the projected time boundaries.
6. When the Software is Released, the Projects is Over
As soon as the product is released, the focus should be on
receiving feedback from the users and incorporating this
feedback into an iterative approach back into the product. There
needs to be an ongoing process of improvement and revisions
along with testing for bugs in order to provide the customer with
the best quality product.
7. A Requirement of Agile is that Product Owners and Developers
Work in a Single Location
Thanks to modern communication technology, distributed teams
can use collaborative tools such as e-mail, shared calendars,
instant messengers, screen sharing, audio and video conferencing
and many others to work together and stay up to date.
8. Outsourcing Solves Everything
Plain old outsourcing can create a far worse problem than you
initially had. Software vendors should start thinking about
establishing long-term relationships and engaging in a dedicated
team model instead of fixed cost projects which lead to
incomplete deliverables, frustration and high overhead costs.

1.4 Software Development Life Cycles

A software life cycle model (also termed process model) is a

pictorial and diagrammatic representation of the software life
cycle. A life cycle model represents all the methods required to
make a software product transit through its life cycle stages. It
also captures the structure in which these methods are to be
undertaken.
 SDLC Cycle:
 requirements
 design
 implementation
 testing
 deployment
 operations
 maintenance

Software Development Process

The Code-and-Fix model

Code and fix model are another level ahead of the Big-Bang
model. Identifies the product to be tested before release.

The testing team detects bugs and sends software to fix it.
Bringing in the repair editors complete the installation of
certain codes and send the software again for testing. This
process is repeated until bugs are found in it, at an acceptable
level.
 Advantages of Code-and-fix model

This model is suitable for small projects.

It needs less project planning.

Disadvantages of Code-and-fix model

It is difficult to accommodate changes.

It is not clear what will be delivered and when.

It is difficult to assess quality.

The Waterfall model,

Winston Royce introduced the Waterfall Model in 1970. This

model has five phases: needs analysis and specification,
construction, implementation, and evaluation of units,
integration and system evaluation, and implementation and
maintenance. The steps always follow this way and are not
consistent. The developer must complete all stages before the
start of the next phase. This model is called the "Waterfall
Model", because its graphic representation is similar to the fall
of a waterfall.
 Requirements analysis and specification phase: The aim of this
phase is to understand the exact requirements of the customer
and to document them properly. It describes the "what" of the
system to be produced and not "how. “In this phase, a large
document called Software Requirement Specification
(SRS) document is created which contained a detailed description
of what the system will do in the common language.
 Design Phase: This phase aims to transform the requirements
gathered in the SRS into a suitable form which permits further
coding in a programming language. It defines the overall software
architecture together with high level and detailed design. All this
work is documented as a Software Design Document (SDD).
 Implementation and unit testing: During this phase, design is
implemented. If the SDD is complete, the implementation or
coding phase proceeds smoothly, because all the information
needed by software developers is contained in the SDD.
 Integration and System Testing: This phase is highly crucial as
the quality of the end product is determined by the effectiveness
of the testing carried out. However, in this phase, the modules are
tested for their interactions with each other and with the system.
 Operation and maintenance phase: Maintenance is the task
performed by every user once the software has been delivered to
the customer, installed, and operational.

Advantages of Waterfall model

This model is simple to implement also the number of resources

that are required for it is minimal.

The requirements are simple and explicitly declared; they remain

unchanged during the entire project development.

The start and end points for each phase is fixed, which makes it
easy to cover progress.

The release date for the complete product, as well as its final
cost, can be determined before development.

It gives easy to control and clarity for the customer due to a strict
reporting system.

Disadvantages of Waterfall model

In this model, the risk factor is higher, so this model is not

suitable for more significant and complex projects.

This model cannot accept the changes in requirements during

development.

It becomes tough to go back to the phase. For example, if the

application has now shifted to the coding phase, and there is a
change in requirement, it becomes tough to go back and change
it.

Since the testing done at a later stage, it does not allow

identifying the challenges and risks in the earlier phase, so the
risk reduction strategy is difficult to prepare.

The Incremental Implementation

An Incremental model is a software development process

where the requirements are divided into multiple independent
software cycle modules. In this model, each module goes
through the stages of need, construction, implementation and
testing. All subsequent release of the module can add function
to the previous release. The process continues until a complete
plan is found.

The various phases of incremental model are as follows:

 Requirement analysis: In the first phase of the incremental
model, the product analysis expertise identifies the requirements.
And the system functional requirements are understood by the
requirement analysis team. To develop the software under the
incremental model, this phase performs a crucial role.
 Design & Development: In this phase of the Incremental
model of SDLC, the design of the system functionality and the
development method are finished with success. When software
develops new practicality, the incremental model uses style and
development phase
 Testing: In the incremental model, the testing phase checks
the performance of each existing function as well as additional
functionality. In the testing phase, the various methods are used
to test the behaviour of each task.
 Implementation: Implementation phase enables the coding
phase of the development system. It involves the final coding that
design in the designing and development phase and tests the
functionality in the testing phase. After completion of this phase,
the number of the product working is enhanced and upgraded up
to the final system product.

Prototype Model
The model of software development where after each iteration
prototype is shown to the customer for evaluation.

Steps of Prototype Model

Requirement Gathering and Analyst

Quick Decision

Build a Prototype

User Evaluation

Prototype Refinement

Engineer Product

Advantage of Prototype Model

Accurate user requirement

Suitable for unstable Requirement

Begins early product marketing

Reduce cost of Maintenance

Errors can be detected much earlier as the system is made side

by side.

Disadvantage of Prototype Model

An unstable product becomes the final product

Require extensive customer support

Costly

Customer committed

May be too customer specific, no broad market

Difficult to know how long the project will last.

 Easy to code and fix without proper requirement analysis,
design, customer evaluation

Tools used expensive.

Special tools & techniques are used

It is a time-consuming process.

The Evolutionary Model

Evolutionary process model resembles the iterative

enhancement model. The same phases are defined for the
waterfall model occurs here in a cyclical fashion. This model
differs from the iterative enhancement model in the sense that
this does not require a useful product at the end of each cycle.
In evolutionary development, requirements are implemented
by category rather than by priority.
 Huge reduction in risk for software projects.

 Reduce costs by providing a structured, disciplined model

 access to early deliveries, facilitating the development

of documentation

 Better fit the product to user needs and market requirements.

 Manage project risk with the definition of early cycle content.

 Uncover key issues early and focus attention appropriately.

 Increase the opportunity to hit market windows.

 Accelerate sales cycles with early customer exposure.

 Increase management visibility of project progress.

 Increase product team productivity and motivations

Spiral Model
The spiral model, initially proposed by Boehm, is an
evolutionary software process model that couples the
iterative feature of prototyping with the controlled and
systematic aspects of the linear sequential model. It
implements the potential for rapid development of new
versions of the software. Using the spiral model, the
software is developed in a series of incremental releases.
During the early iterations, the additional release may be a
paper model or prototype. During later iterations, more and
more complete versions of the engineered system are
produced.

Each cycle in the spiral is divided into four parts:

 Objective setting: Each cycle in the spiral starts with the
identification of purpose for that cycle, the various alternatives
that are possible for achieving the targets, and the constraints
that exists.
 Risk Assessment and reduction: The next phase in the cycle is
to calculate these various alternatives based on the goals and
constraints. The focus of evaluation in this stage is located on the
risk perception for the project.
 Development and validation: The next phase is to develop
strategies that resolve uncertainties and risks. This process may
include activities such as benchmarking, simulation, and
prototyping.
 Planning: Final, step is planned. The project is reviewed, and a
choice made whether to continue with a further period of the
spiral. If it is determined to keep, plans are drawn up for the next
step of the project.
 The development phase depends on the remaining risks. For
example, if performance or user-interface risks are treated more
essential than the program development risks, the next phase
may be an evolutionary development that includes developing a
more detailed prototype for solving the risks.

Advantages

High amount of risk analysis

Useful for large and mission-critical projects.

Disadvantages

Can be a costly model to use.

Risk analysis needed highly particular expertise

Doesn't work well for smaller projects.

Software Reuse

Software reuse is creating new system by combining existing

components that have been used in other systems. Software
engineering always emphasized on original development but
now recognised to achieve better software, quickly at lower
cost, with the help of systematic software reuse.

Benefits of software reuse

 Improving productivity, raising quality and reducing delivery
time-scales.
 Increased dependability
 Reused software
 Reduced process risk

Critical Comparisons of SDLC models

1.4.3 An Introduction to Non-Traditional Software

Development Process: Rational Unified Process,
Rapid Application Development, Agile Development
Process.

Rapid Application: RAD is a linear sequential software

development process model that emphasizes a concise
development cycle using an element based construction
approach. If the requirements are well understood and described,
and the project scope is a constraint, the RAD process enables a
development team to create a fully functional system within a
concise time period.

RAD (Rapid Application Development) is a concept that products

can be developed faster and of higher quality through:

 Gathering requirements using workshops or focus groups

 Prototyping and early, reiterative user testing of designs
 The re-use of software components
 A rigidly paced schedule that refers design improvements to
the next product version
 Less formality in reviews and other team communication

The various phases of RAD are as follows:

1. Business Modelling

2. Data Modelling

3. Process Modelling
4. Application Generation

5. Testing & Turnover

Agile Development Process

The meaning of Agile is swift or versatile. "Agile process model"

refers to a software development approach based on iterative
development. Agile methods break tasks into smaller iterations,
or parts do not directly involve long term planning. The project
scope and requirements are laid down at the beginning of the
development process. Plans regarding the number of iterations,
the duration and the scope of each iteration are clearly defined in
advance.

 Requirements gathering
 Design the requirements
 Construction/ iteration
 Testing/ Quality assurance
 Deployment
 Feedback