Software Engineering

(BCA -405)
 Unit-I (10)
Software Product and SDLC: Software Engineering
Fundamentals, Definition of Software Products, Phases of
Software Development Life Cycle, Software Development
Paradigm, Software Life Cycles Models: Build and Fix Model,
Waterfall Model, Prototype Model, Iterative Model,
Evolutionary Model, Spiral Model.

Text Books:
1. Rajib Mall, “Fundamental of Software Engineering”, PHI.

Reference Books:
1. R. Pressman, “Software Engineering”, TMH.
2. Pankaj Jalote, “An Integrated Approach to Software Engineering”, Narosa.
3. Pankaj Jalote, “Software Project Management in Practice”, Person Education
Software Engineering Fundamentals
Software Engineering provides a standard procedure to design and develop a software.

What is Software Engineering?

• The term software engineering is the product of two words, software, and
engineering.

• The software is a collection of integrated programs.

• Software subsists of carefully-organized instructions and code written by

developers on any of various particular computer languages.

• Computer programs and related documentation such as requirements, design

models and user manuals.

• Engineering is the application of scientific and practical knowledge to invent,

design, build, maintain, and improve frameworks, processes, etc.
Software engineering is an engineering branch associated with development of
software product using well-defined scientific principles, methods and procedures. The
outcome of software engineering is an efficient and reliable software product.

Definitions

IEEE defines software engineering as:

(1) The application of a systematic, disciplined, quantifiable approach to the

development, operation and maintenance of software; that is, the application of
engineering to software.

(2) The study of approaches as in the above statement.

Software Engineering is an engineering branch related to the evolution of software
product using well-defined scientific principles, techniques, and procedures. The
result of software engineering is an effective and reliable software product.

Why is Software Engineering required?

Software Engineering is required due to the following reasons:

• To manage Large software. • To manage the dynamic nature of software

• For more Scalability • For better quality Management
• Cost Management
Need of Software Engineering
The necessity of software engineering appears because of a higher rate of progress
in user requirements and the environment on which the program is working.

Huge Programming: It is simpler to manufacture a wall than to a house or building,

similarly, as the measure of programming become extensive engineering has to step
to give it a scientific process.
Adaptability: If the software procedure were not based on scientific and
engineering ideas, it would be simpler to re-create new software than to scale an
existing one.
Cost: As the hardware industry has demonstrated its skills and huge manufacturing
has let down the cost of computer and electronic hardware. But the cost of
programming remains high if the proper process is not adapted.
Dynamic Nature: The continually growing and adapting nature of programming
hugely depends upon the environment in which the client works. If the quality of
the software is continually changing, new upgrades need to be done in the existing
one.
Quality Management: Better procedure of software development provides a better
and quality software product.
Characteristics of a good software engineer
The features that good software engineers should possess are as follows:

• Exposure to systematic methods, i.e., familiarity with software engineering

principles.

• Good technical knowledge of the project range (Domain knowledge).

• Good programming abilities.

• Good communication skills. These skills comprise of oral, written, and

interpersonal skills.

• High motivation.

• Sound knowledge of fundamentals of computer science.

• Intelligence.

• Ability to work in a team

• Discipline, etc.
 Importance of Software Engineering

The importance of Software engineering is as follows:

Reduces complexity: Big software is always complicated and challenging to progress.

Software engineering has a great solution to reduce the complication of any project.
Software engineering divides big problems into various small issues. And then start solving
each small issue one by one. All these small problems are solved independently to each
other.
To minimize software cost: Software needs a lot of hardwork and software engineers are
highly paid experts. A lot of manpower is required to develop software with a large number
of codes. But in software engineering, programmers project everything and decrease all
those things that are not needed. In turn, the cost for software productions becomes less
as compared to any software that does not use software engineering method.

To decrease time: Anything that is not made according to the project always wastes time.
And if you are making great software, then you may need to run many codes to get the
definitive running code. This is a very time-consuming procedure, and if it is not well
handled, then this can take a lot of time. So if you are making your software according to
the software engineering method, then it will decrease a lot of time.

Handling big projects: Big projects are not done in a couple of days, and they need lots of
patience, planning, and management. And to invest six and seven months of any company,
it requires heaps of planning, direction, testing, and maintenance. No one can say that he
has given four months of a company to the task, and the project is still in its first stage.
Because the company has provided many resources to the plan and it should be completed.
So to handle a big project without any problem, the company has to go for a software
engineering method.
Reliable software: Software should be secure, means if you have delivered the software,
then it should work for at least its given time or subscription. And if any bugs come in the
software, the company is responsible for solving all these bugs. Because in software
engineering, testing and maintenance are given, so there is no worry of its reliability.

Effectiveness: Effectiveness comes if anything has made according to the standards.

Software standards are the big target of companies to make it more effective. So Software
becomes more effective in the act with the help of software engineering.
Definition of Software Products

Software Products are nothing but software systems delivered to the customer with the
documentation that describes how to install and use the system. In certain cases,
software products may be part of system products where hardware, as well as
software, is delivered to a customer. Software products are produced with the help of
the software process. The software process is a way in which we produce software.

Types of software products:

Software products fall into two broad categories:

Generic products:
Generic products are stand-alone systems that are developed by a production unit
and sold on the open market to any customer who is able to buy them.

Customized Products:
Customized products are the systems that are commissioned by a particular customer.
Some contractor develops the software for that customer.
Essential characteristics of Well-Engineered Software Product:

A well-engineered software product should possess the following essential characteristics:

Efficiency:
The software should not make wasteful use of system resources such as memory and
processor cycles.
Maintainability:
It should be possible to evolve the software to meet the changing requirements of
customers.
Dependability:
It is the flexibility of the software that ought to not cause any physical or economic injury
within the event of system failure. It includes a range of characteristics such as reliability,
security, and safety.
In time:
Software should be developed well in time.
Within Budget:
The software development costs should not overrun and it should be within the
budgetary limit.
Functionality:
The software system should exhibit the proper functionality, i.e. it should perform all
the functions it is supposed to perform.
Adaptability:
The software system should have the ability to get adapted to a reasonable extent with
the changing requirements.
Software Processes
The term software specifies to the set of computer programs, procedures and associated
documents (Flowcharts, manuals, etc.) that describe the program and how they are to be
used.

A software process is the set of activities and associated outcome that produce a software
product. Software engineers mostly carry out these activities. These are four key process
activities, which are common to all software processes. These activities are:

1. Software specifications: The functionality of the software and constraints on its

operation must be defined.
2. Software development: The software to meet the requirement must be produced.
3. Software validation: The software must be validated to ensure that it does what the
customer wants.
4. Software evolution: The software must evolve to meet changing client needs.
The Software Process Model

A software process model is a specified definition of a software process, which is

presented from a particular perspective. Models, by their nature, are a simplification,
so a software process model is an abstraction of the actual process, which is being
described. Process models may contain activities, which are part of the software
process, software product, and the roles of people involved in software engineering.
Some examples of the types of software process models that may be produced are:

A workflow model: This shows the series of activities in the process along with their
inputs, outputs and dependencies. The activities in this model perform human
actions.
A dataflow or activity model: This represents the process as a set of activities, each
of which carries out some data transformations. It shows how the input to the
process, such as a specification is converted to an output such as a design. The
activities here may be at a lower level than activities in a workflow model. They may
perform transformations carried out by people or by computers.
A role/action model: This means the roles of the people involved in the software
process and the activities for which they are responsible.
There are several various general models or paradigms of software development:

The waterfall approach: This takes the above activities and produces them as separate
process phases such as requirements specification, software design, implementation,
testing, and so on. After each stage is defined, it is "signed off" and development goes
onto the following stage.

Evolutionary development: This method interleaves the activities of specification,

development, and validation. An initial system is rapidly developed from a very abstract
specification.

Formal transformation: This method is based on producing a formal mathematical system

specification and transforming this specification, using mathematical methods to a
program. These transformations are 'correctness preserving.' This means that you can be
sure that the developed programs meet its specification.

System assembly from reusable components: This method assumes the parts of the
system already exist. The system development process target on integrating these parts
rather than developing them from scratch.
Software Crisis
• Software Crisis is a term used in computer science for the difficulty of writing useful
and efficient computer programs in the required time .
• software crisis was due to using same workforce, same methods, same tools even
though rapidly increasing in software demand, complexity of software and software
challenges.
• With increase in the complexity of software, many software problems arise because
existing methods were insufficient.

1. Size: Software is becoming more expensive and more complex with the growing
complexity and expectation out of software. For example, the code in the consumer
product is doubling every couple of years.
2. Quality: Many software products have poor quality, i.e., the software products defects
after putting into use due to ineffective testing technique. For example, Software testing
typically finds 25 errors per 1000 lines of code.
3. Cost: Software development is costly i.e. in terms of time taken to develop and the
money involved.
4. Delayed Delivery: Serious schedule overruns are common. Very often the software takes
longer than the estimated time to develop, which in turn leads to cost shooting up. For
example, one in four large-scale development projects is never completed.
Phases of Software Development Life Cycle

• 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.
• A life cycle model maps the various activities performed on a software product
from its inception to retirement.
• Different life cycle models may plan the necessary development activities to
phases in different ways.
• Thus, no element which life cycle model is followed, the essential activities are
contained in all life cycle models though the action may be carried out in distinct
orders in different life cycle models.
• During any life cycle stage, more than one activity may also be carried out.
Need of SDLC

• The development team must determine a suitable life cycle model for a particular
plan and then observe to it.
• Without using an exact life cycle model, the development of a software product
would not be in a systematic and disciplined manner.
• When a team is developing a software product, there must be a clear understanding
among team representative about when and what to do. Otherwise, it would point
to confusion and project failure.
• This problem can be defined by using an example. Suppose a software development
issue is divided into various parts and the parts are assigned to the team members.
From then on, suppose the team representative is allowed the freedom to develop
the roles assigned to them in whatever way they like. It is possible that one
representative might start writing the code for his part, another might choose to
prepare the test documents first, and some other engineer might begin with the
design phase of the roles assigned to him. This would be one of the perfect methods
for project failure.
• A software life cycle model describes entry and exit criteria for each phase. A phase
can begin only if its stage-entry criteria have been fulfilled.
• So without a software life cycle model, the entry and exit criteria for a stage cannot
be recognized. Without software life cycle models, it becomes tough for software
project managers to monitor the progress of the project.
SDLC Cycle
SDLC Cycle represents the process of developing software. SDLC framework includes the
following steps:
The stages of SDLC are as follows:

Stage1: Planning and requirement analysis

• Requirement Analysis is the most important and necessary stage in SDLC.

• The senior members of the team perform it with inputs from all the stakeholders and
domain experts or SMEs in the industry.
• Planning for the quality assurance requirements and identifications of the risks
associated with the projects is also done at this stage.
• Business analyst and Project organizer set up a meeting with the client to gather all the
data like what the customer wants to build, who will be the end user, what is the
objective of the product. Before creating a product, a core understanding or knowledge
of the product is very necessary.
• For Example, A client wants to have an application which concerns money
transactions. In this method, the requirement has to be precise like what kind of
operations will be done, how it will be done, in which currency it will be done, etc.
• Once the required function is done, an analysis is complete with auditing the feasibility
of the growth of a product. In case of any ambiguity, a signal is set up for further
discussion.
• Once the requirement is understood, the SRS (Software Requirement Specification)
document is created. The developers should thoroughly follow this document and also
should be reviewed by the customer for future reference.
Stage2: Defining Requirements

• Once the requirement analysis is done, the next stage is to certainly represent and
document the software requirements and get them accepted from the project
stakeholders.

• This is accomplished through "SRS"- Software Requirement Specification document

which contains all the product requirements to be constructed and developed during
the project life cycle.
Stage3: Designing the Software

The next phase is about to bring down all the knowledge of requirements, analysis, and
design of the software project. This phase is the product of the last two, like inputs from
the customer and requirement gathering.

Stage4: Developing the project

In this phase of SDLC, the actual development begins, and the programming is built. The
implementation of design begins concerning writing code. Developers have to follow the
coding guidelines described by their management and programming tools like compilers,
interpreters, debuggers, etc. are used to develop and implement the code.

Stage5: Testing

After the code is generated, it is tested against the requirements to make sure that the
products are solving the needs addressed and gathered during the requirements stage.

During this stage, unit testing, integration testing, system testing, acceptance testing are
done.
Stage6: Deployment

Once the software is certified, and no bugs or errors are stated, then it is deployed.

Then based on the assessment, the software may be released as it is or with suggested
enhancement in the object segment.

After the software is deployed, then its maintenance begins.

Stage7: Maintenance

Once when the client starts using the developed systems, then the real issues come up
and requirements to be solved from time to time.

This procedure where the care is taken for the developed product is known as
maintenance.
Software Paradigms
Software paradigms refer to the methods and steps, which are taken while designing the
software.
There are many methods proposed and are in work today, but we need to see where in
the software engineering these paradigms stand. These can be combined into various
categories, though each of them is contained in one another:
Programming paradigm is a subset of Software design paradigm which is further a subset of
Software development paradigm.
Software Development Paradigm
The software development paradigm helps developer to select a strategy to develop the
software. A software development paradigm has its own set of tools, methods and
procedures, which are expressed clearly and defines software development life cycle. A few
of software development paradigms or process models are defined as follows: It consists of
–
• Requirement gathering
• Software design
• Programming
Software Design Paradigm
This paradigm is a part of Software Development and includes –
• Design
• Maintenance
• Programming
Programming Paradigm
This paradigm is related closely to programming aspect of software development. This
includes –
• Coding
• Testing
• Integration
Build and fix model
• In the build and fix model (also referred to as an ad hoc model), the software is
developed without any specification or design.

• An initial product is built, which is then repeatedly modified until it (software) satisfies
the user.

• That is, the software is developed and delivered to the user. The user checks whether
the desired functions ‘are present. If not, then the software is changed according to
the needs by adding, modifying or deleting functions

• This process goes on until the user feels that the software can be used productively.

• However, the lack of design requirements and repeated modifications result in loss of
acceptability of software.

• Thus, software engineers are strongly discouraged from using this development
approach.
This model includes the following two phases.

Build: In this phase, the software code is developed and passed on to the next phase.

Fix: In this phase, the code developed in the build phase is made error free. Also, in
addition to the corrections to the code, the code is modified according to the user’s
requirements.
Waterfall Model
Waterfall model is the simplest model of software development paradigm. It says the all
the phases of SDLC will function one after another in linear manner. That is, when the
first phase is finished then only the second phase will start and so on.
• This model assumes that everything is carried out and taken place perfectly as
planned in the previous stage and there is no need to think about the past issues
that may arise in the next phase.
• This model does not work smoothly if there are some issues left at the previous
step.
• The sequential nature of model does not allow us go back and undo or redo our
actions.
• This model is best suited when developers already have designed and developed
similar software in the past and are aware of all its domains.
1. Requirements analysis and specification phase:
• The aim of this phase is to understand the exact requirements of the customer and
to document them properly.
• Both the customer and the software developer work together so as to document all
the functions, performance, and interfacing requirement of the software.
• 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.

2. 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).

3. 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.
• During testing, the code is thoroughly examined and modified. Small modules are
tested in isolation initially.

• After that these modules are tested by writing some overhead code to check the
interaction between these modules and the flow of intermediate output.

4. 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.
• The better output will lead to satisfied customers, lower maintenance costs, and
accurate results.
• Unit testing determines the efficiency of individual modules.
• However, in this phase, the modules are tested for their interactions with each other
and with the system.
 5. Operation and maintenance phase:

Maintenance is the task performed by every user once the software has been delivered
to the customer, installed, and operational.

Prototype Model
• The prototyping model starts with the requirements gathering.

• The developer and the user meet and define the purpose of the software, identify the
needs, etc.

• A 'quick design' is then created. This design focuses on those aspects of the software that
will be visible to the user. It then leads to the development of a prototype.

• The customer then checks the prototype, and any modifications or changes that are
needed are made to the prototype.
• Looping takes place in this step, and better versions of the prototype are created.
• These are continuously shown to the user so that any new changes can be updated in
the prototype.
• This process continue until the customer is satisfied with the system. Once a user is
satisfied, the prototype is converted to the actual system with all considerations for
quality and security.
Steps of Prototype Model
1. Requirement Gathering and Analyst
2. Quick Decision
3. Build a Prototype
4. Assessment or User Evaluation
5. Prototype Refinement
6. Engineer Product
Advantage of Prototype Model

1. Reduce the risk of incorrect user requirement

2. Good where requirement are changing/uncommitted
3. Regular visible process aids management
4. Support early product marketing
5. Reduce Maintenance cost.
6. Errors can be detected much earlier as the system is made side by side.
Disadvantage of Prototype Model

1. An unstable/badly implemented prototype often becomes the final product.

2. Require extensive customer collaboration
• Costs customer money
• Needs committed customer
• Difficult to finish if customer withdraw
• May be too customer specific, no broad market
3. Difficult to know how long the project will last.
4. Easy to fall back into the code and fix without proper requirement analysis, design,
customer evaluation, and feedback.
5. Prototyping tools are expensive.
6. Special tools & techniques are required to build a prototype.
7. It is a time-consuming process.
Iterative Model
• In this Model, you can start with some of the software specifications and develop
the first version of the software.
• After the first version if there is a need to change the software, then a new version
of the software is created with a new iteration.
• Every release of the Iterative Model finishes in an exact and fixed period that is
called iteration.
• The Iterative Model allows the accessing earlier phases, in which the variations
made respectively.
• The final output of the project renewed at the end of the Software Development
Life Cycle (SDLC) process.
The various phases of Iterative model are as follows:
1. Requirement gathering & analysis: In this phase, requirements are gathered from
customers and check by an analyst whether requirements will fulfil or not. Analyst
checks that need will achieve within budget or not. After all of this, the software team
skips to the next phase.

2. Design: In the design phase, team design the software by the different diagrams like
Data Flow diagram, activity diagram, class diagram, state transition diagram, etc.
3. Implementation: In the implementation, requirements are written in the coding
language and transformed into computer programmes which are called Software.

4. Testing: After completing the coding phase, software testing starts using different test
methods. There are many test methods, but the most common are white box, black box,
and grey box test methods.
5. Deployment: After completing all the phases, software is deployed to its work
environment.

6. Review: In this phase, after the product deployment, review phase is performed to check
the behaviour and validity of the developed product. And if there are any error found then
the process starts again from the requirement gathering.

7. Maintenance: In the maintenance phase, after deployment of the software in the

working environment there may be some bugs, some errors or new updates are required.
Maintenance involves debugging and new addition options.

When to use the Iterative Model?

1. When requirements are defined clearly and easy to understand.

2. When the software application is large.
3. When there is a requirement of changes in future.
Advantage(Pros) of Iterative Model:

1. Testing and debugging during smaller iteration is easy.

2. A Parallel development can plan.
3. It is easily acceptable to ever-changing needs of the project.
4. Risks are identified and resolved during iteration.
5. Limited time spent on documentation and extra time on designing.
Disadvantage(Cons) of Iterative Model:
6. It is not suitable for smaller projects.
7. More Resources may be required.
8. Design can be changed again and again because of imperfect requirements.
9. Requirement changes can cause over budget.
10. Project completion date not confirmed because of changing requirements.
 Evolutionary Process Model
• Evolutionary process model look like 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.

For example, in a simple database application, one cycle might implement the graphical
user Interface (GUI), another file manipulation, another queries and another updates. All
four cycles must complete before there is a working product available. GUI allows the
users to interact with the system, file manipulation allow the data to be saved and
retrieved, queries allow user to get out of the system, and updates allows users to put
data into the system.
Benefits of Evolutionary Process Model

1. Use of EVO brings a significant reduction in risk for software projects.

2. EVO can reduce costs by providing a structured, disciplined avenue for

experimentation.

3. EVO allows the marketing department access to early deliveries, facilitating the
development of documentation and demonstration.

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

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

6. Uncover key issues early and focus attention appropriately.

7. Increase the opportunity to hit market windows.

8. Accelerate sales cycles with early customer exposure.

9. Increase management visibility of project progress.

10. Increase product team productivity and motivations.

Spiral 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 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.

• It allows incremental releases of the product or incremental refinement through each

iteration around the spiral.
 Activities which are performed in the spiral model phases are shown below:

Phase Name Activities performed Deliverables / Output

Planning -Requirements are studied and gathered. Requirements understanding document
- Feasibility study
- Reviews and walkthroughs to streamline the Finalized list of requirements.
requirements

Risk Analysis Requirements are studied and brain storming Document which highlights all the risks
sessions are done to identify the potential risks and its mitigation plans.

Once the risks are identified , risk mitigation

strategy is planned and finalized

Engineering Actual development and testing if the software Code

takes place in this phase Test cases and test results
Test summary report and defect report.

Evaluation Customers evaluate the software and provide their Features implemented document
feedback and approval
Pictorial Representation Of SDLC Spiral Model
Each cycle in the spiral is divided into four parts:

1. 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.

2. 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.

3. 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.

4. Planning: Finally, the next 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.
When to use Spiral Model?

1. When deliverance is required to be frequent.

2. When the project is large
3. When requirements are unclear and complex
4. When changes may require at any time
5. Large and high budget projects

Advantages
1. High amount of risk analysis
2. Useful for large and mission-critical projects.

Disadvantages
1. Can be a costly model to use.
2. Risk analysis needed highly particular expertise
3. Doesn't work well for smaller projects.