Software Maintenance

Chapter 7: Software Maintenance

Acronyms

Acronym	Full Form
API	Application Programming Interface
CI	Continuous Integration
IEC	The International Electrotechnical Commission
IEEE	The Institute of Electrical and Electronics Engineers
ISO	International Organization for Standardization
ΚΑ	Knowledge Area
LOC	Lines of Code
MR	Modification Request
PR	Problem Report
SCM	Software Configuration Management
SEE	Software Engineering Environment
SLA	Service-Level Agreement
SQA	Software Quality Assurance
V&V	Verification and Validation

Introduction

Software maintenance is an integral part of the software life cycle, though it has historically received less attention than initial development. This is changing as organizations, influenced by practices like DevOps, seek to continuously evolve software while ensuring smooth operation.

Once software is delivered, it must evolve. Defects are found, operating environments change, and new user requirements emerge. Software maintenance is defined as the totality of activities required to provide cost-effective support for software. These activities occur both pre-delivery (planning for operations and maintainability) and post-delivery (modification, training, and help desk support).

Breakdown of Topics for Software Maintenance

The Software Maintenance KA is broken down into the following major topics:

Software Maintenance Fundamentals
Key Issues in Software Maintenance
Software Maintenance Processes
Software Maintenance Techniques
Software Maintenance Tools

1. Software Maintenance Fundamentals

This section introduces the core concepts and terminology of software maintenance.

1.1 Definitions and Terminology

According to the international standard (ISO/IEC/IEEE 14764), the objective of software maintenance is to modify existing software while preserving its integrity. This process involves activities performed both before and after the software is delivered.

1.2 Nature of Software Maintenance

Software maintenance sustains a product throughout its operational life. A maintainer monitors the software, logs and tracks modification requests (MRs) and problem reports (PRs), determines the impact of changes, modifies code, tests, and releases new versions. A key challenge arises when the original developers are no longer available, forcing maintainers to understand and evolve complex artifacts created by others.

1.3 Need for Software Maintenance

Maintenance is essential to ensure software continues to satisfy user requirements. While often perceived as just fixing bugs, studies show that over 80% of maintenance work involves non-corrective activities like enhancements and adaptations. Maintenance is performed to:

Correct faults.
Improve design or performance.
Implement enhancements.
Adapt to changes in the operating environment (e.g., new OS).
Prevent security threats.
Retire the software.

1.4 Majority of Maintenance Costs

A common misconception is that bug fixes constitute the majority of maintenance costs. In reality, most of the financial resources are spent on enhancements and adaptations. Factors that impact maintenance costs include the operating environment (hardware, software) and organizational factors (policies, personnel).

1.5 Evolution of Software

Research by Lehman and others led to eight “Laws of Software Evolution,” which describe how large software systems change over time. The key takeaways are:

Continuing Change: A system must be adapted, or it will become less useful.
Increasing Complexity: As a system evolves, its complexity increases unless work is done to reduce it.
Continuing Growth: The functional content of a system must be continually increased to maintain user satisfaction.

Essentially, large software systems are never truly “complete” and must evolve, which makes maintenance a form of continued development.

1.6 Categories of Software Maintenance

The international standard ISO/IEC/IEEE 14764 classifies maintenance activities into several categories, which can be grouped into Corrections and Enhancements.

Corrective Maintenance: Reactive modification to fix problems discovered after delivery.
Preventive Maintenance: Proactive modification to correct latent faults before they manifest as failures.
Adaptive Maintenance: Modification to keep software usable in a changing environment (e.g., updating for a new OS version).
Additive Maintenance: Modification to add new functionality or features to the software.
Perfective Maintenance: Modification to improve performance, maintainability, or other quality attributes without changing functionality.
Emergency Maintenance: Unscheduled modification to temporarily keep a system operational pending a proper fix.

2. Key Issues in Software Maintenance

Effective maintenance requires addressing unique technical and management challenges.

2.1 Technical Issues

2.1.1 Limited Understanding

A significant portion of maintenance effort is spent just trying to understand how the existing software works, especially when it was developed by someone else. Comprehension depends on domain knowledge, documentation quality, and programming practices.

2.1.2 Testing

The cost of fully re-testing a large system after a change can be prohibitive. Regression testing—the selective re-testing of a system to verify that modifications have not caused unintended effects—is crucial but challenging. It can be difficult to take critical software offline for testing.

2.1.3 Impact Analysis

Impact analysis is the process of assessing the effects of a proposed change. It identifies all system components that would be affected and estimates the resources and risks involved. A thorough impact analysis is essential for making informed decisions about whether and how to proceed with a change.

2.1.4 Maintainability

Maintainability is a quality characteristic that measures the ease with which software can be modified. It should be a focus during initial development to reduce future maintenance costs. Poor maintainability leads to technical debt, which is the implied cost of rework caused by choosing an easy (limited) solution now instead of using a better approach that would take longer.

2.2 Management Issues

2.2.1 Alignment with Organizational Objectives

Initial development is often project-based, with a fixed budget and timeline. Maintenance, in contrast, aims to extend a product’s life. This can create a conflict where adding new features is prioritized over essential maintenance tasks (like refactoring or performance improvements), leading to code decay and technical debt.

2.2.2 Staffing

Maintenance work is sometimes perceived as less glamorous than new development, which can impact morale and staff retention. Valuing the contribution of maintainers is essential, as they perform a critical function that constitutes a significant portion of the software life cycle.

2.2.3 Process

Maintenance requires several processes not typically found in development, such as managing a help desk, handling transitions from development, and specific procedures for accepting or rejecting modification requests.

2.2.4 Supplier Management

Maintenance is often outsourced. This requires careful management of contracts and Service-Level Agreements (SLAs) to ensure quality. Models range from using a single supplier to multi-sourcing, where services from multiple vendors are integrated.

2.2.5 Organizational Aspects of Maintenance

Organizations must decide who performs maintenance.

Developer as Maintainer: Common in Agile models. It keeps knowledge within the team but can disrupt new development when failures occur.
Separate Maintenance Team: Allows developers to focus on new projects but requires a formal handoff process, which can lead to friction and knowledge loss.

The decision depends on the context, but quality documentation and a clear delegation of tasks are critical regardless of the structure.

2.3 Software Maintenance Costs

2.3.1 Technical Debt Cost Estimation

Technical debt makes code more expensive to maintain. It represents the future effort required to fix problems (e.g., poor design, lack of tests) that remain in the code after a release. Tools can help measure technical debt by analyzing code complexity, architectural violations, and other quality indicators.

2.3.2 Maintenance Cost Estimation

Estimating maintenance costs is a key planning activity. Estimates should be prepared early and updated as the project progresses. Factors to include are personnel costs, training, tools, software licenses, and travel.

2.4 Software Maintenance Measurement

Measuring maintenance activities helps organizations understand where effort is spent and how to improve. Key metrics relate to the characteristics of maintainability:

Analyzability: Effort required to diagnose failures or identify parts to modify.
Modifiability: Effort to implement a change without introducing defects.
Testability: Effort needed to test modified software.
Modularity: Degree to which components are independent.
Reusability: How well a component can be used in other contexts.

3. Software Maintenance Processes

Maintenance processes, as defined by ISO/IEC/IEEE 14764, provide a framework for the activities required to modify and support operational software.

3.1 Software Maintenance Activities and Tasks

While maintainers perform many of the same tasks as developers (analysis, design, coding, testing), some activities are unique to maintenance:

Program Understanding: Gaining knowledge of how an existing system works.
Transition: The controlled transfer of software from the development team to the maintenance team.
Modification Request (MR) Acceptance/Rejection: A formal process for deciding whether to undertake requested work.
Maintenance Help Desk: A function to support end-users and trigger the assessment of problems and modification requests.
Impact Analysis: Assessing the consequences of a proposed change before implementation.
Configuration Management: Controlling changes to the software and its documentation, which is especially critical in maintenance due to the high volume of small changes.
Software Quality: Implementing processes for Software Quality Assurance (SQA), Verification and Validation (V&V), reviews, and audits to ensure the integrity of the software is maintained.

4. Software Maintenance Techniques

These are commonly used techniques to aid in the maintenance process.

4.1 Program Comprehension

Maintainers spend considerable time reading and understanding code. Tools like code browsers, which organize and present source code, are essential. Clear and concise documentation is also a critical aid.

4.2 Software Reengineering

Reengineering is the process of examining and altering software to reconstitute it in a new form, often to improve maintainability or migrate from a legacy platform. A key reengineering technique is refactoring, which reorganizes a program’s internal structure to improve it without changing its external behavior.

4.3 Reverse Engineering

Reverse engineering is the process of analyzing software to identify its components and their relationships, creating representations at a higher level of abstraction (e.g., creating a design model from source code). Unlike reengineering, it is a passive process that does not change the software.

4.4 Continuous Integration, Delivery, Testing and Deployment

Modern DevOps practices automate the build, testing, and deployment pipeline.

Continuous Integration (CI): Frequently merging code changes from all developers into a shared mainline, with each merge verified by an automated build and test.
Continuous Delivery/Deployment (CD): Automating the release of software to staging or production environments. These practices enable faster, more reliable delivery of maintenance updates.

4.5 Visualizing Maintenance

Visualization tools help maintainers understand the structure, dependencies, and evolution of complex software systems. They provide graphical representations that make it easier to analyze dependencies, trace changes, and make informed decisions.

5. Software Maintenance Tools

Tools are critical for effective maintenance. They are often integrated into a broader Software Engineering Environment (SEE). Key tool categories include:

Configuration Management and Version Control Tools: For tracking changes (e.g., Git).
Static and Dynamic Analyzers: For inspecting code without executing it (static) or tracing its execution path (dynamic).
Program Slicers: To isolate only the parts of a program affected by a change.
Dependency Analyzers: To understand interrelationships between components.
Reverse Engineering Tools: To create higher-level abstractions from existing code.
Software Quality Assessment Tools: To measure technical debt and code quality.