SOFTWARE

ENGINEERING

Unit – I Introduction to Software Engineering – Software Engineering

Software is a program or set of programs containing instructions that provide the

desired functionality. Engineering is the process of designing and building something
that serves a particular purpose and finds a cost-effective solution to problems

What is Software Engineering?

Software Engineering is the process of designing, developing, testing, and

maintaining software. It is a systematic and disciplined approach to software
development that aims to create high-quality, reliable, and maintainable software.

1. Software engineering includes a variety of techniques, tools, and

methodologies, including requirements analysis, design, testing, and
maintenance.

2. It is a rapidly evolving field, and new tools and technologies are constantly
being developed to improve the software development process.

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

4. Software Engineering is mainly used for large projects based on software

systems rather than single programs or applications.

5. The main goal of Software Engineering is to develop software applications for

improving quality, budget, and time efficiency.

6. Software Engineering ensures that the software that has to be built should be
consistent, correct, also on budget, on time, and within the required
requirements.
Key Principles of Software Engineering

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.

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.

Main Attributes of Software Engineering

Software Engineering is a systematic, disciplined, quantifiable study and approach to

the design, development, operation, and maintenance of a software system. There
are four main Attributes of Software Engineering.

1. Efficiency: It provides a measure of the resource requirement of a software

product efficiently.

2. Reliability: It assures that the product will deliver the same results when used
in similar working environment.

3. Reusability: This attribute makes sure that the module can be used in multiple
applications.

4. Maintainability: It is the ability of the software to be modified, repaired, or

enhanced easily with changing requirements.
Dual Role of Software

There is a dual role of software in the industry. The first one is as a product and the
other one is as a vehicle for delivering the product. We will discuss both of them.

1. As a Product

 It delivers 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

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

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

Advantages of Software Engineering

There are several advantages to using a systematic and disciplined approach to
software development, such as:

1. Improved Quality: By following established software engineering principles

and techniques, the software can be developed with fewer bugs and higher
reliability.

2. Increased Productivity: Using modern tools and methodologies can streamline

the development process, allowing developers to be more productive and
complete projects faster.

3. Better Maintainability: Software that is designed and developed using sound

software engineering practices is easier to maintain and update over time.
 4. Reduced Costs: By identifying and addressing potential problems early in the
development process, software engineering can help to reduce the cost of
fixing bugs and adding new features later on.

5. Increased Customer Satisfaction: By involving customers in the development

process and developing software that meets their needs, software
engineering can help to increase customer satisfaction.

6. Better Team Collaboration: By using Agile methodologies and continuous

integration, software engineering allows for better collaboration among
development teams.

7. Better Scalability: By designing software with scalability in mind, software

engineering can help to ensure that software can handle an increasing
number of users and transactions.

8. Better Security: By following the Software Development Life Cycle (SDLC)

and performing security testing, software engineering can help to prevent
security breaches and protect sensitive data.

In summary, software engineering offers a structured and efficient approach to

software development, which can lead to higher-quality software that is easier to
maintain and adapt to changing requirements. This can help to improve customer
satisfaction and reduce costs, while also promoting better collaboration among
development teams.

Disadvantages of Software Engineering

While Software Engineering offers many advantages, there are also some potential
disadvantages to consider:
1. High upfront costs: Implementing a systematic and disciplined approach to
software development can be resource-intensive and require a significant
investment in tools and training.

2. Limited flexibility: Following established software engineering principles and

methodologies can be rigid and may limit the ability to quickly adapt to
changing requirements.

3. Bureaucratic: Software Engineering can create an environment that is

bureaucratic, with a lot of processes and paperwork, which may slow down
the development process.

4. Complexity: With the increase in the number of tools and methodologies,

software engineering can be complex and difficult to navigate.

5. Limited creativity: The focus on structure and process can stifle creativity and
innovation among developers.
 6. High learning curve: The development process can be complex, and it
requires a lot of learning and training, which can be challenging for new
developers.

7. High dependence on tools: Software engineering heavily depends on the

tools, and if the tools are not properly configured or are not compatible with
the software, it can cause issues.

8. High maintenance: The software engineering process requires regular

maintenance to ensure that the software is running efficiently, which can be
costly and time-consuming.

In summary, software engineering can be expensive and time-consuming, and it may

limit flexibility and creativity. However, the benefits of improved quality, increased
productivity, and better maintainability can outweigh the costs and complexity. It’s
important to weigh the pros and cons of using software engineering and determine if
it is the right approach for a particular software project.
Software Characteristics – Software Engineering

Software is defined as a collection of computer programs, procedures, rules, and

data. Software Characteristics are classified into six major components. Software
engineering is the process of designing, developing, testing, and maintaining
software.
Components of Software Characteristics

There are 6 components of Software Characteristics are discussed here. We

will discuss each one of them in detail.

Functionality:

It refers to the degree of performance of the software against its intended purpose.

Functionality refers to the set of features and capabilities that a software program or
system provides to its users. It is one of the most important characteristics of
software, as it determines the usefulness of the software for the intended purpose.
Examples of functionality in software include:

 Data storage and retrieval

 Data processing and manipulation

 User interface and navigation

 Communication and networking

 Security and access control

 Reporting and visualization

 Automation and scripting
The more functionality a software has, the more powerful and versatile it is, but also
the more complex it can be. It is important to balance the need for functionality with
the need for ease of use, maintainability, and scalability.
Reliability:

A set of attributes that bears on the capability of software to maintain its level of
performance under the given condition for a stated period of time.

Reliability is a characteristic of software that refers to its ability to perform its

intended functions correctly and consistently over time. Reliability is an important
aspect of software quality, as it helps ensure that the software will work correctly and
not fail unexpectedly.

Examples of factors that can affect the reliability of software include:

1. Bugs and errors in the code

2. Lack of testing and validation

3. Poorly designed algorithms and data structures

4. Inadequate error handling and recovery

5. Incompatibilities with other software or hardware

To improve the reliability of software, various techniques, and methodologies can be

used, such as testing and validation, formal verification, and fault tolerance.
Software is considered reliable when the probability of it failing is low and it is able to
recover from the failure quickly, if any.
Efficiency:

It refers to the ability of the software to use system resources in the most effective
and efficient manner. The software should make effective use of storage space and
executive command as per desired timing requirements.

Efficiency is a characteristic of software that refers to its ability to use resources such
as memory, processing power, and network bandwidth in an optimal way. High
efficiency means that a software program can perform its intended functions quickly
and with minimal use of resources, while low efficiency means that a software
program may be slow or consume excessive resources.

Examples of factors that can affect the efficiency of the software include:

1. Poorly designed algorithms and data structures

2. Inefficient use of memory and processing power

3. High network latency or bandwidth usage

4. Unnecessary processing or computation
 5. Unoptimized code

To improve the efficiency of software, various techniques, and methodologies can be

used, such as performance analysis, optimization, and profiling.
Efficiency is important in software systems that are resource-constrained, high-
performance, and real-time systems. It is also important in systems that need to
handle many users or transactions simultaneously.
Usability:

It refers to the extent to which the software can be used with ease. the amount of
effort or time required to learn how to use the software.
Maintainability:

It refers to the ease with which modifications can be made in a software system to
extend its functionality, improve its performance, or correct errors.
Portability:

A set of attributes that bears on the ability of software to be transferred from one
environment to another, without minimum changes.
Characteristics of “Software” in Software Engineering

1. Software is developed or engineered; it is not manufactured in the

classical sense:

 Although some similarities exist between software development and

hardware manufacturing, few activities are fundamentally different.

 In both activities, high quality is achieved through good design, but the
manufacturing phase for hardware can introduce quality problems than
software.
2. The software doesn’t “wear out.”:

 Hardware components suffer from the growing effects of many other

environmental factors. Stated simply, the hardware begins to wear out.

 Software is not susceptible to the environmental maladies that cause

hardware to wear out.

 When a hardware component wears out, it is replaced by a spare part.

 There are no software spare parts.

 Every software failure indicates an error in design or in the process

through which the design was translated into machine-executable
code. Therefore, the software maintenance tasks that accommodate
requests for change involve considerably more complexity than
 hardware maintenance. However, the implication is clear—the software
doesn’t wear out. But it does deteriorate.
3. The software continues to be custom-built:

 A software part should be planned and carried out with the goal that it
tends to be reused in various projects.

 Current reusable segments encapsulate the two pieces of information

and the preparation that is applied to the information, empowering the
programmer to make new applications from reusable parts.

 In the hardware world, component reuse is a natural part of the

engineering process.

Software Development Life Cycle (SDLC)

Software development life cycle (SDLC) is a structured process that is used to

design, develop, and test good-quality software. SDLC, or software development
life cycle, is a methodology that defines the entire procedure of software
development step-by-step.

Software Development Life Cycle (SDLC)

The goal of the SDLC life cycle model is to deliver high-quality, maintainable
software that meets the user’s requirements. SDLC in software engineering models
outlines the plan for each stage so that each stage of the software development
model can perform its task efficiently to deliver the software at a low cost within a
given time frame that meets users’ requirements.
What is the Software Development Life Cycle (SDLC)?
SDLC is a process followed for software building within a software
organization. SDLC consists of a precise plan that describes how to develop,
maintain, replace, and enhance specific software. The life cycle defines a method for
improving the quality of software and the all-around development process.
Stages of the Software Development Life Cycle

SDLC specifies the task(s) to be performed at various stages by a software engineer

or developer. It ensures that the end product is able to meet the customer’s
expectations and fits within the overall budget. Hence, it’s vital for a software
developer to have prior knowledge of this software development process. SDLC is a
collection of these six stages, and the stages of SDLC are as follows:

Software Development Life Cycle Model SDLC Stages

The SDLC Model involves six phases or stages while developing any software.

Stage-1: Planning and Requirement Analysis

Planning is a crucial step in everything, just as in software development. In this same

stage, requirement analysis is also performed by the developers of the organization.
This is attained from customer inputs, and sales department/market surveys.

The information from this analysis forms the building blocks of a basic project. The
quality of the project is a result of planning. Thus, in this stage, the basic project is
designed with all the available information.
Stage-1 : Planning and Requirement Analysis
Stage-2: Defining Requirements

In this stage, all the requirements for the target software are specified. These
requirements get approval from customers, market analysts, and stakeholders.
This is fulfilled by utilizing SRS (Software Requirement Specification). This is a sort
of document that specifies all those things that need to be defined and created
during the entire project cycle.

Stage-2 : Defining Requirements

Stage-3: Designing Architecture
SRS is a reference for software designers to come up with the best architecture for
the software. Hence, with the requirements defined in SRS, multiple designs for the
product architecture are present in the Design Document Specification (DDS).

This DDS is assessed by market analysts and stakeholders. After evaluating all the
possible factors, the most practical and logical design is chosen for development.

Stage 3: Design
Stage-4: Developing Product

At this stage, the fundamental development of the product starts. For this,
developers use a specific programming code as per the design in the DDS. Hence, it
is important for the coders to follow the protocols set by the association.
Conventional programming tools like compilers, interpreters, debuggers, etc. are
also put into use at this stage. Some popular languages like C/C++, Python, Java,
etc. are put into use as per the software regulations.
Stage 4: Development
Stage-5: Product Testing and Integration

After the development of the product, testing of the software is necessary to ensure
its smooth execution. Although, minimal testing is conducted at every stage of
SDLC. Therefore, at this stage, all the probable flaws are tracked, fixed, and
retested. This ensures that the product confronts the quality requirements of SRS.
Documentation, Training, and Support: Software documentation is an essential
part of the software development life cycle. A well-written document acts as a tool
and means to information repository necessary to know about software processes,
functions, and maintenance. Documentation also provides information about how to
use the product. Training in an attempt to improve the current or future employee
performance by increasing an employee’s ability to work through learning, usually by
changing his attitude and developing his skills and understanding.
Stage 5: Testing
Stage-6: Deployment and Maintenance of Products

After detailed testing, the conclusive product is released in phases as per the
organization’s strategy. Then it is tested in a real industrial environment. It is
important to ensure its smooth performance. If it performs well, the organization
sends out the product as a whole. After retrieving beneficial feedback, the company
releases it as it is or with auxiliary improvements to make it further helpful for the
customers. However, this alone is not enough. Therefore, along with the deployment,
the product’s supervision.
 Unit – II Software requirement specification:

Software Processes in Software Engineering

Software is the set of instructions in the form of programs to govern the computer
system and to process the hardware components. To produce a software product the
set of activities is used. This set is called a software process.
What are Software Processes?

Software processes in software engineering refer to the methods and techniques

used to develop and maintain software. Some examples of software processes
include:
 Waterfall: a linear, sequential approach to software development, with distinct
phases such as requirements gathering, design, implementation, testing, and
maintenance.
 Agile: a flexible, iterative approach to software development, with an
emphasis on rapid prototyping and continuous delivery.
 Scrum: a popular Agile methodology that emphasizes teamwork, iterative
development, and a flexible, adaptive approach to planning and management.
 DevOps: a set of practices that aims to improve collaboration and
communication between development and operations teams, with an
emphasis on automating the software delivery process.

Each process has its own set of advantages and disadvantages, and the choice of
which one to use depends on the specific project and organization.
Components of Software

There are three main components of the software:

 1. Program: A computer program is a list of instructions that tell a computer
what to do.
2. Documentation: Source information about the product contained in design
documents, detailed code comments, etc.
3. Operating Procedures: Set of step-by-step instructions compiled by an
organization to help workers carry out complex routine operations.
Other Software Components

Other Software Components are:

1. Code: the instructions that a computer executes in order to perform a specific
task or set of tasks.
2. Data: the information that the software uses or manipulates.

3. User interface: the means by which the user interacts with the software, such
as buttons, menus, and text fields.
4. Libraries: pre-written code that can be reused by the software to perform
common tasks.
5. Documentation: information that explains how to use and maintain the
software, such as user manuals and technical guides.
6. Test cases: a set of inputs, execution conditions, and expected outputs that
are used to test the software for correctness and reliability.
7. Configuration files: files that contain settings and parameters that are used
to configure the software to run in a specific environment.
8. Build and deployment scripts: scripts or tools that are used to build,
package, and deploy the software to different environments.
9. Metadata: information about the software, such as version numbers, authors,
and copyright information.

All these components are important for software development, testing and
deployment.
Key Process Activities

There four basic key process activities are:

1. Software Specifications: In this process, detailed description of a software
system to be developed with its functional and non-functional requirements.
2. Software Development: In this process, designing, programming,
documenting, testing, and bug fixing is done.
3. Software Validation: In this process, evaluation software product is done to
ensure that the software meets the business requirements as well as the end
users needs.
4. Software Evolution: It is a process of developing software initially, then
timely updating it for various reasons.

Waterfall Model – Software Engineering

The classical waterfall model is the basic software development life

cycle model. It is very simple but idealistic. Earlier this model was very
popular but nowadays it is not used. However, it is very important because all
the other software development life cycle models are based on the classical
waterfall model.
What is the SDLC Waterfall Model?

The waterfall model is a software development model used in the context of

large, complex projects, typically in the field of information technology. It is
characterized by a structured, sequential approach to project management
and software development.
The waterfall model is useful in situations where the project requirements are
well-defined and the project goals are clear. It is often used for large-scale
projects with long timelines, where there is little room for error and the project
stakeholders need to have a high level of confidence in the outcome.
Features of the SDLC Waterfall Model

1. Sequential Approach: The waterfall model involves a sequential approach to

software development, where each phase of the project is completed before
moving on to the next one.
2. Document-Driven: The waterfall model relies heavily on documentation to
ensure that the project is well-defined and the project team is working towards
a clear set of goals.
3. Quality Control: The waterfall model places a high emphasis on quality
control and testing at each phase of the project, to ensure that the final
product meets the requirements and expectations of the stakeholders.
4. Rigorous Planning: The waterfall model involves a rigorous planning
process, where the project scope, timelines, and deliverables are carefully
defined and monitored throughout the project lifecycle.
 Overall, the waterfall model is used in situations where there is a need for a
highly structured and systematic approach to software development. It can be
effective in ensuring that large, complex projects are completed on time and
within budget, with a high level of quality and customer satisfaction.
Importance of SDLC Waterfall Model

1. Clarity and Simplicity: The linear form of the Waterfall Model offers a simple
and unambiguous foundation for project development.
2. Clearly Defined Phases: The Waterfall Model’s phases each have unique
inputs and outputs, guaranteeing a planned development with obvious
checkpoints.
3. Documentation: A focus on thorough documentation helps with software
comprehension, upkeep, and future growth.
4. Stability in Requirements: Suitable for projects when the requirements are
clear and steady, reducing modifications as the project progresses.
5. Resource Optimization: It encourages effective task-focused work without
continuously changing contexts by allocating resources according to project
phases.
6. Relevance for Small Projects: Economical for modest projects with simple
specifications and minimal complexity.
Phases of SDLC Waterfall Model – Design

The Waterfall Model is a classical software development methodology that

was first introduced by Winston W. Royce in 1970. It is a linear and sequential
approach to software development that consists of several phases that must
be completed in a specific order.

The Waterfall Model has six phases which are:

1. Requirements: The first phase involves gathering requirements from
stakeholders and analyzing them to understand the scope and objectives of
the project.
2. Design: Once the requirements are understood, the design phase begins.
This involves creating a detailed design document that outlines the software
architecture, user interface, and system components.
3. Development: The Development phase include implementation involves
coding the software based on the design specifications. This phase also
includes unit testing to ensure that each component of the software is working
as expected.
 4. Testing: In the testing phase, the software is tested as a whole to ensure that
it meets the requirements and is free from defects.
5. Deployment: Once the software has been tested and approved, it is
deployed to the production environment.
6. Maintenance: The final phase of the Waterfall Model is maintenance, which
involves fixing any issues that arise after the software has been deployed and
ensuring that it continues to meet the requirements over time.

The classical waterfall model divides the life cycle into a set of phases. This
model considers that one phase can be started after the completion of the
previous phase. That is the output of one phase will be the input to the next
phase. Thus the development process can be considered as a sequential flow
in the waterfall. Here the phases do not overlap with each other. The different
sequential phases of the classical waterfall model are shown in the below
figure.

Let us now learn about each of these phases in detail which include further phases.
1. Feasibility Study:

The main goal of this phase is to determine whether it would be financially

and technically feasible to develop the software.
The feasibility study involves understanding the problem and then determining
the various possible strategies to solve the problem. These different identified
solutions are analyzed based on their benefits and drawbacks, The best
solution is chosen and all the other phases are carried out as per this solution
strategy.
2. Requirements Analysis and Specification:

The requirement analysis and specification phase aims to understand the

exact requirements of the customer and document them properly. This phase
consists of two different activities.
 Requirement gathering and analysis: Firstly all the requirements regarding
the software are gathered from the customer and then the gathered
requirements are analyzed. The goal of the analysis part is to remove
incompleteness (an incomplete requirement is one in which some parts of the
actual requirements have been omitted) and inconsistencies (an inconsistent
requirement is one in which some part of the requirement contradicts some
other part).
 Requirement specification: These analyzed requirements are documented
in a software requirement specification (SRS) document. SRS document
serves as a contract between the development team and customers. Any
 future dispute between the customers and the developers can be settled by
examining the SRS document.
3. Design:

The goal of this phase is to convert the requirements acquired in the SRS into
a format that can be coded in a programming language. It includes high-level
and detailed design as well as the overall software architecture. A Software
Design Document is used to document all of this effort (SDD).
4. Coding and Unit Testing:

In the coding phase software design is translated into source code using any
suitable programming language. Thus each designed module is coded. The
unit testing phase aims to check whether each module is working properly or
not.
5. Integration and System testing:

Integration of different modules is undertaken soon after they have been

coded and unit tested. Integration of various modules is carried out
incrementally over several steps. During each integration step, previously
planned modules are added to the partially integrated system and the
resultant system is tested. Finally, after all the modules have been
successfully integrated and tested, the full working system is obtained and
system testing is carried out on this.
System testing consists of three different kinds of testing activities as
described below.
 Alpha testing: Alpha testing is the system testing performed by the
development team.
 Beta testing: Beta testing is the system testing performed by a friendly set of
customers.
 Acceptance testing: After the software has been delivered, the customer
performs acceptance testing to determine whether to accept the delivered
software or reject it.
6. Maintenance:

Maintenance is the most important phase of a software life cycle. The effort
spent on maintenance is 60% of the total effort spent to develop a full
software. There are three types of maintenance.
 Corrective Maintenance: This type of maintenance is carried out to correct
errors that were not discovered during the product development phase.
 Perfective Maintenance: This type of maintenance is carried out to enhance
the functionalities of the system based on the customer’s request.
  Adaptive Maintenance: Adaptive maintenance is usually required for porting
the software to work in a new environment such as working on a new
computer platform or with a new operating system.

Advantages of the SDLC Waterfall Model

The classical waterfall model is an idealistic model for software development. It is

very simple, so it can be considered the basis for other software development life
cycle models. Below are some of the major advantages of this SDLC model.
 Easy to Understand: The Classical Waterfall Model is very simple and easy
to understand.
 Individual Processing: Phases in the Classical Waterfall model are
processed one at a time.
 Properly Defined: In the classical waterfall model, each stage in the model is
clearly defined.
 Clear Milestones: The classical Waterfall model has very clear and well-
understood milestones.
 Properly Documented: Processes, actions, and results are very well
documented.
 Reinforces Good Habits: The Classical Waterfall Model reinforces good
habits like define-before-design and design-before-code.
 Working: Classical Waterfall Model works well for smaller projects and
projects where requirements are well understood.
Disadvantages of the SDLC Waterfall Model

The Classical Waterfall Model suffers from various shortcomings we can’t use it in
real projects, but we use other software development lifecycle models which are
based on the classical waterfall model. Below are some major drawbacks of this
model.
 No Feedback Path: In the classical waterfall model evolution of software from
one phase to another phase is like a waterfall. It assumes that no error is ever
committed by developers during any phase. Therefore, it does not incorporate
any mechanism for error correction.
 Difficult to accommodate Change Requests: This model assumes that all
the customer requirements can be completely and correctly defined at the
beginning of the project, but the customer’s requirements keep on changing
with time. It is difficult to accommodate any change requests after the
requirements specification phase is complete.
  No Overlapping of Phases: This model recommends that a new phase can
start only after the completion of the previous phase. But in real projects, this
can’t be maintained. To increase efficiency and reduce cost, phases may
overlap.
 Limited Flexibility: The Waterfall Model is a rigid and linear approach to
software development, which means that it is not well-suited for projects with
changing or uncertain requirements. Once a phase has been completed, it is
difficult to make changes or go back to a previous phase.
 Limited Stakeholder Involvement: The Waterfall Model is a structured and
sequential approach, which means that stakeholders are typically involved in
the early phases of the project (requirements gathering and analysis) but may
not be involved in the later phases (implementation, testing, and deployment).
 Late Defect Detection: In the Waterfall Model, testing is typically done
toward the end of the development process. This means that defects may not
be discovered until late in the development process, which can be expensive
and time-consuming to fix.
 Lengthy Development Cycle: The Waterfall Model can result in a lengthy
development cycle, as each phase must be completed before moving on to
the next. This can result in delays and increased costs if requirements change
or new issues arise.
When to Use the SDLC Waterfall Model?

Here are some cases where the use of the Waterfall Model is best suited:
 Well-understood Requirements: Before beginning development, there are
precise, reliable, and thoroughly documented requirements available.
 Very Little Changes Expected: During development, very little adjustments
or expansions to the project’s scope are anticipated.
 Small to Medium-Sized Projects: Ideal for more manageable projects with a
clear development path and little complexity.
 Predictable: Projects that are predictable, low-risk, and able to be addressed
early in the development life cycle are those that have known, controllable
risks.
 Regulatory Compliance is Critical: Circumstances in which paperwork is of
utmost importance and stringent regulatory compliance is required.
 Client Prefers a Linear and Sequential Approach: This situation describes
the client’s preference for a linear and sequential approach to project
development.
  Limited Resources: Projects with limited resources can benefit from a set-up
strategy, which enables targeted resource allocation.

The Waterfall approach involves little client engagement in the product development
process. The product can only be shown to end consumers when it is ready.
Incremental Process Model – Software Engineering

The Incremental Process Model is also known as the Successive version

model. This article focuses on discussing the Incremental Process Model in detail.
What is the Incremental Process Model?

First, a simple working system implementing only a few basic features is built and
then that is delivered to the customer. Then thereafter many successive iterations/
versions are implemented and delivered to the customer until the desired system is
released.

A, B, and C are modules of Software Products that are incrementally developed and
delivered.
Phases of incremental model

Requirements of Software are first broken down into several modules that can be
incrementally constructed and delivered.

Phases of incremental model

1. Requirement analysis: In Requirement Analysis At any time, the plan is
made just for the next increment and not for any kind of long-term plan.
Therefore, it is easier to modify the version as per the needs of the customer.
2. Design & Development: At any time, the plan is made just for the next
increment and not for any kind of long-term plan. Therefore, it is easier to
modify the version as per the needs of the customer. The Development Team
first undertakes to develop core features (these do not need services from
other features) of the system. Once the core features are fully developed,
then these are refined to increase levels of capabilities by adding new
functions in Successive versions. Each incremental version is usually
developed using an iterative waterfall model of development.
 3. Deployment and Testing: After Requirements gathering and specification,
requirements are then split into several different versions starting with version
1, in each successive increment, the next version is constructed and then
deployed at the customer site. in development and Testing the product is
checked and tested for the actual process of the model.
4. Implementation: In implementation After the last version (version n), it is now
deployed at the client site.
Requirement Process Model

Requirement Process Model

Types of Incremental Model

1. Staged Delivery Model

2. Parallel Development Model

1. Staged Delivery Model

Construction of only one part of the project at a time.

Staged Delivery Model
2. Parallel Development Model

Different subsystems are developed at the same time. It can decrease the calendar
time needed for the development, i.e. TTM (Time to Market) if enough resources are
available.
Parallel Development Model
When to use the Incremental Process Model

1. Funding Schedule, Risk, Program Complexity, or need for early realization of

benefits.

2. When Requirements are known up-front.

3. When Projects have lengthy development schedules.

4. Projects with new Technology.

 Error Reduction (core modules are used by the customer from the
beginning of the phase and then these are tested thoroughly).
 Uses divide and conquer for a breakdown of tasks.

 Lowers initial delivery cost.

 Incremental Resource Deployment.

5. Requires good planning and design.

6. The total cost is not lower.

7. Well-defined module interfaces are required.

Characteristics of Incremental Process Model
 1. System development is divided into several smaller projects.

2. To create a final complete system, partial systems are constructed one after
the other.
3. Priority requirements are addressed first.

4. The requirements for that increment are frozen once they are created.
Advantages of the Incremental Process Model

1. Prepares the software fast.

2. Clients have a clear idea of the project.

3. Changes are easy to implement.

4. Provides risk handling support, because of its iterations.

5. Adjusting the criteria and scope is flexible and less costly.

6. Comparing this model to others, it is less expensive.

7. The identification of errors is simple.

Disadvantages of the Incremental Process Model

1. A good team and proper planned execution are required.

2. Because of its continuous iterations the cost increases.

3. Issues may arise from the system design if all needs are not gathered upfront
throughout the program lifecycle.

4. Every iteration step is distinct and does not flow into the next.
5. It takes a lot of time and effort to fix an issue in one unit if it needs to be
corrected in all the units.

What is Spiral Model in Software Engineering?

The Spiral Model is one of the most important Software Development Life Cycle
models. The Spiral Model is a combination of the waterfall model and the iterative
model. It provides support for Risk Handling. The Spiral Model was first proposed
by Barry Boehm. This article focuses on discussing the Spiral Model in detail.

What is the Spiral Model?

The Spiral Model is a Software Development Life Cycle (SDLC) model that
provides a systematic and iterative approach to software development. In its
diagrammatic representation, 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.

Some Key Points regarding the phase of a Spiral Model:

1. The exact number of phases needed to develop the product can be varied by
the project manager depending upon the project risks.

2. As the project manager dynamically determines the number of phases, the

project manager has an important role in developing a product using the spiral
model.

3. 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.
What Are the Phases of the Spiral Model?

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. Objectives Defined: In first phase of the spiral model we clarify what the
project aims to achieve, including functional and non-functional requirements.
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.

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.

The Radius of the spiral at any point represents the expenses (cost) of the project so
far, and the angular dimension represents the progress made so far in the current
phase.
Each phase of the Spiral Model is divided into four quadrants as shown in the
above figure. 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 the 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.
Risk Handling in Spiral Model

A risk is any adverse situation that might affect the successful completion of a
software project. The most important feature of the spiral model is handling these
unknown risks after the project has started. Such risk resolutions are easier done by
developing a prototype.

1. The spiral model supports coping with risks by providing the scope to build a
prototype at every phase of software development.
2. The Prototyping Model also supports risk handling, but the risks must be
identified completely before the start of the development work of the project.

3. But in real life, project risk may occur after the development work starts, in
that case, we cannot use the Prototyping Model.

4. In each phase of the Spiral Model, the features of the product dated and
analyzed, and the risks at that point in time are identified and are resolved
through prototyping.
5. Thus, this model is much more flexible compared to other SDLC models.
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.
1. The spiral model incorporates the stepwise approach of the Classical
Waterfall Model.

2. 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.
 3. 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 the Spiral Model

Below are some advantages of the 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 a later
phase can be incorporated accurately by using this model.
4. Customer Satisfaction: Customers 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.
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 the 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, 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.

The most serious issue we face in the cascade model is that taking a long length to
finish the item, and the product became obsolete. To tackle this issue, we have
another methodology, which is known as the Winding model or spiral model. The
winding model is otherwise called the cyclic model.
When To Use the Spiral Model?

1. When a project is vast in software engineering, a spiral model is utilized.

2. A spiral approach is utilized when frequent releases are necessary.

3. When it is appropriate to create a prototype

4. When evaluating risks and costs is crucial

5. The spiral approach is beneficial for projects with moderate to high risk.
6. The SDLC’s spiral model is helpful when requirements are complicated and
ambiguous.

7. If modifications are possible at any moment

8. When committing to a long-term project is impractical owing to shifting
economic priorities.
Conclusion

Spiral Model is a valuable choice for software development projects where risk
management is on high priority. Spiral Model deliver high-quality software by
promoting risk identification, iterative development and continuous client feedback.
When a project is vast in software engineering, a spiral model is utilized.
Prototyping Model – Software Engineering

Prototyping is defined as the process of developing a working replication of a product

or system that has to be engineered. It offers a small-scale facsimile of the end
product and is used for obtaining customer feedback. The Prototyping concept is
described below:
The Prototyping Model is one of the most popularly used Software Development Life
Cycle Models (SDLC models). This model is used when the customers do not know
the exact project requirements beforehand. In this model, a prototype of the end
product is first developed, tested, and refined as per customer feedback repeatedly
till a final acceptable prototype is achieved which forms the basis for developing the
final product.

Prototyping Model-Concept

In this process model, the system is partially implemented before or during the
analysis phase thereby allowing the customers to see the product early in the life
cycle. The process starts by interviewing the customers and developing the
incomplete high-level paper model. This document is used to build the initial
prototype supporting only the basic functionality as desired by the customer. Once
the customer figures out the problems, the prototype is further refined to eliminate
them. The process continues until the user approves the prototype and finds the
working model to be satisfactory. For those looking to implement prototyping in their
software development process, the System Design Course offers practical insights
and strategies to effectively apply this model in real-world projects.
Steps of Prototyping Model

Step 1: Requirement Gathering and Analysis: This is the initial step in designing a
prototype model. In this phase, users are asked about what they expect or what they
want from the system.
Step 2: Quick Design: This is the second step in the Prototyping Model. This model
covers the basic design of the requirement through which a quick overview can be
easily described.
Step 3: Build a Prototype: This step helps in building an actual prototype from the
knowledge gained from prototype design.
Step 4: Initial User Evaluation: This step describes the preliminary testing where
the investigation of the performance model occurs, as the customer will tell the
strengths and weaknesses of the design, which was sent to the developer.
Step 5: Refining Prototype: If any feedback is given by the user, then improving the
client’s response to feedback and suggestions, the final system is approved.
Step 6: Implement Product and Maintain: This is the final step in the phase of the
Prototyping Model where the final system is tested and distributed to production,
here the program is run regularly to prevent failures.
For more, you can refer to Software Prototyping Model Phases.

Types of Prototyping Models

There are four types of Prototyping Models, which are described below.

 Rapid Throwaway Prototyping

 Evolutionary Prototyping
  Incremental Prototyping

 Extreme Prototyping
1. Rapid Throwaway Prototyping

 This technique offers a useful method of exploring ideas and getting customer
feedback for each of them.

 In this method, a developed prototype need not necessarily be a part of the

accepted prototype.

 Customer feedback helps prevent unnecessary design faults and hence, the
final prototype developed is of better quality.
2. Evolutionary Prototyping

 In this method, the prototype developed initially is incrementally refined based

on customer feedback till it finally gets accepted.

 In comparison to Rapid Throwaway Prototyping, it offers a better approach

that saves time as well as effort.

 This is because developing a prototype from scratch for every iteration of the
process can sometimes be very frustrating for the developers.
3. Incremental Prototyping

 In this type of incremental prototyping, the final expected product is broken

into different small pieces of prototypes and developed individually.

 In the end, when all individual pieces are properly developed, then the
different prototypes are collectively merged into a single final product in their
predefined order.

 It’s a very efficient approach that reduces the complexity of the development
process, where the goal is divided into sub-parts and each sub-part is
developed individually.

 The time interval between the project’s beginning and final delivery is
substantially reduced because all parts of the system are prototyped and
tested simultaneously.

 Of course, there might be the possibility that the pieces just do not fit together
due to some lack of ness in the development phase – this can only be fixed by
careful and complete plotting of the entire system before prototyping starts.
4. Extreme Prototyping

This method is mainly used for web development. It consists of three sequential
independent phases:
  In this phase, a basic prototype with all the existing static pages is presented
in HTML format.

 In the 2nd phase, Functional screens are made with a simulated data process
using a prototype services layer.

 This is the final step where all the services are implemented and associated
with the final prototype.

This Extreme Prototyping method makes the project cycling and delivery robust and
fast and keeps the entire developer team focused and centralized on product
deliveries rather than discovering all possible needs and specifications and adding
necessitated features.
Advantages of Prototyping Model

 The customers get to see the partial product early in the life cycle. This
ensures a greater level of customer satisfaction and comfort.

 New requirements can be easily accommodated as there is scope for

refinement.

 Missing functionalities can be easily figured out.

 Errors can be detected much earlier thereby saving a lot of effort and cost,
besides enhancing the quality of the software.

 The developed prototype can be reused by the developer for more

complicated projects in the future.

 Flexibility in design.

 Early feedback from customers and stakeholders can help guide the
development process and ensure that the final product meets their needs and
expectations.

 Prototyping can be used to test and validate design decisions, allowing for
adjustments to be made before significant resources are invested in
development.
 Prototyping can help reduce the risk of project failure by identifying potential
issues and addressing them early in the process.

 Prototyping can facilitate communication and collaboration among team

members and stakeholders, improving overall project efficiency and
effectiveness.

 Prototyping can help bridge the gap between technical and non-technical
stakeholders by providing a tangible representation of the product.
Disadvantages of the Prototyping Model
  Costly concerning time as well as money.

 There may be too much variation in requirements each time the prototype is
evaluated by the customer.
 Poor Documentation due to continuously changing customer requirements.

 It is very difficult for developers to accommodate all the changes demanded

by the customer.

 There is uncertainty in determining the number of iterations that would be

required before the prototype is finally accepted by the customer.
 After seeing an early prototype, the customers sometimes demand the actual
product to be delivered soon.

 Developers in a hurry to build prototypes may end up with sub-optimal

solutions.

 The customer might lose interest in the product if he/she is not satisfied with
the initial prototype.

 The prototype may not be scalable to meet the future needs of the customer.

 The prototype may not accurately represent the final product due to limited
functionality or incomplete features.

 The focus on prototype development may shift away from the final product,
leading to delays in the development process.

 The prototype may give a false sense of completion, leading to the premature
release of the product.

 The prototype may not consider technical feasibility and scalability issues that
can arise during the final product development.

 The prototype may be developed using different tools and technologies,

leading to additional training and maintenance costs.

 The prototype may not reflect the actual business requirements of the
customer, leading to dissatisfaction with the final product.
Applications of Prototyping Model

 The Prototyping Model should be used when the requirements of the product
are not clearly understood or are unstable.

 The prototyping model can also be used if requirements are changing quickly.

 This model can be successfully used for developing user interfaces, high-
technology software-intensive systems, and systems with complex algorithms
and interfaces.
  The prototyping Model is also a very good choice to demonstrate the technical
feasibility of the product.
Spiral Model vs Prototype Model

Aspect Prototype Model Spiral Model

The spiral model is a risk-

A prototype model is
driven software development
a software development
model and is made with
Definition model in which a prototype is
features of incremental,
built, tested, and then refined
waterfall, or evolutionary
as per customer needs.
prototyping models.

It is also referred to as a
It is also referred to as a meta
Also Known As rapid or closed-ended
model.
prototype.

1. Requirements

2. Quick Design
1. Planning Phase
3. Build Prototype
2. Risk Analysis Phase
Phases 4. User Evaluation
3. Engineering Phase
5. Refining Prototype
4. Evaluation Phase
6. Implement and
Maintain

It takes special care about risk

It does not emphasize risk
Risk Analysis analysis and an alternative
analysis.
solution is undertaken.

In the prototype model,

In the spiral model, there is no
Customer customer interaction is
continuous customer
Interaction continuous until the final
interaction.
prototype is approved.
Aspect Prototype Model Spiral Model

It is best suited when the

It is best suited when the
requirement of the client is
Best Suited customer requirements are
not clear and is supposed to
clear.
be changed.

Cost-effective quality
Cost-effective quality
Cost-Effective improvement is very much
improvement is not possible.
possible.

In the Prototype model, In the Spiral model,

Quality improvement of quality does improvement of quality can
Improvement not increase the cost of the increase the cost of the
product. product.

Large-scale project is Low to medium project size is

Project Size
maintained. maintained.

 Continuous risk
 When end users need
analysis is required for
to have high
the software
interaction like in
online platforms and  In large projects
When to Use web interfaces.
 If Significant changes
 Whenever end-user are required by the
input in terms of software
feedback on the
 In complex project
system is required.
requirements

 Fast development
 End users are highly
involved in the whole  Development of all
Advantages development process. phases is carried out in
controlled manner
 Errors, complexities
get easily identified  Customer feedback is
taken into account for
Aspect Prototype Model Spiral Model

 Modifications can be the modifications to be

done with ease done accordingly
incase required
 Continuous user
feedback ensures  Suitable for large
proper and intended projects
functioning of the
 Suitable for risky
prototype
projects
 Users have better idea
 Continuous risk
about their product
analysis helps in better
development

 Useful in rapidly
changing requirements

 Not suitable for smaller

projects because of the
high cost associated
 Incomplete problem with the development
analysis process
Disadvantages  Continuous  Requirement of the
involvement of user competent risk analysis
may lead to increase team
in complexity
 High possibility of not
meeting the set budget
or time limit.

Factors of Management Dependency in Software Development

In Software Development, task of managing productivity is key issue. The

management of software development is heavily dependent on four factors :
1. People – When we refer to people in software development, we actually mean
hierarchy of roles in software development such as managers, team leaders,
senior developers etc. They are ones who form development team and work
in development of software. The order of priority of people among other
dependency factors is first (highest). Software development is people-centric
activity. Software development requires good managers, people who
understand psychology of people and provide good leadership. A good
manager does not ensure success of project, but can increase probability of
success. A good manager gives priority to areas like proper selection, training,
compensation, career development, work culture, development team’s
efficiency etc. Therefore, Managers are crucial and critical for software
development and it is their responsibility to manage, motivate, encourage,
control and guide his/her development team through tough situations. Hence,
success of project is on shoulders of people who are involved in development.

2. Product – A product is solution of problem that is handed to user who is

struggling with problem. The priority of product among other dependency
factors is second that is after people. The product or solution to problem is
constructed based on requirements, which are objectives and scope work of
problem. This helps managers to select best approach within constraints
imposed by delivery deadlines, budgetary restrictions, personnel availability,
technical interfaces etc. Without well defined requirements, it may be
impossible to define reasonable estimates of cost, development time and
schedule for project.
3. Process – The process is way in which we produce software. It provides
framework from which comprehensive plan for software development can be
established. If process is weak, end product will undoubtedly suffer. The
priority of process among other dependency factors is third,
after people and product, however, it plays very critical role for success of
project. There are many life cycle models and process improvements models.
A suitable process model is determined on basis of requirements
specification, development team, user, type of project and associated risks of
project. A number of different task sets, milestones, work products, and quality
assurance points, enable process framework activities to be adopted to
characteristics of project and requirements of project team.

4. Project – A proper planning is required to monitor status of development and

to control complexity. For project to be successful, it should be within budget,
follow policies and requirements defined, and completed within timeline
stated. Most of projects overrun cost by 100% of budget and are not delivered
on time. The priority of project among other dependency factors
is last(lowest). In order to manage successful project, we must understand
and prevent associated risks. Concrete requirements should be defined and
frozen, wherever possible. Unnecessary changes should not be made to
 avoid software surprises. Software surprises are always risky and should be
minimized. A planning mechanism should be constructed to caution from
occurrence of any surprises.

All four factors: People, Product, Process and Project are important for success of
project. Their relative importance helps us organize development activities in more
scientific and professional way.

Software Measurement and Metrics

Software Measurement: A measurement is a manifestation of the size, quantity,

amount, or dimension of a particular attribute of a product or process. Software
measurement is a titrate impute of a characteristic of a software product or the
software process.

Software Measurement Principles

The software measurement process can be characterized by five activities-

1. Formulation: The derivation of software measures and metrics appropriate for

the representation of the software that is being considered.

2. Collection: The mechanism used to accumulate data required to derive the

formulated metrics.

3. Analysis: The computation of metrics and the application of mathematical

tools.

4. Interpretation: The evaluation of metrics results in insight into the quality of the
representation.

5. Feedback: Recommendation derived from the interpretation of product

metrics transmitted to the software team.
Need for Software Measurement

Software is measured to:

 Create the quality of the current product or process.

 Anticipate future qualities of the product or process.

 Enhance the quality of a product or process.

 Regulate the state of the project concerning budget and schedule.

 Enable data-driven decision-making in project planning and control.

 Identify bottlenecks and areas for improvement to drive process improvement

activities.
 Ensure that industry standards and regulations are followed.
  Give software products and processes a quantitative basis for evaluation.

 Enable the ongoing improvement of software development practices.

Classification of Software Measurement

There are 2 types of software measurement:

1. Direct Measurement: In direct measurement, the product, process, or thing is

measured directly using a standard scale.

2. Indirect Measurement: In indirect measurement, the quantity or quality to be

measured is measured using related parameters i.e. by use of reference.

Software Metrics

A metric is a measurement of the level at which any impute belongs to a system

product or process.

Software metrics are a quantifiable or countable assessment of the attributes of a

software product. There are 4 functions related to software metrics:

1. Planning

2. Organizing

3. Controlling

4. Improving

Characteristics of software Metrics

1. Quantitative: Metrics must possess a quantitative nature. It means metrics
can be expressed in numerical values.
2. Understandable: Metric computation should be easily understood, and the
method of computing metrics should be clearly defined.

3. Applicability: Metrics should be applicable in the initial phases of the

development of the software.

4. Repeatable: When measured repeatedly, the metric values should be the

same and consistent.

5. Economical: The computation of metrics should be economical.

6. Language Independent: Metrics should not depend on any programming
language.

Types of Software Metrics

1 Product Metrics: Product metrics are used to evaluate the state of the product,
tracing risks and undercover prospective problem areas. The ability of the team
 to control quality is evaluated. Examples include lines of code, cyclomatic
complexity, code coverage, defect density, and code maintainability index.

2 Process Metrics: Process metrics pay particular attention to enhancing the

long-term process of the team or organization. These metrics are used to
optimize the development process and maintenance activities of software.
Examples include effort variance, schedule variance, defect injection rate, and
lead time.

3 Project Metrics: The project metrics describes the characteristic and

execution of a project. Examples include effort estimation accuracy,
schedule deviation, cost variance, and productivity. Usually measures-

 Number of software developer

 Staffing patterns over the life cycle of software

 Cost and schedule

 Productivity

Advantages of Software Metrics

1. Reduction in cost or budget.

2. It helps to identify the particular area for improvising.

3. It helps to increase the product quality.

4. Managing the workloads and teams.

5. Reduction in overall time to produce the product,.

6. It helps to determine the complexity of the code and to test the code with
resources.

7. It helps in providing effective planning, controlling and managing of the entire

product.
Disadvantages of Software Metrics

1. It is expensive and difficult to implement the metrics in some cases.

2. Performance of the entire team or an individual from the team can’t be

determined. Only the performance of the product is determined.

3. Sometimes the quality of the product is not met with the expectation.

4. It leads to measure the unwanted data which is wastage of time.

5. Measuring the incorrect data leads to make wrong decision making.

Program Analysis Tools in Software Engineering
The goal of developing software that is reliable, safe and effective is crucial in the
dynamic and always changing field of software development. Programme Analysis
Tools are a developer’s greatest support on this trip, giving them invaluable
knowledge about the inner workings of their code. In this article, we’ll learn about it’s
importance and classification.
What is Program Analysis Tool?

Program Analysis Tool is an automated tool whose input is the source code or the
executable code of a program and the output is the observation of characteristics of
the program. It gives various characteristics of the program such as its size,
complexity, adequacy of commenting, adherence to programming standards and
many other characteristics. These tools are essential to software engineering
because they help programmers comprehend, improve and maintain software
systems over the course of the whole development life cycle.
Importance of Program Analysis Tools
1. Finding faults and Security Vulnerabilities in the Code: Automatic
programme analysis tools can find and highlight possible faults, security
flaws and bugs in the code. This lowers the possibility that bugs will get it into
production by assisting developers in identifying problems early in the
process.
2. Memory Leak Detection: Certain tools are designed specifically to find
memory leaks and inefficiencies. By doing so, developers may make sure that
their software doesn’t gradually use up too much memory.
3. Vulnerability Detection: Potential vulnerabilities like buffer overflows,
injection attacks or other security flaws can be found using programme
analysis tools, particularly those that are security-focused. For the
development of reliable and secure software, this is essential.
4. Dependency analysis: By examining the dependencies among various
system components, tools can assist developers in comprehending and
controlling the connections between modules. This is necessary in order to
make well-informed decisions during refactoring.
5. Automated Testing Support: To automate testing procedures, CI/CD
pipelines frequently combine programme analysis tools. Only well-tested,
high-quality code is released into production thanks to this integration, helping
in identifying problems early in the development cycle.
Classification of Program Analysis Tools

Program Analysis Tools are classified into two categories:

1. Static Program Analysis Tools

Static Program Analysis Tool is such a program analysis tool that evaluates and
computes various characteristics of a software product without executing it.
Normally, static program analysis tools analyze some structural representation of a
program to reach a certain analytical conclusion. Basically some structural properties
are analyzed using static program analysis tools. The structural properties that are
usually analyzed are:

1. Whether the coding standards have been fulfilled or not.

2. Some programming errors such as uninitialized variables.

3. Mismatch between actual and formal parameters.

4. Variables that are declared but never used.

Code walkthroughs and code inspections are considered as static analysis methods
but static program analysis tool is used to designate automated analysis tools.
Hence, a compiler can be considered as a static program analysis tool.
2. Dynamic Program Analysis Tools

Dynamic Program Analysis Tool is such type of program analysis tool that require the
program to be executed and its actual behavior to be observed. A dynamic program
analyzer basically implements the code. It adds additional statements in the source
code to collect the traces of program execution. When the code is executed, it allows
us to observe the behavior of the software for different test cases. Once the software
is tested and its behavior is observed, the dynamic program analysis tool performs a
post execution analysis and produces reports which describe the structural coverage
that has been achieved by the complete testing process for the program.

For example, the post execution dynamic analysis report may provide data on extent
statement, branch and path coverage achieved. The results of dynamic program
analysis tools are in the form of a histogram or a pie chart. It describes the structural
coverage obtained for different modules of the program. The output of a dynamic
program analysis tool can be stored and printed easily and provides evidence that
complete testing has been done. The result of dynamic analysis is the extent of
testing performed as white box testing. If the testing result is not satisfactory then
more test cases are designed and added to the test scenario. Also dynamic analysis
helps in elimination of redundant test cases.
Software Requirement Specification (SRS) Format

In order to form a good SRS, here you will see some points that can be used and
should be considered to form a structure of good Software Requirements
Specification (SRS). These are below mentioned in the table of contents and are well
explained below.
Software Requirement Specification (SRS) Format as the name suggests, is a
complete specification and description of requirements of the software that need to
be fulfilled for the successful development of the software system. These
requirements can be functional as well as non-functional depending upon the type of
requirement. The interaction between different customers and contractors is done
because it is necessary to fully understand the needs of customers.

Depending upon information gathered after

interaction, SRS is developed which describes requirements of software that may
include changes and modifications that is needed to be done to increase quality of
product and to satisfy customer’s demand.
Introduction

 Purpose of this Document – At first, main aim of why this document is

necessary and what’s purpose of document is explained and described.
 Scope of this document – In this, overall working and main objective of
document and what value it will provide to customer is described and
explained. It also includes a description of development cost and time
required.
 Overview – In this, description of product is explained. It’s simply summary or
overall review of product.
General description
In this, general functions of product which includes objective of user, a user
characteristic, features, benefits, about why its importance is mentioned. It also
describes features of user community.
Functional Requirements

In this, possible outcome of software system which includes effects due to operation
of program is fully explained. All functional requirements which may include
calculations, data processing, etc. are placed in a ranked order. Functional
requirements specify the expected behavior of the system-which outputs should be
produced from the given inputs. They describe the relationship between the input
and output of the system. For each functional requirement, detailed description all
the data inputs and their source, the units of measure, and the range of valid inputs
must be specified.
Interface Requirements

In this, software interfaces which mean how software program communicates with
each other or users either in form of any language, code, or message are fully
described and explained. Examples can be shared memory, data streams, etc.
Performance Requirements

In this, how a software system performs desired functions under specific condition is
explained. It also explains required time, required memory, maximum error rate, etc.
The performance requirements part of an SRS specifies the performance constraints
on the software system. All the requirements relating to the performance
characteristics of the system must be clearly specified. There are two types of
performance requirements: static and dynamic. Static requirements are those that do
not impose constraint on the execution characteristics of the system. Dynamic
requirements specify constraints on the execution behaviour of the system.
Design Constraints

In this, constraints which simply means limitation or restriction are specified and
explained for design team. Examples may include use of a particular algorithm,
hardware and software limitations, etc. There are a number of factors in the client’s
environment that may restrict the choices of a designer leading to design constraints
such factors include standards that must be followed resource limits, operating
environment, reliability and security requirements and policies that may have an
impact on the design of the system. An SRS should identify and specify all such
constraints.
Non-Functional Attributes

In this, non-functional attributes are explained that are required by software system
for better performance. An example may include Security, Portability, Reliability,
Reusability, Application compatibility, Data integrity, Scalability capacity, etc.
Preliminary Schedule and Budget

In this, initial version and budget of project plan are explained which include overall
time duration required and overall cost required for development of project.
Appendices

In this, additional information like references from where information is gathered,

definitions of some specific terms, acronyms, abbreviations, etc. are given and
explained.
Uses of SRS document

 Development team require it for developing product according to the need.

 Test plans are generated by testing group based on the describe external
behaviour.

 Maintenance and support staff need it to understand what the software

product is supposed to do.
 Project manager base their plans and estimates of schedule, effort and
resources on it.

 customer rely on it to know that product they can expect.

 As a contract between developer and customer.

 in documentation purpose.
What is Monitoring and Control in Project Management?

Monitoring and control is one of the key processes in any project management which
has great significance in making sure that business goals are achieved successfully.
We are seeing All points and Subpoints in a Detailed way:

These processes enable the ability to supervise, make informed decisions, and
adjust in response to changes during the project life cycle are critical.
What is Monitoring Phase in Project Management?

Monitoring in project management is the systematic process of observing,

measuring, and evaluating activities, resources, and progress to verify that a given
asset has been developed according to the terms set out. It is intended to deliver
instant insights, detect deviations from the plan, and allow quick decision-making.
Purpose

1. Track Progress: Monitor the actual implementation of the project along with
indicators such as designs, timelines budgets, and standards.
2. Identify Risks and Issues: Identify other risks and possible issues in the
early stage to create immediate intervention measures as well as resolutions.
 3. Ensure Resource Efficiency: Monitor how resources are being distributed
and used to improve efficiency while avoiding resource shortages.
4. Facilitate Decision-Making: Supply project managers and stakeholders with
reliable and timely information for informed
5. Enhance Communication: Encourage honest team communication and
stakeholder engagement related to project status, challenges
Key Activities

1. Performance Measurement: Identify and monitor critical performance

indicators (KPIs) to compare the progress of a project against defined targets.
2. Progress Tracking: Update schedules and timelines for the project on a
regular basis, and compare actual work with planned milestones to detect any
delays or deviations.
3. Risk Identification and Assessment: Monitor actual risks, including their
probability and consequences. Find new risks and assess the performance of
current risk mitigation mechanisms.
4. Issue Identification and Resolution: Point out problems discovered in the
process of project implementation, evaluate their scale and introduce
corrective measures immediately.
5. Resource Monitoring: Track how resources are distributed and used, to
ensure there is adequate equipment as well as support by the team members
in meeting their objectives.
6. Quality Assurance: Monitor compliance with quality standards and
processes, reporting deviations to take actions necessary for restoring the
targeted level of quality.
7. Communication and Reporting: Disseminate project status updates,
milestones reached and important findings to the stakeholders on a regular
basis.
8. Change Control: Review and evaluate project scope, schedule or budget
changes. Adopt structured change control processes to define, justify and
approve changes.
9. Documentation Management: Make sure that project documentation is
accurate, current and readily available for ready reference. This involves
project plans, reports and other documents related to a particular project.
Tools and Technologies for Monitoring
 1. Project Management Software: Tools such as Microsoft Project, Jira, and
Trello offer features in terms of scheduling monitoring resources for task
execution.
2. Performance Monitoring Tools: The solutions that New Relic, AppDynamics
and Dynatrace provide cater to monitoring of application performances as well
as infrastructure performance besides user experience.
3. Network Monitoring Tools: The three tools namely SolarWinds Network
Performance Monitor, Wireshark and PRTG Network monitor help in
monitoring and analyzing the network performance.
4. Server and Infrastructure Monitoring Tools: The mentioned monitoring
tools, namely Nagios prometheus and Zabbix monitor servers systems and IT
infrastructure for performance availability.
5. Log Management Tools: Log analysis and visualization are performed using
ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, and Graylog.
6. Cloud Monitoring Tools: Amazon CloudWatch, Google Cloud Operations
Suite, and Azure Monitor provide monitoring solutions for cloud-based
services and resources.
7. Security Monitoring Tools: Security Information and Event Management
tools like Splunk, IBM QRadar or ArcSight provide support to the process of
monitoring security events and incidents.
What is Control Phase in Project Management?

In project management, the control stage refers to taking corrective measures using
data collected during monitoring. It seeks to keep the project on track and in line with
its purpose by resolving issues, minimizing risks, and adopting appropriate
modifications into plan documents for projects.
Purpose

1. Implement Corrective Actions: Using the issues, risks, or deviations from

the project plan as a pretext to implement corrective actions and put back on
course.
2. Adapt to Changes: Accommodate changes in requirements, external
parameters or unknown circumstances by altering project plans resources
and strategies.
3. Optimize Resource Utilization: Do not allow the overruns of resources or
lack thereof that directly affect project performance.
4. Ensure Quality and Compliance: Comply with quality standards, regulatory
mandates and project policies to achieve the best results possible.
 5. Facilitate Communication: Communicate changes, updates and resolutions
to the stakeholders in order to preserve transparency and cooperation through
project.
Key Activities

1. Issue Resolution: Respond to identified issues in a timely manner by

instituting remedial measures. Work with the project team to address
obstacles that threaten progress in this assignment.
2. Risk Mitigation: Perform risk response plans in order to avoid the negative
influence of risks identified. Take proactive actions that can minimize the
possibility or magnitude of potential problems.
3. Change Management: Evaluate and put into practice the approved
amendments to the project scope, schedule or budget. Make sure that
changes are plugged into project plans.
4. Resource Adjustment: Optimize resource allocation based on project
requirements and variability in the workload. Make sure that team members
are provided with adequate support in order to play their respective roles
efficiently.
5. Quality Control: Supervise and ensure that quality standards are followed.
Ensure that project deliverables comply with the stated requirements through
quality control measures.
6. Performance Adjustment: Adjust project schedules, budgets and other
resources according to monitoring observations. Ensure alignment
with project goals.
7. Communication of Changes: Share changes, updates, and resolutions to
stakeholders via periodic reports or project documents. Keep lines of
communication open.
8. Documentation Management: Update project documentation for changes
made in control phase. Record decisions, actions taken and any changes to
project plans.
Tools and Technologies for Control

1. Project Management Software: It is possible to adjust project plans,

schedules and tasks using Microsoft Project Jira or Trello depending on
changes identified in the control phase.
2. Change Control Tools: Change Scout, Prosci or integrated change
management modules within project management software allow for
systematic changes.
 3. Collaboration Platforms: Instruments such as Microsoft Teams, Slack or
Asana enhance interaction and cooperation; the platforms allow real-time
information sharing between team members.
4. Version Control Systems: To control changes to project documentation and
maintain versioning, Git or Subversion tools are necessary.
5. Quality Management Tools: Quality control activities are facilitated by tools
such as TestRail, Jira and Quality Center to make sure the project
deliverables meet predetermined quality standards.
6. Risk Management Software: Tools like RiskWatch, RiskTrak or ARM (Active
risk Management) help in monitoring and controlling risks helping to
implement the mitigation strategies on risks.
7. Resource Management Tools: There are tools such as ResourceGuru,
LiquidPlanner or Smartsheet that contribute to optimizing resource allocation
and easing adjustments in the control phase.
8. Communication Platforms: Communication tools like Zoom, Microsoft
Teams or Slack make it possible to inform the stakeholders of changes,
updates and resolutions in a timely manner.
Integrating Monitoring and Control

Seamless combination of the monitoring and control processes is necessary in

project management for successfully completed projects. While monitoring is
concerned with the constant observation and measurement of project activities,
control refers to controlling actions that arise from these insights. These two
processes form a synergy that shapes an agile environment, promotes efficient
decision-making and mitigates risk as well ensuring good performance of the project.

Here’s an in-depth explanation of how to effectively integrate monitoring and control:

1. Continuous Feedback Loop

The integration starts with continuous feedback loops between the monitoring and
control. Measuring allows real time information on project advancements, risks and
resource utilization as a foundation for control decision making.
2. Establishing Key Performance Indicators (KPIs)

First, identify and check KPIs that are relevant for the project goals. These
parameters act as performance measures and deviations standards which give the
base for control phase to make corrections.
3. Early Identification of Risks and Issues

Using continuous monitoring, the problems are identified in early stages of their
emergence. Through this integration, the organization is able to be proactive where
project teams can implement timely and effective compliance measures keeping
these risks from becoming major issues.
4. Real-Time Data Analysis

During the monitoring phase, use sophisticated instruments to analyze data in real-
time. Some technologies, including artificial intelligence and machine learning as well
as data analytics help to understand what the trends, patterns or anomalies are of
project dynamics for better control.
5. Proactive Change Management

Integration guarantees that changes identified during monitoring smoothly undergo

control. A good change management process enables the assessment, acceptance
and implementation of changes without affecting project stability.
6. Stakeholder Communication and Transparency

To achieve effective integration, errors in transparent communication must be

avoided. Keep stakeholders abreast of the project’s status, changes made and how
they were resolved. Proper communication assures everyone is aligned with the
direction of the project and promotes synergy among monitoring activities.
7. Adaptive Project Plans

Create project plans that can be modified based on changes established during
monitoring. Bringing control in means working with schedules, resource allocations,
and objectives that can be changed depending on the nature of conditions
while project plans remain flexible.
8. Agile Methodologies

The use of agile methodologies enhances integration even more. Agile principles
prioritize iterative development, continual feedback, and flexible planning in
accordance with monitoring-control integration.
9. Documentation and Lessons Learned

It is vital to note insights from the phases of monitoring and control. This
documentation enables future projects to use lessons learned as a resource, fine-
tune the strategy for monitoring and optimize control processes systems on an
ongoing basis.
Benefits of Effective Monitoring and Control

Proper monitoring and control processes play an important role in the success of
projects that are guided by project management. Here are key advantages
associated with implementing robust monitoring and control measures:
1. Timely Issue Identification and Resolution: Prompt resolution of issues is
possible if they are detected early. Monitoring and control effectiveness see
 early challenges, thus preventing the escalation into serious problems likely to
affect project timelines or overall objectives.
2. Optimized Resource Utilization: Monitoring and controlling resource
allocation and use ensures optimum efficiency. Teams can detect resources
underutilized or overallocated, thereby allocating adjusting towards a balance
workload and efficient use of resource.
3. Risk Mitigation: A continuous monitoring approach aids proactive risk
management. Identification of future risks at an early stage enables
establishment of mitigation plans for the project teams to reduce likelihood
and severity levels that often lead adverse events on projects.
4. Adaptability to Changes: Effective monitoring highlights shifts in project
requirements, influences outside the system or stakeholder expectations.
Control processes enable a smooth adjustment of project plans to reflect the
ongoing change, thus minimizing resistance.
5. Improved Decision-Making: As the monitoring processes provide accurate
and real-time data, decision making can be improved. Stakeholders and
project managers can base their decisions on the most current of information,
thereby facilitating more strategic choices that result in better outcomes.
6. Enhanced Communication and Transparency: Frequent communication of
the status, progress and issues supports transparency. The shareholders are
kept with updated information, and this results in the build-up of trust among
the team members’ clients to other interested parties.
7. Quality Assurance: The monitoring and control processes also help in the
quality assurance of project deliverables. Therefore, through continuous
tracking and management of quality metrics, teams can find any deviations
from the standards to take timely corrective actions that meet stakeholders’
needs.
8. Cost Control: Cost overruns, in turn, could be mitigated through continuous
monitoring of project budgets and expenses accompanied by the control
processes. Teams can spot variances early and take corrective actions to
ensure that the project stays within budget limit.
9. Efficient Stakeholder Management: Monitoring and control allows for
providing timely notice about the project’s progress and any changes to
interested parties. This preemptive approach increases the satisfaction of
Stakeholders while reducing misconception.
10. Continuous Improvement: Improvement continues as lessons learned
through monitoring and control activities are applied. Teams can learn from
past projects, understand what needs to improve, and implement good
 practices in future initiatives establishing an atmosphere of constant
development.
11. Increased Predictability: Monitoring and control that is effective make
project outcomes better predictable. The accurate timelines, costs and risk
forecasts are attained through closely controlling project activities which the
teams manage to provide effective stakeholders with a clear understanding of
all their projects expectations.
12. Project Success and Client Satisfaction: Finally, the result of successful
monitoring and control is project success. The final result of the projects
satisfaction for clients and positive outcomes from that project.
Challenges and Solutions

1. Incomplete or Inaccurate Data

 Challenge: Lack of proper or trustworthy data may impair efficient monitoring

and control, making wrong decisions.
 Solution: Develop effective data collection methods, use reliable instruments
and invest in training to increase the accuracy of information captured.
2. Scope Creep

 Challenge: Lack of sufficient control can lead to scope creep that affects
overall timelines and costs.
 Solution: Implement rigid change control procedures, review project scope
on a regular basis and ensure that all changes are appropriately evaluated
assessed approved documented.
3. Communication Breakdowns
 Challenge: Poordiscussions are often based on misunderstandings, delays
and unresolved matters.
 Solution: Set up proper communication channels, use collaboration tools and
have regular meetings about the project’s status to ensure productive
communication between team members and stakeholders.
4. Resource Constraints

 Challenge: Lack of resources, in terms of budget, personnel or technology

hinders timely monitoring and control.
 Solution: Focus on resource requirements, obtain further help where required
and maximize resource utilization by planning carefully.
5. Lack of Stakeholder Engagement
  Challenge: Lack of engagement among some stakeholders affects the pace
and decisions made during such a project.
 Solution: Develop a culture that supports stakeholder engagement by
providing regular updates, conducting feedback sessions and involving key
decision makers at critical junctions.
6. Unforeseen Risks

 Challenge: During the project lifecycle, new risks can surfaced that had not
been previously identified.
 Solution: Apply a risk management approach that is responsive, reassess
risks regularly and ensure contingency plans are in place to cope with the
unexpected.
7. Resistance to Change

 Challenge: Enforced changes made within the control stage might be

rejected by team members or stakeholders.
 Solution: Clearly communicate the rationale for changes, engage appropriate
stakeholders in decision-making processes and emphasize the value of
flexibility to facilitate a more comfortable change process.
8. Technology Integration Issues

 Challenge: The integration of monitoring and control tools is complicated,

which can bring inefficiencies or data inconsistency.
 Solution: In order to achieve effective integration, invest in interoperable
technologies that are easy-to-use while providing continuous training and
keeping the systems up to date.
9. Insufficient Training and Skill Gaps

 Challenge: Lack of proper training and skill deficiencies among the team
members pose a threat to effective use of monitoring and control mechanism.
 Solution: Offer wide training opportunities, point out and resolve the areas of
deficiency as well as build curiosity for continuous learning with a view to
increase effectiveness in project team.
10. Lack of Standardized Processes

 Challenge: Non-uniform or irregular processes may also result in the

confusion and mistakes while performing activities of monitoring and control.
 Solution: Create and record standardized processes, ensure that the entire
team understands these procedures, continually reviewing them when
necessary after going through lessons learned.
Conclusion

In the final analysis, successful project management is based upon the incorporation
of efficient monitoring and control processes. The symbiotic relationship between
these two phases, creates a dynamic framework that allows for adaptability
transparency and informed decision-making throughout the project life cycle.

UNIT III SOFTWARE DESIGN

Principles of Software Design

Design means to draw or plan something to show the look, functions and working of
it.
Software Design is also a process to plan or convert the software requirements into
a step that are needed to be carried out to develop a software system. There are
several principles that are used to organize and arrange the structural components
of Software design. Software Designs in which these principles are applied affect the
content and the working process of the software from the beginning.

These principles are stated below :

Principles Of Software Design :

1. Should not suffer from “Tunnel Vision” –

While designing the process, it should not suffer from “tunnel vision” which
means that is should not only focus on completing or achieving the aim but on
other effects also.

2. Traceable to analysis model –

The design process should be traceable to the analysis model which means it
should satisfy all the requirements that software requires to develop a high-
quality product.

3. Should not “Reinvent The Wheel” –

The design process should not reinvent the wheel that means it should not
waste time or effort in creating things that already exist. Due to this, the
overall development will get increased.

4. Minimize Intellectual distance –

The design process should reduce the gap between real-world problems and
software solutions for that problem meaning it should simply minimize
intellectual distance.
 5. Exhibit uniformity and integration –
The design should display uniformity which means it should be uniform
throughout the process without any change. Integration means it should mix
or combine all parts of software i.e. subsystems into one system.

6. Accommodate change –
The software should be designed in such a way that it accommodates the
change implying that the software should adjust to the change that is required
to be done as per the user’s need.

7. Degrade gently –
The software should be designed in such a way that it degrades gracefully
which means it should work properly even if an error occurs during the
execution.

8. Assessed or quality –
The design should be assessed or evaluated for the quality meaning that
during the evaluation, the quality of the design needs to be checked and
focused on.

9. Review to discover errors –

The design should be reviewed which means that the overall evaluation
should be done to check if there is any error present or if it can be minimized.

10. Design is not coding and coding is not design –

Design means describing the logic of the program to solve any problem and
coding is a type of language that is used for the implementation of a design.

Software Design Process – Software Engineering

The design phase of software development deals with transforming the customer
requirements as described in the SRS documents into a form implementable using a
programming language. The software design process can be divided into the
following three levels or phases of design:
1. Interface Design
 2. Architectural Design

3. Detailed Design
Elements of a System

1. Architecture: This is the conceptual model that defines the structure,

behavior, and views of a system. We can use flowcharts to represent and
illustrate the architecture.
2. Modules: These are components that handle one specific task in a system. A
combination of the modules makes up the system.
3. Components: This provides a particular function or group of related
functions. They are made up of modules.
4. Interfaces: This is the shared boundary across which the components of a
system exchange information and relate.
5. Data: This is the management of the information and data flow.

Software Design Process

Interface Design
Interface design is the specification of the interaction between a system and its
environment. This phase proceeds at a high level of abstraction with respect to the
inner workings of the system i.e, during interface design, the internal of the systems
are completely ignored, and the system is treated as a black box. Attention is
focused on the dialogue between the target system and the users, devices, and
other systems with which it interacts. The design problem statement produced during
the problem analysis step should identify the people, other systems, and devices
which are collectively called agents.

Interface design should include the following details:

1. Precise description of events in the environment, or messages from agents to

which the system must respond.

2. Precise description of the events or messages that the system must produce.

3. Specification of the data, and the formats of the data coming into and going
out of the system.

4. Specification of the ordering and timing relationships between incoming

events or messages, and outgoing events or outputs.
Architectural Design

Architectural design is the specification of the major components of a system, their

responsibilities, properties, interfaces, and the relationships and interactions
between them. In architectural design, the overall structure of the system is chosen,
but the internal details of major components are ignored. Issues in architectural
design includes:

1. Gross decomposition of the systems into major components.

2. Allocation of functional responsibilities to components.

3. Component Interfaces.

4. Component scaling and performance properties, resource consumption

properties, reliability properties, and so forth.

5. Communication and interaction between components.

The architectural design adds important details ignored during the interface design.
Design of the internals of the major components is ignored until the last phase of the
design.
Detailed Design

Detailed design is the specification of the internal elements of all major system
components, their properties, relationships, processing, and often their algorithms
and the data structures. The detailed design may include:
 1. Decomposition of major system components into program units.

2. Allocation of functional responsibilities to units.

3. User interfaces.

4. Unit states and state changes.

5. Data and control interaction between units.

6. Data packaging and implementation, including issues of scope and visibility of

program elements.

7. Algorithms and data structures.

Various Approaches of Partitioning

If the system is having hierarchical architecture, the program structure can easily be
partitioned both horizontally and vertically, figure (a), represents this view.

In given figure (a), horizontal division defines the individual branches of the modular
hierarchy for every major program function. Control modular (shown by rectangles)
are used to coordinate communication between tasks. The three partitions are done
in simple horizontal partitions i.e., input, data transformation (processing) and output.
The following benefits are provided by horizontal partitioning –

1. Software, that can easily be tested.

2. Software, that can easily be maintained.

3. Propagation of fewer side effects.

4. Software, that can easily be extended.

On the other hand, vertical segmentation, also known as “factoring”, states that
control and function must be distributed across the program structure, top to bottom.
The top-level modules have to carry out control functions and perform fewer modules
in the structure are laborious, performing all input, processing and output tasks.
Figure (b), represents vertical partitioning. Due to the nature of changes in program
structures, vertical segmentation is required. Observing the figure (b), it can be said
that a change in the control module would make its subordinates more likely to
cause the spread of side effects. Generally, changes are- changes to input,
computation or transformation, and output.

The basic behavior of the program is much less likely to change. That is why,
vertically partitioned structures are less susceptible to side effects due to changes
and thus be more maintainable, which is its key quality factor.
Introduction of Software Design Process – Set 2

Software Design is the process of transforming user requirements into a suitable

form, which helps the programmer in software coding and implementation. During
the software design phase, the design document is produced, based on the
customer requirements as documented in the SRS document. Hence, this phase
aims to transform the SRS document into a design document.

The following items are designed and documented during the design phase:

1. Different modules are required.

2. Control relationships among modules.

3. Interface among different modules.

4. Data structure among the different modules.

5. Algorithms are required to be implemented among the individual modules.

Objectives of Software Design

1. Correctness: A good design should be correct i.e., it should correctly

implement all the functionalities of the system.
2. Efficiency: A good software design should address the resources, time, and
cost optimization issues.
3. Flexibility: A good software design should have the ability to adapt and
accommodate changes easily. It includes designing the software in a way, that
allows for modifications, enhancements, and scalability without requiring
significant rework or causing major disruptions to the existing functionality.
4. Understandability: A good design should be easily understandable, it should
be modular, and all the modules are arranged in layers.
5. Completeness: The design should have all the components like data
structures, modules, external interfaces, etc.

6. Maintainability: A good software design aims to create a system that is easy

to understand, modify, and maintain over time. This involves using modular
and well-structured design principles e.g.,(employing appropriate naming
conventions and providing clear documentation). Maintainability in Software
and design also enables developers to fix bugs, enhance features, and adapt
the software to changing requirements without excessive effort or introducing
new issues.
Software Design Concepts

Concepts are defined as a principal idea or invention that comes into our mind or in
thought to understand something. The software design concept simply means the
idea or principle behind the design. It describes how you plan to solve the problem of
designing software, and the logic, or thinking behind how you will design software. It
allows the software engineer to create the model of the system software or product
that is to be developed or built. The software design concept provides a supporting
and essential structure or model for developing the right software. There are many
concepts of software design and some of them are given below:
Points to be Considered While Designing Software

1. Abstraction (Hide Irrelevant data): Abstraction simply means to hide the

details to reduce complexity and increase efficiency or quality. Different levels
of Abstraction are necessary and must be applied at each stage of the design
process so that any error that is present can be removed to increase the
efficiency of the software solution and to refine the software solution. The
solution should be described in broad ways that cover a wide range of
different things at a higher level of abstraction and a more detailed description
of a solution of software should be given at the lower level of abstraction.
2. Modularity (subdivide the system): Modularity simply means dividing the
system or project into smaller parts to reduce the complexity of the system or
project. In the same way, modularity in design means subdividing a system
into smaller parts so that these parts can be created independently and then
use these parts in different systems to perform different functions. It is
necessary to divide the software into components known as modules because
nowadays, there are different software available like Monolithic software that
is hard to grasp for software engineers. So, modularity in design has now
become a trend and is also important. If the system contains fewer
components then it would mean the system is complex which requires a lot of
effort (cost) but if we can divide the system into components then the cost
would be small.
3. Architecture (design a structure of something): Architecture simply means
a technique to design a structure of something. Architecture in designing
software is a concept that focuses on various elements and the data of the
structure. These components interact with each other and use the data of the
structure in architecture.
4. Refinement (removes impurities): Refinement simply means to refine
something to remove any impurities if present and increase the quality. The
refinement concept of software design is a process of developing or
presenting the software or system in a detailed manner which means
elaborating a system or software. Refinement is very necessary to find out
any error if present and then to reduce it.
5. Pattern (a Repeated form): A pattern simply means a repeated form or
design in which the same shape is repeated several times to form a pattern.
 The pattern in the design process means the repetition of a solution to a
common recurring problem within a certain context.
6. Information Hiding (Hide the Information): Information hiding simply means
to hide the information so that it cannot be accessed by an unwanted party. In
software design, information hiding is achieved by designing the modules in a
manner that the information gathered or contained in one module is hidden
and can’t be accessed by any other modules.
7. Refactoring (Reconstruct something): Refactoring simply means
reconstructing something in such a way that it does not affect the behavior of
any other features. Refactoring in software design means reconstructing the
design to reduce complexity and simplify it without impacting the behavior or
its functions. Fowler has defined refactoring as “the process of changing a
software system in a way that it won’t impact the behavior of the design and
improves the internal structure”.
Different levels of Software Design

There are three different levels of software design. They are:

1. Architectural Design: The architecture of a system can be viewed as the
overall structure of the system and the way in which structure provides
conceptual integrity of the system. The architectural design identifies the
software as a system with many components interacting with each other. At
this level, the designers get the idea of the proposed solution domain.
2. Preliminary or high-level design: Here the problem is decomposed into a
set of modules, the control relationship among various modules identified, and
also the interfaces among various modules are identified. The outcome of this
stage is called the program architecture. Design representation techniques
used in this stage are structure chart and UML.
3. Detailed design: Once the high-level design is complete, a detailed design is
undertaken. In detailed design, each module is examined carefully to design
the data structure and algorithms. The stage outcome is documented in the
form of a module specification document.
Difference between Bottom-Up Model and Top-Down Model

Top-Down Design Model:

In the top-down model, an overview of the system is formulated without going into
detail for any part of it. Each part of it then refined into more details, defining it in yet
more details until the entire specification is detailed enough to validate the model. if
we glance at a haul as a full, it’s going to appear not possible as a result of it’s so
complicated For example: Writing a University system program, writing a word
processor. Complicated issues may be resolved victimization high down style,
conjointly referred to as Stepwise refinement where,
 1. We break the problem into parts,

2. Then break the parts into parts soon and now each of parts will be easy to
do.

Advantages:

 Breaking problems into parts help us to identify what needs to be done.

 At each step of refinement, new parts will become less complex and therefore
easier to solve.
 Parts of the solution may turn out to be reusable.

 Breaking problems into parts allows more than one person to solve the
problem.

Bottom-Up Design Model:

In this design, individual parts of the system are specified in detail. The parts are
linked to form larger components, which are in turn linked until a complete system is
formed. Object-oriented language such as C++ or java uses a bottom-up approach
where each object is identified first.
Advantage:

 Make decisions about reusable low-level utilities then decide how there will be
put together to create high-level construct. ,

The contrast between Top-down design and bottom-up design.

S.
No. TOP DOWN APPROACH BOTTOM UP APPROACH

In this approach We focus on In bottom up approach, we solve

1. breaking up the problem into smaller problems and integrate it as
smaller parts. whole and complete the solution.

Mainly used by structured Mainly used by object oriented

2. programming language such as programming language such as C++,
COBOL, Fortran, C, etc. C#, Python.
S.
No. TOP DOWN APPROACH BOTTOM UP APPROACH

Each part is programmed

Redundancy is minimized by using data
3. separately therefore contain
encapsulation and data hiding.
redundancy.

In this the communications is In this module must have

4.
less among modules. communication.

It is used in debugging, module

5. It is basically used in testing.
documentation, etc.

In top down approach, In bottom up approach composition

6.
decomposition takes place. takes place.

In this sometimes we can not build a

In this top function of system
7. program from the piece we have
might be hard to identify.
started.

In this implementation details This is not natural for people to

8.
may differ. assemble.

Pros-

 Easier isolation of
interface errors
Pros-
 It benefits in the case
 Easy to create test conditions
error occurs towards the
9. top of the program.  Test results are easy to observe

 Defects in design get  It is suited if defects occur at the

detected early and can be bottom of the program.
corrected as an early
working module of the
program is available.
S.
No. TOP DOWN APPROACH BOTTOM UP APPROACH

Cons- Cons-

 Difficulty in observing the  There is no representation of the

output of test case. working model once several
modules have been constructed.
 Stub writing is quite
crucial as it leads to  There is no existence of the
setting of output program as an entity without the
10. parameters. addition of the last module.

 When stubs are located  From a partially integrated

far from the top level system, test engineers cannot
module, choosing test observe system-level
cases and designing functions. It can be possible
stubs become more only with the installation of the
challenging. top-level test driver.

Structured Programming Approach with Advantages and Disadvantages

Structured Programming Approach

, as the word suggests, can be defined as a programming approach in which the

program is made as a single structure. It means that the code will execute the
instruction by instruction one after the other. It doesn’t support the possibility of
jumping from one instruction to some other with the help of any statement like
GOTO, etc. Therefore, the instructions in this approach will be executed in a serial
and structured manner. The languages that support Structured programming
approach are:

 C

 C++

 Java

 C#

 ..etc
On the contrary, in the Assembly languages like Microprocessor 8085, etc, the
statements do not get executed in a structured manner. It allows jump statements
like GOTO. So the program flow might be random. The structured program mainly
consists of three types of elements:

 Selection Statements

 Sequence Statements

 Iteration Statements

The structured program consists of well structured and separated modules. But the
entry and exit in a Structured program is a single-time event. It means that the
program uses single-entry and single-exit elements. Therefore a structured program
is well maintained, neat and clean program. This is the reason why the Structured
Programming Approach is well accepted in the programming world.
Advantages of Structured Programming Approach:

1. Easier to read and understand

2. User Friendly

3. Easier to Maintain

4. Mainly problem based instead of being machine based

5. Development is easier as it requires less effort and time

6. Easier to Debug
 7. Machine-Independent, mostly.
Disadvantages of Structured Programming Approach:

1. Since it is Machine-Independent, So it takes time to convert into machine

code.

2. The converted machine code is not the same as for assembly language.

3. The program depends upon changeable factors like data-types. Therefore it

needs to be updated with the need on the go.

4. Usually the development in this approach takes longer time as it is language-

dependent. Whereas in the case of assembly language, the development
takes lesser time as it is fixed for the machine.

Difference between Function Oriented Design and Object Oriented Design

Function-oriented design focuses on defining and organizing functions to perform

specific tasks, starting with a high-level description and refining it step-by-step. It
uses a top-down approach and often relies on structured analysis and data flow
diagrams. On the other hand, object-oriented design emphasizes the data to be
manipulated, organizing the software around objects that combine data and
behavior. This approach uses a bottom-up strategy, beginning with identifying objects
and classes, and often employs UML for design.
What is Function Oriented Design?

Function-oriented design is the result of focusing attention on the function of the

program. This is based on the stepwise refinement. Stepwise refinement is based on
the iterative procedural decomposition. Stepwise refinement is a top-down strategy
where a program is refined as a hierarchy of increasing levels of detail.

We start with a high-level description of what the program does. Then, in each step,
we take one part of our high-level description and refine it. Refinement is actually a
process of elaboration. The process should proceed from a highly conceptual model
to lower-level details. The refinement of each module is done until we reach the
statement level of our programming language.
What is Object Oriented Design?

Object-oriented design is the result of focusing attention not on the function

performed by the program, but instead on the data that are to be manipulated by the
program. Thus, it is orthogonal to function-oriented design. The object-oriented
design begins with an examination of real-world “things”. These things have
individual characteristics in terms of their attributes and behaviors.
Objects are independent entities that may readily be changed because all state and
representation information is held within the object itself. Objects may be distributed
and may execute sequentially or in parallel. Object-oriented technology contains the
following three keywords –

1. Objects: Software packages are designed and developed to correspond with

real-world entities that contain all the data and services to function as their
associated entity messages.
2. Communication: Communication mechanisms are established that provide
how objects work together.
3. Methods: Methods are services that objects perform to satisfy the functional
requirements of the problem domain. Objects request services of the other
objects through messages.

Understanding the difference between Function-Oriented Design (FOD) and Object-

Oriented Design (OOD) is crucial for choosing the right approach for your
projects. Check out this System design course to learn more about these design
methodologies and their applications.
Difference Between Function Oriented Design and Object Oriented Design

COMPARISON FUNCTION ORIENTED

FACTORS DESIGN OBJECT ORIENTED DESIGN

The basic abstractions are not

The basic abstractions, the real world functions but are
Abstraction which are given to the user, the data abstraction where the
are real world functions. real world entities are
represented.

Function are grouped together

Functions are grouped
on the basis of the data they
Function together by which a higher
operate since the classes are
level function is obtained.
associated with their methods.

carried out using structured

execute analysis and structured Carried out using UML
design i.e, data flow diagram
COMPARISON FUNCTION ORIENTED
FACTORS DESIGN OBJECT ORIENTED DESIGN

In this approach the state

In this approach the state information is not represented
State information is often in a centralized memory but is
information represented in a centralized implemented or distributed
shared memory. among the objects of the
system.

Approach It is a top down approach. It is a bottom up approach.

Begins by considering the

Begins by identifying objects
Begins basis use case diagrams and the
and classes.
scenarios.

In function oriented design

Decompose we decompose in We decompose in class level.
function/procedure level.

This approach is mainly used

This approach is mainly
for evolving system which
Use used for computation
mimics a business or business
sensitive application.
case.

Verification and Validation in Software Engineering

Verification and Validation is the process of investigating whether a software
system satisfies specifications and standards and fulfills the required purpose. Barry
Boehm described verification and validation as the following:

Verification

Verification is the process of checking that software achieves its goal without any
bugs. It is the process to ensure whether the product that is developed is right or not.
It verifies whether the developed product fulfills the requirements that we have.
Verification is simply known as Static Testing.
Static Testing

Verification Testing is known as Static Testing and it can be simply termed as

checking whether we are developing the right product or not and also whether our
software is fulfilling the customer’s requirement or not. Here are some of the
activities that are involved in verification.

 Inspections

 Reviews

 Walkthroughs
 Desk-checking
Validation

Validation is the process of checking whether the software product is up to the mark
or in other words product has high-level requirements. It is the process of checking
the validation of the product i.e. it checks what we are developing is the right
product. it is a validation of actual and expected products. Validation is simply known
as Dynamic Testing.

Dynamic Testing

Validation Testing is known as Dynamic Testing in which we examine whether we

have developed the product right or not and also about the business needs of the
client. Here are some of the activities that are involved in Validation.

1. Black Box Testing

2. White Box Testing

3. Unit Testing

4. Integration Testing
Differences between Verification and Validation

Verification Validation

Validation refers to the set of

Verification refers to the set of
activities that ensure that the
activities that ensure software
software that has been built
correctly implements the
is traceable to customer
specific function
Definition requirements.
 Verification Validation

It includes checking documents, It includes testing and

Focus designs, codes, and programs. validating the actual product.

Type of
Verification is the static testing. Validation is dynamic testing.
Testing

It does not include the It includes the execution of

Execution execution of the code. the code.

Methods used in validation

Methods used in verification are
are Black Box Testing, White
reviews, walkthroughs,
Box Testing and non-
inspections and desk-checking.
Methods Used functional testing.

It checks whether the

It checks whether the software software meets the
conforms to specifications or requirements and
not. expectations of a customer
Purpose or not.

It can only find the bugs that

It can find the bugs in the early
could not be found by the
stage of the development.
Bug verification process.

The goal of verification is

The goal of validation is an
application and software
actual product.
Goal architecture and specification.

Validation is executed on
Quality assurance team does
software code with the help
verification.
Responsibility of testing team.
 Verification Validation

Timing It comes before validation. It comes after verification.

It consists of checking of It consists of execution of

Human or documents/files and is program and is performed by
Computer performed by human. computer.

After a valid and complete

Validation begins as soon as
specification the verification
project starts.
Lifecycle starts.

Verification is for prevention of Validation is for detection of

Error Focus errors. errors.

Verification is also termed as Validation can be termed as

white box testing or static black box testing or dynamic
Another testing as work product goes testing as work product is
Terminology through reviews. executed.

Verification finds about 50 to Validation finds about 20 to

Performance 60% of the defects. 30% of the defects.

Verification is based on the

Validation is based on the
opinion of reviewer and may
fact and is often stable.
Stability change from person to person.

Real-World Example of Verification vs Validation

 Verification Example: Imagine a team is developing a new mobile banking

app. During the verification phase, they review the requirements and design
documents. They check if all the specified features like fund transfer, account
balance check, and transaction history are included and correctly detailed in
the design. They also perform peer reviews and inspections to ensure the
design aligns with the requirements. This step ensures that the app is being
built according to the initial plan and specifications without actually running the
app.
  Validation Example: In the validation phase, the team starts testing the
mobile banking app on actual devices. They check if users can log in, transfer
money, and view their transaction history as intended. Testers perform
usability tests to ensure the app is user-friendly and functional tests to ensure
all features work correctly. They might also involve real users to provide
feedback on the app’s performance. This phase ensures that the app works
as expected and meets user needs in real-world scenarios.
Advantages of Differentiating Verification and Validation

Differentiating between verification and validation in software testing offers several

advantages:
1. Clear Communication: It ensures that team members understand which
aspects of the software development process are focused on checking
requirements (verification) and which are focused on ensuring functionality
(validation).
2. Efficiency: By clearly defining verification as checking documents and
designs without executing code, and validation as testing the actual software
for functionality and usability, teams avoid redundant efforts and streamline
their testing processes.
3. Minimized Errors: It reduces the chances of overlooking critical requirements
or functionalities during testing, leading to a more thorough evaluation of the
software’s capabilities.
4. Cost Savings: Optimizing resource allocation and focusing efforts on the
right testing activities based on whether they fall under verification or
validation helps in managing costs effectively.
5. Client Satisfaction: Ensuring that software meets or exceeds client and user
expectations by conducting both verification and validation processes
rigorously improves overall software quality and user satisfaction.
6. Process Improvement: By distinguishing between verification and validation,
organizations can refine their testing methodologies, identify areas for
improvement, and enhance the overall software development lifecycle.

In essence, clear differentiation between verification and validation in software

testing contributes to a more structured, efficient, and successful software
development process.
Conclusion

Verification is a static process focused on reviewing and analyzing documentation

and design without running the code. It ensures that the software is being built
correctly according to specifications. In contrast, validation is a dynamic process that
involves executing the software to check its functionality, usability, and suitability,
ensuring the right product is built to meet user needs. Both processes are essential
for delivering a high-quality software product.

What is Coupling and Cohesion?

Coupling refers to the degree of interdependence between software modules. High

coupling means that modules are closely connected and changes in one module
may affect other modules. Low coupling means that modules are independent, and
changes in one module have little impact on other modules.
Cohesion refers to the degree to which elements within a module work together to
fulfill a single, well-defined purpose. High cohesion means that elements are closely
related and focused on a single purpose, while low cohesion means that elements
are loosely related and serve multiple purposes.

Both coupling and cohesion are important factors in determining the maintainability,
scalability, and reliability of a software system. High coupling and low cohesion can
make a system difficult to change and test, while low coupling and high cohesion
make a system easier to maintain and improve.

Basically, design is a two-part iterative process. The first part is Conceptual Design
which tells the customer what the system will do. Second is Technical Design which
allows the system builders to understand the actual hardware and software needed
to solve a customer’s problem.

Conceptual design of the system:

  Written in simple language i.e. customer understandable language.

 Detailed explanation about system characteristics.

 Describes the functionality of the system.

 It is independent of implementation.

 Linked with requirement document.

Technical Design of the System:

 Hardware component and design.

 Functionality and hierarchy of software components.

 Software architecture

 Network architecture

 Data structure and flow of data.

 I/O component of the system.

 Shows interface.

Modularization is the process of dividing a software system into multiple independent

modules where each module works independently. There are many advantages of
Modularization in software engineering. Some of these are given below:

 Easy to understand the system.

 System maintenance is easy.

 A module can be used many times as their requirements. No need to write it

again and again.
Types of Coupling

Coupling is the measure of the degree of interdependence between the modules. A

good software will have low coupling.
Types of Coupling

Following are the types of Coupling:

 Data Coupling: If the dependency between the modules is based on the fact
that they communicate by passing only data, then the modules are said to be
data coupled. In data coupling, the components are independent of each
other and communicate through data. Module communications don’t contain
tramp data. Example-customer billing system.
 Stamp Coupling In stamp coupling, the complete data structure is passed
from one module to another module. Therefore, it involves tramp data. It may
be necessary due to efficiency factors- this choice was made by the insightful
designer, not a lazy programmer.
 Control Coupling: If the modules communicate by passing control
information, then they are said to be control coupled. It can be bad if
parameters indicate completely different behavior and good if parameters
allow factoring and reuse of functionality. Example- sort function that takes
comparison function as an argument.
 External Coupling: In external coupling, the modules depend on other
modules, external to the software being developed or to a particular type of
hardware. Ex- protocol, external file, device format, etc.
 Common Coupling: The modules have shared data such as global data
structures. The changes in global data mean tracing back to all modules
which access that data to evaluate the effect of the change. So it has got
disadvantages like difficulty in reusing modules, reduced ability to control data
accesses, and reduced maintainability.
  Content Coupling: In a content coupling, one module can modify the data of
another module, or control flow is passed from one module to the other
module. This is the worst form of coupling and should be avoided.
 Temporal Coupling: Temporal coupling occurs when two modules depend on
the timing or order of events, such as one module needing to execute before
another. This type of coupling can result in design issues and difficulties in
testing and maintenance.
 Sequential Coupling: Sequential coupling occurs when the output of one
module is used as the input of another module, creating a chain or sequence
of dependencies. This type of coupling can be difficult to maintain and modify.
 Communicational Coupling: Communicational coupling occurs when two or
more modules share a common communication mechanism, such as a
shared message queue or database. This type of coupling can lead to
performance issues and difficulty in debugging.
 Functional Coupling: Functional coupling occurs when two modules depend
on each other’s functionality, such as one module calling a function from
another module. This type of coupling can result in tightly-coupled code that is
difficult to modify and maintain.
 Data-Structured Coupling: Data-structured coupling occurs when two or
more modules share a common data structure, such as a database table or
data file. This type of coupling can lead to difficulty in maintaining the integrity
of the data structure and can result in performance issues.
 Interaction Coupling: Interaction coupling occurs due to the methods of a
class invoking methods of other classes. Like with functions, the worst form of
coupling here is if methods directly access internal parts of other methods.
Coupling is lowest if methods communicate directly through parameters.
 Component Coupling: Component coupling refers to the interaction between
two classes where a class has variables of the other class. Three clear
situations exist as to how this can happen. A class C can be component
coupled with another class C1, if C has an instance variable of type C1, or C
has a method whose parameter is of type C1,or if C has a method which has
a local variable of type C1. It should be clear that whenever there is
component coupling, there is likely to be interaction coupling.
Types of Cohesion

Cohesion is a measure of the degree to which the elements of the module are
functionally related. It is the degree to which all elements directed towards
performing a single task are contained in the component. Basically, cohesion is the
internal glue that keeps the module together. A good software design will have high
cohesion.
Types of Cohesion

Following are the types of Cohesion:

 Functional Cohesion: Every essential element for a single computation is
contained in the component. A functional cohesion performs the task and
functions. It is an ideal situation.
 Sequential Cohesion: An element outputs some data that becomes the input
for other element, i.e., data flow between the parts. It occurs naturally in
functional programming languages.
 Communicational Cohesion: Two elements operate on the same input data
or contribute towards the same output data. Example- update record in the
database and send it to the printer.
 Procedural Cohesion: Elements of procedural cohesion ensure the order of
execution. Actions are still weakly connected and unlikely to be reusable. Ex-
calculate student GPA, print student record, calculate cumulative GPA, print
cumulative GPA.
 Temporal Cohesion: The elements are related by their timing involved. A
module connected with temporal cohesion all the tasks must be executed in
the same time span. This cohesion contains the code for initializing all the
parts of the system. Lots of different activities occur, all at unit time.
 Logical Cohesion: The elements are logically related and not functionally.
Ex- A component reads inputs from tape, disk, and network. All the code for
these functions is in the same component. Operations are related, but the
functions are significantly different.
  Coincidental Cohesion: The elements are not related(unrelated). The
elements have no conceptual relationship other than location in source code.
It is accidental and the worst form of cohesion. Ex- print next line and reverse
the characters of a string in a single component.
 Procedural Cohesion: This type of cohesion occurs when elements or tasks
are grouped together in a module based on their sequence of execution, such
as a module that performs a set of related procedures in a specific order.
Procedural cohesion can be found in structured programming languages.
 Communicational Cohesion: Communicational cohesion occurs when
elements or tasks are grouped together in a module based on their
interactions with each other, such as a module that handles all interactions
with a specific external system or module. This type of cohesion can be found
in object-oriented programming languages.
 Temporal Cohesion: Temporal cohesion occurs when elements or tasks are
grouped together in a module based on their timing or frequency of execution,
such as a module that handles all periodic or scheduled tasks in a system.
Temporal cohesion is commonly used in real-time and embedded systems.
 Informational Cohesion: Informational cohesion occurs when elements or
tasks are grouped together in a module based on their relationship to a
specific data structure or object, such as a module that operates on a specific
data type or object. Informational cohesion is commonly used in object-
oriented programming.
 Functional Cohesion: This type of cohesion occurs when all elements or
tasks in a module contribute to a single well-defined function or purpose, and
there is little or no coupling between the elements. Functional cohesion is
considered the most desirable type of cohesion as it leads to more
maintainable and reusable code.
 Layer Cohesion: Layer cohesion occurs when elements or tasks in a module
are grouped together based on their level of abstraction or responsibility, such
as a module that handles only low-level hardware interactions or a module
that handles only high-level business logic. Layer cohesion is commonly used
in large-scale software systems to organize code into manageable layers.
Advantages of low coupling

 Improved maintainability: Low coupling reduces the impact of changes in one

module on other modules, making it easier to modify or replace individual
components without affecting the entire system.

 Enhanced modularity: Low coupling allows modules to be developed and

tested in isolation, improving the modularity and reusability of code.
  Better scalability: Low coupling facilitates the addition of new modules and the
removal of existing ones, making it easier to scale the system as needed.
Advantages of high cohesion

 Improved readability and understandability: High cohesion results in clear,

focused modules with a single, well-defined purpose, making it easier for
developers to understand the code and make changes.

 Better error isolation: High cohesion reduces the likelihood that a change in
one part of a module will affect other parts, making it easier to

 Improved reliability: High cohesion leads to modules that are less prone to
errors and that function more consistently,

 leading to an overall improvement in the reliability of the system.

Disadvantages of high coupling

 Increased complexity: High coupling increases the interdependence between

modules, making the system more complex and difficult to understand.

 Reduced flexibility: High coupling makes it more difficult to modify or replace

individual components without affecting the entire system.

 Decreased modularity: High coupling makes it more difficult to develop and

test modules in isolation, reducing the modularity and reusability of code.
Disadvantages of low cohesion

 Increased code duplication: Low cohesion can lead to the duplication of code,
as elements that belong together are split into separate modules.

 Reduced functionality: Low cohesion can result in modules that lack a clear
purpose and contain elements that don’t belong together, reducing their
functionality and making them harder to maintain.

 Difficulty in understanding the module: Low cohesion can make it harder for
developers to understand the purpose and behavior of a module, leading to
errors and a lack of clarity.
Conclusion

In conclusion, it’s good for software to have low coupling and high cohesion. Low
coupling means the different parts of the software don’t rely too much on each other,
which makes it safer to make changes without causing unexpected problems. High
cohesion means each part of the software has a clear purpose and sticks to it,
making the code easier to work with and reuse. Following these principles helps
make software stronger, more adaptable, and easier to grow.
What is Fourth Generation Programming Language?
The language which is used to create programs is called a programming language. It
comprises a set of instructions that are used to produce various kinds of output. A
Fourth Generation Programming Language (4GL) is designed to make coding easier
and faster for people by using more human-friendly commands, compared to older
programming languages. In this article, we are going to discuss fourth-generation
programming language in detail.
What is Fourth Generation Programming Language?

A Fourth Generation (Programming) Language (4GL) is a grouping of

programming languages that attempt to get closer than 3GLs to human language, a
form of thinking, and conceptualization and are easier to use than 3GLs. It is a non-
procedural language which means that the programmer defines what has to be done
instead of how the task is to be completed.I4GL is more familiar and similar to
human language. A compiler translates the whole program once i.e. it generates the
object code for the program along with the list of errors. The execution is very fast. It
allows users to develop software. These languages are usually designed for specific
purposes and are commonly used in database programming and scripts such
as PHP, Python, SQL, and many more. 4GLs make programming easier, more
efficient, and more effective for users with less programming skills.

4th generation language is also known as a domain-specific language or a high-

productivity language.
Components of Fourth Generation

The following are the components of 4GL:

 Databases and Tables: The Database and the tables on which the 4GL
programs operate.
 Form: The screen that is displayed for the user data entry. The source code
for forms is kept in operating system files with a .per suffix and contains
instructions for how 4GL is to format the screen. For a form available to a 4GL
program, it must be compiled into a file with a .frm suffix. The 4GL programs in
turn reference the fields on the compiled screens.
 Module: Operating System files that contain the source code to your
programs- a set of functions written in INFORMIX-4GL. These files have a
suffix of .4gl and contain one or more components.
 Main Function: Each executable Informix program has the MAIN function; it
is the first thing that is executed and in turn calls other functions.
 Function: Portions of 4GL programs that can be called from MAIN and other
functions. These start with the FUNCTION keyword.
 Reports: Portions of 4GL programs that create reports. They include headers,
groupings, sorting, and more. They start with the FUNCTION keyword.
  Programs: This is what is actually executed by the users. Depending on the
4GL product that you have (compiled or interpreted “Executable and
Interpreted 4GL”), this file is executed either by the operating system or
through a 4GL interpreter.
Features of 4GL

 It reduces programming costs and time.

 It is a high-level programming language.

 Its program has greater usability.

 It accesses the database.

 Minimum efforts from the user to obtain any information.

Types of 4GL

 Self-generator system.

 Report generator programming language.

 Form generators.

 Codeless programming.

 Data management.
Advantages of 4GL

 Smaller in size as compared to the previous generation’s language.

 Graphics User Interface (GUI) technology was introduced.

 Low maintenance cost.

 The heat generated was negligible.

 Portable and cheaper than the previous generation.

Disadvantages of 4GL

 Requires complex structure.

 The latest technology is required for the manufacturing of Microprocessors.

 Less flexible than other languages.

 Memory consumption is high.

Conclusion

Fourth Generation Languages (4GLs) are a step forward in the process of

programming technology since they provide the programmer with simplified and
more efficient means of developing an application. Abstracting difficult procedural
details and concentrating on what has to be done, 4GLs facilitate programming and
increase its output. As much as they have some benefits, they have some
drawbacks, which include; They are complicated and consume a larger amount of
memory. Knowledge of these languages’ elements and properties for programming
dialogues and potential consequences will help to select the right instruments for
certain tasks.
Introduction to Functional Independence: Functional independence is defined as
a direct improvement or enhancement to the concepts modularity abstraction and
information hiding. It can achieved by developing the modules ( or components) for
their single ,isolated respective functions and then combine these modules through
interacting approaches to achieve a whole sole objective. When a module will have
its single function to perform then it will be easy to achieve its objective
.so functional independence in this respect is associated with the effective
modularity. It is beneficial to compartmentalize the whole function into small sub
functions for the modules then that modules are developed accordingly. After
developing all the modules, they are merged together to achieve the centre land
main function. That why all the modules must be assigned the independent
functions. No two modules must have some function to be achieved. Such
independent modules are easier to maintain. And there will be less error
propagation and even sensibility increase.

Functional independence is a key of good design and design is the key to software
quality. So we strive in most designs to make the modules independent of
one another. Not only is it easier to understand how a module works but is also
much easier to modify an independent module. similarly when a system failure is
traced back through the code to the design, independent modules help to isolate
and fix the cause.
To recognize and measure the degree of module independence in a design two
qualitative criteria are defined cohesion and coupling. We will discuss them in next
two section. Much work has been done on the functional independence. Parens and
Wirth have defined some refinement techniques in landmark paper that improves
the modules independence on software design. Stevens Myers and Constantine
elaborated this concept further.

Effective Modular Design in Software Engineering

The role of effective modular design in software engineering:

Any software comprises of many systems which contains several sub-systems and
those sub-systems further contains their sub-systems. So, designing a complete
system in one go comprising of each and every required functionality is a hectic work
and the process can have many errors because of its vast size.
Thus in order to solve this problem the developing team breakdown the complete
software into various modules. A module is defined as the unique and addressable
components of the software which can be solved and modified independently without
disturbing ( or affecting in very small amount ) other modules of the software. Thus
every software design should follow modularity.

The process of breaking down a software into multiple independent modules where
each module is developed separately is called Modularization.

Effective modular design can be achieved if the partitioned modules are separately
solvable, modifiable as well as compilable. Here separate compilable modules
means that after making changes in a module there is no need of recompiling the
whole software system.

In order to build a software with effective modular design there is a

factor “Functional Independence” which comes into play. The meaning of
Functional Independence is that a function is atomic in nature so that it performs only
a single task of the software without or with least interaction with other modules.
Functional Independence is considered as a sign of growth in modularity i.e.,
presence of larger functional independence results in a software system of good
design and design further affects the quality of the software.
Benefits of Independent modules/functions in a software design:
Since the functionality of the software have been broken down into atomic levels,
thus developers get a clear requirement of each and every functions and hence
designing of the software becomes easy and error free.

As the modules are independent they have limited or almost no dependency on

other modules. So, making changes in a module without affecting the whole system
is possible in this approach.
Error propagation from one module to another and further in whole system can be
neglected and it saves time during testing and debugging.

Independence of modules of a software system can be measured using 2 criteria

: Cohesion, and Coupling. These are explained as following below.
Figure – Cohesion and Coupling between 2 modules

Cohesion:
Cohesion is a measure of strength in relationship between various functions within a
module. It is of 7 types which are listed below in the order of high to low cohesion:
1. Functional cohesion

2. Sequential cohesion

3. Communicational cohesion

4. Procedural cohesion

5. Temporal cohesion

6. Logical cohesion

7. Co-incidental cohesion
Coupling:
Coupling is a measure of strength in relationship between various modules within a
software. It is of 6 types which are listed below in the order of low to high coupling:
1. Data Coupling
2. Stamp Coupling

3. Control Coupling

4. External Coupling
5. Common Coupling
6. Content Coupling

A good software design requires high cohesion and low coupling.

Architectural Design – Software Engineering

The software needs an architectural design to represent the design of the software.
IEEE defines architectural design as “the process of defining a collection of hardware
and software components and their interfaces to establish the framework for the
development of a computer system.” The software that is built for computer-based
systems can exhibit one of these many architectural styles.
System Category Consists of

 A set of components(eg: a database, computational modules) that will perform

a function required by the system.

 The set of connectors will help in coordination, communication, and

cooperation between the components.

 Conditions that defines how components can be integrated to form the

system.

 Semantic models that help the designer to understand the overall properties
of the system.

The use of architectural styles is to establish a structure for all the components of the
system.

For a deeper understanding of architectural design and how it applies to real-world

systems, the System Design Course provides comprehensive insights into best
practices and design strategies.
Taxonomy of Architectural Styles

1] Data centered architectures:

 A data store will reside at the center of this architecture and is accessed
frequently by the other components that update, add, delete, or modify the
data present within the store.

 The figure illustrates a typical data-centered style. The client software

accesses a central repository. Variations of this approach are used to
transform the repository into a blackboard when data related to the client or
data of interest for the client change the notifications to client software.
 This data-centered architecture will promote integrability. This means that the
existing components can be changed and new client components can be
added to the architecture without the permission or concern of other clients.
  Data can be passed among clients using the blackboard mechanism.
Advantages of Data centered architecture:

 Repository of data is independent of clients

 Client work independent of each other

 It may be simple to add additional clients.

 Modification can be very easy

Data centered architecture

2] Data flow architectures:

 This kind of architecture is used when input data is transformed into output
data through a series of computational manipulative components.

 The figure represents pipe-and-filter architecture since it uses both pipe and
filter and it has a set of components called filters connected by lines.
 Pipes are used to transmitting data from one component to the next.

 Each filter will work independently and is designed to take data input of a
certain form and produces data output to the next filter of a specified form.
The filters don’t require any knowledge of the working of neighboring filters.

 If the data flow degenerates into a single line of transforms, then it is termed
as batch sequential. This structure accepts the batch of data and then applies
a series of sequential components to transform it.
Advantages of Data Flow architecture:

 It encourages upkeep, repurposing, and modification.

 With this design, concurrent execution is supported.

Disadvantage of Data Flow architecture:

 It frequently degenerates to batch sequential system

 Data flow architecture does not allow applications that require greater user
engagement.
  It is not easy to coordinate two different but related streams

Data Flow architecture

3] Call and Return architectures

It is used to create a program that is easy to scale and modify. Many sub-styles exist
within this category. Two of them are explained below.
 Remote procedure call architecture: This components is used to present in
a main program or sub program architecture distributed among multiple
computers on a network.
 Main program or Subprogram architectures: The main program structure
decomposes into number of subprograms or function into a control hierarchy.
Main program contains number of subprograms that can invoke other
components.

4] Object Oriented architecture

The components of a system encapsulate data and the operations that must be
applied to manipulate the data. The coordination and communication between the
components are established via the message passing.
Characteristics of Object Oriented architecture:
 Object protect the system’s integrity.
  An object is unaware of the depiction of other items.
Advantage of Object Oriented architecture:

 It enables the designer to separate a challenge into a collection of

autonomous objects.

 Other objects are aware of the implementation details of the object, allowing
changes to be made without having an impact on other objects.
5] Layered architecture

 A number of different layers are defined with each layer performing a well-
defined set of operations. Each layer will do some operations that becomes
closer to machine instruction set progressively.

 At the outer layer, components will receive the user interface operations and
at the inner layers, components will perform the operating system
interfacing(communication and coordination with OS)

 Intermediate layers to utility services and application software functions.

 One common example of this architectural style is OSI-ISO (Open Systems

Interconnection-International Organisation for Standardisation)
communication system.

Unit – IV Coding
INFORMATION HIDING:

"Information hiding" in software design refers to the practice of keeping certain

details of a program module or object concealed from other parts of the system,
allowing only necessary information to be accessed through a defined interface. This
means that internal implementation details are hidden, protecting other modules from
needing to know how the data is stored or manipulated, which ultimately leads to
cleaner, more modular code that is easier to maintain and modify.

Key points about information hiding:

 Encapsulation:

This is the primary mechanism used to achieve information hiding in object-oriented

programming. By declaring variables as "private" within a class, direct access is
restricted, and only public methods can interact with the data, controlling how it is
accessed and modified.

 Benefits:

 Reduced complexity: By hiding implementation details, developers can

focus on the functionality of a module without worrying about the
intricate workings of other parts of the system.
 Improved maintainability: If changes are made to the internal
implementation of a module, other parts of the code that use it won't
need to be modified as long as the public interface remains consistent.

 Enhanced security: By limiting access to sensitive data, information

hiding can help protect against unauthorized modifications.

 Implementation techniques:

 Access modifiers: Programming languages like Java and C++ use

keywords like "public," "private," and "protected" to define visibility
levels for class members.

 Getters and Setters: Methods designed to retrieve or modify private

data within an object, providing controlled access to the information.
Coding Standards and Guidelines

Different modules specified in the design document are coded in the Coding phase
according to the module specification. The main goal of the coding phase is to code
from the design document prepared after the design phase through a high-level
language and then to unit test this code.
What is Coding Standards and Guidelines?
Good software development organizations want their programmers to maintain to
some well-defined and standard style of coding called coding standards. They
usually make their own coding standards and guidelines depending on what suits
their organization best and based on the types of software they develop. It is very
important for the programmers to maintain the coding standards otherwise the code
will be rejected during code review.
Purpose of Having Coding Standards

The following are the purpose of having Coding Standards:

 A coding standard gives a uniform appearance to the codes written by

different engineers.

 It improves readability, and maintainability of the code and it reduces

complexity also.

 It helps in code reuse and helps to detect errors easily.

 It promotes sound programming practices and increases the efficiency of the

programmers.
Coding Standards in Software Engineering

Some of the coding standards are given below:

1. Limited use of globals: These rules tell about which types of data that can
be declared global and the data that can’t be.
2. Standard headers for different modules: For better understanding and
maintenance of the code, the header of different modules should follow some
standard format and information. The header format must contain below
things that is being used in various companies:
 Name of the module

 Date of module creation

 Author of the module

 Modification history

 Synopsis of the module about what the module does

 Different functions supported in the module along with their input output
parameters

 Global variables accessed or modified by the module

3. Naming conventions for local variables, global variables, constants and
functions: Some of the naming conventions are given below:
  Meaningful and understandable variables name helps anyone to
understand the reason of using it.

 Local variables should be named using camel case lettering starting

with small letter (e.g. localData) whereas Global variables names
should start with a capital letter (e.g. GlobalData). Constant names
should be formed using capital letters only (e.g. CONSDATA).

 It is better to avoid the use of digits in variable names.

 The names of the function should be written in camel case starting with
small letters.

 The name of the function must describe the reason of using the
function clearly and briefly.
4. Indentation: Proper indentation is very important to increase the readability of
the code. For making the code readable, programmers should use White
spaces properly. Some of the spacing conventions are given below:

 There must be a space after giving a comma between two function

arguments.

 Each nested block should be properly indented and spaced.

 Proper Indentation should be there at the beginning and at the end of

each block in the program.

 All braces should start from a new line and the code following the end
of braces also start from a new line.
5. Error return values and exception handling conventions: All functions that
encountering an error condition should either return a 0 or 1 for simplifying the
debugging.
Coding Guidelines in Software Engineering

Coding guidelines give some general suggestions regarding the coding style that to
be followed for the betterment of understandability and readability of the code.
Some of the coding guidelines are given below :
1. Avoid using a coding style that is too difficult to understand: Code
should be easily understandable. The complex code makes maintenance and
debugging difficult and expensive.
2. Avoid using an identifier for multiple purposes: Each variable should be
given a descriptive and meaningful name indicating the reason behind using
it. This is not possible if an identifier is used for multiple purposes and thus it
can lead to confusion to the reader. Moreover, it leads to more difficulty during
future enhancements.
 3. Code should be well documented: The code should be properly
commented for understanding easily. Comments regarding the statements
increase the understandability of the code.
4. Length of functions should not be very large: Lengthy functions are very
difficult to understand. That’s why functions should be small enough to carry
out small work and lengthy functions should be broken into small ones for
completing small tasks.
5. Try not to use GOTO statement: GOTO statement makes the program
unstructured, thus it reduces the understandability of the program and also
debugging becomes difficult.
Advantages of Coding Guidelines

1. Coding guidelines increase the efficiency of the software and reduces the
development time.
2. Coding guidelines help in detecting errors in the early phases, so it helps to
reduce the extra cost incurred by the software project.

3. If coding guidelines are maintained properly, then the software code increases
readability and understandability thus it reduces the complexity of the code.

4. It reduces the hidden cost for developing the software.

Conclusion

Coding standards and guidelines ensure consistent, readable, and maintainable

code, promoting efficient development and error detection. They standardize naming,
indentation, and documentation practices, reducing complexity and facilitating code
reuse. Adhering to these practices enhances overall software quality and
development efficiency.
What is Software Testing?

Software testing is an important process in the software development lifecycle .

It involves verifying and validating that a software application is free of bugs,
meets the technical requirements set by its design and development , and satisfies
user requirements efficiently and effectively.

This process ensures that the application can handle all exceptional and boundary
cases, providing a robust and reliable user experience. By systematically identifying
and fixing issues, software testing helps deliver high-quality software that performs
as expected in various scenarios. The process of software testing aims not only at
finding faults in the existing software but also at finding measures to improve the
software in terms of efficiency, accuracy, and usability. The article focuses on
discussing Software Testing in detail. Software Testing is a method to assess the
functionality of the software program. The process checks whether the actual
software matches the expected requirements and ensures the software is bug-free.
The purpose of software testing is to identify the errors, faults, or missing
requirements in contrast to actual requirements. It mainly aims at measuring the
specification, functionality, and performance of a software program or application.

Perform end-to-end test automation, including AI-powered codeless testing, mobile

app, cross-browser, visual UI testing, and more with TestGrid . It is a highly secure
and scalable software testing tool that offers extensive integration with CI/CD
pipelines for continuous testing.
Software testing can be divided into two steps

1. Verification: It refers to the set of tasks that ensure that the software correctly
implements a specific function. It means “Are we building the product right?”.
2. Validation: It refers to a different set of tasks that ensure that the software
that has been built is traceable to customer requirements. It means “Are we
building the right product?”.
Importance of Software Testing

 Defects can be identified early: Software testing is important because if

there are any bugs they can be identified early and can be fixed before the
delivery of the software.
 Improves quality of software: Software Testing uncovers the defects in the
software, and fixing them improves the quality of the software.
 Increased customer satisfaction: Software testing ensures reliability,
security, and high performance which results in saving time, costs, and
customer satisfaction.
 Helps with scalability: Software testing type non-functional testing helps to
identify the scalability issues and the point where an application might stop
working.
 Saves time and money: After the application is launched it will be very
difficult to trace and resolve the issues, as performing this activity will incur
more costs and time. Thus, it is better to conduct software testing at regular
intervals during software development.
Need for Software Testing

Software bugs can cause potential monetary and human loss. There are many
examples in history that clearly depicts that without the testing phase in software
development lot of damage was incurred. Below are some examples:
 1985: Canada’s Therac-25 radiation therapy malfunctioned due to a software
bug and resulted in lethal radiation doses to patients leaving 3 injured and 3
people dead.
  1994: China Airlines Airbus A300 crashed due to a software bug killing 264
people.
 1996: A software bug caused U.S. bank accounts of 823 customers to be
credited with 920 million US dollars.
 1999: A software bug caused the failure of a $1.2 billion military satellite
launch.
 2015: A software bug in fighter plan F-35 resulted in making it unable to
detect targets correctly.
 2015: Bloomberg terminal in London crashed due to a software bug affecting
300,000 traders on the financial market and forcing the government to
postpone the 3bn pound debt sale.

 Starbucks was forced to close more than 60% of its outlet in the U.S. and
Canada due to a software failure in its POS system.

 Nissan cars were forced to recall 1 million cars from the market due to a
software failure in the car’s airbag sensory detectors.
Different Types Of Software Testing

Explore diverse software testing methods including manual and automated testing
for improved quality assurance . Enhance software reliability and performance
through functional and non-functional testing, ensuring user satisfaction. Learn about
the significance of various testing approaches for robust software development.
Types Of Software Testing

Software Testing can be broadly classified into 3 types:

1. Functional testing : It is a type of software testing that validates the software
systems against the functional requirements. It is performed to check whether
the application is working as per the software’s functional requirements or not.
Various types of functional testing are Unit testing, Integration testing, System
testing, Smoke testing, and so on.
2. Non-functional testing : It is a type of software testing that checks the
application for non-functional requirements like performance, scalability,
portability, stress, etc. Various types of non-functional testing are Performance
testing, Stress testing, Usability Testing, and so on.
3. Maintenance testing : It is the process of changing, modifying, and updating
the software to keep up with the customer’s needs. It involves regression
testing that verifies that recent changes to the code have not adversely
affected other previously working parts of the software.

Apart from the above classification software testing can be further divided into 2
more ways of testing:
 1. Manual testing : It includes testing software manually, i.e., without using any
automation tool or script. In this type, the tester takes over the role of an end-
user and tests the software to identify any unexpected behavior or bug. There
are different stages for manual testing such as unit testing, integration testing,
system testing, and user acceptance testing. Testers use test plans, test
cases, or test scenarios to test software to ensure the completeness of
testing. Manual testing also includes exploratory testing, as testers explore
the software to identify errors in it.
2. Automation testing : It is also known as Test Automation, is when the tester
writes scripts and uses another software to test the product. This process
involves the automation of a manual process. Automation Testing is used to
re-run the test scenarios quickly and repeatedly, that were performed
manually in manual testing.
Apart from Regression testing , Automation testing is also used to test the
application from a load, performance, and stress point of view. It increases the test
coverage, improves accuracy, and saves time and money when compared to manual
testing.
Different Types of Software Testing Techniques

Software testing techniques can be majorly classified into two categories:

1. Black box Testing : Testing in which the tester doesn’t have access to the
source code of the software and is conducted at the software interface without
any concern with the internal logical structure of the software known as black-
box testing.
2. White box Testing : Testing in which the tester is aware of the internal
workings of the product, has access to its source code, and is conducted by
making sure that all internal operations are performed according to the
specifications is known as white box testing.
3. Grey Box Testing : Testing in which the testers should have knowledge of
implementation, however, they need not be experts.

S No. Black Box Testing White Box Testing

Internal workings of an
Knowledge of the internal
1 application are not
workings is a must.
required.
S No. Black Box Testing White Box Testing

Also known as closed Also known as clear

2
box/data-driven testing. box/structural testing.

End users, testers, and Normally done by testers

3
developers. and developers.

Data domains and internal

This can only be done by
4 boundaries can be better
a trial and error method.
tested.

Different Levels of Software Testing

Software level testing can be majorly classified into 4 levels:

1. Unit testing : It a level of the software testing process where individual
units/components of a software/system are tested. The purpose is to validate
that each unit of the software performs as designed.
2. Integration testing : It is a level of the software testing process where
individual units are combined and tested as a group. The purpose of this level
of testing is to expose faults in the interaction between integrated units.
3. System testing : It is a level of the software testing process where a
complete, integrated system/software is tested. The purpose of this test is to
evaluate the system’s compliance with the specified requirements.
4. Acceptance testing : It is a level of the software testing process where a
system is tested for acceptability. The purpose of this test is to evaluate the
system’s compliance with the business requirements and assess whether it is
acceptable for delivery.
Best Practices for Software Testing

Below are some of the best practices for software testing:

 Continuous testing : Project teams test each build as it becomes available
thus it enables software to be validated in real environments earlier in the
development cycle, reducing risks and improving the functionality and design.
 Involve users: It is very important for the developers to involve users in the
process and open-ended questions about the functionality required in the
application. This will help to develop and test the software from the customer’s
perspective.
  Divide tests into smaller parts: Dividing tests into smaller fractions save
time and other resources in environments where frequent testing needs to be
conducted. This also helps teams to make better analyses of the tests and the
test results.
 Metrics and Reporting: Reporting enables the team members to share goals
and test results. Advanced tools integrate the project metrics and present an
integrated report in the dashboard that can be easily reviewed by the team
members to see the overall health of the project.
 Don’t skip regression testing: Regression testing is one of the most
important steps as it encourages the validation of the application. Thus, it
should not be skipped.
 Programmers should avoid writing tests: Test cases are usually written
before the start of the coding phase so it is considered a best practice for
programmers to avoid writing test cases as they can be biased towards their
code and the application.
 Service virtualization: Service virtualization simulates the systems and
services that are not yet developed or are missing. Thus, enabling teams to
reduce dependency and start the testing process sooner. They can modify,
and reuse the configuration to test different scenarios without having to alter
the original environment.
Benefits of Software Testing

 Product quality: Testing ensures the delivery of a high-quality product as the

errors are discovered and fixed early in the development cycle.
 Customer satisfaction: Software testing aims to detect the errors or
vulnerabilities in the software early in the development phase so that the
detected bugs can be fixed before the delivery of the product. Usability testing
is a type of software testing that checks the application for how easily usable it
is for the users to use the application.
 Cost-effective: Testing any project on time helps to save money and time for
the long term. If the bugs are caught in the early phases of software testing, it
costs less to fix those errors.
 Security: Security testing is a type of software testing that is focused on
testing the application for security vulnerabilities from internal or external
sources.
Conclusion

Software testing ensures that software works properly, meets user needs, and is free
of problems. It helps find and fix issues early, making sure the final product is reliable
and meets quality standards. By testing regularly and involving users, software
teams can make better products that save time and money.
Principles of software testing – Software Testing
Software testing is an important aspect of software development, ensuring that
applications function correctly and meet user expectations.
In this article, we will go into the principles of software testing, exploring key
concepts and methodologies to enhance product quality. From test planning to
execution and analysis, understanding these principles is vital for delivering robust
and reliable software solutions.
Principles of Software Testing

Below-mentioned are the principles of software testing:

Principles of Software Testing

1. Testing shows the presence of defects

2. Exhaustive testing is not possible

3. Early testing

4. Defect clustering

5. Pesticide paradox

6. Testing is Context-Dependent

7. Absence of Errors fallacy

1. Testing shows the Presence of Defects

The goal of software testing is to make the software fail. Software testing reduces
the presence of defects. Software testing talks about the presence of defects and
doesn’t talk about the absence of defects. Software testing can ensure that defects
are present but it can not prove that software is defect-free. Even multiple tests can
never ensure that software is 100% bug-free. Testing can reduce the number of
defects but not remove all defects.
2. Exhaustive Testing is not Possible

It is the process of testing the functionality of the software in all possible inputs (valid
or invalid) and pre-conditions is known as exhaustive testing. Exhaustive testing is
impossible means the software can never test at every test case. It can test only
some test cases and assume that the software is correct and it will produce the
correct output in every test case. If the software will test every test case then it will
take more cost, effort, etc., which is impractical.
3. Early Testing
To find the defect in the software, early test activity shall be started. The defect
detected in the early phases of SDLC will be very less expensive. For better
performance of software, software testing will start at the initial phase i.e. testing will
perform at the requirement analysis phase.
4. Defect Clustering

In a project, a small number of modules can contain most of the defects. The Pareto
Principle for software testing states that 80% of software defects come from 20% of
modules.
5. Pesticide Paradox

Repeating the same test cases, again and again, will not find new bugs. So it is
necessary to review the test cases and add or update test cases to find new bugs.
6. Testing is Context-Dependent

The testing approach depends on the context of the software developed. Different
types of software need to perform different types of testing. For example, The testing
of the e-commerce site is different from the testing of the Android application.
7. Absence of Errors Fallacy

If a built software is 99% bug-free but does not follow the user requirement then it is
unusable. It is not only necessary that software is 99% bug-free but it is also
mandatory to fulfill all the customer requirements.
Types of Software Testing

1. Unit Testing

2. Integration Testing

3. Regression Testing

4. Smoke Testing

5. System Testing

6. Alpha Testing

7. Beta Testing

8. Performance Testing

1. Unit Testing

Unit tests are typically written by developers as they write the code for a given unit.
They are usually written in the same programming language as the software and use
a testing framework or library that provides the necessary tools for creating and
running the tests. These frameworks often include assertion libraries, which allow
developers to write test cases that check the output of a given unit against expected
results. The tests are usually run automatically and continuously as part of the
software build process, and the results are typically displayed in a test runner or a
continuous integration tool.
Unit Testing has several benefits, including:

Unit testing offers several benefits to software development:

1. Early Detection of Bugs: Unit tests can uncover bugs early in the
development process, making them easier and cheaper to fix.
2. Improved Code Quality: Writing unit tests encourages developers to write
modular, well-structured code that is easier to maintain and understand.
3. Regression Testing: Unit tests serve as a safety net, ensuring that changes
or updates to the codebase do not introduce new bugs or break existing
functionality.
4. Documentation: Unit tests can serve as documentation for the codebase,
providing examples of how the code should be used and what behavior is
expected.
5. Facilitates Refactoring: Unit tests give developers the confidence to refactor
code without fear of introducing bugs, as they can quickly verify that the
refactored code behaves as expected.
2. Integration Testing

Integration testing is a software testing method in which individual units or

components of a software application are combined and tested as a group. The goal
of integration testing is to validate that the interactions between the units or
components of the software work as expected and that the software as a whole
functions correctly.

Integration testing is typically performed after unit testing and before system testing.
It is usually done by developers and test engineers, and it is usually carried out at
the module level. Integration tests are typically automated and run frequently, as part
of the software build process, to ensure that the software remains stable and free of
defects over time.
Integration Testing has several benefits, including:

 Detection of defects that may not be discovered during unit testing, as it

examines the interactions between components.
 Improved system design, as integration testing can help identify design
weaknesses.

 Improved software quality and reliability, as integration testing helps to ensure

that the software as a whole functions correctly.
  Facilitation of continuous integration and delivery, as integration testing helps
to ensure that changes to the software do not break existing functionality.

 Overall, integration testing is an essential part of software development that

helps to ensure the quality and reliability of the software by identifying defects
in the interactions between the units and components of the software early on
in the development process.
3. Regression Testing

Regression testing is a software testing method in which previously developed and

tested software is retested after it has been modified or changed. The goal of
regression testing is to ensure that any changes to the software have not introduced
new bugs or broken existing functionality. It is typically done to verify that changes
such as bug fixes, new features, or updates to existing features have not affected the
overall functionality of the software.

Regression testing is typically performed after unit testing and integration testing. It is
usually done by developers and test engineers and it is usually carried out by re-
running a suite of previously passed test cases. The test cases are chosen to cover
the areas of the software that were affected by the changes and to ensure that the
most critical functionality of the software is still working correctly. Regression testing
is typically automated and run frequently, as part of the software build process, to
ensure that the software remains stable and free of defects over time.
Regression Testing has several benefits, including:

 Early detection and isolation of defects, can save time and money by allowing
developers to fix errors before they become more costly to fix.

 Improved software quality and maintainability, as regression testing helps to

ensure that code changes do not break existing functionality.

 Increased developer and user confidence, as regression testing helps to

ensure that the software is still working correctly after changes have been
made.

 Facilitation of continuous integration and delivery, as regression testing helps

to ensure that changes to the software can be safely released.

 Overall, regression testing is an essential part of software development that

helps to ensure
4. Smoke Testing

Smoke testing, also known as “Build Verification Testing” or “Build Acceptance

Testing”, is a software testing method in which a minimal set of tests are run on a
new build of a software application to determine if it is stable enough to proceed with
further testing. The goal of smoke testing is to quickly identify and isolate major
issues with the software build so that development can be halted if the build is found
to be too unstable or unreliable.

Smoke testing is typically performed early in the software testing process, after the
software has been built and before more extensive testing is done. It is usually done
by developers and test engineers and it is usually carried out by running a small set
of critical test cases that exercise the most important functionality of the software.
Smoke tests are usually automated and can be run as part of the software build
process.
Smoke Testing has several benefits, including:

 Early identification of major issues, can save time and money by allowing
developers to fix errors before they become more costly to fix.

 Improved software quality and reliability, as smoke testing helps to ensure that
the software is stable enough to proceed with further testing.
 Facilitation of continuous integration and delivery, as smoke testing helps to
ensure that new builds of the software are stable and reliable before they are
released.

 Overall, smoke testing is an important part of software development that helps

to ensure the quality and reliability of the software by identifying major issues
early on in the development process.

 It helps to quickly determine if a new build of the software is stable enough to

proceed with further testing, providing increased confidence in the software to
the development team and end-users.
5. System Testing

System testing is a software testing method in which an entire software system is

tested as a whole, to ensure that it meets the requirements and specifications that it
was designed for. The goal of system testing is to validate that the software system
behaves as expected when it is used in its intended environment and that it meets all
the requirements for functionality, performance, security, and usability.

System testing is typically performed after unit testing, integration testing, and
regression testing. It is usually done by test engineers and it is usually carried out by
running a set of test cases that cover all the functionality of the software. The test
cases are chosen to cover the requirements and specifications of the software and to
ensure that the software behaves correctly under different conditions and scenarios.
System testing is typically automated and run frequently, as part of the software build
process, to ensure that the software remains stable and free of defects over time.
System Testing has several benefits, including:
  Early detection and isolation of defects, which can save time and money by
allowing developers to fix errors before they become more costly to fix.

 Improved software quality and reliability, as system testing helps to ensure

that the software meets all the requirements and specifications that it was
designed for.

 Increased user confidence, as system testing helps to ensure that the

software behaves correctly when it is used in its intended environment.

 Facilitation of acceptance testing, as system testing helps to ensure that the

software is ready for release.

 Overall, system testing is an essential part of software development that helps

to ensure the quality and reliability of the software by identifying defects early
on in the development process.

 It helps to ensure that the software meets all the requirements and
specifications that it was designed for, providing increased confidence in the
software to the development team and end-users.
Conclusion

Software testing is essential for ensuring applications meet user expectations and
function correctly. Understanding key principles like detecting defects early and
recognizing the impossibility of exhaustive testing is vital for delivering reliable
software.

Various types of testing, including unit, integration, regression, smoke, and system
testing, offer unique benefits like early bug detection and improved code quality. By
embracing these principles and employing diverse testing methods, developers can
enhance product quality and user satisfaction.
Levels of Software Testing

Software Testing is an activity performed to identify errors so that errors can be

removed to obtain a product with greater quality. To assure and maintain the quality
of software and to represent the ultimate review of specification, design, and coding,
Software testing is required. There are different levels of testing :
1. Unit Testing: In this type of testing, errors are detected individually from
every component or unit by individually testing the components or units of
software to ensure that they are fit for use by the developers. It is the smallest
testable part of the software.
2. Integration Testing: In this testing, two or more modules which are unit
tested are integrated to test i.e., technique interacting components, and are
then verified if these integrated modules work as per the expectation or not,
and interface errors are also detected.
 3. System Testing: In system testing, complete and integrated Softwares are
tested i.e., all the system elements forming the system are tested as a whole
to meet the requirements of the system.
4. Acceptance Testing: This is a kind of testing conducted to ensure that the
requirements of the users are fulfilled before its delivery and that the software
works correctly in the user’s working environment.

These tests can be conducted at various stages of software development.

While performing the software testing, following Testing principles must be applied by
every software engineer:

1. The requirements of customers should be traceable and identified by all

different tests.

2. Planning of tests that how tests will be conducted should be done long before
the beginning of the test.

3. The Pareto principle can be applied to software testing- 80% of all errors
identified during testing will likely be traceable to 20% of all program modules.

4. Testing should begin “in the small” and progress toward testing “in the large”.

5. Exhaustive testing which simply means to test all the possible combinations of
data is not possible.

6. Testing conducted should be most effective and for this purpose, an

independent third party is required.
Functional Testing – Software Testing

Functional Testing is a type of Software Testing in which the system is tested against
the functional requirements and specifications. Functional testing ensures that the
application properly satisfies the requirements or specifications. This type of
testing is particularly concerned with the result of processing. It focuses on the
simulation of actual system usage but does not develop any system structure
assumptions.
What is Functional Testing?

Functional testing is defined as a type of testing that verifies that each function of
the software application works in conformance with the requirement and
specification. This testing is not concerned with the source code of the application.
Each functionality of the software application is tested by providing appropriate test
input, expecting the output, and comparing the actual output with the expected
output. This testing focuses on checking the user
interface, APIs , database , security , client or server application , and functionality of
the Application Under Test. Functional testing can be manual or automated .
Just as functional testing is crucial for ensuring that a software application meets its
specified requirements, having a solid understanding of how to effectively carry out
this type of testing is essential for any software tester. If you’re looking to deepen
your expertise in functional testing and other key areas of software testing, consider
exploring the Complete Guide to Software Testing & Automation by
GeeksforGeeks . This course offers in-depth knowledge on testing methodologies,
including both manual and automated testing, helping you ensure that every function
of your application works flawlessly and meets the needs of your users
Purpose of Functional Testing

Functional testing mainly involves black box testing and can be done manually or
using automation. The purpose of functional testing is to:
 Test each function of the application: Functional testing tests each function
of the application by providing the appropriate input and verifying the output
against the functional requirements of the application.
 Test primary entry function: In functional testing, the tester tests each entry
function of the application to check all the entry and exit points.
 Test flow of the GUI screen: In functional testing, the flow of the GUI screen
is checked so that the user can navigate throughout the application.
What to Test in Functional Testing?

The goal of functional testing is to check the functionalities of the application under
test. It concentrates on:
 Basic Usability: Functional testing involves basic usability testing to check
whether the user can freely navigate through the screens without any
difficulty.
 Mainline functions: This involves testing the main features and functions of
the application.
 Accessibility: This involves testing the accessibility of the system for the
user.
 Error Conditions: Functional testing involves checking whether the
appropriate error messages are being displayed or not in case of error
conditions.
Functional Testing Process

Functional testing involves the following steps:

Step 1. Identify test input: This step involves identifying the functionality that needs
to be tested. This can vary from testing the usability functions, and main functions to
error conditions.
Functional Testing process
Step 2. Compute expected outcomes: Create input data based on the
specifications of the function and determine the output based on these
specifications.
Step 3. Execute test cases: This step involves executing the designed test cases
and recording the output.
Step 4. Compare the actual and expected output: In this step, the actual output
obtained after executing the test cases is compared with the expected output to
determine the amount of deviation in the results. This step reveals if the system is
working as expected or not.
Type of Functional Testing Techniques
There are various types of functional Testing which are as follows:
1. Unit Testing: Unit testing is the type of functional testing technique where the
individual units or modules of the application are tested. It ensures that each
module is working correctly.
2. Integration Testing: In Integration testing , combined individual units are
tested as a group and expose the faults in the interaction between the
integrated units.
3. Smoke Testing: Smoke testing is a type of functional testing technique where
the basic functionality or feature of the application is tested as it ensures that
the most important function works properly.
4. User Acceptance Testing: User acceptance testing is done by the client to
certify that the system meets the requirements and works as intended. It is the
final phase of testing before the product release.
5. Interface Testing: Interface testing is a type of software testing technique
that checks the proper interaction between two different software systems.
6. System Testing: System testing is a type of software testing that is
performed on the complete integrated system to evaluate the compliance of
the system with the corresponding requirements.
7. Regression Testing: Regression testing is done to make sure that the code
changes do not affect the existing functionality and the features of the
application. It concentrates on whether all parts are working or not.
8. Sanity Testing: Sanity testing is a subset of regression testing and is done to
make sure that the code changes introduced are working as expected.
9. White box Testing: White box testing is a type of software testing that allows
the tester to verify the internal workings of the software system. This includes
analyzing the code, infrastructure, and integrations with the external system.
10. Black box Testing: Black box testing is a type of software testing where the
functionality of the software system is tested without looking at the internal
workings or structures of the software system.
11. Database Testing: Database testing is a type of software testing that checks
the schema, tables, etc of the database under test.
12. Adhoc Testing: Adhoc testing also known as monkey testing or random
testing is a type of software testing that does not follow any documentation or
test plan to perform testing.
13. Recovery Testing: Recovery testing is a type of software testing that verifies
the software’s ability to recover from failures like hardware failures, software
failures, crashes, etc.
 14. Static Testing: Static testing is a type of software testing that is performed to
check the defects in software without actually executing the code of the
software application.
15. Grey-box Testing: Grey box testing is a type of software testing that includes
black-box and white-box testing.
16. Component Testing: Component testing also known as program testing or
module testing is a type of software testing that is done after the unit testing.
In this, the test objects can be tested independently as a component without
integrating with other components.
Functional Testing vs Non-Functional Testing

Below are the differences between functional testing and non-functional testing:

Parameters Functional Testing Non-functional Testing

Functional testing verifies Non-functional verifies the

Definition the operations and behavior of an
actions of an application. application.

It is based on the It is based on the

Testing based on requirements of the expectations of the
customer. customer.

The objective is to
The objective is to
Objective performance of the
validate software actions.
software system

Non-functional testing is
Functional testing is
carried out using the
Requirements carried out using the
performance
functional specification.
specifications.

It describes what the It describes how the

Functionality
product does. product works.
Parameters Functional Testing Non-functional Testing

 Unit testing.  Performance

testing.
 Integration testing.
 Load testing.
 Sanity testing
Example
 Stress testing.
 Smoke testing.
 Volume testing.
 Regression
testing.  Usability testing.

Functional Testing Tools

Below are the tools for functional testing:

1. Selenium: Selenium is an open-source umbrella project for a range of tools and
libraries developed with the aim to support browser automation.

 It is used to automate web browsers.

 It provides a single interface that lets the tester write test scripts in languages
like Ruby , Java , NodeJS , etc.

 It provides a playback tool for authoring functional tests across most modern
web browsers.
2. QTP: The QTP tool now can UFT is a tool designed to perform
automated functional testing without the need to monitor the system in intervals.

 It can be used to test web, desktop applications, and client servers.

 It is based on the VB scripting language.

 It is one of the widely used automation tools in the testing industry.

3. JUnit: JUnit is a unit-testing open-source framework for the Java programming
language. It is used by Java developers to write and execute automated test cases.

 It can be used along with the Selenium WebDriver to automate tests for web
applications.

 It provides several annotations to identify test methods.

 It has test runners to run tests.

4. SoapUI: It is one of the leading tools for SOAP and web service testing. It allows
for easy and rapid creation and execution of functional , regression , and load tests .
 It has an easy-to-use graphical interface.
  It provides a code-free test environment where one can create and execute
complex test cases with drag-and-drop options.

 It lets to dynamically analyze how well SOAP and REST service contract is
covered by the functional tests.
5. Cucumber: Cucumber is an open-source testing tool written in Ruby language.

 This tool focuses on end-user experience.

 Quick and easy setup and execution.

 This tool allows for easy reuse of code in tests due to the style of writing the
tests.
Best Practices for Functional Testing

 Automate: Functional tests can be repetitive, time-consuming processes so

the more the tests are automated the faster one can identify and correct
defects, and the more savings can be achieved in time and costs. It may not
be possible to automate all test cases, so automating important test cases
can improve the test ROI.
 Dedicated automation team: Automation requires time, effort, and a special
skill set. It is considered best to allocate automation tasks to those who are
equipped to accomplish them.
 Create test early: It is best to create test cases when the project is in its early
phases as the requirements are fresh and it is always possible to amend test
cases later in the project development cycle.
 Pick the right tests: It is very important to pick the right test cases to
automate. Some tests require setup and configuration during and before
execution, so it’s best not to automate them. Automate tests that need to be
executed repeatedly, tests that are prone to human error.
 Prioritize: Testers have finite time and budget, so it is not possible to test
each and every feature in the application. Consider high-priority functions first
to create test cases.
 Test frequently: Prepare a basic test automation bucket and create a
strategy for frequent execution of this test bucket.
Benefits of Functional Testing

 Bug-free product: Functional testing ensures the delivery of a bug-free and

high-quality product.
 Customer satisfaction: It ensures that all requirements are met and ensures
that the customer is satisfied.
  Testing focused on specifications: Functional testing is focused on
specifications as per customer usage.
 Proper working of application: This ensures that the application works as
expected and ensures proper working of all the functionality of the application.
 Improves quality of the product: Functional testing ensures the security and
safety of the product and improves the quality of the product.
Limitations of Functional Testing

 Missed critical errors: There are chances while executing functional tests
that critical and logical errors are missed.
 Redundant testing: There are high chances of performing redundant testing.

 Incomplete requirements: If the requirement is not complete then

performing this testing becomes difficult.
Conclusion

In conclusion, Functional testing will check that each function of a software

application has been working as expected and focuses on the user interface, APIs ,
and functionality. While it improves product quality and customer satisfaction, it may
miss the major errors and involve repeated testing. overall the important to deliver a
bug-free and high-quality product as output.
Structural Software Testing

Structural testing is a type of software testing that uses the internal design of the
software for testing or in other words the software testing which is performed by the
team which knows the development phase of the software, is known as structural
testing.
Structural testing is related to the internal design and implementation of the software
i.e. it involves the development team members in the testing team. It tests different
aspects of the software according to its types. Structural testing is just the opposite
of behavioral testing.
Types of Structural Testing

There are 4 types of Structural Testing:

Types of Structural Testing

Control Flow Testing:

Control flow testing is a type of structural testing that uses the programs’s control
flow as a model. The entire code, design and structure of the software have to be
known for this type of testing. Often this type of testing is used by the developers to
test their own code and implementation. This method is used to test the logic of the
code so that required result can be obtained.

Data Flow Testing:

It uses the control flow graph to explore the unreasonable things that can happen to
data. The detection of data flow anomalies are based on the associations between
values and variables. Without being initialized usage of variables. Initialized variables
are not used once.
Slice Based Testing:

It was originally proposed by Weiser and Gallagher for the software maintenance. It
is useful for software debugging, software maintenance, program understanding and
quantification of functional cohesion. It divides the program into different slices and
tests that slice which can majorly affect the entire software.

Mutation Testing:

Mutation Testing is a type of Software Testing that is performed to design new

software tests and also evaluate the quality of already existing software tests.
Mutation testing is related to modification a program in small ways. It focuses to help
the tester develop effective tests or locate weaknesses in the test data used for the
program.
Advantages of Structural Testing

 It provides thorough testing of the software.

  It helps in finding out defects at an early stage.

 It helps in elimination of dead code.

 It is not time consuming as it is mostly automated.

Disadvantages of Structural Testing

 It requires knowledge of the code to perform test.

 It requires training in the tool used for testing.

 Sometimes it is expensive.
Structural Testing Tools

 JBehave

 Cucumber

 Junit

 Cfix
Test plan – Software Testing

What is a Test Plan? A test plan is a document that consists of all future testing-
related activities. It is prepared at the project level and in general, it defines work
products to be tested, how they will be tested, and test type distribution among the
testers. Before starting testing there will be a test manager who will be preparing a
test plan. In any company whenever a new project is taken up before the tester is
involved in the testing the test manager of the team would prepare a test Plan.

 The test plan serves as the blueprint that changes according to the
progressions in the project and stays current at all times.

 It serves as a base for conducting testing activities and coordinating activities

among a QA team.

 It is shared with Business Analysts, Project Managers, and anyone associated

with the project.
 Why is Test Plan creation important?

The following are some of the key benefits of making a test plan:
 Defines Objectives: A test plan clearly outlines the testing objectives and the
scope of testing activities, ensuring that all team members understand what
needs to be achieved.
 Structured Approach : It provides a systematic approach to testing, detailing
the steps and processes involved, which helps in organizing the testing effort.
  Avoids Scope Creep : By defining what will and will not be tested, the test
plan helps manage the scope of testing activities, preventing unnecessary
work and focusing on irrelevant areas.
 Resource Allocation : Helps in identifying the necessary resources, including
personnel, tools, and environments, ensuring they are available when
needed.
 Identifies Risks : A test plan identifies potential risks and outlines mitigation
strategies, helping to address issues proactively rather than reactively.
 Contingency Plans : These include contingency plans for dealing with
unexpected events or issues that may arise during testing.
 Stakeholder Alignment : Facilitates communication among stakeholders,
including developers, testers, project managers, and clients, ensuring
everyone is aligned on the testing objectives, approach, and schedule.
 Documentation : Serves as a comprehensive document that can be referred
to by all team members, aiding in knowledge sharing and transparency.
 Resource Optimization : Helps in efficiently utilizing available resources,
including time and personnel, by providing a clear plan of action.
 Focus on Priorities : Ensures that testing efforts are focused on high-priority
areas that are critical to the success of the project.
Objectives of the Test Plan:

1. Overview of testing activities: The test plan provides an overview of the

testing activities and where to start and stop the work.
2. Provides timeline: The test plan helps to create the timeline for the testing
activities based on the number of hours and the workers needed.
3. Helps to estimate resources: The test plan helps to create an estimate of
the number of resources needed to finish the work.
4. Serves as a blueprint: The test plan serves as a blueprint for all the testing
activities, it has every detail from beginning to end.
5. Helps to identify solutions: A test plan helps the team members They
consider the project’s challenges and identify the solutions.
6. Serves as a rulebook: The test plan serves as a rulebook for following rules
when the project is completed phase by phase.
Difference between Test Strategy and Test Plan:
Aspect Test Strategy Test Plan

A detailed document that

A high-level document describes the specific testing
outlining the overall testing activities, resources, schedule,
approach and goals. and scope for a particular
Definition project.

Provides a framework and

Specifies the exact process,
general guidelines for testing
tasks, and timelines for testing
across multiple projects or the
a specific project or release.
Purpose entire organization.

Broad and generic, applicable Narrow and project-specific,

to all projects within the tailored to the needs of a
Scope organization. particular project.

High-level, focusing on overall Detailed, including specific test

methodologies, standards, cases, environments,
Level of Detail and tools to be used. schedules, and resources.

Typically created by senior Typically created by test

management or test managers or test leads for a
Responsibility architects. specific project.

More dynamic, updated

More static and less frequently
regularly to reflect changes in
updated, serving as a long-
project scope, requirements,
term guide.
Components and timelines.

Intended for stakeholders, Intended for the project team,

project managers, and senior including testers, developers,
Audience management. and project managers.

Describes the use of Outlines specific test cases,

Examples
automated testing tools, test environments, and test
Aspect Test Strategy Test Plan

defect tracking processes, and data requirements for a

overall testing standards. particular application.

Emphasizes the “what” and Emphasizes the “how,” “when,”

“why” of testing processes and and “who” of the testing
Focus standards. activities for a specific project.

Short-term, aligned with the

Long-term, spanning multiple
project lifecycle and specific
projects and releases.
Timeframe release schedules.

Less frequent, typically More frequent, updated as the

reviewed annually or semi- project evolves and new
Updates annually. requirements emerge.

Components and Attributes of Test Plan :

There is no hard and fast rule for preparing a test plan but it has some standard 15
attributes that companies follow:

Components and Attributes of Test Plan

1. Objective: It describes the aim of the test plan, whatever the good process and
procedure they are going to follow to give quality software to customers. The overall
objective of the test is to find as many defects as possible and to make software bug-
free. The test objective must be broken into components and sub-components. In
every component following activities should be performed.

 List all the functionality and performance to be tested.

 Make goals and targets based on the application feature.

2. Scope: It consists of information that needs to be tested concerning an
application. The scope can be divided into two parts:
 In-Scope: The modules that are to be tested rigorously.
 Out Scope: The modules that are not to be tested rigorously.

Example: In an application A, B, C, and D features have to be developed, but the B

feature has already been designed by other companies. So the development team
will purchase B from that company and perform only integrated testing with A, B, and
C.
3. Testing Methodology: The methods that are going to be used for testing depend
on application to application. The testing methodology is decided based on the
feature and application requirements. Since the testing terms are not standard, one
should define what kind of testing will be used in the testing methodology. So that
everyone can understand it.
4. Approach: The approach of testing different software is different. It deals with the
flow of applications for future reference. It has two aspects:
 High-Level Scenarios: For testing critical features high-level scenarios are
written. For Example, login to a website, and book from a website.
 The Flow Graph: It is used when one wants to make benefits such as
converging and merging easy.
5. Assumption: In this phase, certain assumptions will be made.

Example:

 The testing team will get proper support from the development team.

 The tester will get proper knowledge transfer from the development team.

 Proper resource allocation will be given by the company to the testing

department.
6. Risk: All the risks that can happen if the assumption is broken. For Example, in
the case of wrong budget estimation, the cost may overrun. Some reason that may
lead to risk is:
 Test Manager has poor management skills.
  Hard to complete the project on time.

 Lack of cooperation.
7. Mitigation Plan: If any risk is involved then the company must have a backup
plan, the purpose is to avoid errors. Some points to resolve/avoid risk:

 Test priority is to be set for each test activity.

 Managers should have leadership skills.

 Training course for the testers.

8. Roles and Responsibilities: All the responsibilities and role of every member of
a particular testing team has to be recorded.
Example:

 Test Manager: Manages the project, takes appropriate resources, and gives
project direction.
 Tester: Identify the testing technique, verify the test approach, and save
project costs.
9. Schedule: Under this, it will record the start and end date of every testing-related
activity. For Example, writing the test case date and ending the test case date.
10. Defect Tracking: It is an important process in software engineering as lots of
issue arises when you develop a critical system for business. If there is any defect
found while testing that defect must be given to the developer team. There are the
following methods for the process of defect tracking:
 Information Capture: In this, we take basic information to begin the process.
 Prioritize: The task is prioritized based on severity and importance.

 Communication: Communication between the identifier of the bug and the

fixer of the bug.
 Environment: Test the application based on hardware and software.

Example: The bug can be identified using bug-tracking tools such as Jira, Mantis,
and Trac.
11. Test Environments: It is the environment that the testing team will use i.e. the
list of hardware and software, while testing the application, the things that are said to
be tested will be written under this section. The installation of software is also
checked under this.
Example:
 Software configuration on different operating systems, such as Windows,
Linux, Mac, etc.
  Hardware Configuration depends on RAM, ROM, etc.
12. Entry and Exit Criteria: The set of conditions that should be met to start any
new type of testing or to end any kind of testing.
 Entry Condition:

o Necessary resources must be ready.

o The application must be prepared.

o Test data should be ready.

 Exit Condition:

o There should not be any major bugs.

o Most test cases should be passed.

o When all test cases are executed.

 Example: If the team member reports that 45% of the test cases failed, then
testing will be suspended until the developer team fixes all defects.

Example of Test Plan

13. Test Automation: It consists of the features that are to be automated and which
features are not to be automated.

 If the feature has lots of bugs then it is categorized as Manual Testing.

 If the feature is frequently tested then it can be automated.
14. Effort Estimation: This involves planning the effort that needs to be applied by
every team member.
15. Test Deliverables: It is the outcome from the testing team that is to be given to
the customers at the end of the project.
 Before the testing phase :

o Test plan document.

o Test case document.

o Test design specification.

 During the testing phase :

o Test scripts.

o Test data.

o Error logs.
 After the testing phase :

o Test Reports.

o Defect Report.

o Installation Report.

It contains a test plan, defect report, automation report, assumption report, tools, and
other components that have been used for developing and maintaining the testing
effort.
16. Template: This is followed by every kind of report that is going to be prepared by
the testing team. All the test engineers will only use these templates in the project to
maintain the consistency of the product.
Types of Test Plans:

The following are the three types of test plans:

 Master Test Plan: In this type of test plan, includes multiple test strategies and
has multiple levels of testing. It goes into great depth on the planning and
management of testing at the various test levels and thus provides a bird’s
eye view of the important decisions made, tactics used, etc. It includes a list of
tests that must be executed, test coverage, the connection between various
test levels, etc.

 Phase Test Plan: In this type of test plan, emphasis is on any one phase of
testing. It includes further information on the levels listed in the master testing
plan. Information like testing schedules, benchmarks, activities, templates,
and other information that is not included in the master test plan is included in
the phase test plan.
  Specific Test Plan: This type of test plan, is designed for specific types of
testing especially non-functional testing for example plans for conducting
performance tests or security tests.
How to create a Test Plan :

Below are the eight steps that can be followed to write a test plan:

Create Test Plan

1. Analyze the product: This phase focuses on analyzing the product, Interviewing
clients, designers, and developers, and performing a product walkthrough. This
stage focuses on answering the following questions:

 What is the primary objective of the product?

 Who will use the product?

 What are the hardware and software specifications of the product?

 How does the product work?
2. Design the test strategy: The test strategy document is prepared by the
manager and details the following information:

 Scope of testing which means the components that will be tested and the
ones that will be skipped.
 Type of testing which means different types of tests that will be used in the
project.

 Risks and issues that will list all the possible risks that may occur during
testing.
  Test logistics mentions the names of the testers and the tests that will be run
by them.
3. Define test objectives: This phase defines the objectives and expected results of
the test execution. Objectives include:

 A list of software features like functionality, GUI, performance standards, etc.

 The ideal expected outcome for every aspect of the software that needs
testing.
4. Define test criteria: Two main testing criteria determine all the activities in the
testing project:
 Suspension criteria: Suspension criteria define the benchmarks for
suspending all the tests.
 Exit criteria: Exit criteria define the benchmarks that signify the successful
completion of the test phase or project. These are expected results and must
match before moving to the next stage of development.
5. Resource planning: This phase aims to create a detailed list of all the resources
required for project completion. For example, human effort, hardware and software
requirements, all infrastructure needed, etc.
6. Plan test environment: This phase is very important as the test environment is
where the QAs run their tests. The test environments must be real devices, installed
with real browsers and operating systems so that testers can monitor software
behavior in real user conditions.
7. Schedule and Estimation: Break down the project into smaller tasks and allocate
time and effort for each task. This helps in efficient time estimation. Create a
schedule to complete these tasks in the designated time with a specific amount of
effort.
8. Determine test deliverables: Test deliverables refer to the list of documents,
tools, and other equipment that must be created, provided, and maintained to
support testing activities in the project.
Best Practices for Creating an effective Test Plan:

Creating an effective test plan is essential for ensuring a comprehensive and

systematic approach to software testing. Here are some best practices to consider
when developing a test plan:
1. Understand the Project Requirements:

 Gather Information: Ensure a thorough understanding of both functional and

non-functional requirements.
  Stakeholder Input: Involve stakeholders to gather expectations and address
specific concerns.
2. Define Clear Objectives and Scope:
 Purpose of Testing : Clearly state the objectives and what you aim to
achieve.
 In-Scope and Out-of-Scope: Define what will be tested and what will not, to
manage expectations and focus resources.
3. Develop a Comprehensive Test Strategy:
 Approach : Outline the types of testing to be performed (e.g., functional,
regression, performance).

 Techniques and Tools: Specify testing techniques (e.g., black-box, white-box)

and tools (e.g., Selenium, JIRA) to be used.
4. Create Detailed Test Cases:
 Test Case Design : Develop detailed test cases covering all scenarios,
including positive, negative, edge, and boundary cases.
 Traceability : Ensure each test case is traceable to specific requirements to
verify comprehensive coverage.
5. Establish a Test Environment:
 Setup Requirements : Define hardware, software, network configurations,
and tools required for testing.
 Environment Management: Ensure the test environment closely mirrors the
production environment to identify environment-specific issues.
6. Plan for Test Data and Reporting Mechanisms:
 Data Requirements : Identify and manage realistic, consistent test data
securely, especially if it includes sensitive information.
 Status Reporting: Establish processes for regular status updates on testing
progress, issues, and results, and use defect tracking systems effectively.
Conclusion:

A test plan is a crucial document in the software testing lifecycle that provides a
structured approach to validating and verifying the quality of a software product. It
outlines the objectives, scope, resources, and methodologies for testing, ensuring
that all aspects of the application are thoroughly assessed. By following best
practices in test plan creation, such as understanding project requirements, defining
clear objectives, and establishing a robust test environment, teams can effectively
manage testing efforts and enhance the overall quality of the software. A well-crafted
test plan not only aligns the team on testing goals but also helps in optimizing
resources, mitigating risks, and ensuring stakeholder satisfaction.

Test Case Specification

In software engineering, quality assurance is one of the most important processes

that a professional can manage. Test case specification comes as one of the
important sub-processes of quality assurance, which is useful when it comes to
ascertaining compliance of software with set requirements and expected
performance. Test case specification is the process of detailing the test cases
needed for testing in addition to the conditions that must be met, input procedures,
and expected results. It must be appended to both manual and automated testing as
it mandates how testing should be done.
What is Test Case Specification?
Test case specification is the documentation detailing how a certain part of the
software is to be tested. It describes the goals and scope of a test case, what is to be
provided as input, the conditions under which the test case is to be conducted, and
the expected results. The specification gives a systematic way of testing since it
outlines what is to be tested, how it is to be done, and what the results should look
like. This helps to ascertain that all the functionalities are well-checked and any flaws
are detected at the early stage of the development.
Why is Test Specification Important?

Test case specifications are important for several reasons:

 Clarity and Consistency: Test case specifications also make it easier for all
the team members to know what has to be tested and how it has to be done
since the framework for testing is clearly laid down. This is useful in ensuring
that the quality of the software being developed is consistent between one
development cycle and the other.
 Traceability: Test case specifications help to connect the requirements and
test cases. This means that every requirement is associated with a test case
and therefore the functionalities are tested and checked.
 Reusability: Test case specifications can be written down and documented
for future use and this can help in cutting down the time and costs of testing.
They can also be used in similar projects to improve efficiency.
 Risk Mitigation: This way, possible risks and defects are detected and
reported from the very beginning of the development process, so that they
cannot cause problems in the production environment.
Identifiers of Test Specifications
Test case specifications also have test case identifiers that differentiate each test
case from the other. These identifiers are very important when it comes to handling
the test cases during the testing phase. Common identifiers include:
 Test Case ID: A name given to each test case usually in the form of a number
or a combination of numbers and alphabets.
 Title: A short phrase that provides information about the goal of the test case.

 Version: Shows the version of the test case especially when the test case is
being developed in cycles or when the test case is being updated.
 Author: The name of the person who has developed the test case
specification.
 Date: The date on which the test case specification was prepared or updated
last.
Components of a Test Specification

A comprehensive test case specification typically includes the following components:

A comprehensive test case specification typically includes the following components:
 Test Case ID: A reference tag for the test case.

 Title: A short name of the test case that briefly describes it.

 Objective: What is being tested and why, the purpose of the test case.
 Prerequisites: Any prerequisite that is needed before running the test case,
including data precondition or environment precondition.
 Test Steps: A description of the actions that are to be performed in order to
execute the test case in a very detailed and in a step by step manner.
 Test Data: The test input data that are necessary for the test, the specific
values and conditions to be used.
 Expected Results: The possible results of the test such as certain outputs or
alterations of the system.
 Actual Results: The results obtained in the course of testing and which are
used to define whether the test case is successful or not.
 Pass/Fail Criteria: The criteria used in the evaluation of the test case in
relation to the comparison of the expected and actual outcomes.
 Comments: Any other comments that can be made about the test case, for
example, problems faced during the test case or recommendations for future
test cases.
Types of Test Case Specifications
Test case specifications can be categorized into different types based on their
purpose and scope:
 Functional Test Cases: Concentrate on the functional testing and make sure
that all the functions of the software are working correctly.
 Non-Functional Test Cases: Tackle the non-technical aspects of the
software like performance, security, usability, and compatibility.
 Regression Test Cases: Designed to ensure that new functions do not
negatively impact the performance of existing functionalities in the software.
 Integration Test Cases: The primary emphasis is placed on checking the
interaction of some of the components or modules of the software.
 User Acceptance Test Cases: Ensure that the software satisfies the end-
users and their expectations towards the software.
Process of Writing Test Specifications

Writing effective test case specifications involves several key steps:

1. Understand Requirements: Ensure you comprehend the software’s
requirements and the goals of the development project. This involves
engaging with the stakeholders, developers and product owners in order to
get all the requirements correct.
2. Define Test Objectives: Define the goal of each test case, that is what
aspect of the software is being tested and with what purpose.
3. Identify Test Conditions: Determine the circumstances under which the
software should be tested, that is, positive conditions and negative conditions.
4. Create Test Data: Identify which input data need to be used to test the
program and which specific values and conditions have to be used.
5. Write Test Steps: Provide clear and unambiguous written procedures for how
the test case is to be performed.
6. Specify Expected Results: Identify the test objectives and their relation to
the expected results in terms of outputs or changes in the system.
7. Review and Refine: Check the test case specification for omissions, errors
and poor presentation. Discuss with the team members to find out if there are
any areas that needs to be filled or improved.
8. Version Control: This means that the specifications of the test cases should
undergo change control so that a record of the changes made can be kept.
Test Case Specification Document Example

Below is an example of a test case specification document:

Field Details

Test Case ID TC002

Title Password Reset Functionality

Verify that users can reset their password using the ‘Forgot
Objective Password’ feature.

User account with a registered email. <br> – Access to the email

Prerequisites account for verification.

1. Navigate to the login page. 2. Click on “Forgot Password” link.

3. Enter the registered email address. 4. Click “Submit.” 5. Check
the email inbox for reset link. 6. Click the link and enter a new
Test Steps password. 7. Confirm the new password and submit.

Email: [email protected] <br> New Password:

Test Data NewPassword123!

The user receives a password reset email, follows the link, enters
Expected a new password, and receives confirmation that the password
Results has been successfully changed.

Actual
[Leave blank for test execution]
Results

The password reset email is received within 5 minutes. – The

Pass/Fail reset link works correctly and leads to the reset page.- The user
Criteria can log in with the new password without any issues.

Ensure that the email template contains the correct information

Comments and branding.

Best Practices for Writing Test Specifications

To ensure the effectiveness of test case specifications, consider the following best
practices:
 Be Clear and Concise: When documenting test cases, it is recommended
that the language used is simple and free from any form of ambiguity so that
other team members can be able to understand the test case specifications.
 Prioritize Test Cases: Organize test cases based on risk, impact and
criticality of the test cases. First of all, prioritization of the most important
features and functionalities that should be tested.
 Use Realistic Data: It is recommended to use real-life data for testing to
make the testing process as close to real life as possible and achieve high
accuracy.
 Include Edge Cases: Focus on the extreme conditions to look for errors and
enhance software quality.
Role of the Document in Test Automation

 Consistency: Test case specifications are important since they make testing
consistent whether it is manual or automated.
 Efficiency: It is easier and faster to create automated test scripts when there
are clear specifications provided hence taking less time to create test scripts.
 Reusability: Test case specifications are useful for future automation where
developers are able to create reusable automated test scripts that can be
used in other projects or in other contexts.
 Traceability: Requirements traceability is made possible by specifications as
it links the automated test scripts to the requirements to confirm that all
functionalities have been tested.
 Maintenance: Automated test scripts can be maintained by using test case
specifications so that the modified test cases can be easily identified.
Conclusion

Test case specification is one of the most important components of software

engineering, as it defines the plan of testing. It is by defining the test cases that
organizations are able to identify if the software meets the set requirements and
performs as required. Test case specifications are used in both manual and
automated testing and are an important tool for increasing the quality, efficiency and
traceability of testing.
Reliability Testing – Software Testing
Reliability Testing is a testing technique that relates to testing the ability of software
to function and given environmental conditions that help in uncovering issues in the
software design and functionality.
What is Reliability Testing?

Reliability testing is a Type of software testing that evaluates the ability of a system
to perform its intended function consistently and without failure over an extended
period.

1. Reliability testing aims to identify and address issues that can cause the
system to fail or become unavailable.

2. It is defined as a type of software testing that determines whether the software

can perform a failure-free operation for a specific period in a specific
environment.

3. It ensures that the product is fault-free and is reliable for its intended purpose.

4. It is an important aspect of software testing as it helps to ensure that the

system will be able to meet the needs of its users over the long term.

5. It can also help to identify issues that may not be immediately apparent during
functional testing, such as memory leaks or other performance issues.

For those looking to gain a comprehensive understanding of reliability testing and

other key testing methodologies, consider enrolling in this in-depth software testing
course. It provides the knowledge and hands-on experience necessary to master the
various aspects of software testing and ensure the quality of your software projects.
Reliability testing Categories

The study of reliability testing can be divided into three categories:-

1. Modelling

Modelling in reliability testing involves creating mathematical or statistical

representations of how a product or system might fail over time. It’s like making an
educated guess about the product’s lifespan based on its design and components.
This helps predict when and how failures might occur without actually waiting for the
product to fail in real life.
Example: Engineers might create a model to estimate how long a new smartphone
battery will last before it degrades significantly.
2. Measurement

Measurement focuses on collecting real-world data about a product’s performance

and failures. This involves testing products under various conditions and recording
when and how they fail. It’s about gathering concrete evidence of reliability rather
than just predictions.
Example: A car manufacturer might test drive hundreds of cars for thousands of
miles, recording any issues that arise during these tests.
3. Improvement

Improvement uses the insights gained from modelling and measurement to enhance
the reliability of a product or system. This involves identifying weak points,
redesigning components, or changing manufacturing processes to make the product
more reliable.
Example: After finding that a particular part in a washing machine fails frequently,
engineers might redesign that part or choose a more durable material to improve its
lifespan.
Different Ways to Perform Reliability Testing

Here are the Different Ways to Perform Reliability Testing are follows:
1. Stress testing: Stress testing involves subjecting the system to high levels of
load or usage to identify performance bottlenecks or issues that can cause the
system to fail
2. Endurance testing: Endurance testing involves running the system
continuously for an extended period to identify issues that may occur over
time
3. Recovery testing: Recovery testing is testing the system’s ability to recover
from failures or crashes.
4. Environmental Testing: Conducting tests on the product or system in various
environmental settings, such as temperature shifts, humidity levels, vibration
exposure or shock exposure, helps in evaluating its dependability in real-world
circumstances.
5. Performance Testing: In Performance Testing It is possible to make sure that
the system continuously satisfies the necessary specifications and
performance criteria by assessing its performance at both peak and normal
load levels.
6. Regression Testing: In Regression Testing After every update or
modification, the system should be tested again using the same set of test
cases to help find any potential problems caused by code changes.
7. Fault Tree Analysis: Understanding the elements that lead to system failures
can be achieved by identifying probable failure modes and examining the
connections between them.

It is important to note that reliability testing may require specialized tools and test
environments, and that it’s often a costly and time-consuming process.
Objective of Reliability Testing

1. To find the perpetual structure of repeating failures.

2. To find the number of failures occurring is the specific period of time.

3. To discover the main cause of failure.

4. To conduct performance testing of various modules of software product after

fixing defects.

5. It builds confidence in the market, stakeholders and users by providing a

dependable product that meets quality criteria and operates as expected.

6. Understanding the dependability characteristics and potential mechanisms of

failure of the system helps companies plan and schedule maintenance actions
more efficiently.

7. It evaluates whether a system or product can be used continuously without

experiencing a major loss in dependability, performance or safety.
8. It confirms that in the absence of unexpected shutdown or degradation, the
system or product maintains constant performance levels under typical
operating settings.
Types of Reliability Testing

Here are the Types of Reliability Testing are follows:

1. Feature Testing

Following three steps are involved in this testing:

 Each function in the software should be executed at least once.

 Interaction between two or more functions should be reduced.

 Each function should be properly executed.

2. Regression Testing

Regression testing is basically performed whenever any new functionality is added,

old functionalities are removed or the bugs are fixed in an application to make sure
with introduction of new functionality or with the fixing of previous bugs, no new bugs
are introduced in the application.
3. Load Testing

Load testing is carried out to determine whether the application is supporting the
required load without getting breakdown. It is performed to check the performance of
the software under maximum work load.
4. Stress Testing
This type of testing involves subjecting the system to high levels of usage or load in
order to identify performance bottlenecks or issues that can cause the system to fail.
5. Endurance Testing

This type of testing involves running the system continuously for an extended period
of time in order to identify issues that may occur over time, such as memory leaks or
other performance issues.
Recovery testing: This type of testing involves testing the system’s ability to recover
from failures or crashes, and to return to normal operation.
6. Volume Testing

Volume Testing is a type of testing involves testing the system’s ability to handle
large amounts of data. This type of testing is similar to endurance testing, but it
focuses on the stability of the system under a normal, expected load over a long
period of time.
7. Spike Testing

This type of testing involves subjecting the system to sudden, unexpected increases
in load or usage in order to identify performance bottlenecks or issues that can
cause the system to fail.
Measurement of Reliability Testing
Mean Time Between Failures (MTBF): Measurement of reliability testing is done in
terms of mean time between failures (MTBF).
Mean Time To Failure (MTTF): The time between two consecutive failures is called
as mean time to failure (MTTF).
Mean Time To Repair (MTTR): The time taken to fix the failures is known as mean
time to repair (MTTR).

MTBF = MTTF + MTTR

Conclusion

Reliability testing is crucial for ensuring software quality and user satisfaction. It
encompasses various techniques including stress testing, endurance testing,
and performance testing to evaluate a system’s ability to function consistently over
time. The key objectives are to identify failure patterns, assess system stability,
and improve overall product dependability.

Measuring reliability through metrics like MTBF (Mean Time Between

Failures), MTTF (Mean Time To Failure), and MTTR (Mean Time To Repair) provides
valuable insights for continuous improvement. Ultimately, reliability testing is an
essential practice in software development that ensures products can with stand
real-world conditions and meet user expectations.
Software Testing Strategies

Software testing is the process of evaluating a software application to identify if it

meets specified requirements and to identify any defects. The following are common
testing strategies:
1. Black box testing – Tests the functionality of the software without looking at
the internal code structure.
2. White box testing – Tests the internal code structure and logic of the
software.
3. Unit testing – Tests individual units or components of the software to ensure
they are functioning as intended.
4. Integration testing – Tests the integration of different components of the
software to ensure they work together as a system.
5. Functional testing – Tests the functional requirements of the software to
ensure they are met.
6. System testing – Tests the complete software system to ensure it meets the
specified requirements.
7. Acceptance testing – Tests the software to ensure it meets the customer’s or
end-user’s expectations.
8. Regression testing – Tests the software after changes or modifications have
been made to ensure the changes have not introduced new defects.
9. Performance testing – Tests the software to determine its performance
characteristics such as speed, scalability, and stability.
10. Security testing – Tests the software to identify vulnerabilities and ensure it
meets security requirements.

Software Testing is a type of investigation to find out if there are any defects or errors
present in the software, so that the errors can be reduced or removed to increase the
quality of the software and to check whether it fulfills the specified requirements or
not.
According to Glen Myers, software testing has the following objectives:

 The process of investigating and checking a program to find whether there is

an error or not and does it fulfill the requirements or not is called testing.

 When the number of errors found during the testing is high, it indicates that
the testing was good and is a sign of good test case.

 Finding an unknown error that wasn’t discovered yet is a sign of a successful

and a good test case.
The main objective of software testing is to design the tests in such a way that it
systematically finds different types of errors without taking much time and effort so
that less time is required for the development of the software. The overall strategy for
testing software includes:

1. Before testing starts, it’s necessary to identify and specify the

requirements of the product in a quantifiable manner. Different
characteristics quality of the software is there such as maintainability that
means the ability to update and modify, the probability that means to find and
estimate any risk, and usability that means how it can easily be used by the
customers or end-users. All these characteristic qualities should be specified
in a particular order to obtain clear test results without any error.
2. Specifying the objectives of testing in a clear and detailed
manner. Several objectives of testing are there such as effectiveness that
 means how effectively the software can achieve the target, any failure that
means inability to fulfill the requirements and perform functions, and the cost
of defects or errors that mean the cost required to fix the error. All these
objectives should be clearly mentioned in the test plan.
3. For the software, identifying the user’s category and developing a
profile for each user. Use cases describe the interactions and
communication among different classes of users and the system to achieve
the target. So as to identify the actual requirement of the users and then
testing the actual use of the product.
4. Developing a test plan to give value and focus on rapid-cycle
testing. Rapid Cycle Testing is a type of test that improves quality by
identifying and measuring the any changes that need to be required for
improving the process of software. Therefore, a test plan is an important and
effective document that helps the tester to perform rapid cycle testing.
5. Robust software is developed that is designed to test itself. The software
should be capable of detecting or identifying different classes of errors.
Moreover, software design should allow automated and regression testing
which tests the software to find out if there is any adverse or side effect on the
features of software due to any change in code or program.
6. Before testing, using effective formal reviews as a filter. Formal technical
reviews is technique to identify the errors that are not discovered yet. The
effective technical reviews conducted before testing reduces a significant
amount of testing efforts and time duration required for testing software so
that the overall development time of software is reduced.
7. Conduct formal technical reviews to evaluate the nature, quality or
ability of the test strategy and test cases. The formal technical review
helps in detecting any unfilled gap in the testing approach. Hence, it is
necessary to evaluate the ability and quality of the test strategy and test cases
by technical reviewers to improve the quality of software.
8. For the testing process, developing a approach for the continuous
development. As a part of a statistical process control approach, a test
strategy that is already measured should be used for software testing to
measure and control the quality during the development of software.
Advantages or Disadvantages:

Advantages of software testing:

1. Improves software quality and reliability – Testing helps to identify and fix
defects early in the development process, reducing the risk of failure or
unexpected behavior in the final product.
 2. Enhances user experience – Testing helps to identify usability issues and
improve the overall user experience.

3. Increases confidence – By testing the software, developers and stakeholders

can have confidence that the software meets the requirements and works as
intended.

4. Facilitates maintenance – By identifying and fixing defects early, testing

makes it easier to maintain and update the software.

5. Reduces costs – Finding and fixing defects early in the development process
is less expensive than fixing them later in the life cycle.
Disadvantages of software testing:

1. Time-consuming – Testing can take a significant amount of time, particularly if

thorough testing is performed.

2. Resource-intensive – Testing requires specialized skills and resources, which

can be expensive.

3. Limited coverage – Testing can only reveal defects that are present in the test
cases, and it is possible for defects to be missed.

4. Unpredictable results – The outcome of testing is not always predictable, and

defects can be hard to replicate and fix.

5. Delays in delivery – Testing can delay the delivery of the software if testing
takes longer than expected or if significant defects are identified.
 Unit – V Software Project Management

The Management Spectrum | 4 P’s in Software Project Planning

For properly building a product, there’s a very important concept that we all should
know in software project planning while developing a product. There are 4 critical
components in software project planning which are known as the 4P’s namely:

 Product

 Process

 People

 Project

These components play a very important role in your project that can help your team
meet its goals and objective. Now, Let’s dive into each of them a little in detail to get
a better understanding:
  People
The most important component of a product and its successful
implementation is human resources. In building a proper product, a well-
managed team with clear-cut roles defined for each person/team will lead to
the success of the product. We need to have a good team in order to save our
time, cost, and effort. Some assigned roles in software project planning
are project manager, team leaders, stakeholders, analysts, and other IT
professionals. Managing people successfully is a tricky process which a
good project manager can do.

 Product
As the name inferred, this is the deliverable or the result of the project. The
project manager should clearly define the product scope to ensure a
successful result, control the team members, as well technical hurdles that he
or she may encounter during the building of a product. The product can
consist of both tangible or intangible such as shifting the company to a new
place or getting a new software in a company.
 Process
In every planning, a clearly defined process is the key to the success of any
product. It regulates how the team will go about its development in the
respective time period. The Process has several steps involved like,
documentation phase, implementation phase, deployment phase, and
interaction phase.
 Project
The last and final P in software project planning is Project. It can also be
considered as a blueprint of process. In this phase, the project manager plays
a critical role. They are responsible to guide the team members to achieve the
project’s target and objectives, helping & assisting them with issues, checking
on cost and budget, and making sure that the project stays on track with the
given deadlines.
Cost Estimation Models in Software Engineering

Cost estimation simply means a technique that is used to find out the cost
estimates. The cost estimate is the financial spend that is done on the efforts to
develop and test software in Software Engineering. Cost estimation models are
some mathematical algorithms or parametric equations that are used to estimate the
cost of a product or a project. Various techniques or models are available for cost
estimation, also known as Cost Estimation Models.
Cost Estimation Models as shown below :
 Cost
Estimation Models
1. Empirical Estimation Technique – Empirical estimation is a technique or
model in which empirically derived formulas are used for predicting the data
that are a required and essential part of the software project planning step.
These techniques are usually based on the data that is collected previously
from a project and also based on some guesses, prior experience with the
development of similar types of projects, and assumptions. It uses the size of
the software to estimate the effort. In this technique, an educated guess of
project parameters is made. Hence, these models are based on common
sense. However, as there are many activities involved in empirical estimation
techniques, this technique is formalized. For example Delphi technique and
Expert Judgement technique.
2. Heuristic Technique – Heuristic word is derived from a Greek word that
means “to discover”. The heuristic technique is a technique or model that is
used for solving problems, learning, or discovery in the practical methods
which are used for achieving immediate goals. These techniques are flexible
and simple for taking quick decisions through shortcuts and good enough
calculations, most probably when working with complex data. But the
decisions that are made using this technique are necessary to be optimal. In
this technique, the relationship among different project parameters is
expressed using mathematical equations. The popular heuristic technique is
given by Constructive Cost Model (COCOMO). This technique is also used to
increase or speed up the analysis and investment decisions.
3. Analytical Estimation Technique – Analytical estimation is a type of
technique that is used to measure work. In this technique, firstly the task is
divided or broken down into its basic component operations or elements for
analyzing. Second, if the standard time is available from some other source,
then these sources are applied to each element or component of work. Third,
if there is no such time available, then the work is estimated based on the
experience of the work. In this technique, results are derived by making
certain basic assumptions about the project. Hence, the analytical estimation
 technique has some scientific basis. Halstead’s software science is based on
an analytical estimation model.
Short note on Project Scheduling

A schedule in your project’s time table actually consists of sequenced activities and
milestones that are needed to be delivered under a given period of time.
Project schedule simply means a mechanism that is used to communicate and
know about that tasks are needed and has to be done or performed and which
organizational resources will be given or allocated to these tasks and in what time
duration or time frame work is needed to be performed. Effective project scheduling
leads to success of project, reduced cost, and increased customer satisfaction.
Scheduling in project management means to list out activities, deliverables, and
milestones within a project that are delivered. It contains more notes than your
average weekly planner notes. The most common and important form of project
schedule is Gantt chart.

Process :
The manager needs to estimate time and resources of project while scheduling
project. All activities in project must be arranged in a coherent sequence that means
activities should be arranged in a logical and well-organized manner for easy to
understand. Initial estimates of project can be made optimistically which means
estimates can be made when all favorable things will happen and no threats or
problems take place.

The total work is separated or divided into various small activities or tasks during
project schedule. Then, Project manager will decide time required for each activity or
task to get completed. Even some activities are conducted and performed in parallel
for efficient performance. The project manager should be aware of fact that each
stage of project is not problem-free.
Problems arise during Project Development Stage :

 People may leave or remain absent during particular stage of development.

 Hardware may get failed while performing.

 Software resource that is required may not be available at present, etc.
The project schedule is represented as set of chart in which work-breakdown
structure and dependencies within various activities are represented. To accomplish
and complete project within a given schedule, required resources must be available
when they are needed. Therefore, resource estimation should be done before
starting development.
Resources required for Development of Project :

 Human effort

 Sufficient disk space on server

 Specialized hardware

 Software technology

 Travel allowance required by project staff, etc.

Advantages of Project Scheduling :
There are several advantages provided by project schedule in our project
management:

 It simply ensures that everyone remains on same page as far as tasks get
completed, dependencies, and deadlines.

 It helps in identifying issues early and concerns such as lack or unavailability

of resources.

 It also helps to identify relationships and to monitor process.

 It provides effective budget management and risk mitigation.

Staffing Process

The process of staffing consists of several interrelated activities, such as planning for
human resources requirements, recruitment, selection, training development,
remuneration, and so on. These activities together make the staffing process.
Therefore, these are called elements or steps of the staffing process.
1. Manpower Planning

Human resource management is a process of determining the number and type of

personnel required for filling the vacant job in an organization. Manpower
requirements involve two kinds of analysis, i.e., workload analysis and workforce
analysis. Workload analysis involves determining the number and type of employees
required to perform various jobs and achieve organizational objectives. Workforce
analysis shows the number and type of human resources available with an
organization.
The difference between workload and workforce is calculated to determine shortage
and surplus of manpower. Excess workload indicates understaffing, i.e., the need of
appointing more people and excess workforce indicates overstaffing, i.e., need to
remove or transfer some employees to other places.
2. Recruitment

After estimating manpower requirements, the second step in the process of staffing
is recruitment. Recruitment refers to a process of searching for prospective
employees and encouraging them to apply for jobs in the organization. It involves
identifying various resources of human force and attracting them to apply for the job.
The main purpose of a requirement is to create a pool of applicants by a large
number of qualified candidates. Recruitment can be done by both internal and
external sources of recruitment. Internal sources may be used to a limited extent,
and to get fresh talent and a wider choice, external sources can be used.
3. Selection

Selection is the process of choosing and appointing the right candidates for various
job positions in the organization. It is treated as a negative process because it
involves the rejection of some candidates. There are many steps involved in the
process of employee selection. These steps include preliminary screening, filling-in
application, written test, interviews, medical examination, checking references, and
issuing a letter of appointment to the candidates. The most suitable candidates who
meet the requirement of the vacant job are selected. The process of selection serves
two important purposes, firstly, it ensures that the organization gets the best among
the available candidates, and secondly, it boosts ups the self-esteem and prestige of
the candidates.
4. Placement and Orientation

After selection, an appropriate job is assigned to each selected person. Placement is

the process of matching the candidates with the jobs in the organization. Under this
process, every selected candidate is assigned a job most suitable for him. The
purpose of placement is to fit the right person to the right job so that the efficiency of
work is high and the employees get personal satisfaction. Correct placement helps to
reduce labour turnover and absenteeism. Here, orientation means introducing new
employees to the organization. It is the process of introducing and familiarizing newly
appointed candidates with their job, work groups and the organization so that they
may feel at home in the new environment.
5. Training and Development

People are in search of careers and not jobs. Every individual must be given a
chance to rise to the top. The most favourable way for this to happen is to promote
employee learning. For this, organizations either provide training themselves within
the organization or through external institutions. This is beneficial for the organization
as well. If the employees are motivated enough, it will increase their competence and
will be able to perform even better for the organization with greater efficiency and
productivity. By providing such opportunities to its employees for career
advancement, the organization captivates the interest and holds on of its talented
employees. The majority of the organization has a distinct department for this
purpose, that is, the Human Resource Department. Though in small organizations,
the line manager has to do all the managerial functions viz, planning, organizing,
staffing, controlling, and directing. The process of staffing further involves three more
stages.
6. Performance appraisal

After training the employees and having them on the job for some time, there should
be an evaluation done on their performance. Every organization has its means of
appraisal whether formal or informal. Appraisal refers to the evaluation of the
employees of the organization based on their past or present performance by some
pre-decided standards. The employee should be well aware of his standards and his
superior is responsible for proving feedback on his performance. The process of
performance appraisal, thus includes specifying the job, performing appraisal
performance, and providing feedback.
7. Promotion and Career planning

It has now become important for all organizations to deal with career-related issues
and promotional routes for employees. The managers should take care of the
activities that serve the long-term interests of the employees. They should be
encouraged from time to time, which will help the employees to grow and find their
true potential. Promotions are an essential part of any employee’s career. Promotion
refers to the transferring of employees from their current positions to a higher level
increasing their responsibilities, authority and pay.
8. Compensation

Every organization needs to set up plans for the salary and wages of the employees.
There are several ways to develop payment plans for the employees depending
upon the significance of the job. The worth of the job needs to be decided. Therefore,
all kinds of payments or rewards provided to the employees is referred to as
compensation. The compensation may be in the form of direct financial payments,
such as salary, wages, bonuses, etc., or indirect payments like insurance or
vacations provided to the employee.
Direct financial payments are of two kinds, that is, performance-based and time-
based. In a time-based payment plan, the salary or wages are paid daily, weekly,
monthly, or annually, whereas, the performance-based payment plan is the payment
of salary or wages according to the set task. There are many ways in which the
compensation of the employee based on their performance can be calculated. There
are also plans, which are a combination of both time-based and performance-based.
There are a few factors that affect the payment plan, such as legal, company policy,
union, and equity. Thus, staffing is the process that includes possession, retention,
promotion, and compensation of the human capital, that is, the most important
resource of the organization. There are several factors such as the supply and
demand of specific skills in the labour market, legal and political considerations, the
company’s image, policy, unemployment rate, human resource planning cost, labour
market conditions, technological developments, general economic environment, etc.,
that may affect the execution of recruitment, selection, and training.
Aspects or Components of Staffing

There are three aspects or components of staffing, namely, recruitment, selection,

and training. They are defined below:
 Recruitment: It is the process of finding potential candidates for a particular
job in an organization. The process of recruitment involves persuading people
to apply for the available positions in the organization.
 Selection: It is the process of recognizing potential and hiring the best people
out of several possible candidates. This is done by shortlisting and choosing
the deserving and eliminating those who are not suitable for the job.
 Training: It is the process that involves providing the employees with an idea
of the type of work they are supposed to do and how it is to be done. It is a
way of keeping the employees updated on the way of work in an organization
and the new and advanced technologies.
System configuration management – Software Engineering

Whenever software is built, there is always scope for improvement and those
improvements bring picture changes. Changes may be required to modify or update
any existing solution or to create a new solution for a problem. Requirements keep
on changing daily so we need to keep on upgrading our systems based on the
current requirements and needs to meet desired outputs. Changes should be
analyzed before they are made to the existing system, recorded before they are
implemented, reported to have details of before and after, and controlled in a manner
that will improve quality and reduce error. This is where the need for System
Configuration Management comes. System Configuration Management (SCM) is
an arrangement of exercises that controls change by recognizing the items for
change, setting up connections between those things, making/characterizing
instruments for overseeing diverse variants, controlling the changes being executed
in the current framework, inspecting and revealing/reporting on the changes made. It
is essential to control the changes because if the changes are not checked
legitimately then they may wind up undermining a well-run programming. In this way,
SCM is a fundamental piece of all project management activities.
Processes involved in SCM – Configuration management provides a disciplined
environment for smooth control of work products. It involves the following activities:
1. Identification and Establishment – Identifying the configuration items from
products that compose baselines at given points in time (a baseline is a set of
mutually consistent Configuration Items, which has been formally reviewed
and agreed upon, and serves as the basis of further development).
Establishing relationships among items, creating a mechanism to manage
multiple levels of control and procedure for the change management system.
2. Version control – Creating versions/specifications of the existing product to
build new products with the help of the SCM system. A description of the
version is given below:

Suppose after some changes, the version of the configuration object changes
from 1.0 to 1.1. Minor corrections and changes result in versions 1.1.1 and
1.1.2, which is followed by a major update that is object 1.2. The development
of object 1.0 continues through 1.3 and 1.4, but finally, a noteworthy change
to the object results in a new evolutionary path, version 2.0. Both versions are
currently supported.
3. Change control – Controlling changes to Configuration items (CI). The
change control process is explained in Figure below:
 A change request (CR) is submitted and evaluated to assess technical merit,
potential side effects, the overall impact on other configuration objects and
system functions, and the projected cost of the change. The results of the
evaluation are presented as a change report, which is used by a change
control board (CCB) —a person or group who makes a final decision on the
status and priority of the change. An engineering change Request (ECR) is
generated for each approved change. Also, CCB notifies the developer in
case the change is rejected with proper reason. The ECR describes the
change to be made, the constraints that must be respected, and the criteria
for review and audit. The object to be changed is “checked out” of the project
database, the change is made, and then the object is tested again. The object
is then “checked in” to the database and appropriate version control
mechanisms are used to create the next version of the software.
4. Configuration auditing – A software configuration audit complements the
formal technical review of the process and product. It focuses on the technical
correctness of the configuration object that has been modified. The audit
confirms the completeness, correctness, and consistency of items in the SCM
system and tracks action items from the audit to closure.
5. Reporting – Providing accurate status and current configuration data to
developers, testers, end users, customers, and stakeholders through admin
guides, user guides, FAQs, Release notes, Memos, Installation Guide,
Configuration guides, etc.
System Configuration Management (SCM) is a software engineering practice that
focuses on managing the configuration of software systems and ensuring that
software components are properly controlled, tracked, and stored. It is a critical
aspect of software development, as it helps to ensure that changes made to a
software system are properly coordinated and that the system is always in a known
and stable state.

SCM involves a set of processes and tools that help to manage the different
components of a software system, including source code, documentation, and other
assets. It enables teams to track changes made to the software system, identify
when and why changes were made, and manage the integration of these changes
into the final product.
Importance of Software Configuration Management

1. Effective Bug Tracking: Linking code modifications to issues that have been
reported, makes bug tracking more effective.

2. Continuous Deployment and Integration: SCM combines with continuous

processes to automate deployment and testing, resulting in more dependable
and timely software delivery.

3. Risk management: SCM lowers the chance of introducing critical flaws by

assisting in the early detection and correction of problems.

4. Support for Big Projects: Source Code Control (SCM) offers an orderly
method to handle code modifications for big projects, fostering a well-
organized development process.

5. Reproducibility: By recording precise versions of code, libraries, and

dependencies, source code versioning (SCM) makes builds repeatable.

6. Parallel Development: SCM facilitates parallel development by enabling

several developers to collaborate on various branches at once.
Why need for System configuration management?

1. Replicability: Software version control (SCM) makes ensures that a software

system can be replicated at any stage of its development. This is necessary
for testing, debugging, and upholding consistent environments in production,
testing, and development.

2. Identification of Configuration: Source code, documentation, and executable

files are examples of configuration elements that SCM helps in locating and
labeling. The management of a system’s constituent parts and their
interactions depend on this identification.

3. Effective Process of Development: By automating monotonous processes like

managing dependencies, merging changes, and resolving disputes, SCM
 simplifies the development process. Error risk is decreased and efficiency is
increased because of this automation.
Key objectives of SCM
1. Control the evolution of software systems: SCM helps to ensure that
changes to a software system are properly planned, tested, and integrated
into the final product.
2. Enable collaboration and coordination: SCM helps teams to collaborate
and coordinate their work, ensuring that changes are properly integrated and
that everyone is working from the same version of the software system.
3. Provide version control: SCM provides version control for software systems,
enabling teams to manage and track different versions of the system and to
revert to earlier versions if necessary.
4. Facilitate replication and distribution: SCM helps to ensure that software
systems can be easily replicated and distributed to other environments, such
as test, production, and customer sites.

5. SCM is a critical component of software development, and effective SCM

practices can help to improve the quality and reliability of software systems,
as well as increase efficiency and reduce the risk of errors.
The main advantages of SCM

1. Improved productivity and efficiency by reducing the time and effort required
to manage software changes.

2. Reduced risk of errors and defects by ensuring that all changes were properly
tested and validated.

3. Increased collaboration and communication among team members by

providing a central repository for software artifacts.

4. Improved quality and stability of software systems by ensuring that all

changes are properly controlled and managed.
The main disadvantages of SCM

1. Increased complexity and overhead, particularly in large software systems.

2. Difficulty in managing dependencies and ensuring that all changes are

properly integrated.

3. Potential for conflicts and delays, particularly in large development teams with
multiple contributors.

Software Maintenance – Software Engineering

Software Maintenance refers to the process of modifying and updating a software
system after it has been delivered to the customer. This involves fixing bugs, adding
new features, and adapting to new hardware or software environments. Effective
maintenance is crucial for extending the software’s lifespan and aligning it with
evolving user needs. It is an essential part of the software development life cycle
(SDLC), involving planned and unplanned activities to keep the system reliable and
up-to-date.
What is Software Maintenance?

Software maintenance is a continuous process that occurs throughout the entire life
cycle of the software system.

 The goal of software maintenance is to keep the software system working

correctly, efficiently, and securely, and to ensure that it continues to meet the
needs of the users.

 This can include fixing bugs, adding new features, improving performance, or
updating the software to work with new hardware or software systems.

 It is also important to consider the cost and effort required for software
maintenance when planning and developing a software system.

 It is important to have a well-defined maintenance process in place, which

includes testing and validation, version control, and communication with
stakeholders.

 It’s important to note that software maintenance can be costly and complex,
especially for large and complex systems. Therefore, the cost and effort of
maintenance should be taken into account during the planning and
development phases of a software project.

 It’s also important to have a clear and well-defined maintenance plan that
includes regular maintenance activities, such as testing, backup, and bug
fixing.
Several Key Aspects of Software Maintenance

1. Bug Fixing: The process of finding and fixing errors and problems in the
software.
2. Enhancements: The process of adding new features or improving existing
features to meet the evolving needs of the users.
3. Performance Optimization: The process of improving the speed, efficiency,
and reliability of the software.
4. Porting and Migration: The process of adapting the software to run on new
hardware or software platforms.
 5. Re-Engineering: The process of improving the design and architecture of the
software to make it more maintainable and scalable.
6. Documentation: The process of creating, updating, and maintaining the
documentation for the software, including user manuals, technical
specifications, and design documents.
Several Types of Software Maintenance

1. Corrective Maintenance: This involves fixing errors and bugs in the software
system.
2. Patching: It is an emergency fix implemented mainly due to pressure from
management. Patching is done for corrective maintenance but it gives rise to
unforeseen future errors due to lack of proper impact analysis.
3. Adaptive Maintenance: This involves modifying the software system to adapt
it to changes in the environment, such as changes in hardware or software,
government policies, and business rules.
4. Perfective Maintenance: This involves improving functionality, performance,
and reliability, and restructuring the software system to improve changeability.
5. Preventive Maintenance: This involves taking measures to prevent future
problems, such as optimization, updating documentation, reviewing and
testing the system, and implementing preventive measures such as backups.

Maintenance can be categorized into proactive and reactive types. Proactive

maintenance involves taking preventive measures to avoid problems from occurring,
while reactive maintenance involves addressing problems that have already
occurred.
Maintenance can be performed by different stakeholders, including the original
development team, an in-house maintenance team, or a third-party maintenance
provider. Maintenance activities can be planned or unplanned. Planned activities
include regular maintenance tasks that are scheduled in advance, such as updates
and backups. Unplanned activities are reactive and are triggered by unexpected
events, such as system crashes or security breaches. Software maintenance can
involve modifying the software code, as well as its documentation, user manuals,
and training materials. This ensures that the software is up-to-date and continues to
meet the needs of its users.
Software maintenance can also involve upgrading the software to a new version or
platform. This can be necessary to keep up with changes in technology and to
ensure that the software remains compatible with other systems. The success of
software maintenance depends on effective communication with stakeholders,
including users, developers, and management. Regular updates and reports can
help to keep stakeholders informed and involved in the maintenance process.
Software maintenance is also an important part of the Software Development Life
Cycle (SDLC). To update the software application and do all modifications in
software application so as to improve performance is the main focus of software
maintenance. Software is a model that runs on the basis of the real world. so,
whenever any change requires in the software that means the need for real-world
changes wherever possible.
Need for Maintenance

Software Maintenance must be performed in order to:

 Correct faults.

 Improve the design.

 Implement enhancements.

 Interface with other systems.

 Accommodate programs so that different hardware, software, system

features, and telecommunications facilities can be used.

 Migrate legacy software.

 Retire software.

 Requirement of user changes.

 Run the code fast

Challenges in Software Maintenance

The various challenges in software maintenance are given below:

 The popular age of any software program is taken into consideration up to ten
to fifteen years. As software program renovation is open-ended and might
maintain for decades making it very expensive.

 Older software programs, which had been intended to paint on sluggish

machines with much less reminiscence and garage ability can not maintain
themselves tough in opposition to newly coming more advantageous software
programs on contemporary-day hardware.
 Changes are frequently left undocumented which can also additionally reason
greater conflicts in the future.

 As the era advances, it turns into high prices to preserve vintage software
programs.

 Often adjustments made can without problems harm the authentic shape of
the software program, making it difficult for any next adjustments.
 There is a lack of Code Comments.
  Lack of documentation: Poorly documented systems can make it difficult to
understand how the system works, making it difficult to identify and fix
problems.
 Legacy code: Maintaining older systems with outdated technologies can be
difficult, as it may require specialized knowledge and skills.
 Complexity: Large and complex systems can be difficult to understand and
modify, making it difficult to identify and fix problems.
 Changing requirements: As user requirements change over time, the
software system may need to be modified to meet these new requirements,
which can be difficult and time-consuming.
 Interoperability issues: Systems that need to work with other systems or
software can be difficult to maintain, as changes to one system can affect the
other systems.
 Lack of test coverage: Systems that have not been thoroughly tested can be
difficult to maintain as it can be hard to identify and fix problems without
knowing how the system behaves in different scenarios.
 Lack of personnel: A lack of personnel with the necessary skills and
knowledge to maintain the system can make it difficult to keep the system up-
to-date and running smoothly.
 High-Cost: The cost of maintenance can be high, especially for large and
complex systems, which can be difficult to budget for and manage.

To overcome these challenges, it is important to have a well-defined maintenance

process in place, which includes testing and validation, version control, and
communication with stakeholders. It is also important to have a clear and well-
defined maintenance plan that includes regular maintenance activities, such as
testing, backup, and bug fixing. Additionally, it is important to have personnel with the
necessary skills and knowledge to maintain the system.
Categories of Software Maintenance

Maintenance can be divided into the following categories.

 Corrective maintenance: Corrective maintenance of a software product may
be essential either to rectify some bugs observed while the system is in use,
or to enhance the performance of the system.
 Adaptive maintenance: This includes modifications and updations when the
customers need the product to run on new platforms, on new operating
systems, or when they need the product to interface with new hardware and
software.
  Perfective maintenance: A software product needs maintenance to support
the new features that the users want or to change different types of
functionalities of the system according to the customer’s demands.
 Preventive maintenance: This type of maintenance includes modifications
and updations to prevent future problems with the software. It goals to attend
to problems, which are not significant at this moment but may cause serious
issues in the future.
Reverse Engineering

Reverse Engineering is the process of extracting knowledge or design information

from anything man-made and reproducing it based on the extracted information. It is
also called back engineering. The main objective of reverse engineering is to check
out how the system works. There are many reasons to perform reverse engineering.
Reverse engineering is used to know how the thing works. Also, reverse engineering
is to recreate the object by adding some enhancements.
Software Reverse Engineering

Software Reverse Engineering is the process of recovering the design and the
requirements specification of a product from an analysis of its code. Reverse
Engineering is becoming important, since several existing software products, lack
proper documentation, are highly unstructured, or their structure has degraded
through a series of maintenance efforts.
Why Reverse Engineering?

 Providing proper system documentation.

 Recovery of lost information.

 Assisting with maintenance.

 The facility of software reuse.

 Discovering unexpected flaws or faults.

 Implements innovative processes for specific use.

 Easy to document the things how efficiency and power can be improved.
Uses of Software Reverse Engineering

 Software Reverse Engineering is used in software design, reverse

engineering enables the developer or programmer to add new features to the
existing software with or without knowing the source code.
 Reverse engineering is also useful in software testing, it helps the testers to
study or detect the virus and other malware code.
  Software reverse engineering is the process of analyzing and understanding
the internal structure and design of a software system. It is often used to
improve the understanding of a software system, to recover lost or
inaccessible source code, and to analyze the behavior of a system for security
or compliance purposes.
 Malware analysis: Reverse engineering is used to understand how malware
works and to identify the vulnerabilities it exploits, in order to develop
countermeasures.
 Legacy systems: Reverse engineering can be used to understand and
maintain legacy systems that are no longer supported by the original
developer.
 Intellectual property protection: Reverse engineering can be used to detect
and prevent intellectual property theft by identifying and preventing the
unauthorized use of code or other assets.
 Security: Reverse engineering is used to identify security vulnerabilities in a
system, such as backdoors, weak encryption, and other weaknesses.
 Compliance: Reverse engineering is used to ensure that a system meets
compliance standards, such as those for accessibility, security, and privacy.
 Reverse-engineering of proprietary software: To understand how a
software works, to improve the software, or to create new software with
similar features.
 Reverse-engineering of software to create a competing product: To
create a product that functions similarly or to identify the features that are
missing in a product and create a new product that incorporates those
features.

 It’s important to note that reverse engineering can be a complex and time-
consuming process, and it is important to have the necessary skills, tools, and
knowledge to perform it effectively. Additionally, it is important to consider the
legal and ethical implications of reverse engineering, as it may be illegal or
restricted in some jurisdictions.
Advantages of Software Maintenance

 Improved Software Quality: Regular software maintenance helps to ensure

that the software is functioning correctly and efficiently and that it continues to
meet the needs of the users.
 Enhanced Security: Maintenance can include security updates and patches,
helping to ensure that the software is protected against potential threats and
attacks.
  Increased User Satisfaction: Regular software maintenance helps to keep
the software up-to-date and relevant, leading to increased user satisfaction
and adoption.
 Extended Software Life: Proper software maintenance can extend the life of
the software, allowing it to be used for longer periods of time and reducing the
need for costly replacements.
 Cost Savings: Regular software maintenance can help to prevent larger,
more expensive problems from occurring, reducing the overall cost of
software ownership.
 Better Alignment with business goals: Regular software maintenance can
help to ensure that the software remains aligned with the changing needs of
the business. This can help to improve overall business efficiency and
productivity.
 Competitive Advantage: Regular software maintenance can help to keep the
software ahead of the competition by improving functionality, performance,
and user experience.
 Compliance with Regulations: Software maintenance can help to ensure
that the software complies with relevant regulations and standards. This is
particularly important in industries such as healthcare, finance, and
government, where compliance is critical.
 Improved Collaboration: Regular software maintenance can help to improve
collaboration between different teams, such as developers, testers, and users.
This can lead to better communication and more effective problem-solving.
 Reduced Downtime: Software maintenance can help to reduce downtime
caused by system failures or errors. This can have a positive impact on
business operations and reduce the risk of lost revenue or customers.
 Improved Scalability: Regular software maintenance can help to ensure that
the software is scalable and can handle increased user demand. This can be
particularly important for growing businesses or for software that is used by a
large number of users.
Disadvantages of Software Maintenance

 Cost: Software maintenance can be time-consuming and expensive, and may

require significant resources and expertise.
 Schedule disruptions: Maintenance can cause disruptions to the normal
schedule and operations of the software, leading to potential downtime and
inconvenience.
 Complexity: Maintaining and updating complex software systems can be
challenging, requiring specialized knowledge and expertise.

 Risk of introducing new bugs: The process of fixing bugs or adding new
features can introduce new bugs or problems, making it important to
thoroughly test the software after maintenance.
 User resistance: Users may resist changes or updates to the software,
leading to decreased satisfaction and adoption.
 Compatibility issues: Maintenance can sometimes cause compatibility
issues with other software or hardware, leading to potential integration
problems.
 Lack of documentation: Poor documentation or lack of documentation can
make software maintenance more difficult and time-consuming, leading to
potential errors or delays.
 Technical debt: Over time, software maintenance can lead to technical debt,
where the cost of maintaining and updating the software becomes
increasingly higher than the cost of developing a new system.
 Skill gaps: Maintaining software systems may require specialized skills or
expertise that may not be available within the organization, leading to
potential outsourcing or increased costs.
 Inadequate testing: Inadequate testing or incomplete testing after
maintenance can lead to errors, bugs, and potential security vulnerabilities.
 End-of-life: Eventually, software systems may reach their end-of-life, making
maintenance and updates no longer feasible or cost-effective. This can lead to
the need for a complete system replacement, which can be costly and time-
consuming.