Software Engineering

Unit – 1
Introduction
The term is made of two words, software, and engineering.
Software is more than just a program code. A program is an executable code, which serves some
computational purpose. Software is collection of executable programming code, associated libraries,
and documentations.
Software, when made for a specific requirement is called software product.
Engineering on the other hand, is all about developing products, using well defined, scientific principles
and methods.
Software engineering is an engineering branch associated with
development of software product using well-defined scientific
principles, methods, and procedures. The outcome of software
engineering is an efficient and reliable software product.
Definitions
IEEE defines software engineering as:
1. The application of a systematic, disciplined, quantifiable approach to the development, operation,
and maintenance of software; that is, the application of engineering to software.

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

Fritz Bauer, a German computer scientist, defines software engineering as:
“Software engineering is the establishment and use of sound engineering principles in order to
obtain economically software that is reliable and work efficiently on real machines.”
Programming paradigm is a subset of Software design paradigm which is
further a subset of Software development paradigm.
Software Development Paradigm
This paradigm is known as software engineering paradigms, where all
the engineering concepts pertaining to the development of software
are applied. It includes various research and requirement gathering
which helps the software product to build. It consists of –
• Requirement gathering
• Software design
• Programming
Software Design Paradigm
This paradigm is a part of Software Development and includes –
• Design
• Maintenance
• Programming
Programming Paradigm
This paradigm is related closely to programming aspect of software development. This includes –
• Coding
• Testing
• Integration
Need of Software Engineering
The need of software engineering arises because of higher rate of change in user requirements and
environment on which the software is working. Following is some of the needs stated:
• Large software - It is easier to build a wall than a house or building, likewise, as the size of the
software becomes large, engineering must step to give it a scientific process.
• Scalability- If the software process were not based on scientific and engineering concepts, it
would be easier to re-create new software than to scale an existing one.
• Cost- As hardware industry has shown its skills and huge manufacturing has lower down the price
of computer and electronic hardware. But cost of the software remains high if proper process is
not adapted.
• Dynamic Nature- Always growing and adapting nature of the software hugely depends upon the
environment in which the user works. If the nature of software is always changing, new
enhancements need to be done in the existing one. This is where the software engineering plays a
good role.
• Quality Management- Better process of software development provides better and quality
software product.
Characteristics of good software
A software product can be judged by what it offers and how well it can be used.
This software must satisfy on the following grounds:
• Operational
• Transitional
• Maintenance
Well-engineered and crafted software is expected to have the following characteristics:
Operational
This tells us how well the software works in operations. It can be measured on:
• Budget
• Usability
• Efficiency
• Correctness
• Functionality
• Dependability
• Security
• Safety

2
Transitional
This aspect is important when the software is moved from one platform to another:
• Portability
• Interoperability
• Reusability Adaptability
Maintenance
This aspect briefs about how well the software has the capabilities to maintain itself in the ever-
changing environment:
• Modularity
• Maintainability
• Flexibility
• Scalability
Software engineering is a branch of computer science, which uses well-defined engineering concepts
required to produce efficient, durable, scalable, in budget, and on-time software products.
Software Processes

The term software specifies to the set of computer programs, procedures, and associated documents
(Flowcharts, manuals, etc.) that describe the program and how they are to be used.

A software process is the set of activities and associated outcome that produce a software product.

These are four key process activities, these activities are:

1. Software specifications: The functionality of the software and constraints on its operation
must be defined.
2. Software development: The software to meet the requirement must be produced.
3. Software validation: The software must be validated to ensure that it does what the customer
wants.
4. Software evolution: The software must evolve to meet changing client needs.

The Software Process Model

A software process model is a specified definition of a software

process, which is presented from a particular perspective.
Models, by their nature, are a simplification, so a software
process model is an abstraction of the actual process, which is
being described.

3
Some examples of the types of software process models that may be produced are:

1. A workflow model: This shows the series of activities in the process along with their inputs,
outputs, and dependencies.
2. 2. A dataflow or activity model: This represents the process as a set of activities, each of
which carries out some data transformations. It shows how the input to the process, such as a
specification is converted to an output such as a design.
3. 3. A role/action model: This means the roles of the people involved in the software process
and the activities for which they are responsible.

Software Crisis

1. Size: Software is becoming more expensive and more complex with the growing complexity
and expectation out of software.
2. Quality: Many software products have poor quality, i.e., the software products defects after
putting into use due to ineffective testing technique.
3. Cost: Software development is costly i.e., in terms of time taken to develop and the money
involved.
4. Delayed Delivery: Very often the software takes longer than the estimated time to develop,
which in turn leads to cost shooting up.

Program vs. Software

Software is more than programs. Any program is a subset of software, and it becomes software only if
documentation & operating procedures manuals are prepared.

There are three components of the software as shown in fig:

1. Program: Program is a combination of source code & object code.

2. Documentation: Documentation consists of different types of manuals. Examples of

documentation manuals are Data Flow Diagram, Flow Charts, ER diagrams, etc.

3. Operating Procedures: Operating Procedures consist of instructions to set up and use the software
system and instructions on how react to the system failure.

Software Development Life Cycle 2

Software Development Life Cycle, SDLC for short, is a well-defined, structured sequence of stages in
software engineering to develop the intended software product.
SDLC Activities
SDLC provides a series of steps to be followed to design and develop a software product efficiently.
SDLC framework includes the following steps:

4
Communication
This is the first step where the user initiates the request for a desired software product. The user
contacts the service provider and tries to negotiate the terms, submits the request to the service
providing organization in writing.
Requirement Gathering
This step onwards the software development team works to
carry on the project. The team holds discussions with various
stakeholders from problem domain and tries to bring out as
much information as possible on their requirements. The
requirements are contemplated and segregated into user
requirements, system requirements and functional
requirements. The requirements are collected using a number
of practices as given -
• studying the existing or obsolete system and software,
• conducting interviews of users and developers,
• referring to the database or
• collecting answers from the questionnaires.
Feasibility Study
After requirement gathering, the team produces a rough plan of software process. At this step, the team
analyses if a software can, be designed to fulfil all requirements of the user, and if there is any possibility
of software being no more useful. It is also analysed if the project is financially, and technologically
feasible for the organization to take up. There are many algorithms available, which help the developers
to conclude the feasibility of a software project.
System Analysis
At this step, the developers decide a roadmap of their plan and try to bring up the best software model
suitable for the project. System analysis includes understanding of software product limitations,
learning system related problems or changes to be done in existing systems beforehand, identifying
and addressing the impact of project on organization and personnel etc. The project team analyses the
scope of the project and plans the schedule and resources accordingly.
Software Design
Next step is to bring down whole knowledge of requirements and analysis on the desk and design the
software product. The inputs from users and information gathered in requirement gathering phase are
the inputs of this step. The output of this step comes in the form of two designs: logical design, and
physical design. Engineers produce meta-data and data dictionaries, logical diagrams, data-flow
diagrams, and in some cases pseudo codes.
Coding
This step is also known as programming phase. The implementation of software design starts in terms
of writing program code in the suitable programming language and developing error-free executable
programs efficiently.

5
Testing
An estimate says that 50% of whole software development process should be tested. Errors may ruin
the software from critical level to its own removal. Software testing is done while coding by the
developers and thorough testing is conducted by testing experts at various levels of code such as
module testing, program testing, product testing, in-house testing, and testing the product at user’s
end. Early discovery of errors and their remedy is the key to reliable software.
Integration
Software may need to be integrated with the libraries, databases, and other program(s). This stage of
SDLC is involved in the integration of software with outer world entities.
Implementation
This means installing the software on user machines. At times, software needs post-installation
configurations at user end. Software is tested for portability, adaptability, and integration related issues
are solved during implementation.
Operation and Maintenance
This phase confirms the software operation in terms of more efficiency and less errors. If required, the
users are trained on or aided with the documentation on how to operate the software and how to keep
the software operational. The software is maintained timely by updating the code according to the
changes taking place in user end environment or technology. This phase may face challenges from
hidden bugs and real-world unidentified problems.
Software Development Paradigm
The software development paradigm helps a developer to select a strategy to develop the software. A
software development paradigm has its own set of tools, methods, and procedures, which are
expressed clearly and defines software development life cycle. A few of software development
paradigms or process models are defined as follows:
Waterfall Model
Waterfall model is the simplest model of software development paradigm. All the phases of SDLC will
function one after another in linear manner. That is, when the first phase is finished then only the
second phase will start and so on.
This model assumes that everything is carried out and
taken place perfectly as planned in the previous stage
and there is no need to think about the past issues that
may arise in the next phase. This model does not work
smoothly if there are some issues left at the previous
step. The sequential nature of model does not allow us
to go back and undo or redo our actions.
This model is best suited when developers already have
designed and developed similar software in the past
and are aware of all its domains.

6
Iterative Model
This model leads the software development process in iterations. It projects the process of
development in cyclic manner repeating every step after every cycle of SDLC process.

The software is first developed on very small scale and all

the steps are followed which are taken into consideration.
Then, on every next iteration, more features and modules
are designed, coded, tested, and added to the software.
Every cycle produces a software, which is complete and
has more features and capabilities than that of the previous
one.
After each iteration, the management team can do work on risk management and prepare for the next
iteration. Because a cycle includes small portion of whole software process, it is easier to manage the
development process, but it consumes more resources.
Spiral Model
Spiral model is a combination of both, iterative model and one of the SDLC model. It can be seen as if
you choose one SDLC model and combined it with cyclic process (iterative model).

This model considers risk, which often goes un-noticed by most

other models. The model starts with determining objectives and
constraints of the software at the start of one iteration. Next phase
is of prototyping the software. This includes risk analysis. Then one
standard SDLC model is used to build the software. In the fourth
phase of the plan of next iteration is prepared.
V – model
The major drawback of waterfall model is we move to the next
stage only when the previous one is finished and there was no
chance to go back if something is found wrong in later
stages. V-Model provides means of testing of software at each
stage in reverse manner.
At every stage, test plans and test cases are created to verify and
validate the product according to the requirement of that stage.
For example, in requirement gathering stage the test team
prepares all the test cases in correspondence to the
requirements. Later, when the product is developed and is ready for testing, test cases of this stage
verify the software against its validity towards requirements at this stage.
This makes both verification and validation go in parallel. This model is also known as verification and
validation model.

7
Big Bang Model
This model is the simplest model in its form. It requires little planning,
lots of programming and lots of funds. This model is conceptualized
around the big bang of universe. As scientists say that after big bang
lots of galaxies, planets, and stars evolved just as an event. Likewise,
if we put together lots of programming and funds, you may achieve
the best software product.
For this model, very small amount of planning is required. It does not
follow any process, or at times the customer is not sure about the requirements and future needs. So,
the input requirements are arbitrary.
This model is not suitable for large software projects but good one for learning and experimenting.

The job pattern of an IT company engaged in software development can be seen split in two parts:
• Software Creation
• Software Project Management
A project is well-defined task, which is a collection of several operations done to achieve a goal (for
example, software development and delivery). A Project can be characterized as:
• Every project may have a unique and distinct goal.
• Project is not a routine activity or day-to-day operation.
• Project comes with a start and end time.
• Project ends when its goal is achieved. Hence, it is a temporary phase in the lifetime of an
organization.
• Project needs adequate resources in terms of time, workforce, finance, material, and
knowledge-bank.
Software Project
A Software Project is the complete procedure of software development from requirement gathering to
testing and maintenance, carried out according to the execution methodologies, in a specified period
to achieve intended software product.
Software Metrics and Measures
Software Measures can be understood as a process of quantifying and symbolizing various attributes
and aspects of software.
Software Metrics provide measures for various aspects of software process and software product.
Software measures are fundamental requirements of software engineering. They not only help to
control the software development process but also aid to keep the quality of ultimate product
excellent.
According to Tom DeMarco, a (Software Engineer), “You cannot control what you cannot measure.” By
his saying, it is very clear how important software measures are.

8
Let us see some software metrics:
• Size Metrics - Lines of Code (LOC) (), mostly calculated in thousands of delivered source code
lines, denoted as KLOC.
• Function Point Count is measure of the functionality provided by the software. Function Point
count defines the size of functional aspect of the software.
• Complexity Metrics - McCabe’s Cyclomatic complexity quantifies the upper bound of the
number of independent paths in a program, which is perceived as complexity of the program or
its modules. It is represented in terms of graph theory concepts by using control flow graph.
• Quality Metrics - Defects, their types and causes, consequence, intensity of severity and their
implications define the quality of the product.
• The number of defects found in development process and number of defects reported by the
client after the product is installed or delivered at client end, define quality of the product.
• Process Metrics - In various phases of SDLC, the methods and tools used, the company
standards and the performance of development are software process metrics.
• Resource Metrics - Effort, time, and various resources used, represents metrics for resource
measurement.

9
 Unit - 2
Need of software project management
Software is said to be an intangible product. Software development is an all-new stream in world
business and there is very little experience in building software products. Most software products are
tailor made to fit client’s requirements. The most important is that the underlying technology changes
and advances so frequently and rapidly that the experience of one product may not be applied to the
other one. All such business and environmental constraints bring risk in software development hence
it is essential to manage software projects efficiently.
The image above shows triple constraints for software projects. It is an
essential part of software organization to deliver quality product, keeping the
cost within client’s budget constrain and deliver the project as per
scheduled. There are several factors, both internal and external, which may
impact this triple constrain triangle. Any of the three factors can severely
impact the other two.
Therefore, software project management is essential to incorporate user requirements along with
budget and time constraints.
Software Project Manager
A software project manager is a person who undertakes the responsibility of executing the software
project. Software project manager is thoroughly aware of all the phases of SDLC that the software
would go through. The project manager may never directly involve in producing the product, but he
controls and manages the activities involved in production.
A project manager closely monitors the development process, prepares, and executes various plans,
arranges necessary and adequate resources, maintains communication among all team members to
address issues of cost, budget, resources, time, quality, and customer satisfaction.
Let us see few responsibilities that a project manager shoulders -
Managing People
• Act as project leader!
• Lesion with stakeholders.
• Managing human resources
• Setting up reporting hierarchy etc.
Managing Project
• Defining and setting up project scope
• Managing project management activities
• Monitoring progress and performance
• Risk analysis at every phase.
• Take necessary step to avoid or come out of problems.
• Act as project spokesperson.
Software Management Activities
Software project management comprises of a number of activities, which contains planning of project,
deciding scope of software product, estimation of cost in various terms, scheduling of tasks and
events, and resource management. Project management activities may include:

10
 • Project Planning
• Scope Management
• Project Estimation
Software Project Planning
Software project planning is task, which is performed before the production of software starts. It is
there for the software production but involves no concrete activity that has any direct connection with
the software production; rather it is a set of multiple processes, which facilitates software production.
Project planning may include the following:
Scope Management
It defines scope of the project; this includes all the activities; process need to be done to make a
deliverable software product. Scope management is essential because it creates boundaries of the
project by clearly defining what would be done in the project and what would not be done. This makes
project to contain limited and quantifiable tasks, which can easily be documented and in turn avoids
cost and time overrun.
During Project Scope management, it is necessary to -
• Define the scope.
• Decide its verification and control.
• Divide the project into various smaller parts for ease of management.
• Verify the scope.
• Control the scope by incorporating changes to the scope.
Project Estimation
For an effective management, accurate estimation of various measures is necessary. With the correct
estimation, managers can manage and control the project more efficiently and effectively.
Project estimation may involve the following:
Software size estimation: Software size may be estimated either in terms of KLOC (Kilo Line of Code)
or by calculating number of function points in the software. Lines of code depend upon coding
practices. Function points vary according to the user or software requirement.
Effort estimation: The manager estimates efforts in terms of personnel requirement and person-hour
required to produce the software. For effort estimation software size should be known. This can either
be derived by manager’s experience, historical data of organization, or software size can be converted
into efforts by using some standard formulae.
Time estimation: Once size and efforts are estimated, the time required to produce the software can
be estimated. Efforts required is segregated into subcategories as per the requirement specifications
and interdependency of various components of software. Software tasks are divided into smaller tasks,
activities, or events by Work Breakthrough Structure (WBS). The tasks are scheduled on day-to-day
basis or in calendar months.
The sum of time required to complete all tasks in hours or days is the total time invested to complete
the project.

11
Cost estimation: This might be considered as the most difficult of all because it depends on more
elements than any of the previous ones. For estimating project cost, it is required to consider -
• Size of the software
• Software quality
• Hardware
• Additional software or tools, licenses etc.
• Skilled personnel with task-specific skills
• Travel involved.
• Communication
• Training and support
Project Estimation Techniques
We discussed various parameters involving project estimation such as size, effort, time, and cost.
Project manager can estimate the listed factors using two recognized techniques –
Decomposition Technique
This technique assumes the software as a product of various compositions.
There are two main models -
• Line of Code: Here the estimation is done on behalf of number of line of codes in the software
product.
• Function Points: Here the estimation is done on behalf of number of function points in the
software product.
Empirical Estimation Technique
This technique uses empirically derived formulae to make estimation. These formulae are based on
LOC or FPs.
• Putnam Model
This model is made by Lawrence H. Putnam, which is based on Norden’s frequency distribution
(Rayleigh curve). Putnam model maps time and efforts required with software size.
• COCOMO
COCOMO stands for Constructive Cost Model, developed by Barry W. Boehm. It divides the
software product into three categories of software: organic, semi-detached, and embedded.
Project Scheduling
Project Scheduling in a project refers to roadmap of all activities to be done with specified order and
within time slot allotted to each activity. Project managers tend to define various tasks, and project
milestones and then arrange them keeping several factors in mind. They look for tasks like in critical
path in the schedule, which are necessary to complete in specific manner (because of task
interdependency) and strictly within the time allocated. Arrangement of tasks which lies out of critical
path are less likely to impact over all schedule of the project.

12
For scheduling a project, it is necessary to -
• Break down the project tasks into smaller, manageable form.
• Find out various tasks and correlate them.
• Estimate time required for each task.
• Divide time into work-units.
• Assign adequate number of work-units for each task.
• Calculate total time required for the project from start to finish.
Resource management
All elements used to develop a software product may be assumed as resource for that project. This
may include human resource, productive tools, and software libraries.
The resources are available in limited quantity and stay in the organization as a pool of assets. The
shortage of resources hampers development of the project, and it can lag the schedule. Allocating extra
resources increases development cost in the end. It is therefore necessary to estimate and allocate
adequate resources for the project.
Resource management includes -
• Defining proper organization project by creating a project team and allocating responsibilities to
each team member
• Determining resources required at a particular stage and their availability.
• Manage Resources by generating resource request when they are required and de-allocating
them when they are no more needed.
Project Risk Management
Risk management involves all activities pertaining to identification, analysing, and making provision for
predictable and non-predictable risks in the project. Risk may include the following:
• Experienced staff leaving the project and new staff coming in.
• Change in organizational management.
• Requirement change or misinterpreting requirement.
• Under-estimation of required time and resources.
• Technological changes, environmental changes, business competition.
Risk Management Process
There are following activities involved in risk management process:
• Identification - Make note of all risks, which may occur in the project.
• Categorize - Categorize known risks into high, medium, and low risk intensity as per their
possible impact on the project.
• Manage - Analyse the probability of occurrence of risks at various phases.
Make plan to avoid or face risks. Attempt to minimize their side-effects.
• Monitor - Closely monitor the potential risks and their early symptoms.
Also monitor the effective steps taken to mitigate or avoid them.

13
Software Requirements
The software requirements are description of features and functionalities of the target system.
Requirements convey the expectations of users from the software product. The requirements can be
obvious or hidden, known or unknown, expected, or unexpected from client’s point of view.
Requirement Engineering
The process to gather the software requirements from client, analyse, and document them is known as
requirement engineering.
The goal of requirement engineering is to develop and maintain sophisticated and descriptive ‘System
Requirements Specification’ document.
Requirement Engineering Process
It is a four-step process, which includes –
• Feasibility Study
• Requirement Gathering
• Software Requirement Specification
• Software Requirement Validation
Let us see the process briefly -
Feasibility study
When the client approaches the organization for getting the desired product developed, it produces a
rough idea about what all functions the software must perform and which all features are expected
from the software.
Referencing to this information, the analysts do a detailed study about whether the desired system and
its functionality are feasible to develop.
This feasibility study is focused on goal of the organization. This study analyses whether the software
product can be practically materialized in terms of implementation, contribution of project to
organization, cost constraints, and as per values and objectives of the organization. It explores
technical aspects of the
project and product such as usability, maintainability, productivity, and integration ability.
The output of this phase should be a feasibility study report that should contain adequate comments
and recommendations for management about whether the project should be undertaken.
Requirement Gathering
If the feasibility report is positive towards undertaking the project, next phase starts with gathering
requirements from the user. Analysts and engineers communicate with the client and end-users to
know their ideas on what the software should provide, and which features they want the software to
include.
Software Requirement Specification (SRS)
SRS is a document created by system analyst after the requirements are collected from various
stakeholders.
SRS defines how the intended software will interact with hardware, external interfaces, speed of
operation, response time of system, portability of software across various platforms, maintainability,
speed of recovery after crashing, Security, Quality, Limitations etc.

14
The requirements received from client are written in natural language. It is the responsibility of the
system analyst to document the requirements in technical language so that they can be comprehended
and used by the software development team.
SRS should produce the following features:
• User Requirements are expressed in natural language.
• Technical requirements are expressed in structured language, which is used inside the
organization.
• Design description should be written in Pseudo code.
• Format of Forms and GUI screen prints.
• Conditional and mathematical notations for DFDs etc.
Software Requirement Validation
After requirement specifications are developed, the requirements mentioned in this document are
validated. User might ask for illegal, impractical solution or experts may interpret the requirements
inaccurately. This results in huge increase in cost if not nipped in the bud. Requirements can be checked
against following conditions -
• If they can be practically implemented
• If they are valid and as per functionality and domain of software
• If there are any ambiguities
• If they are complete
• If they can be demonstrated
Software Quality

Software quality product is defined in term of its fitness of purpose. That is, a quality product does
precisely what the users want it to do. For software products, the fitness of use is explained in terms of
satisfaction of the requirements laid down in the SRS document.

Software Product Quality Methods are as follows:

Portability: A software device is said to be portable, if it can be freely made to work in various operating
system environments, in multiple machines, with other software products, etc.

Usability: A software product has better usability if various categories of users can easily invoke the
functions of the product.

Reusability: A software product has excellent reusability if different modules of the product can
quickly be reused to develop new products.

Correctness: A software product is correct if various requirements as specified in the SRS document
have been correctly implemented.

Maintainability: A software product is maintainable if bugs can be easily corrected as and when they
show up, new tasks can be easily added to the product, and the functionalities of the product can be
easily modified, etc.

15
Quality System Activities: The quality system activities encompass the following:

• Auditing of projects
• Review of the quality system
• Development of standards, methods, and guidelines, etc.
• Production of documents for the top management summarizing the effectiveness of the quality
system in the organization.

Software Quality Assurance

Assurance (SQA) is simply a way to assure quality in the software. It is the set of activities that ensure
processes, procedures as well as standards are suitable for the project and implemented correctly.

Software Quality Assurance is a process that works parallel to Software Development. It focuses on
improving the process of development of software so that problems can be prevented before they
become major issues. Software Quality Assurance is a kind of Umbrella activity that is applied
throughout the software process.

What is quality?

Quality in a product or service can be defined by several measurable characteristics. Each of these
characteristics plays a crucial role in determining the overall quality.

Elements of Software Quality Assurance (SQA)

1. Standards: The IEEE, ISO, and other standards organizations have produced a broad array of
software engineering standards and related documents. The job of SQA is to ensure that
standards that have been adopted are followed and that all work products conform to them.

2. Reviews and audits: Technical reviews are a quality control activity performed by software
engineers for software engineers. Their intent is to uncover errors. Audits are a type of review
performed by SQA personnel (people employed in an organization) with the intent of ensuring
that quality guidelines are being followed for software engineering work.

3. Testing: Software testing is a quality control function that has one primary goal—to find errors.
The job of SQA is to ensure that testing is properly planned and efficiently conducted for primary
goal of software.

4. Error/defect collection and analysis: SQA collects and analyses error and defect data to
better understand how errors are introduced and what software engineering activities are best
suited to eliminating them.

5. Change management: SQA ensures that adequate change management practices have been
instituted.

6. Education: Every software organization wants to improve its software engineering practices. A
key contributor to improvement is education of software engineers, their managers, and other
stakeholders. The SQA organization takes the lead in software process improvement which is
key proponent and sponsor of educational programs.

16
7. Security management: SQA ensures that appropriate process and technology are used to
achieve software security.

8. Safety: SQA may be responsible for assessing the impact of software failure and for initiating
those steps required to reduce risk.

9. Risk management: The SQA organization ensures that risk management activities are properly
conducted and that risk-related contingency plans have been established.

17
 Unit - 3
System configuration management
• When we develop software, the product (software) undergoes many changes in their
maintenance phase; we need to handle these changes effectively.
• Several individuals (programs) work together to achieve these common goals. This individual
produces several work products (SC Items) e.g., Intermediate version of modules or test data
used during debugging, parts of the final product.
• The elements that comprise all information produced as a part of the software process are
collectively called a software configuration.

As software development progresses, the number of Software Configuration elements (SCI's) grow
rapidly. These are handled and controlled by SCM. This is where we require software configuration
management.

Therefore, SCM is the discipline which.

o Identify change.
o Monitor and control change.
o Ensure the proper implementation of change made to the item.
o Auditing and reporting on the change made.
Configuration Management (CM) is a technic of identifying, organizing, and controlling modification to
software being built by a programming team.
The objective is to maximize productivity by minimizing mistakes (errors).
CM is used to essential due to the inventory management, library management, and Updation
management of the items essential for the project.
Why do we need Configuration Management?
Multiple people are working on software which is consistently updating. It may be a method where
multiple versions, branches, authors are involved in a software project, and the team is geographically
distributed and works concurrently. It changes in user requirements, and policy, budget, schedules
need to be accommodated.
Importance of SCM
• It is practical in controlling and managing the access to various SCIs e.g., by preventing the two
members of a team for checking out the same component for modification at the same time.
• It provides the tool to ensure that changes are being properly implemented.
• It has the capability of describing and storing the various constituent of software.
• SCM is used in keeping a system in a consistent state by automatically producing derived
version upon modification of the same component.
SCM Process
It uses the tools which keep that the necessary change has been implemented adequately to the
appropriate component. The SCM process defines a few tasks:
o Identification of objects in the software configuration
o Version Control
o Change Control

18
 o Configuration Audit
o Status Reporting
Identification
• Basic Object: Unit of Text created by a software engineer
during analysis, design, code, or test.
• Aggregate Object: A collection of essential objects and
other aggregate objects. Design Specification is an
aggregate object.
• Each object has a set of distinct characteristics that
identify it uniquely: a name, a description, a list of
resources, and a "realization."
• The interrelationships between configuration objects can be described with a Module
Interconnection Language (MIL).
Version Control
• Version Control combines procedures and tools to handle different version of configuration
objects that are generated during the software process.
• Clemm defines version control in the context of SCM: Configuration management allows a user
to specify the alternative configuration of the software system through the selection of
appropriate versions.
• This is supported by associating attributes with each software version, and then allowing a
configuration to be specified [and constructed] by describing the set of desired attributes.
Change Control
• James Bach describes change control in the context of SCM is Change Control is Vital. But the
forces that make it essential also make it annoying.
• We worry about change because a small confusion in the code can create a big failure in the
product. But it can also fix a significant failure or enable incredible new capabilities.
• We worry about change because a single rogue developer could sink the project, yet brilliant
ideas originate in the mind of those rogues, and
• A burdensome change control process could effectively discourage them from doing creative
work.
• A change request is submitted and calculated to assess technical merit, potential side effects,
the overall impact on other configuration objects and system functions, and projected cost of
the change.
• The results of the evaluations are presented as a change report, which is used by a change
control authority (CCA) - a person or a group who makes a final decision on the status and
priority of the change.
• The "check-in" and "check-out" process implements two necessary elements of change
control-access control and synchronization control.
• Access Control governs which software engineers have the authority to access and modify a
particular configuration object.
• Synchronization Control helps to ensure that parallel changes, performed by two different
people, do not overwrite one another.

19
Configuration Audit
• SCM audits to verify that the software product satisfies the baselines requirements and ensures
that what is built and what is delivered.
• SCM audits also ensure that traceability is maintained between all CIs and that all work
requests are associated with one or more CI modification.
• SCM audits are the "watchdogs" that ensures that the integrity of the project's scope is
preserved.
Status Reporting
Configuration Status reporting (sometimes also called status accounting) providing accurate status
and current configuration data to developers, testers, end users, customers and stakeholders through
admin guides, user guides, FAQs, Release Notes, Installation Guide, Configuration Guide, etc.
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.

20
Analysis principles – Analysis Modelling in Software Engineering
Analysis Model is a technical representation of the system. It acts as a link between the system
description and the design model. In Analysis Modelling, information, behaviour, and functions of the
system are defined and translated into the architecture, component, and interface level design in the
design modelling.
Objectives of Analysis Modelling
• Understanding Needs: The process of analysis modelling helps in the understanding and
extraction of user needs for the software system.
• Communication: Analysis models facilitate communication between users, clients,
developers, and testers, among other stakeholders.
• Clarifying Ambiguities: Analysis models assist in resolving requirements disputes and
providing clarification on unclear areas.
• Finding the Data Requirements: Analysis modelling assists in determining the relationships,
entities, and qualities of the data that the system needs.
• Defining Behaviour: Analysis modelling aids in the definition of the system’s dynamic
behaviour, including workflows, processes, and inter-component interactions.
• System Boundary Identification: It is made easier by analysis modelling, which helps in
defining the parameters of the software system and its interactions with users, other systems,
and hardware components.
Elements of Analysis Model
1. Data Dictionary: It is a repository that consists of a
description of all data objects used or produced by
the software. It stores the collection of data present
in the software. It is a very crucial element of the
analysis model. It acts as a centralized repository
and helps in modelling data objects defined during
software requirements.
2. Entity Relationship Diagram (ERD): It depicts the
relationship between data objects and is used in
conducting data modelling activities. The attributes
of each object in the Entity-Relationship Diagram
can be described using Data object description. It
provides the basis for activity related to data design.
3. Data Flow Diagram (DFD): It depicts the functions that transform data flow, and it also shows
how data is transformed when moving from input to output. It provides the additional
information that is used during the analysis of the information domain and serves as a basis for
the modelling of function. It also enables the engineer to develop models of functional and
information domains at the same time.
4. State Transition Diagram: It shows various modes of behaviour (states) of the system and
shows the transitions from one state to another state in the system. It also provides the details
of how the system behaves due to the consequences of external events. It represents the
behaviour of a system by presenting its states and the events that cause the system to change
state. It also describes what actions are taken due to the occurrence of a particular event.

21
 5. Process Specification: It stores the description of each function present in the data flow
diagram. It describes the input to a function, the algorithm that is applied for the transformation
of input, and the output that is produced. It also shows regulations and barriers imposed on the
performance characteristics that apply to the process and layout constraints that could
influence how the process will be implemented.
6. Control Specification: It stores additional information about the control aspects of the
software. It is used to indicate how the software behaves when an event occurs, and which
processes are invoked due to the occurrence of the event. It also provides the details of the
processes which are executed to manage events.
7. Data Object Description: It stores and provides complete knowledge about a data object
present and used in the software. It also gives us the details of attributes of the data object
present in the Entity Relationship Diagram. Hence, it incorporates all the data objects and their
attributes.
Key Principles of Analysis Modelling
1. Abstraction: Analysis modelling involves separating important system components from
unneeded specifics. While leaving out unnecessary or low-level information, it concentrates on
capturing the essential ideas, behaviours, and relationships relevant to the system’s
requirements.
2. Modularity: Analysis models ought to be able to break down a system into smaller, more
manageable parts. It is simpler to understand, assess, and alter the system when each module
or component reflects a different part of its functionality.
3. Consistency: Internally and with other project artifacts, including requirements documents,
design specifications, and implementation code, analysis models should be consistent. By
preventing opposing or conflicting representations of the system, consistency promotes greater
stakeholder comprehension and alignment.
4. Traceability: Analysis models ought to be able to be linked to other project components so that
interested parties may follow requirements from their inception to their execution. Throughout
the software development lifecycle, it helps with impact analysis, change management, and
requirements coverage verification.
5. Precision: To provide an unambiguous picture of the needs and behaviours of the system,
analysis models must be accurate and exact. Accuracy lowers the chance of
miscommunication and misunderstanding among stakeholders as well as implementation
problems.
6. Separation of Concerns: Analysis modelling divides various system components or concerns
into discrete representations. For instance, behavioural modelling aims to capture the dynamic
behaviour of the system, whereas data modelling concentrates on expressing the relationships
and structure of data items.

22
 Software Engineering Tutorial
Unit - 4
Software design
Software design is a process to transform user requirements into some suitable form, which helps the
programmer in software coding and implementation.
For assessing user requirements, an SRS (Software Requirement Specification) document is created
whereas for coding and implementation, there is a need of more specific and detailed requirements in
software terms. The output of this process can directly be used into implementation in programming
languages.
Software design is the first step in SDLC (Software Design Life Cycle), which moves the concentration
from problem domain to solution domain. It tries to specify how to fulfil the requirements mentioned in
SRS.
Software Design Levels
Software design yields three levels of results:
• Architectural Design - The architectural design is the highest abstract version of the system. It
identifies the software as a system with many components interacting with each other. At this
level, the designers get the idea of proposed solution domain.
• High-level Design - The high-level design breaks the ‘single entity multiple component’ concept
of architectural design into less-abstracted view of sub-systems and modules and depicts their
interaction with each other. High-level design focuses on how the system along with all its
components can be implemented in forms of modules. It recognizes modular structure of each
sub-system and their relation and interaction among each other.
• Detailed Design- Detailed design deals with the implementation part of what is seen as a
system and its sub-systems in the previous two designs. It is more detailed towards modules
and their implementations. It defines logical structure of each module and their interfaces to
communicate with other modules.
Modularization
Modularization is a technique to divide a software system into multiple discrete and independent
modules, which are expected to be capable of carrying out task(s) independently. These modules may
work as basic constructs for the entire software. Designers tend to design modules such that they can
be executed and/or compiled separately and independently.
Modular design unintentionally follows the rule of ‘divide and conquer’ problem solving strategy, this is
because there are many other benefits attached with the modular design of a software.
Advantage of modularization:
• Smaller components are easier to maintain.
• Program can be divided based on functional aspects.
• Desired level of abstraction can be brought in the program.
• Components with high cohesion can be re-used again.
• Concurrent execution can be made possible.
• Desired from security aspect.
 Software Engineering

Concurrency
Back in time, all software is meant to be executed sequentially. By sequential execution, we mean that
the coded instruction will be executed one after another implying only one portion of program being
activated at any given time. Say, a software has multiple modules, then only one of all the modules can
be found active at any time of execution.
In software design, concurrency is implemented by splitting the software into multiple independent
units of execution, like modules and executing them in parallel. In other words, concurrency provides
capability to the software to execute more than one part of code in parallel to each other.
It is necessary for the programmers and designers to recognize those modules, which can be made
parallel execution.
Example
The spell check feature in word processor is a module of software, which runs alongside the word
processor itself.
Coupling and Cohesion
When a software program is modularized, its tasks are divided into several modules based on some
characteristics. As we know, modules are set of instructions put together to achieve some tasks. They
are though, considered as a single entity but, may refer to each other to work together. There are
measures by which the quality of a design of modules and their interaction among them can be
measured. These measures are called coupling and cohesion.
Cohesion
Cohesion is a measure that defines the degree of intra-dependability within elements of a module. The
greater the cohesion, the better is the program design. There are seven types of cohesion, namely –
• Co-incidental cohesion - It is unplanned and random cohesion, which might be the result of
breaking the program into smaller modules for the sake of modularization. Because it is
unplanned, it may serve confusion to the programmers and is not accepted.
• Logical cohesion - When logically categorized elements are put together into a module, it is
called logical cohesion.
• Emporal Cohesion - When elements of module are organized such that they are processed at
a similar point of time, it is called temporal cohesion.
• Procedural cohesion - When elements of module are grouped together, which are executed
sequentially to perform a task, it is called procedural cohesion.
• Communicational cohesion - When elements of module are grouped together, which are
executed sequentially and work on same data (information), it is called communicational
cohesion.
• Sequential cohesion - When elements of module are grouped because the output of one
element serves as input to another and so on, it is called sequential cohesion.
• Functional cohesion - It is the highest degree of cohesion, and it is highly expected. Elements
of module in functional cohesion are grouped because they all contribute to a single well-
defined function. It can also be reused.

24
 Software Engineering

Coupling
Coupling is a measure that defines the level of inter-dependability among modules of a program. It tells
at what level the modules interfere and interact with each other. The lower the coupling, the better the
program.
There are five levels of coupling, namely -
• Content coupling - When a module can directly access or modify or refer to the content of
another module, it is called content level coupling.
• Common coupling- When multiple modules have read and write access to some global data,
it is called common or global coupling.
• Control coupling- Two modules are called control-coupled if one of them decides the function
of the other module or changes its flow of execution.
• Stamp coupling- When multiple modules share common data structure and work on different
part of it, it is called stamp coupling.
• Data coupling- Data coupling is when two modules interact with each other by means of
passing data (as parameter). If a module passes data structure as parameter, then the receiving
module should use all its components.
Ideally, no coupling is the best.
Design Verification
The output of software design process is design documentation, pseudo codes, detailed logic
diagrams, process diagrams, and detailed description of all functional or non-functional requirements.
The next phase, which is the implementation of software, depends on all outputs mentioned above.
It is then becoming necessary to verify the output before proceeding to the next phase. The early any
mistake is detected, the better it is, or it might not be detected until testing of the product. If the outputs
of design phase are in formal notation form, then their associated tools for verification should be used
otherwise a thorough design review can be used for verification and validation.
By structured verification approach, reviewers can detect defects that might be caused by overlooking
some conditions. A good design review is important for good software design, accuracy, and quality.
Software Analysis and Design Tools 6
Software analysis and design includes all activities, which help the transformation of requirement
specification into implementation. Requirement specifications specify all functional and non-
functional expectations from the software. These requirement specifications come in the shape of
human readable and understandable documents, to which a computer has nothing to do.
Software analysis and design is the intermediate stage, which helps human readable requirements to
be transformed into actual code.
Let us see few analysis and design tools used by software designers:
Data Flow Diagram
Data Flow Diagram (DFD) is a graphical representation of flow of data in an information system. It can
depict incoming data flow, outgoing data flow, and stored data. The DFD does not mention anything
about how data flows through the system.

25
 Software Engineering

There is a prominent difference between DFD and Flowchart. The flowchart depicts flow of control in
program modules. DFDs depict flow of data in the system at various levels. It does not contain any
control or branch elements.
Types of DFD
Data Flow Diagrams are either Logical or Physical.
• Logical DFD - This type of DFD concentrates on the system process, and flow of data in the
system. For example, in a banking software system, how data is moved between different
entities.
• Physical DFD - This type of DFD shows how the data flow is implemented in the system. It is
more specific and closer to the implementation.
DFD Components
DFD can represent source, destination, storage, and flow of data using the following set of components
-

• Entities - Entities are sources and destinations of information data. Entities are represented by
rectangles with their respective names.
• Process - Activities and action taken on the data are represented by Circle or Round-edged
rectangles.
• Data Storage - There are two variants of data storage - it can either be represented as a
rectangle with absence of both smaller sides or as an open-sided rectangle with only one side
missing.
• Data Flow - Movement of data is shown by pointed arrows. Data movement is shown from the
base of arrow as its source towards head of the arrow as destination.
Levels of DFD
• Level 0 - Highest abstraction level DFD is known as Level 0 DFD,
which depicts the entire information system as one diagram
concealing all the underlying details. Level 0 DFDs are also
known as context level DFDs.

• Level 1 - The Level 0 DFD is broken down into more

specific, Level 1 DFD. Level 1 DFD depicts basic modules
in the system and flow of data among various modules.
Level 1 DFD also mentions basic processes and sources of
information.

• Level 2 - At this level, DFD shows how data flows inside the
modules mentioned in Level 1.

26
 Software Engineering

Higher level DFDs can be transformed into more specific lower level DFDs with deeper level of
understanding unless the desired level of specification is achieved.
Structure Charts
Structure chart is a chart derived from Data Flow Diagram. It represents the system in more detail than
DFD. It breaks down the entire system into lowest functional modules, describes functions and sub-
functions of each module of the system to a greater detail than DFD.
Structure chart represents hierarchical structure of modules. At each layer, a specific task is
performed.
Here are the symbols used in construction of structure charts -
• Module - It represents process, subroutine, or task. A
control module branches to more than one sub-
module. Library Modules are re-usable and invokable
from any module.

• Condition - It is represented by small diamond at base of the

module. It depicts that control module can select any of sub-routine
based on some condition.

• Jump - An arrow is shown pointing inside the module to depict that the control will jump in the
middle of the sub-module.

• Loop - A curved arrow represents loop in the module. All sub-modules covered by loop repeat
execution of module.

• Data flow - A directed arrow with empty circle at the end represents data flow.

27
 Software Engineering

Entity-Relationship Model
Entity-Relationship model is a type of database model based on the notion of real-world entities and
relationship among them. We can map real world scenario onto ER database model. ER Model creates
a set of entities with their attributes, a set of constraints and relation among them.
ER Model is best used for the conceptual design of database. ER Model can be represented as follows:

• Entity - An entity in ER Model is a real world being, which has some properties called attributes.
Every attribute is defined by its corresponding set of values, called domain.
For example, Consider a school database. Here, a student is an entity. Student has various
attributes like name, id, age, and class etc.
• Relationship - The logical association among entities is called relationship. Relationships are
mapped with entities in various ways. Mapping cardinalities define the number of associations
between two entities.
Mapping cardinalities:
• one to one
• one to many
• many to one many to many
Data Dictionary
Data dictionary is the centralized collection of information about data. It stores meaning and origin of
data, its relationship with other data, data format for usage, etc. Data dictionary has rigorous definitions
of all names to facilitate user and software designers.
Data dictionary is often referenced as meta-data (data about data) repository. It is created along with
DFD (Data Flow Diagram) model of software program and is expected to be updated whenever DFD is
changed or updated.
Requirement of Data Dictionary
The data is referenced via data dictionary while designing and implementing software. Data dictionary
removes any chances of ambiguity. It helps keeping work of programmers and designers synchronized
while using same object reference everywhere in the program.
Data dictionary provides a way of documentation for the complete database system in one place.
Validation of DFD is carried out using data dictionary.
Contents
Data dictionary should contain information about the following:
• Data Flow
• Data Structure
• Data Elements

28
 Software Engineering

• Data Stores
Data Elements
Data elements consist of Name and descriptions of Data and Control Items, Internal or External data
stores etc. with the following details:
• Primary Name
• Secondary Name (Alias)
• Use-case (How and where to use)
• Content Description (Notation etc.)
• Supplementary Information (preset values, constraints etc.)
Data Store
It stores the information from where the data enters the system and exists out of the system. The Data
Store may include -
• Files of Internal to software. o External to software but on the same machine.
o External to software and system, located on different machine.
• Tables o Naming convention o Indexing property
Data Processing
There are two types of Data Processing:
• Logical: As user sees it
• Physical: As software sees it

29
 Software Engineering Tutorial
Unit - 5
Software Testing 11
Software Testing is evaluation of the software against requirements gathered from users and system
specifications. Testing is conducted at the phase level in software development life cycle or at module
level in program code. Software testing comprises of Validation and Verification.
Software Validation
Validation is process of examining whether the software satisfies the user requirements. It is carried
out at the end of the SDLC. If the software matches requirements for which it was made, it is validated.
• Validation ensures the product under development is as per the user requirements.
• Validation answers the question – "Are we developing the product which attempts all that user
needs from this software?".
• Validation emphasizes on user requirements.
Software Verification
Verification is the process of confirming if the software is meeting the business requirements and is
developed adhering to the proper specifications and methodologies.
• Verification ensures the product being developed is according to design specifications.
• Verification answers the question– "Are we developing this product by firmly following all design
specifications?"
• Verifications concentrates on the design and system specifications.
Target of the test are -
• Errors - These are actual coding mistakes made by developers. In addition, there is a difference
in output of software and desired output, is considered as an error.
• Fault - When error exists fault occurs. A fault, also known as a bug, is a result of an error which
can cause system to fail.
• Failure - failure is said to be the inability of the system to perform the desired task. Failure
occurs when fault exists in the system.
Manual Vs Automated Testing
Testing can either be done manually or using an automated testing tool:
• Manual - This testing is performed without taking help of automated testing tools. The software
tester prepares test cases for different sections and levels of the code, executes the tests, and
reports the result to the manager.
Manual testing is time and resource consuming. The tester needs to confirm whether right test
cases are used. Major portion of testing involves manual testing.
• Automated This testing is a testing procedure done with aid of automated testing tools. The
limitations with manual testing can be overcome using automated test tools.
A test needs to check if a webpage can be opened in Internet Explorer. This can be easily done with
manual testing. But to check if the webserver can take the load of one million users, it is quite
impossible to test manually.
There are software and hardware tools which helps tester in conducting load testing, stress testing,
regression testing.

30
 Software Engineering
Testing Approaches
Tests can be conducted based on two approaches –
1. Functionality testing
2. Implementation testing
When functionality is being tested without taking the actual implementation in concern it is known as
black-box testing. The other side is known as white box testing where not only functionality is tested
but the way it is implemented is also analysed.
Exhaustive tests are the best-desired method for a perfect testing. Every single value in the range of
the input and output values is tested. It is not possible to test every value in real world scenario if the
range of values is large.
Black-box testing
It is carried out to test functionality of the program and called ‘Behavioural’ testing. The tester in this
case, has a set of input values and respective desired results. On providing input, if the output matches
with the desired results, the program is tested ‘ok,’ and problematic otherwise.

In this testing method, the design and structure of the code are not known to the tester, and testing
engineers and end users conduct this test on the software.
Black box testing techniques:
• Equivalence class - The input is divided into similar classes. If one element of a class passes
the test, it is assumed that all the class is passed.
• Boundary values - The input is divided into higher and lower end values. If these values pass
the test, it is assumed that all values in between may pass too.
• Cause-effect graphing - In both previous methods, only one input value at a time is tested.
Cause (input) – Effect (output) is a testing technique where combinations of input values are
tested in a systematic way.
• Pair-wise Testing - The behaviour of software depends on multiple parameters. In pairwise
testing, the multiple parameters are tested pairwise for their different values.
• State-based testing - The system changes state on provision of input.
These systems are tested based on their states and input.
White-box testing
It is conducted to test program and its implementation, to improve code efficiency or structure. It is
also known as ‘Structural’ testing.

31
 Software Engineering

In this testing method, the design and structure of the code are known to the tester. Programmers of
the code conduct this test on the code.
The below are some White box testing techniques:
• Control-flow testing - The purpose of the control-flow testing to set up test cases which covers
all statements and branch conditions. The branch conditions are tested for both being true and
false, so that all statements can be covered.
• Data-flow testing - This testing technique emphasis to cover all the data variables included in
the program. It tests where the variables were declared and defined and where they were used
or changed.
Testing Levels
Testing itself may be defined at various levels of SDLC. The testing process runs parallel to software
development. Before jumping on the next stage, a stage is tested, validated, and verified.
Testing separately is done just to make sure that there are no hidden bugs or issues left in the software.
Software is tested on various levels -
Unit Testing
While coding, the programmer performs some tests on that unit of program to know if it is error free.
Testing is performed under white box testing approach. Unit testing helps developers decide that
individual units of the program are working as per requirement and are error free.
Integration Testing
Even if the units of software are working fine individually, there is a need to find out if the units if
integrated together would also work without errors. For example, argument passing and data Updation
etc.
System Testing
The software is compiled as product and then it is tested. This can be accomplished using one or more
of the following tests:
• Functionality testing - Tests all functionalities of the software against the requirement.
• Performance testing - This test proves how efficient the software is. It tests the effectiveness
and average time taken by the software to do desired task. Performance testing is done by
means of load testing and stress testing where the software is put under high user and data load
under various environment conditions.
• Security & Portability - These tests are done when the software is meant to work on various
platforms and accessed by number of persons.
 Software Engineering
Acceptance Testing
When the software is ready to hand over to the customer it must go through last phase of testing where
it is tested for user-interaction and response. This is important because even if the software matches
all user requirements and if user does not like the way it appears or works, it may be rejected.
• Alpha testing - The team of developer themselves perform alpha testing by using the system
as if it is being used in work environment. They try to find out how user would react to some
action in software and how the system should respond to inputs.
• Beta testing - After the software is tested internally, it is handed over to the users to use it under
their production environment only for testing purpose. This is not yet the delivered product.
Developers expect that users at this stage will bring minute problems, which were skipped to
attend.
Regression Testing
Whenever a software product is updated with new code, feature, or functionality, it is tested thoroughly
to detect if there is any negative impact of the added code.
This is known as regression testing.
Testing Documentation
Testing documents are prepared at different stages -
Before Testing
Testing starts with test cases generation. Following documents are needed for reference –
• SRS document - Functional Requirements document
• Test Policy document - This describes how far testing should take place before releasing the
product.
• Test Strategy document - This mentions detail aspects of test team, responsibility matrix and
rights/responsibility of test manager and test engineer.
• Traceability Matrix document - This is SDLC document, which is related to requirement
gathering process. As new requirements come, they are added to this matrix. These matrices
help testers know the source of requirement. They can be traced forward and backward.
While Being Tested
The following documents may be required while testing is started and is being done:
• Test Case document - This document contains list of tests required to be conducted. It
includes Unit test plan, Integration test plan, System test plan and Acceptance test plan.
• Test description - This document is a detailed description of all test cases and procedures to
execute them.
• Test case report - This document contains test case report because of the test.
• Test logs - This document contains test logs for every test case report.
After Testing
The following documents may be generated after testing:
Test summary - This test summary is collective analysis of all test reports and logs. It summarizes
and concludes if the software is ready to be launched. The software is released under version
control system if it is ready to launch.

33
 Software Engineering
Testing vs. Quality Control & Assurance and Audit
We need to understand that software testing is different from software quality assurance, software
quality control and software auditing.
• Software quality assurance - These are software development process monitoring means, by
which it is assured that all the measures are taken as per the standards of organization. This
monitoring is done to make sure that proper software development methods were followed.
• Software quality control - This is a system to maintain the quality of software product. It may
include functional and non-functional aspects of software product, which enhance the goodwill
of the organization. This system makes sure that the customer is receiving quality product for
their requirement and the product certified as ‘fit for use.’
• Software audit - This is a review of procedure used by the organization to develop the software.
A team of auditors, independent of development team examines the software process,
procedure, requirements, and other aspects of SDLC. The purpose of software audit is to check
that software and its development process, both conform standards, rules, and regulations.
Software Maintenance 2
Software maintenance is widely accepted part of SDLC now a days. It stands for all the modifications
and Updation done after the delivery of software product. There are number of reasons, why
modifications are required, some of them are briefly mentioned below:
• Market Conditions - Policies, which changes over the time, such as taxation and newly
introduced constraints like, how to maintain bookkeeping, may trigger need for modification.
• Client Requirements - Over the time, customer may ask for new features or functions in the
software.
• Host Modifications - If any of the hardware and/or platform (such as operating system) of the
target host changes, software changes are needed to keep adaptability.
• Organization Changes - If there is any business level change at client end, such as reduction of
organization strength, acquiring another company, organization venturing into new business,
need to modify in the original software may arise.
Types of maintenance
In a software lifetime, type of maintenance may vary based on its nature. It may be just a routine
maintenance tasks as some bug discovered by some user or it may be a large event based on
maintenance size or nature. Following are some types of maintenance based on their characteristics:
• Corrective Maintenance - This includes modifications and Updation done to correct or fix
problems, which are either discovered by user or concluded by user error reports.
• Adaptive Maintenance - This includes modifications and Updation applied to keep the
software product up-to date and tuned to the ever-changing world of technology and business
environment.
• Perfective Maintenance - This includes modifications and updates done to keep the software
usable over long period of time. It includes new features, new user requirements for refining the
software and improve its reliability and performance.
• Preventive Maintenance - This includes modifications and Updation to prevent future
problems of the software. It aims to attend problems, which are not significant at this moment
but may cause serious issues in future.
 Software Engineering
Cost of Maintenance
Reports suggest that the cost of maintenance is high. A study on
estimating software maintenance found that the cost of
maintenance is as high as 67% of the cost of entire software
process cycle.

On an average, the cost of software maintenance is more than 50%

of all SDLC phases. There are various factors, which trigger maintenance cost go high, such as:
Real-world factors affecting Maintenance Cost
• The standard age of any software is considered up to 10 to 15 years.
• Older software’s, which were meant to work on slow machines with less memory and storage
capacity cannot keep themselves challenging against newly coming enhanced software’s on
modern hardware.
• As technology advances, it becomes costly to maintain old software.
• Most maintenance engineers are newbie and use trial and error method to rectify problem.
• Often, changes made can easily hurt the original structure of the software, making it hard for
any subsequent changes.
• Changes are often left undocumented which may cause more conflicts in future.
Software-end factors affecting Maintenance Cost
• Structure of Software Program
• Programming Language
• Dependence on external environment
• Staff reliability and availability
Maintenance Activities
IEEE provides a framework for sequential maintenance process activities. It can be used in iterative
manner and can be extended so that customized items and processes can be included.

These activities go together with each of the following phase:

• Identification & Tracing - It involves activities
pertaining to identification of requirement of
modification or maintenance. It is generated by user or
system may itself report via logs or error messages.
Here, the maintenance type is classified also.
• Analysis - The modification is analysed for its impact on
the system including safety and security implications. If probable impact is severe, alternative
solution is looked for. A set of required modifications then materialized into requirement
specifications. The cost of modification/maintenance is analysed, and estimation is concluded.
• Design - New modules, which need to be replaced or modified, are designed against
requirement specifications set in the previous stage. Test cases are created for validation and
verification.

35
 Software Engineering
• Implementation - The new modules are coded with the help of structured design created in the
design step. Every programmer is expected to do unit testing in parallel.
• System Testing - Integration testing is done among newly created modules. Integration testing
is also carried out between new modules and the system. Finally, the system is tested as a
whole, following regressive testing procedures.
• Acceptance Testing - After testing the system internally, it is tested for acceptance with the
help of users. If at this state, user complaints some issues they are addressed or noted to
address in next iteration.
• Delivery - After acceptance test, the system is deployed all over the organization either by small
update package or fresh installation of the system. The final testing takes place at client end
after the software is delivered.
Training facility is provided if required, in addition to the hard copy of user manual.
• Maintenance management - Configuration management is an essential part of system
maintenance. It is aided with version control tools to control versions, semi-version, or patch
management.
Software Re-engineering
When we need to update the software to keep it to the current market, without impacting its
functionality, it is called software re-engineering. It is a thorough process where the design of software
is changed, and programs are re-written.
Legacy software cannot keep tuning with the latest technology available in the market. As the hardware
become obsolete, updating of software becomes a headache. Even if software grows old with time, its
functionality does not.
For example, initially Unix was developed in assembly language. When language C came into existence,
Unix was re-engineered in C, because working in assembly language was difficult.
Other than this, sometimes programmers notice that few parts of software need more maintenance
than others and they also need re-engineering.

Re-Engineering Process
• Decide what to re-engineer. Is it whole software or a part of it?
• Perform Reverse Engineering, to obtain specifications of
existing software.
• Restructure Program if required. For example, changing
function-oriented programs into object-oriented programs.
• Re-structure data as required.
• Apply Forward engineering concepts to get re-engineered software.
There are few important terms used in Software re-engineering.
Reverse Engineering
It is a process to achieve system
specification by thoroughly
analysing, understanding the
existing system. This process
 Software Engineering
can be seen as reverse SDLC model, i.e., we try to get higher abstraction level by analysing lower
abstraction levels.
An existing system is previously implemented design, about which we know nothing. Designers then
do reverse engineering by looking at the code and try to get the design. With design in hand, they try to
conclude the specifications. Thus, going in reverse from code to system specification.

Program Restructuring
It is a process to re-structure and re-construct the existing software. It is all about re-arranging the
source code, either in same programming language or from one programming language to a different
one. Restructuring can have either source code-restructuring and data-restructuring or both.
Re-structuring does not impact the functionality of the software but enhance reliability and
maintainability. Program components, which cause errors very frequently can be changed, or updated
with re-structuring.
The dependability of software on obsolete hardware platform can be removed via re-structuring.
Forward Engineering
Forward engineering is a process of
obtaining desired software from the
specifications in hand which were brought
down by means of reverse engineering. It
assumes that there was some software engineering already done in the past.
Forward engineering is same as software engineering process with only one difference – it is carried
out always after reverse engineering.

37