Software Maintenance & Evolution: Types, Challenges & Strategies

Why Maintenance? The Hidden 70% of Software Costs

Software doesn’t just “work and forget.” Studies show 70–80% of a system’s lifetime costs come after deployment. Why?

• Bugs slip through (even in Agile/DevOps).
• User needs change (e.g., Ncell adding UPI payments).
• Technology becomes obsolete (e.g., Daraz migrating from PHP to microservices).
• Regulations evolve (e.g., NEPSE’s new compliance rules for stock apps).

stateDiagram-v2
    [*] --> Software_Deployment
    Software_Deployment --> Maintenance_Phase: 70-80% of costs here!
    Maintenance_Phase --> Corrective: Fix bugs
    Maintenance_Phase --> Adaptive: Change environment
    Maintenance_Phase --> Perfective: Improve performance
    Maintenance_Phase --> Preventive: Avoid future issues
    Maintenance_Phase --> Evolution: Major redesigns
    Maintenance_Phase --> [*]

Types of Software Maintenance

The syllabus divides maintenance into four categories, each with distinct goals and techniques.

1. Corrective Maintenance: Fixing the Broken

Definition: Identifying and repairing faults (bugs, crashes, security flaws) in live software. Example: When eSewa’s payment gateway failed during Dashain 2022 due to a race condition in transaction logging, developers had to patch the concurrency bug under pressure.

How It Works

1. Problem Reporting: Users/file logs report issues (e.g., NullPointerException in a Daraz order processing script).
2. Diagnosis: Use debuggers (GDB, Visual Studio Debugger), logging frameworks (Log4j), or static analysis tools (SonarQube).
3. Fix: Write a patch (e.g., adding input validation).
4. Testing: Regression testing to ensure the fix doesn’t break other features.
5. Deployment: Hotfix (emergency) or scheduled update.

Real-World Trace: Pathao’s Driver App Crash

• Symptom: App crashes when GPS signal drops in Kathmandu’s narrow alleys.
• Root Cause: Unhandled LocationManager exceptions.
• Fix: Added a fallback to cached locations + retry logic.
• Tool Used: Firebase Crashlytics for real-time crash analytics.

2. Adaptive Maintenance: Keeping Up with Change

Definition: Modifying software to adapt to changes in the environment (hardware, OS, laws, or user needs). Example: When NTC upgraded Nepal’s internet infrastructure to fiber, many websites had to update their HTTP request timeouts and compression algorithms.

Common Adaptation Scenarios

Worked Example: NEPSE’s API Changes

• Old System: REST API with JSON responses (2018).
• New Requirement: Real-time WebSocket updates for stock prices (2023).
• Adaptation:
  • Added WebSocket endpoint /live-prices.
  • Updated frontend to handle both REST and WebSocket.
  • Tool: Postman for API versioning tests.

3. Perfective Maintenance: Making It Better

Definition: Enhancing non-functional attributes (speed, security, usability) or adding new features without changing core functionality. Example: WhatsApp’s end-to-end encryption (2016) was a perfective maintenance—it didn’t break existing chats but added security.

Common Perfective Tasks

• Performance tuning: Optimizing SQL queries (e.g., Daraz’s MySQL indexes for product searches).
• Security patches: Fixing vulnerabilities (e.g., Heartbleed in OpenSSL).
• Usability improvements: Redesigning UI/UX (e.g., Khalti’s one-tap payment flow).
• Localization: Adding Nepali language support (e.g., Google Maps in Nepalese).

Visual: Before vs. After Optimization

flowchart LR
    A["Slow Query: 'SELECT * FROM orders WHERE status='pending''"] -->|"Before"| B["1.2s response time"]
    A -->|"After adding INDEX on status"| C["80ms response time"]

4. Preventive Maintenance: Avoiding Future Problems

Definition: Proactively modifying software to prevent future failures or maintenance needs. Example: Google’s use of static analysis tools (like Error Prone) to catch bugs before they reach production.

Preventive Techniques

Real-World Example: Pathao’s Microservices

• Problem: Monolithic app led to slow deployments.
• Prevention: Split into microservices (e.g., payment-service, ride-service) with Docker + Kubernetes.
• Tool: SonarQube for continuous code quality checks.

Software Evolution: Beyond Maintenance

While maintenance is reactive, evolution is proactive—it involves major redesigns to meet new requirements or technologies.

Lehman’s Laws of Software Evolution

Three key principles (critical for exams!):

1. Continuing Change: Software must evolve or become obsolete.
2. Increasing Complexity: Without refactoring, systems grow harder to maintain.
3. Self-Regulation: Markets drive evolution (e.g., WhatsApp replacing SMS).

Visual: Lehman’s Laws in Action

mindmap
  root((Lehman's Laws))
    Continuing_Change
      Example: eSewa adding QR payments
    Increasing_Complexity
      Example: Monolithic apps → Microservices
    Self_Regulation
      Example: Ncell’s USSD → Mobile App shift

Evolution Strategies

Worked Example: Khalti’s Evolution

1. 2016: Basic mobile wallet (perfective maintenance).
2. 2018: Added API for merchants (adaptive maintenance).
3. 2020: Full banking-as-a-service platform (evolution).
4. 2023: Integrated with NPCI’s RuPay (regulatory adaptive maintenance).

Maintenance vs. Evolution: Key Differences

In the Real World

1. eSewa’s API Maintenance

   • Type: Adaptive + Perfective
   • How: When NPCI mandated new encryption standards (2022), eSewa had to:
     • Update their payment gateway to use AES-256 (adaptive).
     • Add real-time fraud detection (perfective).
   • Tool: Postman for API versioning tests + GitHub Actions for CI/CD.

2. WhatsApp’s End-to-End Encryption

   • Type: Perfective Maintenance → Evolution
   • How:
     • 2014–2016: Added Signal Protocol for encryption (perfective).
     • 2016–2023: Became a standard for messaging apps (evolution).
   • Impact: Forced competitors (e.g., Telegram) to adopt similar security.

3. NTC’s Fiber Upgrade Challenges

   • Type: Adaptive Maintenance
   • Problem: Older ISPs’ software couldn’t handle 1Gbps speeds.
   • Solution: NTC provided SDK updates for ISPs to optimize TCP window scaling and QoS policies.
   • Tool: Wireshark for packet analysis during testing.

Challenges in Software Maintenance

Tools for Maintenance and Evolution

Exam Tip

What Examiners Want to See

1. Definitions with Examples

   • Don’t just say “corrective maintenance is fixing bugs.” Give a real example (e.g., “Like when Daraz’s checkout page crashed during Black Friday due to a race condition in the cart service”).

2. Lehman’s Laws

   • Always relate them to Nepali software (e.g., “Ncell’s app becomes more complex each year because new features like UPI are added, following Lehman’s Increasing Complexity law”).

3. Tool Names

   • Mention specific tools in answers:
     • Debugging → GDB or Visual Studio Debugger
     • Testing → Jest or Selenium
     • Version control → GitHub Actions

4. Comparison Tables

   • Examiners love structured comparisons (e.g., maintenance vs. evolution, adaptive vs. perfective).

5. Real-World Scenarios

   • Tie every concept to Nepal:
     • “eSewa’s API updates are an example of adaptive maintenance because they had to change their system to comply with NPCI’s new security standards.”
     • “Pathao’s driver app crashes during peak hours are fixed via corrective maintenance using Firebase Crashlytics.”

Common Pitfalls to Avoid

• ❌ Saying “maintenance is only about fixing bugs” (forgetting adaptive/perfective/preventive).
• ❌ Ignoring Lehman’s Laws—they’re a must-mention in TU/PU exams.
• ❌ Vague answers like “use tools.” Name the tool (e.g., “Use SonarQube for static analysis”).
• ❌ Skipping cost models (e.g., “Maintenance costs rise exponentially over time due to Lehman’s laws”).

Sample Exam Question & Answer

Question: “Explain the difference between adaptive and perfective maintenance with a Nepali example for each. How would you implement preventive maintenance for a banking app like NMB Bank’s mobile app?”

Model Answer: Adaptive and perfective maintenance differ in their primary goals:

• Adaptive maintenance adjusts software to external changes (e.g., new OS, hardware, or regulations).
  • Example: When Nepal Rastra Bank mandated stronger KYC (Know Your Customer) rules in 2023, NMB Bank had to update their mobile app to include AI-based document verification (adaptive).
• Perfective maintenance improves non-functional aspects (speed, security, usability) or adds minor features without changing core functionality.
  • Example: NMB Bank’s biometric login (fingerprint/face ID) was a perfective enhancement—it didn’t alter the banking core but improved user experience.

For preventive maintenance in NMB Bank’s app, I would:

1. Refactor legacy code using IntelliJ IDEA’s refactoring tools to reduce technical debt.
2. Implement automated testing with Selenium for UI and JUnit for backend to catch regressions early.
3. Use static analysis tools like SonarQube to detect vulnerabilities (e.g., SQL injection risks) before deployment.
4. Update dependencies regularly via Dependabot to patch security flaws (e.g., Log4j).
5. Document APIs using Swagger to ensure future developers understand the system.

Visual Summary:

flowchart TD
    A["Adaptive Maintenance"] -->|"Example"| B["NMB Bank's KYC Update"]
    C["Perfective Maintenance"] -->|"Example"| D["NMB Bank's Biometric Login"]
    E["Preventive Maintenance"] -->|"Tools"| F["SonarQube<br/>Selenium<br/>Dependabot"]