Unit - 5 Software Maintenance and Software Project Management

Software As an Evolutionary Entity

The term "evolution" refers to a gradual process of change and development over time, often
leading to improvement, adaptation, or increased complexity.

In General:

Evolution means a slow and continuous process of growth, development, or transformation.

It can apply to natural phenomena, ideas, technologies, societies, and more.
In Different Contexts:
1. Biology:
Evolution is the process by which living organisms change over generations through natural
selection and genetic variation.
2. Technology/Software:
Evolution refers to the progressive development of systems or software, adapting to new
requirements, environments, or user needs.
3. Social/Cultural:
Evolution describes how cultures, languages, or societies transform over time.

The phrase "Software as an Evolutionary Entity" means that software is not static; it constantly
changes and evolves over time in response to new requirements, technologies, environments,
and user expectations—similar to how living organisms evolve.
1. Continuous Change:
Software needs regular updates to fix bugs, add features, improve performance, or adapt to
new hardware/software environments.
2. Growing Complexity:
As more features are added, software becomes more complex and harder to manage—unless it
is carefully designed.
3. Adaptation:
Just like organisms adapt to survive, software must adapt to survive in a competitive and fast-
changing technology landscape.
4. Maintenance:
Most of the software’s lifecycle is spent in maintenance and enhancement, not in initial
development.
5. User-driven Evolution:
Feedback from users influences how software changes and improves.

Real-Life Example: Google Chrome

Initial version: Simple web browser for fast browsing.
Later versions: Added features like incognito mode, tab grouping, performance optimization,
extension support, dark mode, etc.
Why? Users wanted better privacy, speed, customization, and compatibility with modern
websites.
Google Chrome keeps evolving to meet new user needs, security demands, and technology
trends.

What is Software Maintenance?

Software maintenance means making changes to a software program after it has been
delivered, to keep it working well, fix problems, or improve it. Just like machines or cars need
regular care, software also needs updates and fixes over time.

Why is Software Maintenance Needed?

1. To Fix Bugs (Errors):

Sometimes users find errors after using the software. These need to be corrected.
Example: If a mobile app crashes when you press a button, the developer will fix that in the next
update.

2. To Improve Performance:
Developers may improve the speed, security, or memory usage of software.
Example: A new version of the app loads faster and uses less battery.

3. To Add New Features:

Users may request new functions, or the company may want to update the software.
Example: Adding a dark mode to a mobile app after user feedback.

4. To Adapt to New Environments:

Technology keeps changing—new hardware, new operating systems, etc. Software must adapt.
Example: Updating software to work on the latest version of Windows or Android.

5. To Remove Outdated Functions:

Some features may become useless or unnecessary over time and should be removed.
Example: Removing support for old file formats that no one uses anymore.

Types of Software Maintenance

Corrective Maintenance-
This type of maintenance involves fixing bugs or errors found in the software after it has been
released.
Example:
Imagine you have developed an e-commerce app. After launch, users report that the "Add to
Cart" button is not working properly. When you fix this issue by modifying the code, it is
called Corrective Maintenance.

2. Adaptive Maintenance
This maintenance is done to make the software adaptable to changes in the environment such
as new operating systems, hardware, or third-party software.

Example:
Your app was working fine on Android 11, but now Android 14 is released and your app crashes
on it. You update your code to make the app compatible with Android 14. This is Adaptive
Maintenance.

3. Perfective Maintenance
This involves improving or enhancing the software’s functionality based on user feedback or
new requirements, even if the system is working correctly.

Example:
Your fitness tracking app currently tracks steps. Based on user requests, you add a feature to
track sleep and water intake as well. This enhancement is Perfective Maintenance.

4. Preventive Maintenance
This type of maintenance focuses on detecting and fixing potential issues before they become
real problems. It also includes optimizing the software for better performance in the future.

Example:
You analyze your website and find some outdated code that may slow down performance in the
future. You refactor and clean up that code in advance. This is Preventive Maintenance.

Reverse Engineering
Reverse engineering is the process of analyzing a system, product, or software to identify its
components, structure, and functioning — usually with the aim of understanding how it works or
how it was built, especially when the original design or source code is not available.

In software engineering, reverse engineering involves examining an existing software

application (often without source code or documentation) to extract knowledge about its
architecture, functionality, and design.

Why is Reverse Engineering Used?

To understand old or undocumented software systems (legacy systems).

To recreate or enhance software when original developers or source code are unavailable.
To identify security vulnerabilities or analyze malware.
To ensure compatibility or integration with other systems.
For academic or learning purposes (ethical use).
Note: Reverse engineering copyrighted software without permission can be illegal or unethical.
Key Activities in Reverse Engineering
1. Code Analysis – Reviewing the machine code or executable to understand logic.
2. System Decomposition – Breaking the system into parts (UI, logic, database).
3. Design Recovery – Reconstructing design diagrams like UML or data flow diagrams.
4. Documentation Generation – Creating missing documentation.
Real-Life Example
Example 1: Legacy Software Understanding
A bank uses a 20-year-old software for handling transactions. The original developers left years
ago, and there’s no documentation or source code available. To upgrade or integrate this
system with a new mobile banking app, engineers perform reverse engineering:
They study the behavior of the current software.
They monitor database queries, input-output behavior, and system flow.
They recreate models or diagrams to understand how it functions.
Using this knowledge, they build a compatible modern application or safely upgrade the old one.

Software Re- Engineering

Software Re-engineering is the process of improving or transforming an existing software
system to meet current needs without completely rewriting it. It focuses on updating or
enhancing the software's design, functionality, or architecture while maintaining its core
behavior.
Software Re-engineering is the process of analyzing and modifying existing software to improve
its performance, maintainability, or to adapt it to new technologies—without changing its core
functionality.

It helps in:

Reducing maintenance cost

Adapting software to new hardware or platforms

Improving code readability and structure

Adding new features more easily

Key Steps in Re-engineering:

1. Reverse Engineering – Understand the existing system (code, structure, documentation)

2. Analysis – Identify issues in performance, design, or structure

3. Restructuring/Refactoring – Improve code quality and architecture

4. Forward Engineering – Rebuild or upgrade the software using modern technologies

Example:

Let’s say a school uses a software for managing student records. It was developed in 2005
using Visual Basic 6 and MS Access.

Problems:

It only works on Windows XP

It’s slow and crashes often

It lacks support for online access or mobile usage

Adding new features (like online attendance or fee payment) is difficult

Re-engineering Approach:

1. Reverse Engineering
Developers study the existing VB code and database structure to understand how it works.

2. Analysis
They find issues like bad database design, poor UI, and lack of modularity in code.

3. Restructuring
Code is refactored and divided into reusable modules. The database is redesigned using
MySQL.

4. Forward Engineering
The application is re-developed using modern technologies like Java, Python or PHP with a web
interface—keeping the same core functionalities, but improving user experience and
performance.

Result:
The new version is faster, easier to maintain, supports online access, and can be extended for
new features.
Why Choose Re-engineering Over a Complete Rewrite?

Cost-Effective: Re-engineering is usually cheaper and faster than building an entirely new
system from scratch.

Minimized Risk: Since the core system is retained, there’s less risk of new, untested features
causing problems.
Preserves Functionality: The existing software’s core functionality remains intact, meaning users
can still rely on it while improvements are made.

In Simple Words:
Software re-engineering is like renovating an old house instead of building a new one. You fix
what’s broken, upgrade the parts that are outdated, and make the house better without
demolishing it. In software, this means improving an old system so it works better, looks better,
and can handle new technologies or user needs.

Software Configuration Management

Software Configuration Management is the process of systematically tracking, organizing, and
controlling changes in software during its development and maintenance.

Key Objectives:

Maintain integrity and traceability of the software.

Ensure that changes are made in a controlled and systematic way.

Prevent conflicts and confusion from multiple developers working on the same code.

Main Activities in SCM:

1. Version Control – Tracking changes in source code over time.

2. Change Control – Approving and managing modifications to the software.

3. Build Management – Automating the process of compiling and building the software.

4. Release Management – Handling the delivery of software versions to users.

5. Configuration Identification – Defining the items that need to be controlled.

Tools Used:

Git

SVN (Subversion)

Mercurial

CVS
SCM Activities
Configuration Identification
What: Identify all the parts of the software that need to be managed.
Example: Listing all code files, documents, images, and databases used in your project.

2. Configuration Control (Change Control)

What: Manage changes to the software in an organized way.
Example: If someone wants to change the login page, the change must be reviewed and
approved first.

3. Version Control
What: Keep records of every change made to the software.
Example: You saved Version 1.0 of your project today, and after adding a feature tomorrow, you
save Version 1.1.

4. Configuration Status Accounting

What: Keep track of all items and changes made over time.
Example: A report that tells you which version of which file was used in the last release.

5. Configuration Auditing
What: Check if all parts of the software are correct and follow the rules.
Example: Before submitting your project, someone checks that all files are there and properly
named.

6. Build and Release Management

What: Make sure the software is built correctly and released in a planned way.
Example: Finalizing your project and giving it to the user as a complete version (like a packaged
app or file).

What is Software Version Control?

Software Version Control is a system that helps track and manage changes to software code
over time. It allows multiple developers to work on the same project without overwriting each
other's work, and helps you go back to an earlier version if something goes wrong.

Key Features of Version Control:

1. Track Changes: Every time you save (or "commit") your code, the version control system
saves that version.

2. Collaboration: Many developers can work on different parts of the code at the same time.

3. Rollback: If a mistake is made, you can undo the changes and go back to a previous version.

4. Branching and Merging: Developers can work on separate features or fixes in parallel
(branches), and later combine (merge) them into the main code.
What is the COCOMO Model?
COCOMO Model is a procedural cost estimate model for Software Projects and is often used as
a process of reliably predicting the various parameters associated with making a project such as
size, effort, cost, time, and quality.

The key parameters that define the quality of any Software Product, which are also an outcome
of COCOMO, are primarily effort and schedule.

Types of Projects in COCOMO Model

In the COCOMO model, software projects are categorized into three types based on their
complexity, size, and the development environment. These types are:

1. Organic
A software project is said to be an organic type if the team size required is adequately small, the
problem is well understood and has been solved in the past and also the team members have a
nominal experience regarding the problem.

2. Semi-detached
A software project is said to be a Semi-detached type if the vital characteristics such as team
size, experience, and knowledge of the various programming environments lie in between
organic and embedded.

The projects classified as Semi-Detached are comparatively less familiar and difficult to develop
compared to the organic ones and require more experience better guidance and creativity. Eg:
Compilers or different Embedded Systems can be considered Semi-Detached types.

3. Embedded
A software project requiring the highest level of complexity, creativity, and experience
requirement falls under this category. Such software requires a larger team size than the other
two models and also the developers need to be sufficiently experienced and creative to develop
such complex models.

Risk analysis and management in software engineering is the process of identifying,

assessing, and controlling risks that could affect the success of a software project.

What is a Risk?

A risk is a potential problem — an event that may or may not happen — that can negatively
impact a project’s:

Cost

Schedule
Performance

Quality

Risk Management Process

1. Risk Identification

Find all possible risks.

Example: “The team has never used this programming language before.”

2. Risk Analysis

Estimate the likelihood and impact of each risk.

Prioritize them using Risk Exposure = Probability × Impact

3. Risk Planning (Mitigation)

Create plans to reduce the chances of the risk or lessen its impact.
Example: Provide training on the new technology.

4. Risk Monitoring and Control

Regularly review risks during the project.
Take action if a risk begins to occur.

Software project risks can be classified into several categories based on their nature and
source. Here are the main types of risks:

1. Project Risks
These are related to project management and planning.
Examples:
Poor project planning
Inaccurate time or cost estimation
Unclear roles and responsibilities
Lack of stakeholder support

2. Technical Risks

These come from technology, tools, or technical processes.

Examples:
Using new or untested technology
Integration problems between modules
Performance issues
Incomplete technical specifications

3. Business Risks
These affect the overall business value of the software.

Examples:
Changing customer requirements
Product no longer needed
Market competition changes
Budget cuts or funding issues

4. People Risks
Related to the development team and stakeholders.
Examples:
Lack of skilled developers
Team member leaves
Poor communication
Low morale or motivation
5. Process Risks
Arise from ineffective development processes.
Examples:
No defined development process
Ignoring quality standards
Lack of testing or documentation
6. External Risks
Come from outside the project team or company.
Examples:
Government regulation changes
Natural disasters
Cybersecurity threats
Third-party vendor failure