Fact-checked by Grok 2 weeks ago

Software maintenance

Software maintenance is the process of modifying a software product after delivery to correct faults, improve performance, or adapt to a changed environment.^[1] It encompasses the totality of activities required to provide cost-effective support to a software system, encompassing both predelivery planning and postdelivery execution to ensure ongoing reliability and functionality.^[1] Defined in international standards such as ISO/IEC/IEEE 14764, this discipline addresses the evolution of software throughout its lifecycle, managing changes to meet new requirements or mitigate issues.^[2] The four primary types of software maintenance are corrective, adaptive, perfective, and preventive. Corrective maintenance involves reactive fixes for discovered defects or faults in the software.^[1] Adaptive maintenance modifies the software to accommodate changes in its operating environment, such as hardware upgrades or regulatory shifts.^[1] Perfective maintenance enhances attributes like performance, usability, or functionality to better satisfy user needs.^[1] Preventive maintenance proactively detects and corrects potential faults to avert future problems and reduce long-term costs.^[1] Key activities in software maintenance follow an iterative process outlined in standards like ISO/IEC 14764, including process implementation, problem and modification analysis, impact assessment, design and coding of changes, testing and validation, review and acceptance, and eventual migration or retirement of the software.^[2] These activities require tools for program understanding, configuration management, and testing to handle technical challenges such as limited documentation or complex dependencies.^[1] Economically, software maintenance dominates the total lifecycle costs of software systems, typically accounting for 50% to 80% of expenditures, with the majority dedicated to non-corrective enhancements rather than mere bug fixes.^[1] This emphasis underscores its role in sustaining software value amid evolving technologies and user demands, often exceeding initial development costs due to the prolonged operational lifespan of modern applications.^[1]

Overview

Definition

Software maintenance is the process of modifying a software product after delivery to correct faults, improve performance or other attributes, or adapt the product to a changed environment.^[2] This encompasses a range of activities aimed at ensuring the software remains functional, reliable, and aligned with evolving user needs and technological contexts throughout its operational life.^[3] Unlike software development, which involves the initial creation of new systems from scratch—often termed "greenfield" projects—maintenance focuses on post-deployment modifications to existing, operational software.^[3] Development emphasizes design, coding, and initial testing to build functionality, whereas maintenance prioritizes sustaining and enhancing deployed systems without disrupting their core integrity.^[4] Key terms in software maintenance include fault, synonymous with defect, referring to an error in the software that causes unintended behavior and requires correction.^[3] A modification request is a formal document or record that identifies proposed changes, such as fixes or enhancements, initiating the maintenance workflow.^[3] The release cycle describes the iterative process of implementing approved modifications, testing them, and deploying updates as major or minor versions to users.^[3] These terms underpin the structured approach to maintenance, which later categorizes activities such as corrective or adaptive efforts.^[2]

Importance and Costs

Software maintenance represents a critical phase in the software lifecycle, often dominating the overall economic burden of software projects. Studies indicate that maintenance activities account for 60-90% of the total software lifecycle costs, far exceeding initial development expenditures.^[5] This range has been consistently reported in empirical analyses since the 1970s, with Barry Boehm's 1981 work highlighting a typical distribution of approximately 30% for development and 70% for maintenance across various systems.^[6] The lifecycle cost can be expressed as:

\text{Total Cost} = \text{Development Cost} + \text{Maintenance Cost},

where \text{Maintenance Cost} \approx 0.6 - 0.9 \times \text{Total Cost}. This economic dominance underscores the strategic necessity of prioritizing maintenance to control long-term project viability. The elevated costs of software maintenance stem from several interconnected factors, including the need for ongoing long-term support to ensure operational stability, the pressure of adapting to evolving user and environmental requirements, and the progressive accumulation of technical debt. Long-term support involves continuous monitoring, updates, and fixes to sustain functionality over extended periods, often spanning decades for enterprise systems.^[7] Evolving requirements, driven by business changes or technological shifts, necessitate frequent modifications that compound effort over time.^[8] Meanwhile, technical debt—arising from shortcuts or deferred refactoring—builds up, increasing the complexity and effort required for subsequent changes, much like accruing interest on financial obligations.^[9] Failure to invest adequately in maintenance exposes organizations to severe risks, including heightened security vulnerabilities, regulatory compliance failures, and rapid technological obsolescence. Unmaintained software often harbors unpatched flaws that cybercriminals exploit, leading to breaches as seen in widespread incidents from delayed updates.^[10] Non-compliance with evolving standards, such as data protection regulations, can result in fines and legal penalties when outdated systems fail audits.^[11] Additionally, obsolescence renders software incompatible with modern hardware or integrations, stifling innovation and increasing replacement costs.^[12]

Historical Development

Origins in the 1970s

The recognition of software maintenance as a distinct phase emerged in the late 1960s and early 1970s, driven by the escalating complexity of large-scale software projects that outpaced initial development efforts. IBM's OS/360 operating system, launched in 1966 after a development process involving over 5,000 staff-years and costing more than $500 million, exemplified these challenges, as its intricate design led to persistent bugs, frequent redesigns, and ongoing modifications that blurred the lines between development and post-delivery support.^[13]^[14] This period, often termed the "software crisis," highlighted how such systems required substantial resources for upkeep, with maintenance activities consuming 50% to 70% of total software expenditures by the 1970s.^[13] A pivotal contribution came in 1972 from analyst R.G. Canning, who in his article "That Maintenance 'Iceberg'" described the underestimation of maintenance efforts, likening visible costs to the tip of an iceberg while emphasizing the hidden, substantial burdens of sustaining software in operational environments.^[13] Canning argued that maintenance extended beyond mere fixes, encompassing adaptations and enhancements that demanded resources comparable to initial development, thereby alerting practitioners to the need for dedicated strategies.^[13] Early IEEE publications in the 1970s began to advocate for separating maintenance from development teams to address these issues more effectively, recognizing that post-delivery work required specialized skills distinct from upfront coding.^[13] This separation allowed development groups to focus on new projects while maintenance personnel handled ongoing support, a practice increasingly adopted in large organizations like IBM. The first formal definitions of software maintenance appeared in 1976 through E. Burton Swanson's paper "The Dimensions of Maintenance," presented at the IEEE's Second International Conference on Software Engineering, which established it as the modification of software after delivery to correct faults, adapt to changing environments, or improve performance and other attributes.^[15] Swanson's work provided a foundational framework, categorizing maintenance into corrective, adaptive, and perfective types, and solidified its status as a critical post-delivery activity separate from the development lifecycle.^[16]

Key Milestones and Publications

One of the earliest formal taxonomies for software maintenance was introduced by E. Burton Swanson in 1976, classifying maintenance activities into three primary categories: adaptive (adjusting to environmental changes), corrective (fixing defects), and perfective (enhancing functionality or performance).^[15] This framework, presented at the Second International Conference on Software Engineering, provided a foundational structure that influenced subsequent classifications and emphasized maintenance as distinct from development.^[17] A significant empirical study was published in 1980 by Bennet P. Lientz and E. Burton Swanson in their book Software Maintenance Management: A Study of the Maintenance of Computer Application Software in 487 Installations. Based on a survey of 487 sites, it revealed that maintenance accounted for about 50% of the software budget, with roughly 60% dedicated to adaptive and perfective activities rather than corrective fixes, and highlighted common challenges like staff turnover and lack of documentation.^[18] This work provided the first large-scale data on maintenance practices and influenced cost management strategies. Building on these early concepts from the 1970s, Barry Boehm's 1983 software maintenance model highlighted the economic implications of maintenance within the software lifecycle, estimating that it accounts for approximately 75% of total costs due to ongoing enhancements and adaptations.^[19] Boehm's approach, rooted in constructive cost modeling principles, integrated maintenance into broader lifecycle economics, underscoring the need for predictive tools to manage these expenses effectively.^[20] In the 1990s, the International Organization for Standardization (ISO) introduced the ISO/IEC 14764 standard in 1999, which formalized processes for software maintenance, including planning, execution, and evaluation, while classifying maintenance into corrective, adaptive, perfective, and preventive types.^[21] This standard was revised in 2006 to align with evolving lifecycle models like ISO/IEC 12207, providing detailed guidance on maintenance management and integrating it with quality assurance practices. Concurrently, Thomas M. Pigoski's 1996 book Practical Software Maintenance: Best Practices for Managing Your Software Investment offered a comprehensive process guide, detailing best practices for maintenance teams, including reverse engineering, impact analysis, and configuration management to optimize legacy system support.^[22] The concept of technical debt emerged in the early 1990s, coined by Ward Cunningham in a 1992 experience report on the WyCash portfolio management system, describing how expedited development decisions accrue future maintenance burdens akin to financial interest.^[23] This metaphor gained prominence in the 2000s as software practices evolved toward agile methodologies, with expansions in literature emphasizing strategies to refactor and repay debt to sustain long-term maintainability.^[24]

Integration with Software Life Cycle

Role in the Overall Life Cycle

Software maintenance constitutes the culminating and most enduring phase within the software development life cycle (SDLC), ensuring the sustained functionality, adaptability, and relevance of deployed software systems. The SDLC generally comprises sequential or iterative stages, including requirements analysis, system design, implementation (or coding), testing, deployment, and maintenance as the final, ongoing phase that supports the software post-release.^[25] This phase addresses real-world usage challenges, environmental changes, and enhancement needs, distinguishing it from preceding stages focused on creation and validation. Maintenance often dominates the lifecycle in both duration and resource allocation, typically accounting for 50-75% of total costs across all phases.^[26] For typical enterprise software, the total lifespan averages 6-8 years, with the maintenance phase comprising the majority of that duration following initial development, which usually requires 1-2 years.^[27]^[28] However, for legacy systems in sectors like banking, maintenance can span 20-50 years or more due to stability, integration complexities, and high replacement costs.^[29] This extended timeline for legacy systems reflects long-term operational demands of critical applications, such as ERP platforms or financial systems, where decommissioning is rare. The prolonged nature underscores maintenance's role in preserving value over time, with activities continuing until strategic obsolescence or replacement. As of 2025, cloud-native and modern enterprise applications often have shorter lifespans of 3-5 years due to rapid technological evolution, influencing integration approaches.^[30] Maintenance exhibits strong interdependencies with earlier SDLC phases, particularly requirements, as operational insights from usage—such as user feedback, performance issues, or regulatory shifts—inform iterative refinements and future iterations. This feedback loop promotes software evolution, allowing enhancements that align with evolving needs without full redevelopment. In practice, unresolved issues from testing or deployment can resurface, reinforcing maintenance's connective function across the lifecycle.^[3] The integration of maintenance varies by SDLC model. In the Waterfall model, a linear approach, maintenance follows deployment as a distinct post-development stage, with changes managed reactively after all upfront phases conclude. Conversely, Agile models integrate maintenance seamlessly through iterative sprints and continuous integration, blurring phase boundaries to enable proactive updates and rapid responses to emerging needs throughout the product's life.^[31] This contrast highlights how model choice influences maintenance's timing and efficiency in the overall lifecycle.

Transition from Development to Maintenance

The transition from software development to the maintenance phase marks a critical boundary in the software life cycle, where responsibility for the system shifts from creating new features to sustaining, adapting, and evolving the existing codebase. This handover ensures continuity, minimizing disruptions while establishing processes for ongoing support. Effective transitions rely on structured activities to transfer artifacts, knowledge, and responsibilities, preventing knowledge silos that could impede long-term viability. Key handover activities include the transfer of comprehensive documentation, such as architectural overviews, code comments, and operational manuals, which provide maintainers with essential insights into system design and behavior. Knowledge sessions, often in the form of training workshops or embedded shadowing, facilitate the sharing of tacit expertise from developers to maintenance teams. Additionally, setting up initial bug triage involves configuring issue-tracking tools and defining protocols for prioritizing and resolving defects post-release, ensuring rapid response to early issues. Common challenges during this transition encompass the loss of developer knowledge, particularly when original team members depart without adequate overlap, leading to difficulties in understanding system intricacies. Incomplete or outdated documentation exacerbates these issues, often resulting in substantial initial maintenance overhead as teams spend excessive time reverse-engineering code or reconstructing missing details; case studies indicate this can complicate project starts and increase effort significantly. Such gaps frequently arise from rushed development schedules or agile practices that deprioritize formal artifacts. Best practices to mitigate these challenges emphasize parallel team involvement during late development stages, where maintenance personnel join the project to gain hands-on exposure and contribute to final deliverables. Utilizing configuration management tools, such as version control systems like Git, supports seamless baseline establishment and change tracking, enabling maintainers to baseline the release and handle the first modification requests efficiently. These approaches, aligned with standards like IEEE/ISO/IEC 14764, promote a structured initiation of the change cycle from the stable release to iterative updates.

End-of-Life Considerations

Software reaches the end of its maintenance lifespan when the costs of continued support outweigh the benefits, often marked by escalating maintenance expenses that can consume up to 75% of total IT budgets for legacy systems. Unsupported technologies, such as outdated programming languages or operating systems no longer receiving vendor updates, further signal this phase, as seen in official end-of-life announcements from developers that halt patches and feature enhancements. Security risks intensify as unpatched vulnerabilities accumulate, exemplified by the 2017 Equifax breach where a legacy system from the 1970s exposed 147 million individuals to exploitation.^[29]^[32]^[32]^[29] The decommissioning process begins with assessing dependencies and impacts, followed by data migration to ensure business-critical information is transferred to modern systems or archived securely for compliance and future reference. User notification is essential, involving multiple communications to stakeholders about timelines and alternatives to minimize disruptions, often scheduled during low-impact periods with rollback plans in place. Code and configurations are archived, preserving them in repositories or backups while removing associated infrastructure like databases and networks, adhering to change management protocols to avoid operational gaps.^[33]^[34]^[35]^[36]^[33] Typical software lifespans vary by type, with consumer applications often lasting 5-10 years before obsolescence, while legacy systems in sectors like banking, powered by COBOL, can endure 20 years or more—some operational for over 60 years due to their stability and the high cost of replacement. Factors influencing duration include the complexity of the system, evolving regulatory requirements, and technological shifts, with average enterprise software averaging 6-8 years.^[37]^[38]^[29]^[37] After decommissioning, options include full shutdown to eliminate risks or open-sourcing the codebase to enable community-driven support, allowing forks or independent maintenance for niche uses while reducing proprietary burdens. This approach has been adopted for some legacy projects to extend utility without ongoing vendor investment, though it requires careful licensing to protect intellectual property.^[39]^[40]

Categories of Maintenance

Corrective Maintenance

Corrective maintenance involves the modification of a software product after delivery to identify and resolve bugs, errors, or failures that prevent it from meeting its specified requirements. This reactive approach addresses defects discovered during post-deployment use, such as runtime crashes, incorrect outputs, or security vulnerabilities that were not detected in prior testing phases.^[41] According to the ISO/IEC/IEEE 14764 standard, which outlines the categories of software maintenance, corrective maintenance focuses exclusively on rectifying these internal faults to restore functionality without altering the software's intended behavior or adapting to external changes. The process of corrective maintenance typically begins with fault reporting, where users or automated monitoring systems submit details of issues encountered in production.^[41] Diagnosis follows, involving techniques like analyzing system logs, reproducing the error in a test environment, and using debugging tools to isolate the root cause within the codebase.^[41] Once identified, developers implement patches or code fixes, followed by rigorous testing—including unit tests and regression testing—to verify the resolution and ensure no new defects are introduced.^[41] The updated software is then deployed, often through controlled releases, with documentation of the issue and fix maintained for audit and future reference.^[41] Corrective maintenance accounts for approximately 20-25% of total software maintenance efforts, though this proportion can be higher—sometimes exceeding 30%—in the early post-release period when latent defects from development are more likely to surface.^[42] Common tools supporting this process include debuggers such as GDB, which enable step-by-step code execution and variable inspection to pinpoint faults in compiled programs, and issue trackers like Jira, which facilitate reporting, prioritization, and workflow management for bug resolutions.^[43]

Adaptive Maintenance

Adaptive maintenance refers to the modifications made to a software system after its delivery to ensure it remains functional and compatible with changes in its operating environment, including hardware upgrades, operating system updates, or evolving regulatory requirements. This type of maintenance is essential for adapting software to external factors beyond the original development context, preventing obsolescence without altering core functionality. According to IEEE standards, adaptive maintenance specifically makes a computer program usable in a changed environment.^[44] Common examples of adaptive maintenance include updating software to support new operating systems, such as migrating from Windows 10 to Windows 11 compatibility, or adjusting applications to run on upgraded hardware like transitioning from on-premises servers to modern processors. Another key instance involves regulatory adaptations, such as modifying data handling processes to comply with updates to the General Data Protection Regulation (GDPR), which may require enhanced encryption or consent mechanisms for personal data. Porting software to new cloud platforms, for example, shifting from Amazon Web Services (AWS) to Microsoft Azure to align with organizational infrastructure changes or leverage updated services, also exemplifies this maintenance category.^[45]^[46] The process of adaptive maintenance typically starts with impact analysis to evaluate how environmental changes affect the software's components, dependencies, and performance. This is followed by code refactoring, where developers modify the codebase to restore compatibility, often involving updates to APIs, libraries, or configuration files. Finally, compatibility testing is conducted across the new environment to verify functionality, integration, and absence of regressions, ensuring the software meets operational standards before redeployment.^[47]^[48] Adaptive maintenance generally accounts for about 25% of total software maintenance efforts, though this proportion can increase significantly for legacy systems that face frequent environmental shifts due to outdated architectures. In such cases, the need for repeated adaptations to modern technologies or compliance standards amplifies the resource demands compared to newer, more flexible systems.^[49]^[50]

Perfective Maintenance

Perfective maintenance refers to the modification of a software product after delivery to improve its performance, maintainability, or other attributes in response to user requests for enhancements. This type of maintenance focuses on adding new features, optimizing code for better efficiency, or refining the user interface based on feedback to enhance overall functionality and user experience. According to the IEEE Standard for Software Maintenance, these changes aim to elevate the software's value without addressing environmental adaptations or error corrections.^[51] Perfective maintenance typically dominates maintenance efforts, accounting for approximately 50-60% of total time and resources allocated to software upkeep, often surpassing other categories due to ongoing user demands and the need to keep software competitive in evolving markets. This high proportion is evidenced in empirical studies of maintenance distributions, where perfective activities consumed around 60% of efforts in surveyed projects. The drive stems primarily from user feedback highlighting areas for improvement, such as usability enhancements, and broader pressures to align software with advancing business needs.^[52]^[53] The process for perfective maintenance mirrors general software modification workflows but emphasizes post-release requirement elicitation. It begins with gathering and analyzing new or refined requirements from users, even after initial deployment, to identify enhancement opportunities. This is followed by impact analysis, design of the updates, implementation of code changes, and rigorous testing, including user acceptance testing to validate improvements in functionality and performance. The ISO/IEC 14764 standard outlines these steps within the broader maintenance process, ensuring enhancements are integrated without disrupting existing operations.^[54] Representative examples include incorporating mobile responsiveness into a web application to better serve users on handheld devices, thereby improving accessibility and engagement based on usage analytics. Another common instance is integrating new application programming interfaces (APIs) to enable compatibility with emerging services, such as third-party payment systems, which expands functionality and meets evolving user expectations for seamless integrations. These enhancements help sustain software relevance in dynamic environments.^[3]

Preventive Maintenance

Preventive maintenance in software engineering involves proactive activities designed to avert the emergence of faults and enhance long-term system stability without altering current functionality. This includes refactoring code to improve structure and readability, updating dependencies to address vulnerabilities and compatibility issues, and conducting regular code reviews to identify potential weaknesses early. These measures aim to minimize technical debt and ensure the software remains robust over time.^[55]^[56]^[57] Key techniques for preventive maintenance leverage automated tools to scale efforts efficiently. Static analysis tools, such as SonarQube, scan source code for code smells, security hotspots, and maintainability issues, enabling developers to address them before they lead to failures. Automated refactoring tools like OpenRewrite support large-scale transformations, such as migrating deprecated APIs or optimizing code patterns, reducing manual effort while preserving behavior. These approaches are integrated into development workflows, often through continuous integration pipelines, to make prevention a routine part of the process.^[58]^[59] The benefits of preventive maintenance are well-documented in industry studies, particularly in terms of cost efficiency and reliability. By proactively addressing issues, it can reduce future corrective maintenance costs compared to reactive strategies, as planned interventions avoid the escalation of minor problems into major defects. This leads to lower overall downtime and improved software quality, with organizations reporting enhanced productivity and fewer unplanned repairs. In safety-critical domains like aviation software, periodic audits—such as systematic code inspections and compliance checks—are essential applications, ensuring adherence to stringent standards like DO-178C for airborne systems and preventing catastrophic failures.^[60] Preventive maintenance complements perfective enhancements by emphasizing foresight over response, though both contribute to overall code health.^[47]

Maintainability

Factors Affecting Maintainability

Maintainability of software is influenced by a range of internal code attributes and external conditions that determine the ease of modification, debugging, and extension over time. Key internal factors include the inherent quality of the codebase, which encompasses modularity, readability, and documentation, as these directly impact the effort required for comprehension and alteration.^[61]^[62] Code modularity refers to the division of software into independent, cohesive modules that encapsulate related functionality, reducing interdependencies and facilitating isolated updates without widespread ripple effects. Readability involves clear, consistent naming conventions, logical structure, and avoidance of overly complex constructs, which enable developers to quickly understand and navigate the code. Adequate documentation, such as inline comments and external specifications, provides context for implementation decisions and usage, significantly lowering the cognitive load during maintenance tasks. For instance, maintaining cyclomatic complexity below 10—a measure of the number of linearly independent paths through the code—correlates with higher maintainability by limiting decision points that complicate testing and error-prone modifications.^[61]^[63]^[64] Design principles further enhance maintainability by promoting architectures that isolate changes and promote reusability. The SOLID principles, comprising Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion, guide object-oriented design to create flexible systems where modifications in one component minimally affect others. Similarly, separation of concerns divides the software into distinct layers or modules based on responsibilities—such as presentation, business logic, and data access—to minimize coupling and contain the scope of changes, thereby reducing the risk of unintended side effects during updates.^[65]^[66] External factors, including legacy codebases and third-party dependencies, often introduce challenges to maintainability. Legacy systems, built with outdated technologies or poor initial practices, accumulate technical debt that increases vulnerability to errors and complicates integration with modern tools. Third-party dependencies, while accelerating development, heighten risks through potential incompatibilities, unpatched vulnerabilities, or supply chain disruptions that propagate issues across the system.^[67]^[68] Metrics like Halstead's software science provide quantitative insights into maintainability by assessing code attributes such as volume and difficulty. Volume measures the total size of the program in terms of unique operators and operands, while difficulty gauges the effort needed to understand or implement it, with higher values indicating greater maintenance overhead; these can help predict the cognitive effort for ongoing support.^[69]

Strategies to Improve Maintainability

Modular design enhances software maintainability by promoting high isolation between components, which facilitates error location, communication visibility, and easier updates without widespread impacts.^[70] This approach decomposes complex systems into smaller, independent modules, reducing coupling and improving overall system comprehension and scalability. Consistent naming conventions further support maintainability by improving code readability and reducing cognitive load during comprehension and modification tasks.^[71] Adopting standards such as camelCase for variables or PascalCase for classes ensures uniformity, minimizing errors in refactoring and collaboration.^[71] Automated testing with high coverage, typically aiming for over 80% of code paths, bolsters maintainability by enabling rapid verification of changes and early detection of regressions.^[72] Such practices allow developers to confidently modify code while preserving functionality, as evidenced in frameworks like JUnit or pytest that integrate seamlessly into development workflows.^[73] Version control systems like Git improve maintainability by providing a structured history of changes, enabling rollback to stable states and collaborative editing without conflicts.^[74] Best practices include frequent, atomic commits with descriptive messages to track evolution and facilitate debugging.^[75] CI/CD pipelines enhance this by automating integration and deployment of small, incremental changes, which reduces integration risks and maintains code quality over time.^[76] Tools such as Jenkins or GitHub Actions enforce automated builds and tests on every commit, promoting frequent releases and minimizing technical drift.^[77] Organizational strategies like mandatory code reviews foster maintainability by catching issues early and enforcing adherence to standards across teams.^[78] Reviews typically involve peer evaluation for clarity, security, and efficiency, leading to more robust codebases.^[79] Tracking technical debt using tools like SonarQube quantifies maintainability risks through metrics such as code smells and remediation effort, allowing prioritization of refactoring efforts.^[80] SonarQube's analysis generates reports on debt in person-days, helping organizations allocate resources to high-impact areas without disrupting delivery.^[81] Refactoring techniques, such as extract method and rename variables, directly reduce code complexity and improve long-term maintainability.^[71] Extract method breaks down lengthy procedures into focused functions, enhancing readability and reusability while preserving behavior.^[82] Renaming variables to descriptive terms eliminates ambiguity, aiding comprehension in large codebases and supporting automated tools for bulk updates.^[83] These methods, when applied iteratively, lower cyclomatic complexity and boost metrics like the maintainability index.^[84]

Human and Organizational Aspects

Workforce and Skills Required

Software maintenance relies on a diverse workforce comprising specialized professionals who ensure the ongoing functionality, security, and efficiency of software systems. Key roles include maintenance engineers, who focus on diagnosing and resolving defects in existing codebases; support analysts, who handle user-reported issues and provide troubleshooting assistance; and DevOps specialists, who integrate maintenance activities with deployment pipelines to facilitate seamless updates. A significant portion of software development and related jobs involve maintenance and support activities, underscoring the scale of this workforce segment.^[85] Essential technical skills for these professionals encompass advanced debugging techniques to identify and fix bugs, deep domain knowledge to understand the specific industry context of the software (such as finance or healthcare), and proficiency in scripting languages like Python and Bash for automating routine maintenance tasks. Beyond technical expertise, soft skills are critical, particularly communication abilities that enable effective interaction with end-users, stakeholders, and cross-functional teams to gather requirements and explain resolutions. These competencies ensure that maintenance efforts align with business needs while minimizing disruptions. Emerging trends as of 2025 highlight the growing importance of skills in AI and machine learning for predictive maintenance and automated code analysis.^[86] Training for software maintenance roles often emphasizes formal certifications and hands-on experience with legacy technologies. The International Software Testing Qualifications Board (ISTQB) certification, for instance, equips professionals with standardized testing methodologies essential for preventive and corrective maintenance. Additionally, there is a strong focus on skills in outdated but persistent languages like COBOL and Fortran, which power many critical systems in sectors such as banking and government, requiring ongoing expertise to avoid obsolescence. The software maintenance workforce continues to grow globally, driven by the proliferation of legacy systems and the need for continuous updates in cloud-based environments. This reflects increasing demand for roles augmented by AI tools that support predictive maintenance without replacing human oversight.

Challenges in Maintenance Teams

Maintenance teams in software projects often grapple with organizational hurdles that impede efficiency and long-term sustainability. Knowledge silos, where expertise is concentrated among a few individuals or isolated groups, hinder collaborative problem-solving and increase dependency risks during personnel changes.^[87] These silos emerge as projects scale, limiting the broader team's ability to address maintenance issues promptly and leading to duplicated efforts or overlooked bugs.^[88] High turnover rates exacerbate these issues, particularly in support roles where attrition often exceeds industry averages, driven by demanding workloads and limited career progression.^[89] This churn disrupts continuity, as departing members take institutional knowledge with them, forcing remaining staff to onboard newcomers amid ongoing maintenance demands. Underfunding compounds the problem, as maintenance budgets typically receive less allocation than new development initiatives, despite maintenance comprising 60-80% of long-term software lifecycle costs.^[1] Such disparities result in deferred updates, heightened technical debt, and reactive rather than proactive team operations.^[90] Outsourcing maintenance to offshore hubs like India and Eastern Europe introduces additional risks, including communication barriers from time zone differences and cultural nuances that delay issue resolution.^[91] High internal turnover and challenges in handling complex legacy systems can lead to inconsistent deliverables and quality issues in these models.^[92] These factors can extend project timelines and elevate error rates in cross-border handoffs.^[93] Motivation within maintenance teams suffers from the repetitive nature of tasks like bug fixes and patch applications, with 38% of engineers citing too many tedious tasks, including maintenance, as a barrier to meaningful work and contributing to burnout.^[94] The lack of opportunities for innovation or creative problem-solving further erodes engagement, with burnout from repetitive workloads cited as a key factor in developer turnover.^[95] This skill gap in areas like advanced debugging highlights the need for targeted training, yet resource constraints often prevent it. In 2025, the persistence of remote work post-pandemic has amplified coordination challenges for distributed maintenance teams, with communication breakdowns reducing collaboration efficiency compared to in-office setups.^[96] Asynchronous tools help, but unresolved issues in real-time troubleshooting persist, particularly for time-sensitive fixes in global teams.^[97]

Modern Approaches and Alternatives

DevOps and Continuous Integration Practices

DevOps emerged as a response to the silos between development and operations teams that plagued traditional software maintenance, originating from discussions in 2007–2008 and gaining momentum at the 2009 DevOpsDays conference organized by Patrick Debois.^[98]^[99] This movement addressed inefficiencies in maintenance by promoting collaboration, automation, and shared responsibility, evolving from agile principles to integrate operations into the development lifecycle.^[98] In software maintenance, DevOps integrates continuous deployment (CD) practices to enable rapid fixes and updates, automating the release process to production after passing tests, which minimizes downtime and accelerates issue resolution.^[100] Infrastructure as code (IaC) further supports this by allowing maintenance tasks, such as provisioning and configuring environments, to be managed declaratively through code rather than manual processes; tools like Terraform exemplify this by enabling version-controlled, repeatable infrastructure changes across cloud providers.^[101] Key DevOps practices in maintenance include automated testing within continuous integration (CI) pipelines, where tools like Jenkins orchestrate build, test, and deployment workflows to catch regressions early, and GitHub Actions provide cloud-hosted automation directly integrated with repositories for streamlined maintenance workflows. Additionally, monitoring solutions like Prometheus facilitate proactive issue detection by collecting time-series metrics from applications and infrastructure, enabling alerting on anomalies before they impact users.^[102] These practices yield significant benefits for software maintenance, with high-performing (elite) DevOps teams achieving recovery times from failures of less than one hour—2,293 times faster than low performers—and change failure rates of 5%, reducing overall maintenance effort through higher stability and faster iterations.^[103] DevOps also supports maintenance of cloud-native applications via orchestration tools like Kubernetes, which automates scaling, updates, and self-healing to handle distributed systems efficiently. Recent advancements in DevOps include AI-assisted maintenance, where machine learning tools automate code refactoring, anomaly detection in logs, and predictive fault analysis to enhance preventive and perfective maintenance activities. As of 2025, the DORA report on AI-assisted software development notes that AI amplifies organizational strengths in delivery stability by up to 7.2%, though it can exacerbate weaknesses if not managed properly.^[104]

Alternatives to Traditional Maintenance

Alternatives to traditional maintenance of legacy software systems often involve strategies that encapsulate, replace, or isolate outdated components to minimize ongoing costs and risks associated with continuous updates. These approaches aim to integrate legacy systems with modern architectures without full-scale overhauls, allowing organizations to leverage existing functionality while transitioning toward sustainable solutions. Key methods include system wrapping, full redevelopment, and freezing, each tailored to different levels of system complexity and business needs.^[105] System wrapping involves creating adapter layers or interfaces around legacy systems to expose their functionalities to new applications, effectively hiding internal complexities and enabling integration with contemporary technologies like web services. This technique, often implemented through design patterns, allows multiple similar legacy systems to be unified under a common wrapper, facilitating interoperability without altering the core code. For instance, wrappers can translate legacy protocols into modern APIs, reducing maintenance burdens by isolating changes to the adapter layer rather than the original system.^[106]^[107] Full redevelopment, particularly through migration to microservices architectures, replaces monolithic legacy systems with modular, scalable components that can be developed, deployed, and maintained independently. This strategy typically follows a structured process: assessing the monolith for decomposition, identifying service boundaries based on business capabilities, and incrementally refactoring code into microservices while ensuring data consistency and minimal downtime. Organizations often use patterns like the Strangler Fig to gradually envelop the legacy system, allowing parallel operation during transition. Such migrations enhance agility and reduce long-term maintenance by distributing responsibilities across smaller, specialized services.^[108]^[109] Freezing a legacy system entails halting all modifications and shifts to a monitoring-only mode, where the system runs in isolation with continuous surveillance for stability and security vulnerabilities. This retain strategy, part of broader cloud migration frameworks like the 7 Rs, is suitable for non-critical systems where the cost of change outweighs benefits, allowing resources to be redirected elsewhere while automated tools track performance and compliance. However, it requires robust isolation to prevent cascading failures and periodic audits to assess ongoing viability.^[110] Migration to cloud platforms via lift-and-shift methods provides another pathway by rehosting on-premises legacy systems directly into environments like AWS or Azure without architectural changes, thereby retiring physical infrastructure while preserving application logic. This approach accelerates relocation by virtualizing servers and databases, often using tools for automated discovery and replication, which can cut deployment time from months to weeks. It serves as a bridge to further optimizations, reducing maintenance overhead through managed services for scaling and backups.^[111]^[112] For open-source legacy software, alternatives include forking the codebase to create a community-maintained variant or relying on external community support to distribute maintenance efforts. Forking allows organizations to diverge from an unmaintained upstream project, applying custom updates while benefiting from collective contributions, though it risks fragmentation if not coordinated. Community-driven support offloads costs by crowdsourcing fixes and enhancements, as seen in ecosystems where end-of-life projects are revived through collaborative forks, ensuring longevity without proprietary investment.^[113] Notable case studies illustrate these alternatives in practice. During the Y2K crisis around 2000, numerous organizations addressed date-handling flaws in legacy systems through targeted migrations and wrapping techniques, with the U.S. government and enterprises investing in assessments that revealed widespread vulnerabilities in COBOL-based mainframes, leading to systematic renovations to avert potential disruptions. In modern contexts, COBOL-to-Java transitions have been pivotal in finance; for example, ING Bank automated the conversion of its mainframe applications to Java using refactoring tools, achieving seamless integration with cloud services and reducing operational costs significantly.^[114] Similarly, AT&T modernized its UPS-EMS system by transforming 409,568 lines of IBM z/OS COBOL into Java on AWS in four months, enhancing scalability for utility management without business interruption.^[115] The New York Times also refactored its mainframe codebase to Java and relational databases over two years, enabling agile content delivery while decommissioning legacy hardware.^[116] These examples highlight how alternatives can mitigate risks in high-stakes environments like banking and utilities.

Research and Future Trends

Current Research Areas

Current research in software maintenance emphasizes automated techniques to enhance efficiency and reduce costs, particularly in bug detection and technical debt management. Automated bug detection has seen significant advancements through AI-driven approaches, such as SynergyBug, which integrates BERT and GPT-3 models to autonomously identify and repair bugs across diverse code sources, achieving higher accuracy in resolving complex issues compared to traditional methods.^[117] These efforts address the growing complexity of legacy systems, where manual debugging consumes substantial developer time. Similarly, research on technical debt quantification utilizes tools like SonarQube to measure and prioritize debt items, with a 2023 Sonar study analyzing over 200 projects revealing that technical debt incurs an average annual cost of $306,000 for a project of one million lines of code, highlighting the need for proactive repayment strategies.^[118] Empirical studies continue to explore the tangible impacts of code quality issues on maintenance activities. Investigations into code smells—structural deficiencies in code—demonstrate their correlation with increased maintenance effort; for instance, a 2025 bibliometric analysis of publications from 2020 to 2024 found that code smells contribute to higher change proneness and effort in refactoring tasks, with metrics like cyclomatic complexity serving as key predictors.^[119] These studies, often drawing from large-scale repositories such as Apache projects, quantify how smell interactions amplify dependencies, thereby elevating the risk of defects during updates. Despite maintenance accounting for 50-90% of total software lifecycle costs, it remains under-researched, comprising only a fraction of software engineering literature.^[120] Methodologies in this domain increasingly rely on systematic literature reviews (SLRs) to evaluate intervention effectiveness, particularly refactoring. A 2020 tertiary SLR on code smells and refactoring, covering studies up to 2018, confirms that refactoring improves maintainability attributes like understandability and testability, though its impact varies by smell type.^[121] Ongoing SLRs address gaps in long-term outcomes, advocating for integrated metrics that combine static analysis with developer feedback to better guide maintenance practices. These research directions underscore a shift toward evidence-based tools that mitigate the persistent challenges in sustaining software over time.

Emerging Technologies in Maintenance

Artificial intelligence and machine learning are revolutionizing software maintenance through predictive techniques that anticipate faults before they occur, thereby minimizing downtime and corrective efforts. In predictive maintenance, models such as Long Short-Term Memory (LSTM) networks analyze historical data patterns to forecast software defects with high precision. For instance, a hybrid deep learning model using CNN, LSTM, and dense layers applied to software fault prediction achieved up to 93% accuracy on projects like Xerces as of 2025.^[122] Studies from 2025 confirm that such LSTM-based approaches exceed 85% accuracy in software fault prediction, enabling proactive interventions that can reduce maintenance costs by 25-30%.^[123] Cloud computing and serverless architectures further streamline maintenance by automating infrastructure management, particularly through auto-scaling features that dynamically adjust resources to demand, thereby decreasing the need for adaptive maintenance tasks like manual scaling or provisioning. AWS Lambda exemplifies this with its event-driven execution model, where functions trigger automatically in response to events, facilitating rapid fixes without underlying server oversight.^[124] Research highlights that serverless platforms eliminate deployment and maintenance complexities, allowing developers to focus on code rather than operational upkeep, with operational costs nearing negligible levels compared to traditional setups.^[125] Open-source tools integrated with AI are enhancing refactoring and collaborative maintenance efforts. GitHub Copilot, an AI-powered coding assistant, automates code refactoring by suggesting improvements that enhance readability and reduce complexity, directly supporting long-term maintainability.^[126] In community-driven models, tools like Copilot enable distributed open-source projects to accelerate bug fixes and updates, fostering collective ownership and faster iteration cycles.^[127] Looking ahead, quantum-resistant updates and blockchain technologies promise to secure maintenance processes against emerging threats. Post-quantum cryptography standards, such as those standardized by NIST, facilitate seamless software updates that resist quantum attacks, offering a cost-effective alternative to traditional key distribution methods with easier long-term maintenance.^[128] Blockchain ensures version integrity by providing an immutable, decentralized ledger for tracking changes, preventing tampering and enhancing traceability in software evolution.^[129] These trends, projected to mature by 2030, will integrate with DevOps practices to bolster resilient maintenance pipelines.

References

[1]
swebok v3 pdf - IEEE Computer Society
Digital copies of SWEBOK Guide V3.0 may be downloaded free of charge for personal and academic use via www.swebok.org. IEEE Computer Society Staff for This ...
[2]
ISO/IEC/IEEE 14764:2022 - Maintenance
In stockThis document provides guidance for the maintenance of software, based on the maintenance process and its activities and tasks defined in ISO/IEC/IEEE ...
[3]
What is Software Maintenance? - IEEE Computer Society
The goal of maintenance is to correct faults, improve performance or other attributes, and adapt the software to a changing environment throughout its lifetime.
[4]
IEEE/ISO/IEC 14764-2021
Jan 21, 2022 · This standard defines the activities and tasks of software maintenance, and provides maintenance planning requirements.
[5]
On the relationship of concern metrics and requirements ...
Many studies in the literature reveal that software maintenance is the most costly phase in the software life cycle, currently draining 60–90% of the total cost ...
[6]
[PDF] B. Boehm and V. Basili, "Software Defect Reduction Top 10 List ...
For a typical life-cycle cost distribution of 30 percent development and 70 per- cent maintenance, low-dependability software becomes about the same in cost per ...
[7]
Understanding the Cost of Software Maintenance - Baytech Consulting
May 20, 2020 · Maintenance frequently accounts for at least 70 percent of the software's TCO, but this figure can be significantly higher. In the case of ...Missing: lifecycle | Show results with:lifecycle
[8]
Software Development vs Maintenance: The True Cost Equation
May 7, 2025 · Development happens once, but maintenance continues throughout the software's lifetime. Even if annual maintenance costs are lower than initial ...
[9]
What is Technical Debt? Causes, Types & Definition Guide - Sonar
Technical debt refers to the future costs of rework or maintenance that arise from prioritizing speed and short cuts over code quality in software ...Missing: evolving | Show results with:evolving
[10]
CrowdStrike Chaos Highlights Key Cyber Vulnerabilities with ... - GAO
Jul 30, 2024 · Disruptions were widespread. Around the world, businesses and services were unable to operate as computers crashed, and some critical ...
[11]
The Top 5 Risks of Using Obsolete and Unsupported Software in 2025
Oct 22, 2025 · Unsupported software increases cybersecurity threats, compliance issues, and IT costs. Discover the top 5 risks of outdated systems, ...
[12]
5 Risks Of Outdated Software & Operating Systems
Sep 20, 2024 · Outdated software risks can leave you open to a variety of hacks, including ransomware, malware, data breaches, and more.
[13]
[PDF] When Good Software Goes Bad
Sep 11, 2014 · with maintenance31 By the late 1970s it was common knowledge that maintenance represented at least 40%, and as much as 75%, or all software ...Missing: origins | Show results with:origins
[14]
Building the System/360 Mainframe Nearly Destroyed IBM
Software problems also slowed production of the 360. The software development staff was described as being in “disarray” as early as 1963. The operating ...
[15]
Managing application program maintenance expenditures
Canning, R. G. That maintenance "iceberg" EDP Anal. (Oct. 1972). Google Scholar. [9]. Codasyl. Selection and acquisition of DBMS: A report of the CODASYL ...
[16]
The dimensions of maintenance - ACM Digital Library
The dimensions of maintenance. Author: E. Burton Swanson. E. Burton Swanson ... Published: 13 October 1976 Publication History. 101citation2,725Downloads.
[17]
https://www.semanticscholar.org/paper/The-dimensions-of-maintenance-Swanson/d14a38783decf5611343c2b551d53ff6ed921721
[18]
The dimensions of maintenance - Semantic Scholar
The dimensions of maintenance · E. Swanson · Published in International Conference on… 13 October 1976 · Computer Science.
[19]
Boehm's Software Maintenance Model - GeeksforGeeks
Jul 15, 2025 · Boehm proposed a formula for calculating the maintenance cost as it is a part of the COCOMO Model. All the collected data from the various ...
[20]
(PDF) Cost models for future software life cycle processes
Aug 7, 2025 · Current software cost estimation models, such as the 1981 Constructive Cost Model (COCOMO) for software cost estimation and its 1987 Ada ...
[21]
Best Practices for Managing Your Software Investment | Guide books
Practical Software Maintenance: Best Practices for Managing Your Software InvestmentNovember 1996. Journal cover image. Author: Author Picture Thomas M. Pigoski.
[22]
[PDF] Introduction to the Technical Debt Concept | Agile Alliance
Where does it comes from? Ward Cunningham, one of the authors of the Agile Manifesto, once said that some problems with code are like financial debt.
[23]
Defining, Measuring, and Managing Technical Debt - IEEE Xplore
Apr 26, 2023 · Ward Cunningham introduced the metaphor underlying the term technical debt in a 1992 experience report, where he described how his company incrementally ...
[24]
What is SDLC (Software Development Lifecycle)? - Amazon AWS
The software development lifecycle (SDLC) is the cost-effective and time-efficient process that development teams use to design and build high-quality software.Why is SDLC important? · How does SDLC work? · What are SDLC models?
[25]
[PDF] Software Development Cost Estimating Handbook - DAU
. Software maintenance cost estimates in 1976 ranged from 50 to 75 percent of the overall software life-cycle costs6. The trend is about the same today in.
[26]
What is a typical lifespan of a software application? Is there any 'rule ...
Aug 30, 2017 · My co-workers have worked with software that was 30+ years old. It really depends. If the business use case for the software remains the same, ...How long is the life of ERP software? - QuoraDoes a computer software or program have a lifespan? - QuoraMore results from www.quora.com
[27]
Software Development Timeline Guide 2025: Realistic Project ...
Dec 6, 2024 · Enterprise software development typically takes 12-24 months for full implementation. The timeline includes 3-4 months for planning and ...
[28]
Agile vs. Waterfall: What's the Difference? | IBM
In contrast to waterfall development, agile is defined by its iterative approach to project management. Instead of drafting lengthy project requirements at the ...Which project management... · What is waterfall?
[29]
Inside the Hidden World of Legacy IT Systems - IEEE Spectrum
Aug 28, 2020 · TSB's modernization of its banking IT systems causes 1.9 million customers to be locked out of their accounts, some for weeks; cost of the ...<|separator|>
[30]
End-of-Life Software: Definition, Management, & Best Practices
Apr 21, 2025 · End-of-life (EoL) software is when a product no longer receives support or updates, and is no longer sold or renewed.
[31]
Best practices for retiring applications before decommissioning ...
Best practices include capturing dependencies, communicating the plan, controlled shutdowns, preserving settings, following change management, and ...
[32]
Navigating the End-of-Life: A Guide to Decommissioning Software ...
Dec 20, 2023 · This involves identifying dependencies, understanding the impact on existing processes, and evaluating potential alternatives.
[33]
How to decommission a system: 3 keys to success - Red Hat
Oct 8, 2021 · Verify the resource's function. Once you get a decommissioning request from stakeholders, verify that the resource actually is unused. Perform ...
[34]
Application Decommissioning & Application Retirement: Guide for ...
Sep 10, 2025 · Reality: Decommissioning requires careful planning from data migration and archival strategies to compliance checks and user access validation.
[35]
Software Evolution - Mitosystems
Studies have shown the average software program lifespan over the last 20 years to be around 6-8 years. Longevity increases somewhat for larger programs.
[36]
Why COBOL Still Dominates Banking—and How to Modernize
May 16, 2024 · An over 60-year-old programming language is still the backbone of nearly half of all banking systems. Meet COBOL: the unsung hero behind 95% of ATM ...
[37]
Winding Down an Open Source Project - Linux Foundation
This guide will help you decide when a project is no longer useful, understand how to disengage from a project, and determine what to do about its code.
[38]
HeroDevs Blog | Navigating End-of-Life in Open-Source Software
Aug 6, 2024 · Explore the critical strategies for managing end-of-life software in the open-source ecosystem, highlighting key challenges and success stories.
[39]
What Are 4 Software Maintenance Types? Process And Cost
Nov 30, 2023 · Corrective software maintenance Corrective maintenance is focused on identifying, analyzing, and rectifying defects, errors, or issues that ...
[40]
Software Maintenance Costs: How to Estimate and Optimize
Depending on the software type, the number of users, and the required activities, monthly software maintenance costs may vary from $5,000 to $50,000+*. Below ...
[41]
Bug Tracking with Jira | Atlassian
Bug tracking tools like Jira provide a comprehensive solution for managing and resolving bugs and issues in software development. They offer efficiency, ...Benefits Of Bug Tracking... · Jira For Bug Tracking · Capture And Track Bugs In...
[42]
an illustrative case study of adaptive maintenance - IEEE Xplore
Adaptive maintenance is software maintenance performed to make a computer program usable in a changed environment [IEEE 1990].
[43]
Adaptive maintenance (AM)– Software Engineering - GeeksforGeeks
Jul 23, 2025 · Adaptive maintenance (AM) refers to the ongoing process of updating software to ensure it continues to function in the response to the changes in its operating ...Missing: proportion | Show results with:proportion
[44]
Migrating Legacy Systems to Cloud: Ensuring GDPR Compliance In ...
Feb 19, 2024 · Cloud migration with GDPR compliance involves moving data and apps from on-premise or legacy systems to cloud settings while adhering to the General Data ...
[45]
Software Maintenance: Types, Process, Cost & Best Practices
Oct 28, 2025 · Complete guide to software maintenance in SDLC. Learn 4 types of maintenance (corrective, adaptive, perfective, preventive), process, ...Missing: fault | Show results with:fault
[46]
What is a Software Maintenance Process? 4 Types of ... - Thales
What is Software Maintenance? Software maintenance is the process of changing, modifying, and updating software to keep up with customer needs.
[47]
Adaptive maintenance - AnAr Solutions
Adaptive maintenance consists of adapting software to changes in the environment such as the hardware or the operating system. The term environment in this ...Missing: proportion | Show results with:proportion
[48]
(PDF) Software maintenance productivity and maturity - ResearchGate
... effort as a percentage for adaptive maintenance varies between 41% and 67%. The same maintainer can perform corrective or adaptive maintenance, depending on ...Missing: proportion | Show results with:proportion
[49]
[PDF] IEEE Standard For Software Maintenance - IEEE Std 1219-1998
This standard provides additional software maintenance guidance on associated topics in Annex A and tools/ technology assistance in Annex B. Maintenance plan ...
[50]
[PDF] Software Maintenance and Evolution Overview - GMU CS Department
Percent of Total Maintenance. Perfective. ( 50% ). Adaptive. ( 25% ). Corrective. ( 21% ). Preventive. ( 4% ). Page 6. SWE 437 - Software Testing and ...<|control11|><|separator|>
[51]
Determining the Distribution of Maintenance Categories: Survey ...
They found that 17.4% of maintenance effort was categorized as corrective in nature, 18.2% as adaptive, 60.3% as perfective, and 4.1% was categorized as other. ...<|control11|><|separator|>
[52]
[PDF] ISO/IEC/IEEE 14764:2022 - iTeh Standards
“Maintenance” in this document means software maintenance unless otherwise stated. The document does not address the operation of software and the ...
[53]
Mastering Code Maintenance For Software Development
Feb 4, 2025 · Preventive Maintenance: Aims to foresee and preclude future problems. Regularly updating dependencies, writing comprehensive tests, and ...
[54]
4 Essential Types of Software Maintenance
Code Refactoring for Maintainability: Refactoring the codebase is an integral part of preventive maintenance. By restructuring the code without altering its ...
[55]
Types of software maintenance: Practical guide - N-iX
Aug 18, 2025 · Each maintenance cycle typically begins with a change request, followed by in-depth code analysis to implement updates without disrupting ...<|control11|><|separator|>
[56]
Software Maintainability: Developer Code Tools with SonarQube
Secure, high quality code makes maintenance easy. Minimal code maintenance leads to an optimized development workflow that supports more maintainable software.
[57]
OpenRewrite by Moderne | Large Scale Automated Refactoring ...
OpenRewrite is an open-source automated refactoring ecosystem for source code, enabling developers to effectively eliminate technical debt within their ...
[58]
Slash Maintenance Costs by 35% With Preventive CMMS | LLumin
Sep 12, 2025 · Preventive maintenance can reduce overall maintenance costs by 20–30% compared to a reactive strategy. Studies show that planned work is 3–5 ...<|separator|>
[59]
The critical role of reliability in aviation software
Preventative maintenance, as another example, is a key to ensuring the continued airworthiness of aircraft. Software-driven maintenance and diagnostic systems ...<|control11|><|separator|>
[60]
A Survey of Key Factors Affecting Software Maintainability
Mar 9, 2023 · This paper describes the several types of vital factors that affect the maintainability of software systems as proposed by different researchers.
[61]
[PDF] Comparative Study of the Factors that Affect Maintainability
Dec 12, 2011 · Abstract—The maintainability of the software system is becoming a very important characteristic due to growth in demand of quality software ...
[62]
Code metrics - Cyclomatic complexity - Visual Studio (Windows)
Dec 10, 2024 · Cyclomatic complexity measures the amount of decision logic in code, indicating how hard it is to test, maintain, and troubleshoot. Higher ...
[63]
A Complexity Measure | IEEE Journals & Magazine
This paper describes a graph-theoretic complexity measure and illustrates how it can be used to manage and control program complexity. The paper first explains.
[64]
[PDF] Design Principles and Design Patterns
Every fix makes it worse, introducing more problems than are solved. Page 3. Robert C. Martin. Copyright (c) 2000 by Robert C. Martin.
[65]
(PDF) Understanding separation of concerns - ResearchGate
The separation of concerns, as a conceptual tool, enables us to manage the complexity of the software systems that we develop.<|separator|>
[66]
Applying SOLID principles for the refactoring of legacy code
Such dependencies can introduce various issues, including increased coupling, reduced modularity, decreased maintainability, and challenges in scalability (Bass ...
[67]
An empirical analysis of the impact of software development ...
Many problem factors in the software development phase affect the maintainability of the delivered software systems. Therefore, understanding software ...
[68]
Elements of Software Science (Operating and programming systems ...
Elements of Software Science (Operating and programming systems series)May 1977. Author: Author Picture Maurice H. Halstead.Missing: original | Show results with:original
[69]
Software Maintainability - What It Means and How to Achieve It
The benefits of this approach are: • High isolation between modules. • Communication visibility and monitoring. • Error location. • Overload control. • ...
[70]
Refactoring: improving the design of existing code | Guide books
In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one.
[71]
[PDF] Improving the maintainability of automated test suites - Cem Kaner
Maintenance of the test suites is (allegedly) not a problem. Therefore, the story goes, a development manager can save lots of money and aggravation, and can ...
[72]
Maintainability in software: Definition & best practices - Tricentis
Sep 16, 2025 · Efficient testing workflows. Maintainable code enables better test isolation, faster test execution, and more predictable test results. Faster ...
[73]
What is version control | Atlassian Git Tutorial
Version control, also known as source control, is the practice of tracking and managing changes to software code. Version control systems are software tools ...What is Git · Source Code Management · 5 Key DevOps principlesMissing: maintenance | Show results with:maintenance
[74]
Version Control Best Practices | Tower Blog
Best practices include committing related, small changes often, testing before committing, and writing good commit messages. Don't commit half-done work.1. Commit Related Changes · 3. Don't Commit Half-Done... · 5. Write Good Commit...Missing: maintenance | Show results with:maintenance<|separator|>
[75]
What is CI/CD? - Red Hat
Jun 10, 2025 · CI/CD helps organizations avoid bugs and code failures while maintaining a continuous cycle of software development and updates. As apps grow ...
[76]
CI/CD Pipeline: Improving the CI/CD Process | Perforce Software
Mar 27, 2020 · A CI/CD pipeline is essential to accelerating delivery without sacrificing quality. Here we take a closer look at Continuous Integration and ...<|separator|>
[77]
[PDF] CODE REVIEW GUIDE - OWASP Foundation
• Maintainability code reviews. These types of code reviews are more towards the organizations internal best coding practices. This book does cover code ...<|separator|>
[78]
Code Review Best Practices - Palantir Blog
Mar 4, 2018 · We perform code reviews (CRs) in order to improve code quality and benefit from positive effects on team and company culture.
[79]
Understanding measures and metrics | SonarQube Server
Oct 16, 2025 · ... Technical debt in the Maintainability section). An 8-hour day is assumed when values are shown in days. Security remediation effort on new ...
[80]
On the diffuseness of technical debt items and accuracy of ...
Among the static analysis tools available, SonarQube is one of the most used. SonarQube detects Technical Debt (TD) items—i.e., violations of coding rules ...
[81]
Optimized Refactoring Mechanisms to Improve Quality ... - IEEE Xplore
Sep 15, 2023 · It involves tasks such as removing code duplications, renam- ing ambiguous variables and functions, and applying appro- priate design patterns.
[82]
Recommending Variable Names for Extract Local Variable ...
Jul 1, 2025 · Extract local variable is one of the most popular refactorings. It is frequently employed to replace occurrences of a complex expression ...
[83]
How Software Refactoring Impacts Execution Time
Dec 24, 2021 · Refactoring types aimed at decomposing complex code entities (e.g., Extract Class/Interface, Extract Method) have higher chances of triggering ...
[84]
Hidden and Siloed Knowledge Within Your Organization
Sep 30, 2019 · Knowledge silos are part of the natural evolution of project growth. As a project grows beyond the scope of one or two key team members, the ...Missing: maintenance turnover underfunding
[85]
The knowledge crisis in financial software: How talent shortages are ...
Apr 10, 2025 · The risks of knowledge monopolies · Higher operational costs: New developers spend more time navigating undocumented or overly complex code.
[86]
The Top 10 Challenges IT Teams Face This Year - Skillsoft
Workload remains a leading barrier to training, exacerbating issues like skill gaps and employee turnover. Whenever an employee quits, it can cause disruption ...
[87]
Top 5 Software Maintenance Services Problems & How to Avoid
May 21, 2025 · Inadequate Budget Allocation. Because software maintenance is often overlooked, it is often underfunded in favor of new development, leading ...
[88]
Planning for Long-Term Software Sustainability - Instandart
Oct 1, 2024 · By integrating maintenance costs into long-term financial planning, you can avoid the common mistake of underfunding software maintenance, which ...<|separator|>
[89]
IT Outsourcing to India – 8 Key Challenges and Solutions - TTMS
Jul 1, 2025 · Key challenges include communication, cultural differences, time zones, high employee turnover, quality control, data security, infrastructure, ...Missing: Eastern | Show results with:Eastern
[90]
India vs Latin America vs Eastern Europe for IT Outsourcing [2025]
Nov 12, 2024 · Explore the key strengths, challenges, and ideal use cases of India, Latin America, and Eastern Europe for IT outsourcing.Missing: dips | Show results with:dips
[91]
IT Outsourcing Insights & Red Flags 2025 - KITRUM
Oct 8, 2024 · Despite its widespread adoption, outsourcing can come with significant risks like communication barriers, data security concerns, quality ...Missing: dips | Show results with:dips<|separator|>
[92]
Chainguard Research Shows Engineers Struggle With Burnout ...
Oct 8, 2025 · Repetitive tasks and maintenance weigh heavily: 38% of engineers cited too many tedious tasks as a barrier to doing meaningful work, while ...Missing: statistics | Show results with:statistics
[93]
Toil Takes Its Toll: Developer Burnout Is Straining Organizational ...
Jun 25, 2024 · The report found that relentless workloads lead to burnout and are the primary reason most developers quit. More than half (52%) of developers ...
[94]
How Remote Work Impacts Software Development Projects
Oct 28, 2025 · The Cons of Remote Work in Software Development · Communication and Collaboration Issues · Management Difficulties · Motivation challenges.Missing: maintenance | Show results with:maintenance
[95]
The rise of remote work: challenges and opportunities for businesses
Oct 9, 2025 · Even well-run remote teams may suffer communication challenges in response to poor internet connections or software glitches. Furthermore ...Missing: maintenance post-
[96]
History of DevOps | Atlassian
DevOps started between 2007 and 2008 when IT and development teams, siloed by traditional models, began to collaborate to address dysfunction.Missing: 2009 | Show results with:2009
[97]
The Incredible True Story of How DevOps Got Its Name - New Relic
May 16, 2014 · A look back at how Patrick Debois and Andrew Shafer created the DevOps movement and gave it the name we all know it by today.Missing: origin | Show results with:origin
[98]
What is Continuous Delivery? - Continuous Delivery
Continuous Delivery is the ability to get changes of all types—including new features, configuration changes, bug fixes and experiments—into production ...About · Blog · Continuous Integration · Continuous TestingMissing: rapid maintenance
[99]
HashiCorp Developer
**Summary:**
[100]
Overview | Prometheus
### Summary: Prometheus for Proactive Issue Detection in DevOps
[101]
[PDF] 2021 Accelerate State of DevOps Report - Dora.dev
Elite performers now make up 26% of teams in our study, and have decreased their lead times for changes to production. The industry continues to accelerate, and ...
[102]
(PDF) Approaches and techniques for legacy software modernization
May 16, 2016 · ... 2) Wrapping [1, 7] : is a solution that surrounds legacy systems with a software layer that hides the unwanted features of the old ...
[103]
Design Patterns for Wrapping Similar Legacy Systems ... - IEEE Xplore
Abstract: Web services are increasingly being used to create a wide range of distributed systems, many of which involve legacy software.Missing: alternative | Show results with:alternative
[104]
(PDF) Encapsulation of legacy software: A technique for reusing ...
Aug 7, 2025 · The following paper reviews the possibilities of encapsulating existing legacy software for reuse in new distributed architectures.<|separator|>
[105]
8 Steps for Migrating Existing Applications to Microservices
Sep 28, 2020 · In this blog post, I describe a plan for how organizations that wish to migrate existing applications to microservices can do so safely and ...
[106]
Monolith to microservices: step-by-step migration strategies | CircleCI
Apr 28, 2025 · Learn proven strategies for breaking down monolithic applications into microservices with practical steps, patterns, and techniques to ...Assess Monolith Suitability · Build Microservices... · Data Migration StrategiesMissing: redevelopment | Show results with:redevelopment
[107]
The 7 Rs of Cloud Migration: 7 Strategies Explained - NetApp
Jun 9, 2023 · The 7 cloud migration strategies are: rehost, relocate, replatform, refactor, repurchase, retire, and retain.
[108]
About the migration strategies - AWS Prescriptive Guidance
This strategy is also known as lift and shift. Using this strategy, you move your applications from your source environment to the AWS Cloud without making any ...
[109]
Select your cloud migration strategies - Cloud Adoption Framework
Jul 25, 2025 · A migration strategy defines how each workload transitions to Azure based on its business driver. Review the narrowed list of strategies and ...
[110]
What To Do When Critical Open Source Projects Go End of Life
Aug 8, 2025 · Open source software churn is accelerating. Here's how to plan for EOL and mitigate projects with uncertain futures.
[111]
ING Bank COBOL-to-Java Migration Case Study - SoftwareMining
Rating 5.0 (6) · Free · WindowsUsing SoftwareMining's COBOL-to-Java conversion tools, the bank seamlessly transformed its mainframe COBOL/CICS applications into modern Java code. Because the ...
[112]
AT&T UPS-EMS System - IBM COBOL to Java Modernization on AWS
TSRI's engineers employed their 99.987% automated modernization solutions to transform all 409,568 lines of IBM z/OS COBOL to Java in just 4 months. TSRI ...
[113]
Automated Refactoring of a New York Times Mainframe to AWS with ...
May 22, 2019 · This phase lasted around two years and included both the COBOL-to-Java transformation as well as the VSAM-to-relational database conversion, ...
[114]
SynergyBug: A deep learning approach to autonomous debugging ...
Jul 10, 2025 · SynergyBug combines BERT and GPT-3 to autonomously detect and repair bugs across multiple sources. It resolves essential requirements by implementing an ...
[115]
Cost of Technical Debt: New Research by Sonar
Jul 19, 2023 · The research, based on an examination of over 200 projects within a 12-month span, calculates that the attributed technical debt cost is ...
[116]
(PDF) Analysis Of Software Maintenance Cost Affecting Factors And ...
Aug 6, 2025 · Estimates of the proportion of resources and time devoted to maintenance range from 50% to 80%. [ Boehm, 1981 ] The greatest part of the ...
[117]
Code smells and refactoring: A tertiary systematic review of ...
We show that code smells and refactoring have a strong relationship with quality attributes, ie, with understandability, maintainability, testability, ...
[118]
Research on Fault Prognosis Technology for Mechanical Equipment ...
Sep 17, 2025 · Experimental results demonstrate that the CNN-LSTM model achieves an accuracy of 98.24% in time-series fault prediction, outperforming ...
[119]
An LSTM approach for fault prediction | Request PDF - ResearchGate
Nov 1, 2025 · Results show that LSTM networks effectively capture temporal failure patterns in both cases. The generalized model achieved outstanding accuracy ...
[120]
Creating event-driven architectures with Lambda
Understand how events drive serverless applications, which informs the design of your workload. How Lambda fits into this paradigm.Missing: cloud software
[121]
Serverless Computing: A Survey of Opportunities, Challenges, and ...
3.1 No Deployment and Maintenance Complexity. The very first and foremost opportunity that serverless computing offers is to relieve users from managing the ...
[122]
Refactoring code with GitHub Copilot
The benefits of refactoring include improving code readability, reducing complexity, making the code easier to maintain, and allowing new features to be added ...Refactoring data access layers · Fix database deadlocks · Performance optimization
[123]
Research: Quantifying GitHub Copilot's impact in the enterprise with ...
May 13, 2024 · We conducted research with developers at Accenture to understand GitHub Copilot's real-world impact in enterprise organizations.
[124]
Post-Quantum Cybersecurity Resources - National Security Agency
In summary, NSA views quantum-resistant (or post-quantum) cryptography as a more cost effective and easily maintained solution than quantum key distribution.Missing: maintenance | Show results with:maintenance
[125]
Blockchain-Based Decentralized Architecture for Software Version ...
Feb 27, 2023 · In a blockchain-based system, the data is stored in a distributed location to maintain the transparency of the data and achieve data integrity.Missing: maintenance | Show results with:maintenance