SOFTWARE ENGINEERING (Unit I)

Introduction of Software Engineering

Software is a program or set of programs containing instructions that
provide desired functionality. And Engineering is the process of designing and
building something that serves a particular purpose and finds a cost-effective
solution to problems.

Software engineering is the process

of designing, developing, testing,
“Software engineering discusses
and maintaining software. It is a
systematic and cost-effective
systematic and disciplined approach
techniques for software
to software development that aims to
development. These techniques help
create high-quality, reliable, and
develop software using an
maintainable software. Software
engineering approach.”
engineering includes a variety of
techniques, tools, and
methodologies, including
requirements analysis, design,
testing, and maintenance.

What is software engineering?

A popular definition of software engineering is: “A systematic collection of
good program development practices and techniques”. Good program development
techniques have resulted from research innovations as well as from the lessons learnt
by programmers through years of programming experiences. An alternative definition
of software engineering is: “ An engineering approach to develop software ”.

Some key principles of software engineering include:

1. Modularity: Breaking the software into smaller, reusable components that can
be developed and tested independently.
2. Abstraction: Hiding the implementation details of a component and exposing
only the necessary functionality to other parts of the software.
3. Encapsulation: Wrapping up the data and functions of an object into a single
unit, and protecting the internal state of an object from external modifications.
4. Reusability: Creating components that can be used in multiple projects, which
can save time and resources.
5. Maintenance: Regularly updating and improving the software to fix bugs, add
new features, and address security vulnerabilities.
6. Testing: Verifying that the software meets its requirements and is free of bugs.

1
 SOFTWARE ENGINEERING (Unit I)
7. Design Patterns: Solving recurring problems in software design by providing
templates for solving them.
8. Agile methodologies: Using iterative and incremental development processes
that focus on customer satisfaction, rapid delivery, and flexibility.
9. Continuous Integration & Deployment: Continuously integrating the code
changes and deploying them into the production environment.

Software engineering is a rapidly evolving field, and new tools and technologies
are constantly being developed to improve the software development process. By
following the principles of software engineering and using the appropriate tools and
methodologies, software developers can create high-quality, reliable, and
maintainable software that meets the needs of its users.
Software Engineering is mainly used for large projects based on software
systems rather than single programs or applications. The main goal of software
Engineering is to develop software application for improving the quality, budget
and time efficiency. Software Engineering ensures that the software that has to built
should be consistent, correct, also on budget, on time and within the required
requirements.
There are Four main Attributes of Software Engineering:

 Efficiency
 Reliability
 Robustness
 Maintainability

Software Engineering is a systematic, disciplined, quantifiable study and

approach to the design, development, operation, and maintenance of a
software system.
Dual Role of Software:

1. As a product
 It delivers the computing potential across networks of Hardware.
 It enables the Hardware to deliver the expected functionality.
 It acts as an information transformer because it produces, manages, acquires,
modifies, displays, or transmits information.

2. As a vehicle for delivering a product

 It provides system functionality (e.g., payroll system)
 It controls other software (e.g., an operating system)
 It helps build other software (e.g., software tools)

Objectives of Software Engineering:

2
 SOFTWARE ENGINEERING (Unit I)

1. Maintainability – It should be feasible for the software to evolve to meet

changing requirements.
2. Efficiency – The software should not make wasteful use of computing
devices such as memory, processor cycles, etc.
3. Correctness – A software product is correct if the different requirements as
specified in the SRS document have been correctly implemented.
4. Reusability – A software product has good reusability if the different
modules of the product can easily be reused to develop new products.
5. Testability – Here software facilitates both the establishment of test criteria
and the evaluation of the software with respect to those criteria.
6. Reliability – It is an attribute of software quality. The extent to which a
program can be expected to perform its desired function, over an arbitrary
time period.
7. Portability – In this case, the software can be transferred from one computer
system or environment to another.
8. Adaptability – In this case, the software allows differing system constraints
and the user needs to be satisfied by making changes to the software.
9. Interoperability – Capability of 2 or more functional units to process data
cooperatively.

Program vs Software Product:

1. A program is a set of instructions that are given to a computer in order to

achieve a specific task whereas software is when a program is made available
for commercial business and is properly documented along with its licensing.
Software=Program+documentation+licensing.

2. A program is one of the stages involved in the development of the software,

whereas a software development usually follows a life cycle, which involves the

3
 SOFTWARE ENGINEERING (Unit I)
feasibility study of the project, requirement gathering, development of a
prototype, system design, coding, and testing.

Evolution of Software Engineering

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 and 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.
Necessity of Software evolution:

a) Change in requirement with time: With the passes of time, the

organization‟s needs and modus Operandi of working could substantially be
changed so in this frequently changing time the tools(software) that they are
using need to change for maximizing the performance.

b) Environment change: As the working environment changes the things(tools)

that enable us to work in that environment also changes proportionally same
happens in the software world as the working environment changes then, the
organizations need reintroduction of old software with updated features and
functionality to adapt the new environment.

c) Errors and bugs: As the age of the deployed software within an organization
increases their preciseness or impeccability decrease and the efficiency to bear
the increasing complexity workload also continually degrades. So, in that case, it
becomes necessary to avoid use of obsolete and aged software. All such obsolete
Software‟s need to undergo the evolution process in order to become robust as
per the workload complexity of the current environment.

d) Security risks: Using outdated software within an organization may lead you
to at the verge of various software-based cyber attacks and could expose your
confidential data illegally associated with the software that is in use. So, it
4
 SOFTWARE ENGINEERING (Unit I)
becomes necessary to avoid such security breaches through regular assessment
of the security patches/modules are used within the software. If the software
isn‟t robust enough to bear the current occurring Cyber attacks so it must be
changed (updated).

e) For having new functionality and features: In order to increase the

performance and fast data processing and other functionalities, an organization
need to continuously evolute the software throughout its life cycle so that
stakeholders & clients of the product could work efficiently.

Software Evolution Laws

Lehman has given laws for software evolution. He divided the software into three
different categories:

 S-type (static-type) - This is a software, which works strictly according to

defined specifications and solutions. The solution and the method to achieve
it, both are immediately understood before coding. The s-type software is
least subjected to changes hence this is the simplest of all. For example,
calculator program for mathematical computation.
 P-type (practical-type) - This is a software with a collection
of procedures. This is defined by exactly what procedures can do. In this

5
 SOFTWARE ENGINEERING (Unit I)
software, the specifications can be described but the solution is not obvious
instantly. For example, gaming software.
 E-type (embedded-type) - This software works closely as the requirement
of real-world environment. This software has a high degree of evolution as
there are various changes in laws, taxes etc. in the real world situations. For
example, Online trading software

Evolution of Software Engineering : From an Art To Engineering

Discipline
The evolution of software engineering from an art to an engineering
discipline has been a gradual process driven by various factors. In the early days of
software development, programming was often seen as an artistic pursuit, with
individual programmers using their creativity and intuition to write code. However,
as software systems became larger and more complex, it became clear that a more
disciplined and systematic approach was needed to ensure quality and manage the
inherent challenges of software development. Here are some key milestones in the
evolution of software engineering:

The Software Crisis: In the 1960s and 1970s, as software systems grew in
complexity, many projects experienced significant delays, cost overruns, and
failures. This period became known as the "software crisis," highlighting the need
for more rigorous methodologies and processes.

6
 SOFTWARE ENGINEERING (Unit I)
Structured Programming: In response to the software crisis, the idea of
structured programming emerged. It emphasized the use of control structures (e.g.,
loops, conditionals) and the concept of modular programming, where code is
divided into reusable modules. This approach improved code readability,
maintainability, and made it easier to reason about program behavior.

Software Engineering Principles: In the late 1960s, the term "software

engineering" was coined, and efforts were made to define principles and practices
for systematic software development. The NATO Software Engineering
Conference in 1968 played a significant role in establishing software engineering
as a distinct discipline. Concepts such as abstraction, encapsulation, and
information hiding became fundamental principles.

Development Methodologies: In the 1970s and 1980s, various software

development methodologies emerged, such as the Waterfall model, the Spiral
model, and later the Agile methodologies. These approaches provided frameworks
for managing the software development process, including requirements gathering,
design, implementation, testing, and maintenance.

Software Process Improvement: The Capability Maturity Model (CMM) was

introduced in the 1980s by the Software Engineering Institute (SEI) to assess and
improve the maturity of software development processes. It provided a framework
for organizations to evaluate and enhance their software development practices.

Formal Methods and Software Verification: Formal methods gained

prominence in the 1980s and 1990s as techniques for mathematically specifying
and verifying software systems. Formal methods use mathematical logic to reason
about the correctness of software designs and implementations, providing a more
rigorous approach to software development.

Standardization and Certification: The establishment of international standards,

such as ISO 9001, and the introduction of software engineering certifications, such
as the Certified Software Development Professional (CSDP) designation, further
contributed to the professionalization of software engineering. These initiatives
emphasized the importance of quality management, documentation, and adherence
to standardized processes.

Tools and Automation: The advent of integrated development environments

(IDEs), code repositories, automated testing frameworks, and other software
development tools significantly improved productivity and quality in software

7
 SOFTWARE ENGINEERING (Unit I)
engineering. These tools automated repetitive tasks, facilitated collaboration, and
provided mechanisms for code versioning and tracking.

DevOps and Continuous Integration/Deployment: The rise of DevOps practices

further revolutionized software engineering by emphasizing the integration of
development and operations teams, and the automation of software delivery
processes. Continuous integration and deployment (CI/CD) pipelines became
standard practices, enabling frequent and automated software releases.

Software Engineering Education: Over time, universities and educational

institutions have developed dedicated software engineering curricula to train
professionals in the discipline. The focus shifted from merely teaching
programming languages to imparting knowledge of software development
methodologies, design patterns, quality assurance, and project management.

Software Development projects

The software should be produced at a reasonable cost, in a reasonable time, and
should be of good quality. these three parameters often drive and define a
software project.

1. Cost: As the main cost of producing software is the manpower employed, the
cost of developing software is generally measured in terms of person-months
of effort spent in development. The productivity in the software industry for
writing fresh code generally ranges from a few hundred to about 1000 + LOC
per person per month.
2. Schedule: The schedule is another important factor in many projects.
Business trends are dictating that the time to market a product should be
reduced; that is, the cycle time from concept to delivery should be small. this
means that software needs to be developed faster and within the specified
time.
3. Quality: Quality is one of the main mantras, and business strategies are
designed around it. Developing high-quality software is another fundamental
goal of software engineering.

8
 SOFTWARE ENGINEERING (Unit I)
The international standard on software product quality suggests that software
quality comprises six main attributes:

 Reliability: The capability to provide failure-free service.

 Functionality: The capability to provide functions that meet stated and
implied needs when the software is used.
 Usability: The capability to be understood, learned, and used.
 Efficiency: The capability to provide appropriate performance relative to the
amount of resources used.
 Maintainability: the capability to be modified for purposes of making
corrections, improvements, or adaptations.
 Portability: The capability to be adapted for different specified
environments without applying actions or means other than those provided
for this purpose in the product.

Types of Software

The software is used extensively in several domains including hospitals, banks,

schools, defense, finance, stock markets, and so on. It can be categorized into
different types:
 Based on Application
 Based on Copyright

Based on Application
1. System Software
System Software is necessary to manage computer resources and support the
execution of application programs. Software like operating systems, compilers,
editors and drivers, etc., come under this category. A computer cannot function
without the presence of these. Operating systems are needed to link the machine-
dependent needs of a program with the capabilities of the machine on which it
runs. Compilers translate programs from high-level language to machine
language.

2. Application Software
Application software is designed to fulfill the user‟s requirement by interacting
with the user directly. It could be classified into two major categories:- generic
or customized. Generic Software is software that is open to all and behaves the
same for all of its users. Its function is limited and not customized as per the
user‟s changing requirements. However, on the other hand, Customized software
is the software products designed per the client‟s requirement, and are not
available for all.

9
 SOFTWARE ENGINEERING (Unit I)
3. Networking and Web Applications Software
Networking Software provides the required support necessary for computers to
interact with each other and with data storage facilities. Networking software is
also used when software is running on a network of computers (such as the
World Wide Web). It includes all network management software, server
software, security and encryption software, and software to develop web-based
applications like HTML, PHP, XML, etc.

4. Embedded Software
This type of software is embedded into the hardware normally in the Read-Only
Memory (ROM) as a part of a large system and is used to support certain
functionality under the control conditions. Examples are software used in
instrumentation and control applications like washing machines, satellites,
microwaves, etc.

Based on Copyright
1. Commercial Software
It represents the majority of software that we purchase from software companies,
commercial computer stores, etc. In this case, when a user buys software, they
acquire a license key to use it. Users are not allowed to make copies of the
software. The company owns the copyright of the program.

2. Shareware Software
Shareware software is also covered under copyright but the purchasers are
allowed to make and distribute copies with the condition that after testing the
software, if the purchaser adopts it for use, then they must pay for it. In both of
the above types of software, changes to the software are not allowed.

3. Freeware Software
In general, according to freeware software licenses, copies of the software can be
made both for archival and distribution purposes but here, distribution cannot be
for making a profit. Derivative works and modifications to the software are
allowed and encouraged. Decompiling of the program code is also allowed
without the explicit permission of the copyright holder.

4. Public Domain Software

In the case of public domain software, the original copyright holder explicitly
relinquishes all rights to the software. Hence software copies can be made both
for archival and distribution purposes with no restrictions on distribution.
Modifications to the software and reverse engineering are also allowed.

10
 SOFTWARE ENGINEERING (Unit I)
Types of Software Development projects
A software development company typically has a large number of on-going
projects. Each of these projects may be classified into software product development
projects or services type of projects.

Software product
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:

1. 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.
2. Customized Products:
Customized products are the systems that are commissioned by a particular
customer. Some contractor develops the software for that customer.

11
 SOFTWARE ENGINEERING (Unit I)
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 services
Software services projects refer to projects that involve providing software-related
services to clients or organizations. These projects typically focus on delivering
customized software solutions, consulting, implementation, maintenance, and support.
Here are some examples of software services projects:

1. Custom Software Development: These projects involve developing tailor-

made software solutions to meet specific client requirements. The development
team works closely with the client to understand their needs and design and
build software applications or systems that address those needs.

2. System Integration and Implementation: These projects involve integrating

software systems with existing infrastructure or other software applications.
The service provider ensures that the different components work together
seamlessly and that data flows smoothly between systems.

3. Software Consulting and Requirement Analysis: In these projects, software

consultants work with clients to assess their needs, analyze business processes,
12
 SOFTWARE ENGINEERING (Unit I)
and define software requirements. They provide expertise and guidance on
technology choices, system architecture, and best practices.

4. Software Testing and Quality Assurance: These projects focus on ensuring

the quality and reliability of software solutions. Software testers conduct
various testing activities, including functional testing, performance testing,
security testing, and user acceptance testing, to identify and resolve any issues
or defects.

5. Maintenance and Support: These projects involve providing ongoing

maintenance and support services for software applications. This includes
activities such as bug fixing, performance optimization, security updates, and
providing technical assistance to address any issues or questions that arise.

6. Software Upgrades and Enhancements: Projects involving upgrades and

enhancements aim to improve existing software solutions based on client
feedback, changing requirements, or emerging technologies. This may include
adding new features, enhancing functionality, improving user interfaces, or
optimizing performance.

7. Training and Documentation: These projects focus on providing training and

documentation to ensure clients can effectively use and maintain the software
solutions. This may involve conducting training sessions, creating user
manuals, technical guides, and knowledge bases.

8. Software Migration and Modernization: These projects involve migrating

software applications from legacy systems to newer platforms or technologies.
The service provider ensures a smooth transition and helps clients modernize
their software infrastructure.

9. Software-as-a-Service (SaaS) Development: SaaS projects involve

developing cloud-based software solutions that are delivered as services over
the internet. The service provider designs, develops, and deploys the software
solution, taking care of infrastructure, maintenance, and updates.

10. Data Migration and Integration: Projects focused on data migration and
integration involve transferring data from one system to another, ensuring data
integrity and consistency. The service provider designs and implements
strategies to migrate and integrate data across different platforms or databases.

13
 SOFTWARE ENGINEERING (Unit I)
Emergence of Software Engineering
Software engineering discipline is the result of advancement in the field of
technology. In this section, we will discuss various innovations and technologies
that led to the emergence of software engineering discipline.

 Early Computer Programming

 High Level Language Programming
 Control Flow Based Design
 Data Structure-Oriented Design
 Data Flow-Oriented Design
 Object Oriented Design

Early Computer Programming

As we know that in the early 1950s, computers were slow and expensive. Though
the programs at that time were very small in size, these computers took
considerable time to process them. They relied on assembly language which was
specific to computer architecture. Thus, developing a program required lot of
effort. Every programmer used his own style to develop the programs.
High Level Language Programming

With the introduction of semiconductor technology, the computers became

smaller, faster, cheaper, and reliable than their predecessors. One of the major
developments includes the progress from assembly language to high-level
languages. Early high level programming languages such as COBOL and
FORTRAN came into existence. As a result, the programming became easier and
thus, increased the productivity of the programmers. However, still the programs
were limited in size and the programmers developed programs using their own
style and experience.
Control Flow Based Design

With the advent of powerful machines and high level languages, the usage of
computers grew rapidly: In addition, the nature of programs also changed from
simple to complex. The increased size and the complexity could not be managed
by individual style. It was analyzed that clarity of control flow (the sequence in
which the program‟s instructions are executed) is of great importance. To help the
programmer to design programs having good control flow
structure, flowcharting technique was developed. In flowcharting technique, the
algorithm is represented using flowcharts. A flowchart is a graphical
representation that depicts the sequence of operations to be carried out to solve a
given problem.

14
 SOFTWARE ENGINEERING (Unit I)
Note that having more GOTO constructs in the
flowchart makes the control flow messy, which
makes it difficult to understand and debug. In “A Program’s control flow
order to provide clarity of control flow, the use of structure indicates the
GOTO constructs in flowcharts should be avoided sequence in which the
and structured constructs-decision, sequence, program’s instructions are
and loop-should be used to develop structured executed”
flowcharts. The decision structures are used for
conditional execution of statements (for example,
if statement). The sequence structures are used for the sequentially executed
statements. The loop structures are used for performing some repetitive tasks in
the program. The use of structured constructs formed the basis of the structured
programming methodology.
Structured programming became a powerful tool that allowed programmers to
write moderately complex programs easily. It forces a logical structure in the
program to be written in an efficient and understandable manner. The purpose of
structured programming is to make the software code easy to modify when
required. Some languages such as Ada, Pascal, and dBase are designed with
features that implement the logical program structure in the software code.
Data Structure-Oriented Design
Computers became even more powerful with
the advent of integrated circuits (ICs) in the “Using data structure-oriented
early seventies. These could now be used to design techniques, first a
solve more complex problems. Software program's data structures are
developers were tasked to develop larger and designed. The code structure is
more complicated software. This often designed based on the data
required writing in excess of several tens of structure.”
thousands of lines of source code. The control
flow-based program development techniques
could not be used satisfactorily any more to
write those programs, and more effective program development techniques were
needed.
An example of a data structure-oriented design technique is the Jackson's
Structured Programming (JSP) technique developed by Michael Jackson [1975].
In JSP methodology, a program's data structure is first designed using the
notations for sequence, selection, and iteration. The JSP methodology provides an
interesting technique to derive the program structure from its data structure
representation. Several other data structure- based design techniques were also
developed. Some of these techniques became very popular and were extensively
used.

15
 SOFTWARE ENGINEERING (Unit I)
Data-Flow Oriented Design
“The data flow-oriented
With the introduction of very Large Scale
techniques advocate that the
Integrated circuits (VLSI), the computers
became more powerful and faster. As a result, major data items handled by a
various significant developments like system must be identified and
networking and GUIs came into being. Clearly, the processing required on these
the complexity of software could not be dealt data items to produce the
using control flow based design. Thus, a new desired outputs should be
technique, namely, data-flow- determined.”
oriented technique came into existence. In this
technique, the flow of data through business
functions or processes is represented using Data-flow Diagram (DFD).
IEEE defines a data-flow diagram (also known as bubble chart and work-flow
diagram) as „a diagram that depicts data sources, data sinks, data storage, and
processes performed on data as nodes, and logical flow of data as links between
the nodes.‟
Object Oriented Design

Object-oriented design technique has revolutionized the process of software

development. It not only includes the best features of structured programming but
also some new and powerful features such as encapsulation, abstraction,
inheritance, and polymorphism. These new features have tremendously helped in
the development of well-designed and high-quality software. Object-oriented
techniques are widely used these days as they allow reusability of the code. They
lead to faster software development and high-quality programs. Moreover, they
are easier to adapt and scale, that is, large systems can be created by assembling
reusable subsystems.

16
 SOFTWARE ENGINEERING (Unit I)
Software Development Life Cycle (SDLC)
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.

In other words, 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.

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:

17
 SOFTWARE ENGINEERING (Unit I)
The stages of SDLC are as follows:

Stage1: Planning and requirement analysis

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

o The senior members of the team perform it with inputs from all the
stakeholders and domain experts or SMEs in the industry.
o Planning for the quality assurance requirements and identifications of the
risks associated with the projects is also done at this stage.
o 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.
o 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.
o 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.
o 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

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

o 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

o 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
18
 SOFTWARE ENGINEERING (Unit I)
management and programming tools like compilers, interpreters, debuggers,
etc. are used to develop and implement the code.

Stage5: Testing

o 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.
o During this stage, unit testing, integration testing, system testing, acceptance
testing are done.

Stage6: Deployment

o Once the software is certified, and no bugs or errors are stated, then it is
deployed.
o Then based on the assessment, the software may be released as it is or with
suggested enhancement in the object segment.
o After the software is deployed, then its maintenance begins.

Stage7: Maintenance

o Once when the client starts using the developed systems, then the real issues
come up and requirements to be solved from time to time.
o This procedure where the care is taken for the developed product is known
as maintenance.

SDLC Models

Software Development life cycle (SDLC) is a spiritual model used in project

management that defines the stages include in an information system development
project, from an initial feasibility study to the maintenance of the completed
application.

There are different software development life cycle models specify and design,
which are followed during the software development phase. These models are also
called "Software Development Process Models." Each process model follows a
series of phase unique to its type to ensure success in the step of software
development.

19
 SOFTWARE ENGINEERING (Unit I)
Here, are some important phases of SDLC life cycle:

Waterfall Model
The Waterfall Model was the first Process Model to be introduced. It is also
referred to as a linear-sequential life cycle model. It is very simple to understand
and use. In a waterfall model, each phase must be completed before the next phase
can begin and there is no overlapping in the phases.
The Waterfall model is the earliest SDLC approach that was used for software
development.
The waterfall Model illustrates the software development process in a linear
sequential flow. This means that any phase in the development process begins only
if the previous phase is complete. In this waterfall model, the phases do not
overlap.
Waterfall Model - Design
Waterfall approach was first SDLC Model to be used widely in Software
Engineering to ensure success of the project. In "The Waterfall" approach, the
whole process of software development is divided into separate phases. In this
Waterfall model, typically, the outcome of one phase acts as the input for the next
phase sequentially.

20
 SOFTWARE ENGINEERING (Unit I)
The following illustration is a representation of the different phases of the
Waterfall Model.

The sequential phases in Waterfall model are −

 Requirement Gathering and analysis − All possible requirements of the
system to be developed are captured in this phase and documented in a
requirement specification document.
 System 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.
 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.
 Integration and 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.
 Deployment of system − Once the functional and non-functional testing is
done; the product is deployed in the customer environment or released into
the market.
 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.

21
 SOFTWARE ENGINEERING (Unit I)
All these phases are cascaded to each other in which progress is seen as flowing
steadily downwards (like a waterfall) through the phases. The next phase is started
only after the defined set of goals are achieved for previous phase and it is signed
off, so the name "Waterfall Model". In this model, phases do not overlap.
Waterfall Model - Application
Every software developed is different and requires a suitable SDLC approach to be
followed based on the internal and external factors. Some situations where the use
of 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.

Waterfall Model - Advantages

The advantages of waterfall development are that it allows for departmentalization
and control. A schedule can be set with deadlines for each stage of development
and a product can proceed through the development process model phases one by
one.
Development moves from concept, through design, implementation, testing,
installation, troubleshooting, and ends up at operation and maintenance. Each
phase of development proceeds in strict order.
Some of the 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.

Waterfall Model - Disadvantages

The disadvantage of waterfall development is that it does not allow much
reflection or revision. Once an application is in the testing stage, it is very difficult

22
 SOFTWARE ENGINEERING (Unit I)
to go back and change something that was not well-documented or thought upon in
the concept stage.
The major disadvantages of the Waterfall Model are as follows −
 No working software is produced until late during the life cycle.
 High amounts of risk and uncertainty.
 Not a good model for complex and object-oriented projects.
 Poor model for long and ongoing projects.
 Not suitable for the projects where requirements are at a moderate to high
risk of changing. So, risk and uncertainty is high with this process model.
 It is difficult to measure progress within stages.
 Cannot accommodate changing requirements.
 Adjusting scope during the life cycle can end a project.
 Integration is done as a "big-bang. at the very end, which doesn't allow
identifying any technological or business bottleneck or challenges early.

RAD (Rapid Application Development) Model

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:

o Gathering requirements using workshops or focus groups

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

In the RAD model, the functional modules are developed in parallel as prototypes
and are integrated to make the complete product for faster product delivery. Since
there is no detailed preplanning, it makes it easier to incorporate the changes
within the development process.

23
 SOFTWARE ENGINEERING (Unit I)

Business Modelling
The business model for the product under development is designed in terms
of flow of information and the distribution of information between various
business channels. A complete business analysis is performed to find the vital
information for business, how it can be obtained, how and when is the information
processed and what are the factors driving successful flow of information.
Data Modelling
The information gathered in the Business Modelling phase is reviewed and
analyzed to form sets of data objects vital for the business. The attributes of all
data sets is identified and defined. The relation between these data objects are
established and defined in detail in relevance to the business model.
Process Modelling
The data object sets defined in the Data Modelling phase are converted to
establish the business information flow needed to achieve specific business
objectives as per the business model. The process model for any changes or
enhancements to the data object sets is defined in this phase. Process descriptions
for adding, deleting, retrieving or modifying a data object are given.
Application Generation
The actual system is built and coding is done by using automation tools to
convert process and data models into actual prototypes.

24
 SOFTWARE ENGINEERING (Unit I)
Testing and Turnover
The overall testing time is reduced in the RAD model as the prototypes are
independently tested during every iteration. However, the data flow and the
interfaces between all the components need to be thoroughly tested with complete
test coverage. Since most of the programming components have already been
tested, it reduces the risk of any major issues.

Advantages of RAD:

 The use of reusable components helps to reduce the cycle time of the
project.
 Feedback from the customer is available at the initial stages.
 Reduced costs as fewer developers are required.
 The use of powerful development tools results in better quality products in
comparatively shorter time spans.
 The progress and development of the project can be measured through the
various stages.
 It is easier to accommodate changing requirements due to the short
iteration time spans.
 Productivity may be quickly boosted with a lower number of employees.

Disadvantages of RAD:

 The use of powerful and efficient tools requires highly skilled

professionals.
 The absence of reusable components can lead to the failure of the project.
 The team leader must work closely with the developers and customers to
close the project on time.
 The systems which cannot be modularized suitably cannot use this model.
 Customer involvement is required throughout the life cycle.
 It is not meant for small-scale projects as in such cases, the cost of using
automated tools and techniques may exceed the entire budget of the
project.
 Not every application can be used with RAD.

Applications of RAD:

1. This model should be used for a system with known requirements and
requiring a short development time.
2. It is also suitable for projects where requirements can be modularized and
reusable components are also available for development.

25
 SOFTWARE ENGINEERING (Unit I)
3. The model can also be used when already existing system components can be
used in developing a new system with minimum changes.
4. This model can only be used if the teams consist of domain experts. This is
because relevant knowledge and the ability to use powerful techniques are a
necessity.
5. The model should be chosen when the budget permits the use of automated
tools and techniques required.

Drawbacks of rapid application development:

 It requires multiple teams or a large number of people to work on the

scalable projects.
 This model requires heavily committed developer and customers. If
commitment is lacking then RAD projects will fail.
 The projects using RAD model requires heavy resources.
 If there is no appropriate modularization then RAD projects fail.
Performance can be problem to such projects.
 The projects using RAD model find it difficult to adopt new technologies.

Agile Model
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.

In earlier days, the Iterative Waterfall model was very popular for
completing a project. But nowadays, developers face various problems while
using it to develop software. The main difficulties included handling customer
change requests during project development and the high cost and time required
to incorporate these changes.

To overcome these drawbacks of the Waterfall model, in the mid-1990s

the Agile Software Development model was proposed. The Agile model was
primarily designed to help a project adapt quickly to change requests. So, the
main aim of the Agile model is to facilitate quick project completion. To
accomplish this task, agility is required. Agility is achieved by fitting the process
to the project and removing activities that may not be essential for a specific
project. Also, anything that is a waste of time and effort is avoided.

26
 SOFTWARE ENGINEERING (Unit I)
The agile model refers to a group of development processes. These processes
share some basic characteristics but do have certain subtle differences among
themselves.

Following are the phases in the Agile model are as follows:

1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback

1. Requirements gathering: In this phase, you must define the requirements. You
should explain business opportunities and plan the time and effort needed to build
the project. Based on this information, you can evaluate technical and economic
feasibility.

2. Design the requirements: When you have identified the project, work with
stakeholders to define requirements. You can use the user flow diagram or the
high-level UML diagram to show the work of new features and show how it will
apply to your existing system.

27
 SOFTWARE ENGINEERING (Unit I)
3. Construction/ iteration: When the team defines the requirements, the work
begins. Designers and developers start working on their project, which aims to
deploy a working product. The product will undergo various stages of
improvement, so it includes simple, minimal functionality.

4. Testing: In this phase, the Quality Assurance team examines the product's
performance and looks for the bug.

5. Deployment: In this phase, the team issues a product for the user's work
environment.

6. Feedback: After releasing the product, the last step is feedback. In this, the team
receives feedback about the product and works through the feedback.

Agile Testing Methods:

o Scrum
o Crystal
o Dynamic Software Development Method(DSDM)
o Feature Driven Development(FDD)
o Lean Software Development
o eXtreme Programming(XP)

Scrum
SCRUM is an agile development process focused primarily on ways to manage
tasks in team-based development conditions.

There are three roles in it, and their responsibilities are:

o Scrum Master: The scrum can set up the master team, arrange the meeting
and remove obstacles for the process
o Product owner: The product owner makes the product backlog, prioritizes
the delay and is responsible for the distribution of functionality on each
repetition.
o Scrum Team: The team manages its work and organizes the work to
complete the sprint or cycle.

28
 SOFTWARE ENGINEERING (Unit I)
eXtreme Programming(XP)
This type of methodology is used when customers are constantly changing
demands or requirements, or when they are not sure about the system's
performance.

Crystal:
There are three concepts of this method-

1. Chartering: Multi activities are involved in this phase such as making a

development team, performing feasibility analysis, developing plans, etc.
2. Cyclic delivery: under this, two more cycles consist, these are:
A. Team updates the release plan.
B. Integrated product delivers to the users.
Wrap up: According to the user environment, this phase performs
deployment, post-deployment.

Dynamic Software Development Method(DSDM):

DSDM is a rapid application development strategy for software development and
gives an agile project distribution structure. The essential features of DSDM are
that users must be actively connected, and teams have been given the right to make
decisions. The techniques used in DSDM are:

1. Time Boxing
2. MoSCoW Rules
3. Prototyping

When to use the Agile Model?

o When frequent changes are required.
o When a highly qualified and experienced team is available.
o When a customer is ready to have a meeting with a software team all the
time.
o When project size is small.

29
 SOFTWARE ENGINEERING (Unit I)
Advantage(Pros) of Agile Method:
1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.
5. It reduces total development time.

Disadvantages(Cons) of Agile Model:

1. Due to the shortage of formal documents, it creates confusion and crucial
decisions taken throughout various phases can be misinterpreted at any time
by different team members.
2. Due to the lack of proper documentation, once the project completes and the
developers allotted to another project, maintenance of the finished project
can become a difficulty.

Spiral Model
Spiral model is one of the most important Software Development Life Cycle
models, which provides support for Risk Handling. In its diagrammatic
representation, it looks like a spiral with many loops. The exact number of loops
of the spiral is unknown and can vary from project to project. Each loop of the
spiral is called a Phase of the software development process.

The exact number of phases needed to

develop the product can be varied by the
project manager depending upon the project
risks. As the project manager dynamically
determines the number of phases, so the
project manager has an important role to
develop a product using the spiral model.

The Spiral Model is a software

development life cycle (SDLC) model that
provides a systematic and iterative approach
to software development. It is based on the
idea of a spiral, with each iteration of the
spiral representing a complete software development cycle, from requirements
gathering and analysis to design, implementation, testing, and maintenance.

30
 SOFTWARE ENGINEERING (Unit I)
The Spiral Model is a risk-driven model, meaning that the focus is on managing
risk through multiple iterations of the software development process. It consists
of the following phases:
1. Planning: The first phase of the Spiral Model is the planning phase, where
the scope of the project is determined and a plan is created for the next
iteration of the spiral.
2. Risk Analysis: In the risk analysis phase, the risks associated with the
project are identified and evaluated.
3. Engineering: In the engineering phase, the software is developed based on
the requirements gathered in the previous iteration.
4. Evaluation: In the evaluation phase, the software is evaluated to determine if
it meets the customer‟s requirements and if it is of high quality.
5. Planning: The next iteration of the spiral begins with a new planning phase,
based on the results of the evaluation.
6. The Spiral Model is often used for complex and large software development
projects, as it allows for a more flexible and adaptable approach to software
development. It is also well-suited to projects with significant uncertainty or
high levels of risk.

31
 SOFTWARE ENGINEERING (Unit I)
The functions of these four quadrants are discussed below
1. Objectives determination and identify alternative solutions:
Requirements are gathered from the customers and the objectives are
identified, elaborated, and analyzed at the start of every phase. Then
alternative solutions possible for the phase are proposed in this quadrant.

2. Identify and resolve Risks: During the second quadrant, all the possible
solutions are evaluated to select the best possible solution. Then the risks
associated with that solution are identified and the risks are resolved using
the best possible strategy. At the end of this quadrant, the Prototype is built
for the best possible solution.

3. Develop next version of the Product: During the third quadrant, the
identified features are developed and verified through testing. At the end of
the third quadrant, the next version of the software is available.

4. Review and plan for the next Phase: In the fourth quadrant, the Customers
evaluate the so far developed version of the software. In the end, planning for
the next phase is started.

Why Spiral Model is called Meta Model?

The Spiral model is called a Meta-Model because it subsumes all the other
SDLC models. For example, a single loop spiral actually represents the Iterative
Waterfall Model. The spiral model incorporates the stepwise approach of
the Classical Waterfall Model. The spiral model uses the approach of
the Prototyping Model by building a prototype at the start of each phase as a
risk-handling technique. Also, the spiral model can be considered as supporting
the Evolutionary model – the iterations along the spiral can be considered as
evolutionary levels through which the complete system is built.

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.

32
 SOFTWARE ENGINEERING (Unit I)
5. Iterative and Incremental Approach: The Spiral Model provides an
iterative and incremental approach to software development, allowing for
flexibility and adaptability in response to changing requirements or
unexpected events.
6. Emphasis on Risk Management: The Spiral Model places a strong
emphasis on risk management, which helps to minimize the impact of
uncertainty and risk on the software development process.
7. Improved Communication: The Spiral Model provides for regular
evaluations and reviews, which can improve communication between the
customer and the development team.
8. Improved Quality: The Spiral Model allows for multiple iterations of the
software development process, which can result in improved software quality
and reliability

Disadvantages of 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.
5. Complexity: The Spiral Model can be complex, as it involves multiple
iterations of the software development process.
6. Time-Consuming: The Spiral Model can be time-consuming, as it requires
multiple evaluations and reviews.
7. Resource Intensive: The Spiral Model can be resource-intensive, as it
requires a significant investment in planning, risk analysis, and evaluations.

33