Software Maintenance & Evolution: Types, Challenges & Strategies

Key Concepts and Definitions

What is Software Maintenance?

Software maintenance is the modification of a software product after delivery to correct faults, improve performance, or adapt to a changed environment. It is not a one-time activity but an ongoing process that ensures software remains useful, efficient, and relevant.

stateDiagram-v2
    [*] --> Idle: Software Deployed
    Idle --> Corrective: Fault Reported
    Idle --> Adaptive: Environment Change
    Idle --> Perfective: Performance Request
    Idle --> Preventive: Risk Mitigation
    Corrective --> Idle: Fix Applied
    Adaptive --> Idle: Update Applied
    Perfective --> Idle: Enhancement Applied
    Preventive --> Idle: Patch Applied

Types of Software Maintenance

In the Real World

1. eSewa (Corrective & Adaptive Maintenance)

   • When users report payment failures, eSewa’s team fixes the bug (corrective).
   • When Nepal’s tax laws change, eSewa updates its tax calculation logic (adaptive).

2. Khalti (Perfective & Preventive Maintenance)

   • Khalti adds QR code payments (perfective) to improve user experience.
   • After a security vulnerability is found, Khalti patches the system (preventive).

3. NTC (National Telecom) Network Upgrades (Adaptive Maintenance)

   • When 5G technology arrives, NTC must update its infrastructure to support new speeds (adaptive).
   • If old routers fail, NTC replaces them with faster models (corrective).

Software Evolution

Software evolution refers to the long-term growth and adaptation of software to meet new requirements, technologies, and business needs. It involves:

• Forward Engineering: Building software from scratch (used in initial development).
• Reverse Engineering: Analyzing existing software to understand its structure (used in maintenance).
• Redesign: Restructuring software to improve maintainability.

Reverse Engineering Example: eSewa’s Payment System

Suppose eSewa’s old payment system is hard to modify because its code is poorly documented. The team uses reverse engineering to:

1. Decompile the old system to understand its architecture.
2. Document key components (e.g., payment gateway, user authentication).
3. Redesign the system using modular design for easier future updates.

sequenceDiagram
    participant User
    participant OldSystem
    participant Analyst
    participant NewSystem

    User->>OldSystem: Reports Bug (e.g., Payment Failure)
    OldSystem-->>Analyst: Undocumented Code
    Analyst->>Analyst: Reverse Engineer (Decompile, Document)
    Analyst->>NewSystem: Redesign with Modular Structure
    NewSystem->>User: Fixed & Improved Payment Flow

Challenges in Software Maintenance

Maintenance Strategies for Long-Term Success

Worked Example: NTC’s Network Maintenance

Scenario: NTC’s old fiber-optic network is slow and unreliable in Kathmandu. The team must decide how to maintain it.

Step 1: Identify Maintenance Type

• Corrective: Fix current failures (e.g., broken cables).
• Perfective: Upgrade bandwidth for faster speeds.
• Adaptive: Integrate with 5G for future compatibility.
• Preventive: Replace old routers before they fail.

Step 2: Choose a Strategy

• Modular Upgrade: Replace only faulty routers first (cost-effective).
• Full Redesign: Migrate to a new fiber network (expensive but future-proof).

Step 3: Implement & Test

• Phase 1: Fix critical failures (corrective).
• Phase 2: Upgrade bandwidth (perfective).
• Phase 3: Test with 5G-ready hardware (adaptive).

flowchart TD
    A["Old Network"] -->|"Corrective"| B["Fix Broken Cables"]
    A -->|"Perfective"| C["Upgrade Bandwidth"]
    A -->|"Adaptive"| D["5G Integration"]
    A -->|"Preventive"| E["Replace Routers"]
    B --> F["Stable Network"]
    C --> F
    D --> F
    E --> F
    F --> G["Future-Proof Network"]

Exam Tip

1. Define Clearly: Always distinguish between maintenance types (corrective vs. adaptive vs. perfective).
2. Real-World Links: Exams often ask for Nepali examples (e.g., eSewa, Khalti, NTC). Relate theory to these.
3. Diagrams Matter: Draw state diagrams for maintenance workflows or sequence diagrams for reverse engineering.
4. Challenges vs. Strategies: Compare problems (high cost, poor docs) with solutions (modular design, Git).
5. Worked Examples: If asked to design a maintenance plan, follow:
   • Identify type (corrective/adaptive/perfective).
   • Choose strategy (modular, automated testing).
   • Show steps (e.g., "Phase 1: Fix bugs, Phase 2: Add features").