Software is more than just a program code.

A program is an executable code, which serves some

computational purpose. Software is considered to be a collection of executable programming code,
associated libraries and documentations. Software, when made for a specific requirement is called
software product.

Engineering is all about developing products, using well-defined, scientific principles and methods.

Software engineering as an engineering branch associated with the development of software product
using well-defined scientific principles, methods and procedures. The outcome of software
engineering is an efficient and reliable software product.

IEEE defines software engineering as:

The application of a systematic, disciplined, quantifiable approach to the development, operation and
maintenance of software

Software engineers should

1. adopt a systematic and organised approach to their work

2. use appropriate tools and techniques depending on
a. the problem to be solved,
b. the development constraints and
3. use the resources available

Stephen Schach defined software engineering as “A discipline whose aim is the production of quality
software, software that is delivered on time, within budget, and that satisfies its requirements”.

Software engineering principles use two important techniques to reduce problem

complexity: abstraction and decomposition.
Abstraction: implies that a problem can be simplified by omitting irrelevant details. The
main purpose of abstraction is to consider only those aspects of the problem that are
relevant for certain purpose and suppress other aspects that are not relevant for the given
purpose.
Once the simpler problem is solved, then the omitted details can be taken into consideration
to solve the next lower level abstraction, and so on. Abstraction is a powerful way of
reducing the complexity of the problem.
Decomposition: complex problem is divided into several smaller problems and then the smaller
problems are solved one by one. However, in this technique any random decomposition of a problem
into smaller parts will not help. The problem has to be decomposed such that each component of the
decomposed problem can be solved independently and then the solution of the different components
can be combined to get the full solution.

A good decomposition of a problem should minimize interactions among various components. If the
different subcomponents are interrelated, then the different components cannot be solved separately
and the desired reduction in complexity will not be realized
NEED OF SOFTWARE ENGINEERING
The need of software engineering arises because of higher rate of change in user
requirements and environment on which the software is working.

• Large software - It is easier to build a wall than to a house or building,

likewise, as the size of software become large engineering has to step to give
it a scientific process.
• Scalability- If the software process were not based on scientific and
engineering concepts, it would be easier to re-create new software than to
scale an existing one.
• Cost- As hardware industry has shown its skills and huge manufacturing has
lower down the price of computer and electronic hardware. But the cost of
software remains high if proper process is not adapted.
• Dynamic Nature- The always growing and adapting nature of software hugely
depends upon the environment in which the user works. If the nature of
software is always changing, new enhancements need to be done in the
existing one. This is where software engineering plays a good role.
• Quality Management- Better process of software development provides
better and quality software product.

CHARACTERESTICS OF GOOD SOFTWARE

A software product can be judged by what it offers and how well it can be used. This
software must satisfy on the following grounds:

• Operational
• Transitional
• Maintenance
Well-engineered and crafted software is expected to have the following characteristics:

Operational
This tells us how well software works in operations. It can be measured on:

• Budget
• Usability
• Efficiency
• Correctness
• Functionality
• Dependability
 • Security
• Safety

Transitional
This aspect is important when the software is moved from one platform to another:

• Portability
• Interoperability
• Reusability
• Adaptability
Maintenance
This aspect briefs about how well a software has the capabilities to maintain itself
in the ever-changing environment:

• Modularity
• Maintainability
• Flexibility
• Scalability
In short, Software engineering is a branch of computer science, which uses well-
defined engineering concepts required to produce efficient, durable, scalable, in-
budget and on-time software products

LIFE CYCLE MODEL

A software life cycle model (also called process model) is a descriptive and diagrammatic
representation of the software life cycle. A life cycle model represents all the activities required to
make a software product transit through its life cycle phases. It also captures the order in which these
activities are to be undertaken

NEED LIFE CYCLE MODEL

• The development team must identify a suitable life cycle model for the particular project.
• Without using of a particular life cycle model, the development of a software product would
not be in a systematic and disciplined manner.
• When a software product is being developed by a team there must be a clear understanding
among team members about when and what to do, otherwise it would lead to chaos and
project failure.
• A software life cycle model defines entry and exit criteria for every phase.
• A phase can start only if its phase-entry criteria have been satisfied. So without software life
cycle model the entry and exit criteria for a phase cannot be recognized.
• Without software life cycle models it becomes difficultfor software project managers to
monitor the progress of the project.
 life cycle models

• Classical Waterfall Model

• Iterative Waterfall Model
• Prototyping Model
• Evolutionary Model
• Spiral Model

1. CLASSICAL WATERFALL MODEL

this model can be considered to be a theoretical way of developing software. But all other life
cycle models are essentially derived from the classical waterfall model. So, in order to be able to
appreciate other life cycle models it is necessary to learn the classical waterfall model.

Feasibility study - The main aim of feasibility study is to determine whether it would be financially and
technically feasible to develop the product.

o what is required to be done by visiting the client side.

o what kind of processingis needed
o whether the solution is feasible financially and technically.
o cost of the product and whether they have sufficient technical expertise in
the area of development

Requirements analysis and specification: - The aim of the requirements analysis and
specification phase is to understand the exact requirements of the customer and to
document them properly. This phase consists of two distinct activities, namely
 • Requirements gathering and analysis
• Requirements specification
The goal of the requirements gathering activity is to collect all relevant information from
the customer regarding the product to be developed. This is done to clearly understand the
customer requirements so that incompleteness and inconsistencies are removed.
The requirements analysis activity is begun by collecting all relevant data regarding the
product to be developed from the users of the product and from the customer through
interviews and discussions.
Design − The requirement specifications from first phase are studied in this phase and
the system design is prepared. This system design helps in specifying hardware and
system requirements and helps in defining the overall system architecture.
Coding / Implementation − With inputs from the system design, the system is first developed
in small programs called units, which are integrated in the next phase. Each unit is developed
and tested for its functionality, which is referred to as Unit Testing.
Testing − All the units developed in the implementation phase are integrated into a system
after testing of each unit. Post integration the entire system is tested for any faults and
failures.
• α – testing: It is the system testing performed by the development team.
• β –testing: It is the system testing performed by a friendly set of customers.
• Acceptance testing: It is the system testing performed by the customer
himself after theproduct delivery to determine whether to accept or reject
the delivered product.

Maintenance − There are some issues which come up in the client environment. To fix those
issues, patches are released. Also to enhance the product some better versions are released.
Maintenance is done to deliver these changes in the customer environment.
• Correcting errors that were not discovered during the product development
phase. This is called corrective maintenance.
• Improving the implementation of the system, and enhancing the
functionalities of the system according to the customer’s requirements. This
is called perfective maintenance.
• Porting the software to work in a new environment. For example, porting may
be required to get the software to work on a new computer platform or with
a new operating system. This is called adaptive maintenance.

Waterfall model is most appropriate are

• Requirements are very well documented, clear and fixed.
• Product definition is stable.
• Technology is understood and is not dynamic.
• There are no ambiguous requirements.
• Ample resources with required expertise are available to support the product.
• The project is short.
 Advantages
major advantages of the Waterfall Model are as follows
• Simple and easy to understand and use
• Easy to manage due to the rigidity of the model. Each phase has specific
deliverables and a review process.
• Phases are processed and completed one at a time.
• Works well for smaller projects where requirements are very well understood.
• Clearly defined stages.
• Well understood milestones.
• Easy to arrange tasks.
• Process and results are well documented.

ITERATIVE WATERFALL MODEL

To overcome the major shortcomings of the classical waterfall model, we come up with
the iterative waterfall model.

Here, we provide feedback paths for error correction as & when detected later in a phase.
Though errors are inevitable, but it is desirable to detect them in the same phase in which
they occur. If so, this can reduce the effort to correct the bug.

The advantage of this model is that there is a working model of the system at a very early
stage of development which makes it easier to find functional or design flaws. Finding
issues at an early stage of development enables to take corrective measures in a limited
budget.

The disadvantage with this SDLC model is that it is applicable only to large and bulky
software development projects. This is because it is hard to break a small software system
into further small serviceable increments/modules.

This model is most often used in the following scenarios −

• Requirements of the complete system are clearly defined and
understood.
• Major requirements must be defined; however, some functionalities or
requested enhancements may evolve with time.
• There is a time to the market constraint.
• A new technology is being used and is being learnt by the development
team while working on the project.

The advantages of the Iterative and Incremental SDLC Model are as follows −
• Some working functionality can be developed quickly and early in the
life cycle.
• Results are obtained early and periodically.
• Parallel development can be planned.
• Progress can be measured.
• Less costly to change the scope/requirements.
• Testing and debugging during smaller iteration is easy.
The disadvantages of the Iterative and Incremental SDLC Model are as follows −
• More resources may be required.
• Although cost of change is lesser, but it is not very suitable for changing
requirements.
• More management attention is required.
• System architecture or design issues may arise because not all
requirements are gathered in the beginning of the entire life cycle.
• Defining increments may require definition of the complete system.
• Not suitable for smaller projects.
• Management complexity is more.

PRTOTYPING MODEL
A prototype is a toy implementation of the system. A prototype usually exhibits limited functional
capabilities, low reliability, and inefficient performance compared to the actual software. A
prototype is usually built using several shortcuts. The shortcuts might involve using inefficient,
inaccurate, or dummy functions
 Need for a prototype in software development

There are several uses of a prototype. An important purpose is to illustrate the input data
formats, messages, reports, and the interactive dialogues to the customer. This is a valuable
mechanism for gaining better understanding of the customer’s needs:
• how the screens might look like
• how the user interface would behave
• how the system would produce outputs
A prototype of the actual product is preferred in situations such as:

• User requirements are not complete

• Technical issues are not clear

EVOLUTIONARY MODEL

It is also called successive versions model or incremental model. At first, a simple working
model is built. Subsequently it undergoes functional improvements & we keep on adding
new functions till the desired system is built.

Applications:
• Large projects where you can easily find modules for incremental
implementation. Often used when the customer wants to start using the core
features rather than waiting for the full software.
• Also used in object oriented software development because the system can
be easily portioned into units in terms of objects.
 Advantages:
• User gets a chance to experiment partially developed system
• Reduce the error because the core modules get
tested thoroughly.

Disadvantages:
• It is difficult to divide the problem into several versions that would be
acceptable to thecustomer which can be incrementally implemented &
delivered.

SPIRAL MODEL

The Spiral model of software development is shown in fig. 4.1. The diagrammatic
representationof this model appears like a spiral with many loops. The exact number
of loops in the spiral is not fixed. Each loop of the spiral represents a phase of the
software process. For example, the innermost loop might be concerned with feasibility
study, the next loop with requirementsspecification, the next one with design, and so
on. Each phase in this model is split into four sectors (or quadrants) The following
activities are carried out during each phase of a spiral model.
First quadrant (Objective Setting)
• During the first quadrant, it is needed to identify the objectives of the phase.
• Examine the risks associated with these objectives.

Second Quadrant (Risk Assessment and Reduction)

• A detailed analysis is carried out for each identified project risk.
• Steps are taken to reduce the risks. For example, if there is a risk that
therequirements are inappropriate, a prototype system may be developed.
Third Quadrant (Development and Validation)
• Develop and validate the next level of the product after resolving
the identifiedrisks.
Fourth Quadrant (Review and Planning)
• Review the results achieved so far with the customer and plan the
next iterationaround the spiral.
• Progressively more complete version of the software gets built with
each iterationaround the spiral.
Circumstances to use spiral model
The spiral model is called a meta model since it encompasses all other life cycle
models. Risk handling is inherently built into this model. The spiral model is suitable
for development of technically challenging software products that are prone to
several kinds of risks. However, this model is much more complex than the other
model.

Advantages of Spiral Model:

1. Risk Handling: The projects with many unknown risks that occur as the
development proceeds, in that case, Spiral Model is the best development
model to follow due to the risk analysis and risk handling at every phase.
2. Good for large projects: It is recommended to use the Spiral Model in large and
complex projects.
3. Flexibility in Requirements: Change requests in the Requirements at later
phase can be incorporated accurately by using this model.
4. Customer Satisfaction: Customer can see the development of the product at
the early phase of the software development and thus, they habituated with
the system by using it before completion of the total product.
Disadvantages of Spiral Model:
Below are some main disadvantages of the spiral model.
1. Complex: The Spiral Model is much more complex than other SDLC models.
2. Expensive: Spiral Model is not suitable for small projects as it is expensive.
3. Too much dependability on Risk Analysis: The successful completion of the
project is very much dependent on Risk Analysis. Without very highly
experienced experts, it is going to be a failure to develop a project using this
model.
4. Difficulty in time management: As the number of phases is unknown at the
start of the project, so time estimation is very difficult.