Chapter 10: Software Evolution
a) Introduction – Software Evolution Process
Definition
- Software Evolution (meaning: the ongoing process of updating and improving software after its initial release to meet changing needs and environments) is the practice of developing software and then continuously updating it over time for various reasons.
Causes
- User feedback during early development stages
- Changing user requirements after delivery
- Advancing technology (e.g., new hardware, operating systems)
- Business rule or government policy changes
- Need to fix faults or improve performance
Goals / Objectives
- Achieve the desired software through iterative user feedback and updates
- Keep software relevant and functional in a changing technological and business environment
- Avoid the high cost and risk of rebuilding software from scratch
Importance
- Re-creating software from scratch to match new requirements is not feasible or economical
- Evolution allows organizations to extend the life and value of existing software systems
- Supports continuous alignment between software functionality and real-world needs
Procedures
- Starts from the requirement-gathering process
- Developers create a prototype and show it to users for early feedback
- Users suggest changes → developers implement updates → repeat until desired software is achieved
- After delivery, software continues to evolve through:
- Change Request
- Impact Analysis
- Release Planning
- Change Implementation
- System Release
- Types of changes include:
- Fault Repair
- Platform Adaptation
- System Enhancement
Advantages & Disadvantages
- Advantages:
- More economical than rewriting from scratch
- Preserves existing business logic and knowledge embedded in the system
- Enables gradual improvement based on real user experience
- Disadvantages:
- Not specified in notes
Impact / Effect
- Software structure may degrade over time due to repeated changes
- Documentation may become outdated or inconsistent with code
- Can lead to increased maintenance costs if not managed well
Examples
- A banking app initially built for desktop is later adapted for mobile platforms as user behavior shifts
- A legacy inventory system is updated to comply with new tax regulations
Key Takeaways
- Software evolution begins during development and continues long after delivery
- It’s driven by user feedback, tech changes, and business needs
- Updating existing software is far more practical than rebuilding it
b) Software Maintenance
Definition
- Software Maintenance (meaning: the process of modifying and updating a software system after it has been delivered to the customer) includes fixing bugs, adding features, and adapting to new environments.
Causes
- Software errors (bugs or faults)
- Installation of new hardware or changes in software environment (e.g., OS upgrades)
- Changing customer needs (new functional or non-functional requirements)
Goals / Objectives
- Keep software operational, secure, and useful over time
- Ensure compatibility with evolving technology and business rules
- Improve performance, reliability, and usability
Importance
- Maintenance and evolution account for 80% of total software expenditure
- Critical for sustaining business operations that rely on legacy systems
- Poor maintenance leads to system failure, security risks, and high long-term costs
Procedures
- Involves three main types of activities (see sub-parts below)
- Requires:
- Impact analysis of proposed changes
- Testing and validation
- Documentation updates
- Version control via configuration management
Corrective Maintenance
Definition
- Maintenance performed to fix faults or bugs discovered after delivery.
Causes
- Software errors reported by users or detected during operation
Goals / Objectives
- Restore correct system behavior
Importance
- Essential for system reliability and user trust
Procedures
- Identify fault → locate error in code → fix → test → release patch
Examples
- Fixing a crash that occurs when users submit a form with special characters
Adaptive Maintenance
Definition
- Modifying software to adapt to changes in its external environment, such as new hardware, operating systems, or regulations.
Causes
- Hardware platform upgrades
- OS or third-party software updates
- Changes in government policies or business rules
Goals / Objectives
- Ensure continued compatibility and compliance
Examples
- Updating a payroll system to support new tax laws
- Porting an application from Windows 7 to Windows 11
Perfective Maintenance
Definition
- Improving software functionality, performance, reliability, or maintainability based on new requirements or user feedback.
Causes
- New functional or non-functional requirements
- Desire to improve user experience or system efficiency
Goals / Objectives
- Enhance software quality and user satisfaction
- Make future changes easier (e.g., through restructuring)
Examples
- Adding a dark mode feature
- Optimizing database queries to speed up response time
Advantages & Disadvantages
- Advantages:
- Extends software lifespan
- Supports business agility through incremental updates
- Disadvantages:
- Maintenance costs are often much higher than initial development costs for similar functionality
- Changes can introduce new faults or degrade system structure
Impact / Effect
- Increased costs due to:
- Inexperienced maintenance staff unfamiliar with the application domain
- Poorly structured or outdated code (e.g., “spaghetti” logic)
- Missing or unreliable documentation
- Changes can cause:
- New faults → more change requests
- Structural degradation → harder to understand and modify
- Broken links to documentation → reduced maintainability
Examples
- A 1990s COBOL-based insurance system still in use but requiring constant updates for regulatory compliance
Key Takeaways
- Software maintenance includes corrective, adaptive, and perfective types
- It’s expensive—often costing more than original development
- Good documentation, modular design, and stable staff reduce maintenance costs
c) Software Reengineering
Definition
- Software Reengineering (meaning: the process of updating and restructuring legacy software to make it easier to maintain and understand) involves analyzing, transforming, and modernizing existing systems without changing their external behavior.
Causes
- Legacy systems suffer from:
- Poor structure
- Outdated or inconsistent documentation
- Use of obsolete programming languages
- High maintenance costs
- Business knowledge is embedded in the system and not documented elsewhere
- Rewriting from scratch is too risky or costly
Goals / Objectives
- Improve system structure and readability
- Generate accurate and complete documentation
- Make the system easier to maintain and evolve
- Re-implement legacy systems using modern technologies or practices
Importance
- Addresses the challenge of maintaining legacy systems, which dominate enterprise IT
- Helps organizations avoid the high risk and cost of full replacement
- Preserves valuable business logic while improving software quality
Procedures
Reengineering includes five key activities:
Source Code Translation
- Translating code from one programming language to another (e.g., Fortran → C)
- Reasons: hardware updates, staff skill gaps, or organizational policy
- Often uses CASE tools (e.g., REFINE), but still requires manual work
Reverse Engineering
- Analyzing software to recover its design and specifications
- Produces documentation such as:
- Program structure diagrams
- Data structure diagrams
- Traceability matrices (showing where system entities are defined/used)
- Output used for:
- Program modularization
- Requirement specification for replacement
- Maintenance support
Program Structure Improvement
- Restructuring “spaghetti code” into clear, logical control flow
- Simplifying complex conditions (e.g., rewriting nested
ifstatements) - Example: converting a
goto-heavy program into a structured loop withcasestatements
Program Modularization
- Grouping related code into cohesive modules
- Removing redundancy
- May involve architectural transformation (e.g., moving from centralized to distributed systems)
Data Re-engineering
- Converting file-based or inconsistent data into a relational DBMS
- Fixes problems like:
- Poor data naming (files/attributes)
- Field length issues
- Hard-coded literals
- Missing data dictionary
- Inconsistent default values, validation rules, units, or representations
- Inconsistent handling of negative values
Advantages & Disadvantages
- Advantages:
- Reduced risk compared to full rewrite
- Reduced cost, effort, and development time
- Preserves business-critical functionality
- Disadvantages:
- Practical limits – not all systems can be effectively reengineered
- Limited tool support
- Requires knowledgeable engineers familiar with both old and new technologies
Impact / Effect
- Makes legacy systems more maintainable and understandable
- Reduces long-term maintenance costs
- Enables integration with modern platforms and practices
- May reveal hidden system complexities or inconsistencies
Examples
- Converting a 1980s mainframe-based trading system from COBOL to Java while preserving its core logic
- Migrating flat-file customer data into a relational database with consistent naming and validation rules
Key Takeaways
- Reengineering modernizes legacy systems without full replacement
- It includes code translation, reverse engineering, restructuring, modularization, and data cleanup
- It’s less risky and cheaper than rewriting—but requires expertise and good tools
Legacy System Management
Definition
- Legacy System Management (meaning: the strategic approach to handling old but still-used software systems) involves deciding whether to scrap, maintain, re-engineer, or replace a legacy system based on its quality and business value.
Causes
- Systems become legacy due to age, outdated tech, poor documentation, or structural issues
- Yet they often contain critical business logic that isn’t documented elsewhere
Goals / Objectives
- Make informed decisions about the future of legacy systems
- Balance business value against system quality and maintenance cost
Importance
- Organizations spend massive resources maintaining legacy code (e.g., 250 billion lines of code by 2000)
- Poor decisions can lead to system failure, security breaches, or wasted investment
Procedures
- Assess systems using two dimensions:
- System Quality (high/low)
- Business Value (high/low)
- Based on assessment, choose one of four strategies:
- High Quality, High Business Value → Maintain
- High Quality, Low Business Value → Leave unchanged (or scrap if expensive)
- Low Quality, High Business Value → Re-engineer or Replace
- Low Quality, Low Business Value → Scrap
Advantages & Disadvantages
- Advantages:
- Provides a clear framework for decision-making
- Prevents unnecessary spending on low-value systems
- Disadvantages:
- Not specified in notes
Impact / Effect
- Helps organizations prioritize IT investments
- Reduces risk of unexpected system failures
- Guides resource allocation for maintenance vs. modernization
Examples
- An online trading system from the 1980s with high business value but poor structure → Re-engineer (as suggested in the quiz example)
Key Takeaways
- Legacy systems are evaluated based on quality and business value
- High-value, low-quality systems should be re-engineered
- Low-value, low-quality systems should be scrapped to save costs