Jump to content

Software maintenance: Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
VisualWikitext
No edit summary
→Sources: fix categories
(2 intermediate revisions by 2 users not shown)
Line 1: Line 1:
{{short description|Modification of a software product after delivery}}
{{short description|Modification of a software product after delivery}}

{{Multiple issues|
{{Citation style|date=September 2010}}
{{More citations needed|date=January 2015}}
}}
{{Software development process|Core activities}}
{{Software development process|Core activities}}
'''Software maintenance''' is the modification of a software product after delivery.
'''Software maintenance''' in [[software engineering]] is the modification of a software product after delivery to correct faults, to improve performance or other attributes.<ref name="iso14764">{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39064 |title=ISO/IEC 14764:2006 Software Engineering — Software Life Cycle Processes — Maintenance |publisher=Iso.org |date=2011-12-17 |access-date=2013-12-02}}</ref><ref>{{Cite journal|last1=Soleimani Neysiani|first1=Behzad|last2=Babamir|first2=Seyed Morteza|last3=Aritsugi|first3=Masayoshi|date=2020-10-01|title=Efficient feature extraction model for validation performance improvement of duplicate bug report detection in software bug triage systems|url=https://linkinghub.elsevier.com/retrieve/pii/S0950584920301117|journal=Information and Software Technology|language=en|volume=126|pages=106344|doi=10.1016/j.infsof.2020.106344|s2cid=219733047}}</ref>


Software maintenance is often considered lower skilled and less rewarding than new development. As such, it is a common target for [[outsourcing]] or [[offshoring]]. Usually, the team developing the software is different from those who will be maintaining it. The developers lack an incentive to write the code to be easily maintained. Software is often delivered incomplete and almost always contains some bugs that the maintenance team must fix. Software maintenence often initially includes the development of new functionality, but as the product nears the end of its lifespan maintenence is reduced to the bare minimum and then cut off entirely before the product is withdrawn.
A common perception of maintenance is that it merely involves fixing [[Software bug|defects]]. However, one study indicated that over 80% of maintenance effort is used for non-corrective actions.<ref>Pigoski, Thomas M., 1997: Practical software maintenance: Best practices for managing your software investment. Wiley Computer Pub. (New York)</ref> This perception is perpetuated by users submitting problem reports that in reality are functionality enhancements to the system.{{citation needed|date=January 2015}} More recent studies put the bug-fixing proportion closer to 21%.<ref>Eick, S., Graves, T., Karr, A., Marron, J., and Mockus, A. 2001. Does Code Decay? Assessing Evidence from Change Management Data. IEEE Transactions on Software Engineering. 27(1) 1-12.</ref>


Each maintenence cycle begins with a change request typically originating from a customer. That request is evaluated and if it is decided to implement it, the programmer studies the existing code to understand how it works before implementing the change. Testing to make sure the existing functionality is retained and the desired new functionality is added often comprises the majority of the maintenance cost.
==History==
Software maintenance and [[Software evolution|evolution]] of systems was first addressed by [[Meir M. Lehman]] in 1969. Over a period of twenty years, his research led to the formulation of [[Software evolution#Lehman's Laws of Software Evolution|Lehman's Laws]] (Lehman 1997). Key findings of his research conclude that maintenance is really evolutionary development and that maintenance decisions are aided by understanding what happens to systems (and software) over time. Lehman demonstrated that systems continue to evolve over time. As they evolve, they grow more complex unless some action such as [[code refactoring]] is taken to reduce the complexity.
In the late 1970s, a famous and widely cited survey study by Lientz and Swanson, exposed the very high fraction of [[Whole-life cost|life-cycle costs]] that were being expended on maintenance.


Software maintenance is not as well studied as other phases of the software life cycle, despite comprising the majority of costs. Understanding has not changed significantly since the 1980s. Software maintenance can be categorized into several types depending on whether it is preventative or reactive and whether it is seeking to add functionality or preserve existing functionality.
The survey showed that around 75% of the maintenance effort was on the first two types, and error correction consumed about 21%. Many subsequent studies suggest a similar problem magnitude. Studies show that the contribution of end users is crucial during the new requirement data gathering and analysis. This is the main cause of any problem during software evolution and maintenance. Software maintenance is important because it consumes a large part of the overall lifecycle costs and also the inability to change software quickly and reliably means that business opportunities are lost.
<ref>Lientz B., Swanson E., 1980: Software Maintenance Management. Addison Wesley, Reading, MA</ref>
<ref>Lehman M. M., 1980: Program, Life-Cycles and the Laws of Software Evolution. In Proceedings of IEEE, 68, 9,1060-1076</ref>
<ref>Penny Grubb, Armstrong A. Takang, 2003: Software Maintenance: Concepts and Practice. World Scientific Publishing Company</ref>


==History==
==Importance of software maintenance==
In the early 1970s, companies began to separate out software maintenance with its own team of engineers to free up [[software development]] teams from support tasks.{{sfn|Tripathy |Naik|2014|p=25}} In 1972, R. G. Canning published "The Maintenance 'Iceberg{{'"}}, in which he contended that software maintenance was an extension of software development with an additional input: the existing system.{{sfn|Tripathy |Naik|2014|p=25}} The discipline of software maintenance has changed little since then.<ref name=Offutt>{{cite web |last1=Offutt |first1=Jeff |author1-link=Jeff Offutt |title=Overview of Software Maintenance and Evolution |url=https://cs.gmu.edu/~offutt/classes/437/maintessays/maintEvolutionOverview.html |website=[[George Mason University]] Department of Computer Science |access-date=5 May 2024 |date=January 2018}}</ref> One twenty-first century innovation has been companies deliberately releasing incomplete software and planning to finish it post-release. This type of change, and others that expand functionality, is often called [[software evolution]] instead of maintenance.<ref name=Offutt/>
==Software life cycle==
[[File:Traditional software development life cycle diagram.png|thumb|upright=2.5|center|Diagram for a traditional [[software development life cycle]] from 1988]]
Despite [[software testing|testing]] and [[Software quality assurance|quality assurance]], virtually all software contains [[software bug|bugs]] where the system does not work as intended. Post-release maintenance is necessary to remediate these bugs when they are found.{{sfn|Tripathy |Naik|2014|p=4}} Most software is a combination of pre-existing [[commercial off-the-shelf]] (COTS) and [[open-source software]] components with custom-written code. COTS and open-source software is typically updated over time, which can reduce the maintenance burden, but the modifications to these software components will need to be adjusted for in the final product.{{sfn|Tripathy |Naik|2014|pp=5-6}} Unlike [[software development]], which is focused on meeting specified requirements, software maintenance is driven by events—such as customer requests or detection of a bug.{{sfn|Tripathy |Naik|2014|p=26}} Its main purpose is to preserve the usefulness of the software, usually in the face of changing requirements.{{sfn|Madhusudhan ''et al.''|2017|p=761}}


If conceived of as part of the [[software development life cycle]], maintenance is the last and typically the longest phase of the cycle,{{sfn|Varga|2018|p=3}}{{sfn|Tripathy |Naik|2014|p=7}} comprising about 75 percent of resources, with only 25 percent going to the initial development phase.{{sfn|Varga|2018|p=6}} Other estimates of the cost of maintenance are even higher, reaching 80 to 90 percent of the lifecycle cost.{{sfn|Ulziit ''et al.''|2015|p=764}} Other models consider maintenance separate from software development, instead as part of the software maintenance life cycle (SMLC).{{sfn|Tripathy |Naik|2014|p=7}} SMLC models typically include understanding the code, modifying it, and revalidating it.{{sfn|Tripathy |Naik|2014|p=7}}
The key software maintenance issues are managerial and technical. Management issues include alignment with customer priorities, staffing, assigning responsibilities, and estimating costs. Technical issues include: limited understanding, [[Change impact analysis|impact analysis]], testing, and maintainability measurement.
===Transition from release to maintenance to end of the lifespan===
[[File:Software retirement diagram.png|thumb|upright=1.5|Diagram showing the steps for [[Application retirement|software retirement]]]]
Frequently, software is delivered in an incomplete state. Developers will test a product until running out of time or funding, because they face fewer consequences for an imperfect product than going over time or budget.{{sfn |Reifer|2012|p=22}} The transition from the development to the maintenance team is often inefficient, without lists of known issues or validation tests, which the maintenance team will likely recreate.{{sfn |Reifer|2012|p=21}} After release, members of the development team are likely to be reassigned or otherwise become unavailable. The maintenance team will require additional resources for the first year after release, both for [[technical support]] and fixing defects left over from development.{{sfn |Reifer|2012|p=22}}


Initially, software may go through a period of enhancements after release. New features are added according to customer feedback. At some point, the company may decide that it is no longer profitable to make functional improvements, and restrict support to bug fixing and emergency updates. Changes become increasingly difficult and expensive due to lack of expertise or decaying architecture due to [[software aging]]. After a product is no longer maintained, and does not receive even this limited level of updating, some vendors will seek to extract revenue from the software as long as possible, even though the product is likely to become increasingly avoided. Eventually, the software will be withdrawn from the market, although it may remain in use. During this process, the software becomes a [[legacy system]].{{sfn|Tripathy |Naik|2014|p=89}}
Software maintenance is a broad activity that include error correction, enhancements of capabilities, removal of obsolete capabilities, and optimization. Because change is inevitable, mechanisms must be developed for evaluation, control and making modifications.


===Change cycle ===
Any work done on software after it is deployed is considered maintenance.
The first step in the change cycle is receiving a change request from a customer and analyzing it to confirm the problem and decide whether to implement the change.{{sfn|Madhusudhan ''et al.''|2017|p=763}} This may require input from multiple departments; for example, the marketing team can help evaluate whether the change is expected to bring more business.{{sfn|Tripathy |Naik|2014|p=120}} [[Software development effort estimation]] is a difficult problem, including for maintenance change requests,{{sfn|Madhusudhan ''et al.''|2017|p=762}} but the request is likely to be declined if it is too expensive or infeasible.{{sfn|Tripathy |Naik|2014|p=123}} If it is decided to implement the request, it can be assigned to a scheduled release and implemented.{{sfn|Tripathy |Naik|2014|p=123}}
Maintenance preserves software's value over time. Value can be enhanced by expanding the customer base, meeting new and additional requirements, becoming easier to use, more efficient and employing newer technology. Maintenance may span decades, whereas initial development is typically less than 3 years.


Understanding existing code is an essential step before modifying it.<ref name=Offutt/> The rate of understanding depends both on the code base as well as the skill of the programmer.{{sfn|Tripathy |Naik|2014|p=296}} Following coding conventions such as using clear function and variable names that correspond to their purpose makes understanding easier.{{sfn|Tripathy |Naik|2014|pp=296-297}} Use of [[conditional loop]] statements only if the code could execute more than once, and eliminating code that will never execute can also increase understandability.{{sfn|Tripathy |Naik|2014|p=309}} Experienced programmers have an easier time understanding what the code does at a high level.{{sfn|Tripathy |Naik|2014|p=297}} [[Software visualization]] is sometimes used to speed up this process.{{sfn|Tripathy |Naik|2014|pp=318-319}}
==Software maintenance planning==
An integral part of software is maintenance, which requires an accurate maintenance plan to be constructed during the software development. It should specify how users will request modifications or report problems. The budget should include resource and cost estimates, and a new decision should be addressed for the development of every new system feature and its quality objectives. The software maintenance, which can last for 5+ years (or even decades) after the development process, calls for an effective plan which can address the scope of software maintenance, the tailoring of the post delivery/deployment process, the designation of who will provide maintenance, and an estimate of the life-cycle costs.


Modification to the code may take place in any way. On the one hand, it is common to haphazardly apply a quick fix without being granted enough time to update the [[code documentation]].{{sfn|Tripathy |Naik|2014|pp=85-86}} On the other hard structured iterative enhancement can begin by changing the top-level requirements document and propagating the change down to lower levels of the system.{{sfn|Tripathy |Naik|2014|p=86}} Modification often includes [[code refactoring]] (improving the structure without changing functionality) and restructuring (improving structure and functionality at the same time). {{sfn|Tripathy |Naik|2014|p=94}} Unlike commercial software, [[free and open source software]] change cycles are largely restricted to coding and testing, with minimal documentation. Open-source software projects instead rely on mailing lists and a large number of contributors to understand the code base and fix bugs efficiently.{{sfn|Tripathy |Naik|2014|p=59}}
==Software maintenance processes==
This section describes the six software maintenance processes as:
# Implementation - software preparation and transition activities, such as the creation of the maintenance plan; the preparation for handling problems identified during development; and the follow-up on product configuration management.
# Problem and modification analysis - Requests and problems are confirmed (reproduced), analyzed and investigated. Solutions are proposed and documented. Authorization to apply modifications is obtained.
# Modification implementation - software code, data and/or configuration is updated, compiled, and re-deployed.
# Modification acceptance - the individual who submitted the request operates/tests the software to confirm that the issue has been resolved.
# Migration ([[Software migration|platform migration]], for example) is exceptional, and is not part of daily maintenance tasks. If the software must be ported to another platform without any change in functionality, this process will be used and a maintenance project team is likely to be assigned to this task.
# Retirement of obsolete/replaced software components. This, typically does not occur on a daily basis.


An additional problem with maintenance is that nearly every change to code will introduce new bugs or unexpected [[ripple effect]]s, which require another round of fixes.<ref name=Offutt/> Testing can consume the majority of maintenance resource for safety-critical code, due to the need to revalidate the entire software if any changes are made.{{sfn|Reifer |2012|p=5}} Revalidation may include [[code review]], [[regression test]]ing with a subset of [[unit test]]s, [[integration test]]s, and [[system test]]s.{{sfn|Tripathy |Naik|2014|p=94}} The goal of the testing is to verify that previous functionality is retained, and the new functionality has been added. {{sfn|Tripathy |Naik|2014|p=98}}
There are a number of processes, activities, and practices that are unique to maintainers, for example:
* Transition: a controlled and coordinated sequence of activities during which a system is transferred progressively from the developer to the maintainer. Ideally, it should include a Knowledge Transfer (KT) to occur during a typical hand-over.
* [[Service Level Agreement]]s (SLAs) and specialized (domain-specific) maintenance contracts negotiated by maintainers
* Modification Request and Problem Report Help Desk: a problem-handling process used by maintainers to prioritize, document, and route requests.


==Categories of software maintenance==
==Categories of software maintenance==
The key purpose of software maintenance is ensuring that the product continues to meet usability requirements. At times, this may mean extending the product's capabilities beyond what was initially envisioned.{{sfn|Varga|2018|p=4}}
E.B. Swanson initially identified three categories of maintenance: corrective, adaptive, and perfective.<ref>{{cite journal|url=http://portal.acm.org/citation.cfm?id=359522 |title=E. Burt Swanson, The dimensions of maintenance. Proceedings of the 2nd international conference on Software engineering, San Francisco, 1976, pp 492 — 497 |journal=Communications of the ACM |date=June 1978 |volume=21 |issue=6 |pages=466–471 |doi=10.1145/359511.359522 |publisher=Portal.acm.org |s2cid=14950091 |access-date=2013-12-02|last1=Lientz |first1=B. P. |last2=Swanson |first2=E. B. |last3=Tompkins |first3=G. E. |doi-access=free }}</ref> The '''IEEE 1219''' standard was superseded in June 2010 by '''P14764'''.<ref>[http://standards.ieee.org/cgi-bin/status?1219-1998 Status of 1219-1998] by IEEE Standards</ref>
These have since been updated and ISO/IEC 14764 presents:
* [[Corrective maintenance]]: Reactive modification of a software product performed after delivery to correct discovered problems. Corrective maintenance can be automated with [[automatic bug fixing]].
* Adaptive maintenance: Modification of a software product performed after delivery to keep a software product usable in a changed or changing environment.
* Perfective maintenance: Modification of a software product after delivery to improve performance or [[maintainability]].
* [[Preventive maintenance]]: Modification of a software product after delivery to detect and correct latent faults in the software product before they become effective faults.


According to the [[International Organization for Standardization|ISO]]/[[International Electrotechnical Commission|IEC]] 14764 specification, software maintenance can be classified into four types:{{sfn|Varga|2018|p=5}}
There is also a notion of pre-delivery/pre-release maintenance which is all the good things you do to lower the total cost of ownership of the software. Things like compliance with coding standards that includes software maintainability goals. The management of coupling and cohesion of the software. The attainment of software supportability goals (SAE JA1004, JA1005 and JA1006 for example). Some academic institutions{{Who|date=January 2015}} are carrying out research to quantify the cost of ongoing software maintenance due to the lack of resources such as design documents and system/software comprehension training and resources (multiply costs by approx. 1.5-2.0 where there is no design data available).
* [[Corrective maintenance]]: modification of software to fix a [[software bug|bug]] or other failure to meet requirements, typically reported by a customer.{{sfn|Varga|2018|p=5}}{{sfn|Tripathy |Naik|2014|pp=26-27}}
* [[Preventive maintenance]]: forward-looking modification of a software product after delivery to ensure it continues to meet requirements or fix problems that have not manifested yet.{{sfn|Tripathy |Naik|2014|p=27}}{{sfn|Varga|2018|p=5}} This type of maintenance is performed especially on systems that are required to be highly safe or available.{{sfn|Tripathy |Naik|2014|p=27}} [[Software rejuvenation]] is one form of preventative maintenance to clean up state and prevent future problems.{{sfn|Tripathy |Naik|2014|p=27}}
* Adaptive maintenance: modification of a software product performed after delivery to keep a software product usable in a changed or changing environment.{{sfn|Varga|2018|p=5}}{{sfn|Tripathy |Naik|2014|p=27}}
* Perfective maintenance: enhancement of a software product after delivery to improve qualities such as [[user experience]], processing efficiency, and [[maintainability]].{{sfn|Tripathy |Naik|2014|p=27}}{{sfn|Varga|2018|pp=5-6}} Perfective maintenance is necessary if other types of maintenance are carried out, because modification of an existing code base will otherwise increase complexity and cause the existing structure to deteriorate.{{sfn|Varga|2018|pp=5-6}} Perfective maintenance may include rewriting [[software documentation|documentation]], [[code refactoring]], and performance tuning.{{sfn|Tripathy |Naik|2014|p=27}}
According to some estimates, enhancement (the latter two categories) comprises some 80 percent of software maintenance.{{sfn|Varga|2018|p=5 fn 4}}
==Maintainability==
{{main|Maintainability}}
Maintainability is the quality of software enabling it to be easily modified without breaking existing functionality.{{sfn|Varga|2018|p=5}} According to the ISO/IEC 14764 specification, activity to ensure software maintainability prior to release counts as part of software maintenance.{{sfn|Tripathy |Naik|2014|p=26}} Many software development organizations neglect maintainability, even though it will increase long-term costs.{{sfn|Varga|2018|p=12}} [[Technical debt]] is incurred when programmers, often out of laziness or urgency to meet a deadline, choose quick and dirty solutions rather than build maintainability into their code.{{sfn|Varga|2018|pp=6-7}} A common cause is underestimates in [[software development effort estimation]], leading to insufficient resources allocated to development.{{sfn|Varga|2018|p=7}}One important aspect is having a large amount of automated [[software test]]s that can detect if existing functionality is compromised by a change.{{sfn|Varga|2018|p=5}}


A challenge with maintainability is that many [[software engineering]] courses do not emphasize it, and give out one-and-done assignments that have clear and unchanging specifications.{{sfn|Varga|2018|pp=7-8}} Software engineering courses do not cover the systems as complex as occur in the real world.{{sfn|Varga|2018|p=9}} Development engineers who know that they will not be responsible for maintaining the software do not have an incentive to build in maintainability.<ref name=Offutt/>
==Maintenance factors==
Impact of key adjustment factors on maintenance (sorted in order of maximum positive impact)
{|
|-
! Maintenance Factors !! Plus Range
|-
| Maintenance specialists || 35%
|-
| High staff experience || 34%
|-
| Table-driven variables and data || 33%
|-
| Low complexity of base code || 32%
|-
| Y2K and special search engines || 30%
|-
| Code restructuring tools || 29%
|-
| Re-engineering tools || 27%
|-
| High level programming languages || 25%
|-
| Reverse engineering tools || 23%
|-
| Complexity analysis tools || 20%
|-
| Defect tracking tools || 20%
|-
| Y2K “mass update” specialists || 20%
|-
| Automated change control tools || 18%
|-
| Unpaid overtime || 18%
|-
| Quality measurements || 16%
|-
| Formal base code inspections || 15%
|-
| Regression test libraries || 15%
|-
| Excellent response time || 12%
|-
| Annual training of > 10 days || 12%
|-
| High management experience || 12%
|-
| HELP desk automation || 12%
|-
| No error prone modules || 10%
|-
| On-line defect reporting || 10%
|-
| Productivity measurements || 8%
|-
| Excellent ease of use || 7%
|-
| User satisfaction measurements || 5%
|-
| High team morale || 5%
|-
! Sum !! 503%
|}


==Workforce==
Not only are error-prone modules troublesome, but they can degrade performance too. For example, very complex [[spaghetti code]] is quite difficult to maintain safely.
Maintenance is often considered an unrewarding job for [[software engineer]]s, who, if assigned to maintenance, were more likely to quit.{{sfn|Madhusudhan ''et al.''|2017|p=764}}{{sfn |Reifer |2012|p=7}} It often pays less than a comparable job in software development.{{sfn |Reifer |2012|p=7}} The task is often assigned to temporary workers or lesser-skilled staff,<ref name=Offutt/>{{sfn |Reifer |2012|p=8}} although maintenance engineers are also typically older than developers, partly because they must be familiar with outdated technologies.{{sfn |Reifer |2012|p=8}} Companies started separate teams for maintenance, which led to [[outsourcing]] this work to a different company, and by the turn of the twenty-first century, sometimes [[offshoring]] it to a different part of the world—whether as part of the original company or a separate entity.{{sfn|Rahman ''et al.''|2024|p=1}}{{sfn|Ulziit ''et al.''|2015|p=764}} Reasons for offshoring include taking advantage of lower labor costs, enabling around-the-clock support, reducing time pressure on developers, and to move support closer to the market for the product.{{sfn|Ulziit ''et al.''|2015|p=763}} Downsides of offshoring include communication barriers in the form of such factors as [[time zone]] and organizational disjunction and cultural differences.{{sfn|Ulziit ''et al.''|2015|p=764}} Despite many employers considering maintenance lower-skilled work and the phase of software development most suited to offshoring,{{sfn|Ulziit ''et al.''|2015|p=764}}{{sfn |Reifer |2012|p=2}} it requires close communication with the customer and rapid response, both of which are hampered by these communication difficulties.{{sfn|Ulziit ''et al.''|2015|p=764}} In 2008, around 900,000 of the 1.3 million software engineers and programmers working in the United States were doing maintenance, and that number was rising despite increasing offshoring.{{sfn |Reifer|2012|p=1}}
A very common situation which often degrades performance is lack of suitable maintenance tools, such as defect tracking software, change management software, and test library software. Below describe some of the factors and the range of impact on software maintenance.


==Alternatives to maintenance==
Impact of key adjustment factors on maintenance (sorted in order of maximum negative impact)
In software engineering, the term [[legacy system]] does not have a fixed meaning, but often refers to older systems which are large, difficult to modify, and also necessary for current business needs. Often legacy systems are written in obsolete [[programming language]]s, lack documentation, have a deteriorating structure after years of changes, and depends on experts to keep it operational.{{sfn|Tripathy |Naik|2014|pp=187-188}} When dealing with these systems, at some point so much technical debt accumulates that maintenance is not be practical or economical.{{sfn|Tripathy |Naik|2014|p=89}} Other choices include:
{|
*Freezing—do no more work on the legacy system.{{sfn|Tripathy |Naik|2014|p=188}}
|-
*[[Outsourcing]] functionality of the legacy system to a different company, especially if it is not considered a core business function.{{sfn|Tripathy |Naik|2014|p=188}}
! Maintenance Factors !! Minus Range
*Discarding the existing legacy system and redeveloping a new application from scratch to fulfill the same purpose as the legacy system.{{sfn|Tripathy |Naik|2014|p=188}}
|-
*Wrapping the legacy application in an [[abstraction layer]] to simplify outdated interfaces{{sfn|Tripathy |Naik|2014|p=188}}
| Error prone modules || -50%
*Migrating the legacy system to a new platform, which can reduce the expense of new software development by enabling reuse of the implementation, design, specification, and requirements of the legacy system.{{sfn|Tripathy |Naik|2014|pp=188-189}}
|-
| Embedded variables and data || -45%
|-
| Staff inexperience || -40%
|-
| High code complexity || -30%
|-
| No Y2K of special search engines || -28%
|-
| Manual change control methods || -27%
|-
| Low level programming languages || -25%
|-
| No defect tracking tools || -24%
|-
| No Y2K “mass update” specialists || -22%
|-
| Poor ease of use || -18%
|-
| No quality measurements || -18%
|-
| No maintenance specialists || -18%
|-
| Poor response time || -16%
|-
| No code inspections || -15%
|-
| No regression test libraries || -15%
|-
| No help desk automation || -15%
|-
| No on-line defect reporting || -12%
|-
| Management inexperience || -15%
|-
| No code restructuring tools || -10%
|-
| No annual training || -10%
|-
| No reengineering tools || -10%
|-
| No reverse-engineering tools || -10%
|-
| No complexity analysis tools || -10%
|-
| No productivity measurements || -7%
|-
| Poor team morale || -6%
|-
| No user satisfaction measurements || -4%
|-
| No unpaid overtime || 0%
|-
!Sum !! -500%
|}


==Research==
<ref>{{cite web |url=http://www.compaid.com/caiinternet/ezine/capersjones-maintenance.pdf |title=The Economics Of Software Maintenance In The Twenty First Century |access-date=2013-12-02 |url-status=dead |archive-url=https://web.archive.org/web/20150319075401/http://www.compaid.com/caiinternet/ezine/capersjones-maintenance.pdf |archive-date=2015-03-19 }}</ref>
Despite taking up the lion's share of software development resources, maintenance is the least studied phase of software development.{{sfn|Madhusudhan ''et al.''|2017|p=759}}{{sfn|Ulziit ''et al.''|2015|p=766}} Much of the literature has focused on how to develop maintainable code from the outset, with less focus on motivating engineers to make maintainability a priority.{{sfn|Reifer|2012|pp=4-5}} {{as of|2020}}, automated solutions for code refactoring to reduce maintenance effort are an active area of research,{{sfn|Baqais |Alshayeb |2020|p=459}} as is [[machine-learning]] enhanced maintainability assessment.{{sfn|Alsolai|Roper|2020|p=106214}}

== Maintenance debt ==
In a paper for the 27th International Conference on Software Quality Management in 2019,<ref>{{Cite book|title=Proc of Software Quality Management XXVII: International Experiences and Initiatives in IT Quality Management|last1=Khan|first1=O|last2=Marchbank|first2=P|last3=Georgiadou|first3=E|last4=Linecar|first4=P|last5=Ross|first5=M|last6=Staples|first6=G|publisher=Solent University|year=2019|isbn=978-1-9996549-2-4|location=Southampton}}</ref> John Estdale introduced the term “maintenance debt” for maintenance needs generated by an implementation’s dependence on external IT factors such as libraries, platforms and tools, that have become obsolescent.<ref name=":0">{{Cite book|url=https://www.researchgate.net/publication/335983023|title=Delaying Maintenance Can Prove Fatal|last=Estdale|first=John|publisher=in [11]|pages=95–106}}</ref> The application continues to run, and the IT department forgets this theoretical liability, focusing on more urgent requirements and problems elsewhere. Such debt accumulates over time, silently eating away at the value of the software asset. Eventually something happens that makes system change unavoidable.

The owner may then discover that the system can no longer be modified – it is literally unmaintainable. Less dramatically, it may take too long, or cost too much, for maintenance to solve the business problem, and an alternative solution must be found. The software has suddenly crashed to £0 value.

Estdale defines "Maintenance Debt"<ref name=":0" /> as: the gap between the current implementation state of an application and the ideal, using only functionality of external components that is fully maintained and supported. This debt is often hidden or not recognized. An application’s overall maintainability is dependent on the continuing obtainability of components of all sorts from other suppliers, including:
* Development tools: source editing, configuration management, compilation and build
* Testing tools: test selection, execution/verification/reporting
* Platforms to execute the above: hardware, operating system and other services
* Production environment and any standby/Disaster Recovery facilities, including the source code language’s Run-Time Support Environment, and the wider ecosystem of job scheduling, file transfer, replicated storage, backup and archive, single sign-on, etc etc.
* Separately acquired packages, eg DBMS, graphics, comms, middleware
* Bought in source-code, object code libraries, and other invocable services
* Any requirements arising from other applications sharing the production environment or interworking with the application in question

and of course
* The availability of relevant skills, in-house, or in the marketplace.

The complete disappearance of a component could make the application unrebuildable, or imminently unmaintainable.

==See also==
* [[Application retirement]]
* ''[[Journal of Software Maintenance and Evolution: Research and Practice]]''
* [[Long-term support]]
* [[Search-based software engineering]]
* [[Software archaeology]]
* [[Software maintainer]]
* [[Software development]]


==References==
==References==
<ref>{{cite web|last=Pigoski|first=Thomas|title=Chapter 6: Software Maintenance|url=http://sce.uhcl.edu/helm/SWEBOK_IEEE/data/swebok_chapter_06.pdf|work=SWEBOK|publisher=IEEE|access-date=5 November 2012}}</ref>
{{reflist}}
{{reflist}}


==Further reading==
==Sources==
{{refbegin|indent=yes}}
* {{Cite book | doi = 10.1109/IEEESTD.2006.235774| year = 2006| isbn = 0-7381-4960-8| title = ISO/IEC/IEEE International Standard for Software Engineering - Software Life Cycle Processes - Maintenance}}
*{{cite journal |last1=Alsolai |first1=Hadeel |last2=Roper |first2=Marc |title=A systematic literature review of machine learning techniques for software maintainability prediction |journal=Information and Software Technology |date=2020 |volume=119 |pages=106214 |doi=10.1016/j.infsof.2019.106214}}
* {{cite book | author= Pigoski, Thomas M. | title=Practical Software Maintenance | location= New York | publisher=John Wiley & Sons | year=1996 |isbn= 978-0-471-17001-3}}
*{{cite journal |last1=Baqais |first1=Abdulrahman Ahmed Bobakr |last2=Alshayeb |first2=Mohammad |title=Automatic software refactoring: a systematic literature review |journal=Software Quality Journal |date=2020 |volume=28 |issue=2 |pages=459–502 |doi=10.1007/s11219-019-09477-y}}
* {{cite book | author= Pigoski, Thomas M. | title=Description for Software Evolution and Maintenance (version 0.5) | publisher= SWEBOK Knowledge Area}}
*{{cite conference |last1=Madhusudhan |first1=V. |last2=Suma |first2=V. |last3=Rao |first3=Jawahar J. |title=Software Maintenance: From the Perspective of Effort and Cost Requirement |date=2017 |publisher=Springer |isbn=978-981-10-1678-3 |pages=759–768 |language=en|ref={{sfnref|Madhusudhan et al.|2017}}|conference=Proceedings of the International Conference on Data Engineering and Communication Technology }}
* {{cite book |author1=April, Alain |author2=Abran, Alain | title=Software Maintenance Management | location=New York | publisher=Wiley-IEEE | year=2008 | isbn=978-0-470-14707-8 }}
*{{cite journal |last1=Rahman |first1=Hanif Ur |last2=da Silva |first2=Alberto Rodrigues |last3=Alzayed |first3=Asaad |last4=Raza |first4=Mushtaq |title=A Systematic Literature Review on Software Maintenance Offshoring Decisions |journal=Information and Software Technology |date=2024 |volume=172 |pages=107475 |doi=10.1016/j.infsof.2024.107475|ref={{sfnref|Rahman et al.|2024}}}}
* {{cite book |author1=Gopalaswamy Ramesh |author2=Ramesh Bhattiprolu | title=Software maintenance : effective practices for geographically distributed environments| location=New Delhi| publisher=Tata McGraw-Hill| year=2006 | isbn=978-0-07-048345-3}}
* {{cite book |author1=Grubb, Penny |author2=Takang, Armstrong | title=Software Maintenance | location=New Jersey | publisher=World Scientific Publishing | year=2003 | isbn=978-981-238-425-6 }}
*{{cite book |last1=Reifer |first1=Donald J. |title=Software Maintenance Success Recipes |date=2012 |publisher=CRC Press |isbn=978-1-4398-5167-8 |language=en}}
* {{cite book |author1=Lehman, M.M. |author2=Belady, L.A. | title=Program evolution : processes of software change | location=London | publisher=Academic Press Inc | year=1985 | isbn=0-12-442441-4 }}
*{{cite book |last1=Tripathy |first1=Priyadarshi |last2=Naik |first2=Kshirasagar |title=Software Evolution and Maintenance: A Practitioner's Approach |date=2014 |publisher=John Wiley & Sons |isbn=978-0-470-60341-3 |language=en}}
*{{cite journal |last1=Ulziit |first1=Bayarbuyan |last2=Warraich |first2=Zeeshan Akhtar |last3=Gencel |first3=Cigdem |last4=Petersen |first4=Kai |title=A conceptual framework of challenges and solutions for managing global software maintenance |journal=Journal of Software: Evolution and Process |date=2015 |volume=27 |issue=10 |pages=763–792 |doi=10.1002/smr.1720|ref={{sfnref|Ulziit et al.|2015}}}}
* {{cite book | author=Page-Jones, Meilir | title=The Practical Guide to Structured Systems Design | location=New York | publisher=Yourdon Press | year=1980 | isbn=0-917072-17-0 | url-access=registration | url=https://archive.org/details/practicalguideto00page }}
*{{cite book |last1=Varga |first1=Ervin |title=Unraveling Software Maintenance and Evolution: Thinking Outside the Box |date=2018 |publisher=Springer |isbn=978-3-319-71303-8 |language=en}}

{{refend}}
==External links==
* [https://archive.today/20101203052606/http://www3.interscience.wiley.com/cgi-bin/jhome/5391/ Journal of Software Maintenance]

{{Computer science}}
{{Computer science}}
{{Software engineering}}
{{Software engineering}}
Line 234: Line 80:
{{ISO standards}}
{{ISO standards}}


{{Authority control}}

{{DEFAULTSORT:Software Maintenance}}
[[Category:Software maintenance| ]]
[[Category:Software maintenance| ]]
[[Category:IEEE standards]]
[[Category:IEEE standards]]

Revision as of 06:13, 9 May 2024

Part of a series on
Software development
Core activities
Paradigms and models
Methodologies and frameworks
Supporting disciplines
Practices
Tools
Standards and bodies of knowledge
Glossaries
Outlines

Software maintenance is the modification of a software product after delivery.

Software maintenance is often considered lower skilled and less rewarding than new development. As such, it is a common target for outsourcing or offshoring. Usually, the team developing the software is different from those who will be maintaining it. The developers lack an incentive to write the code to be easily maintained. Software is often delivered incomplete and almost always contains some bugs that the maintenance team must fix. Software maintenence often initially includes the development of new functionality, but as the product nears the end of its lifespan maintenence is reduced to the bare minimum and then cut off entirely before the product is withdrawn.

Each maintenence cycle begins with a change request typically originating from a customer. That request is evaluated and if it is decided to implement it, the programmer studies the existing code to understand how it works before implementing the change. Testing to make sure the existing functionality is retained and the desired new functionality is added often comprises the majority of the maintenance cost.

Software maintenance is not as well studied as other phases of the software life cycle, despite comprising the majority of costs. Understanding has not changed significantly since the 1980s. Software maintenance can be categorized into several types depending on whether it is preventative or reactive and whether it is seeking to add functionality or preserve existing functionality.

History

In the early 1970s, companies began to separate out software maintenance with its own team of engineers to free up software development teams from support tasks.[1] In 1972, R. G. Canning published "The Maintenance 'Iceberg'", in which he contended that software maintenance was an extension of software development with an additional input: the existing system.[1] The discipline of software maintenance has changed little since then.[2] One twenty-first century innovation has been companies deliberately releasing incomplete software and planning to finish it post-release. This type of change, and others that expand functionality, is often called software evolution instead of maintenance.[2]

Software life cycle

Diagram for a traditional software development life cycle from 1988

Despite testing and quality assurance, virtually all software contains bugs where the system does not work as intended. Post-release maintenance is necessary to remediate these bugs when they are found.[3] Most software is a combination of pre-existing commercial off-the-shelf (COTS) and open-source software components with custom-written code. COTS and open-source software is typically updated over time, which can reduce the maintenance burden, but the modifications to these software components will need to be adjusted for in the final product.[4] Unlike software development, which is focused on meeting specified requirements, software maintenance is driven by events—such as customer requests or detection of a bug.[5] Its main purpose is to preserve the usefulness of the software, usually in the face of changing requirements.[6]

If conceived of as part of the software development life cycle, maintenance is the last and typically the longest phase of the cycle,[7][8] comprising about 75 percent of resources, with only 25 percent going to the initial development phase.[9] Other estimates of the cost of maintenance are even higher, reaching 80 to 90 percent of the lifecycle cost.[10] Other models consider maintenance separate from software development, instead as part of the software maintenance life cycle (SMLC).[8] SMLC models typically include understanding the code, modifying it, and revalidating it.[8]

Transition from release to maintenance to end of the lifespan

Diagram showing the steps for software retirement

Frequently, software is delivered in an incomplete state. Developers will test a product until running out of time or funding, because they face fewer consequences for an imperfect product than going over time or budget.[11] The transition from the development to the maintenance team is often inefficient, without lists of known issues or validation tests, which the maintenance team will likely recreate.[12] After release, members of the development team are likely to be reassigned or otherwise become unavailable. The maintenance team will require additional resources for the first year after release, both for technical support and fixing defects left over from development.[11]

Initially, software may go through a period of enhancements after release. New features are added according to customer feedback. At some point, the company may decide that it is no longer profitable to make functional improvements, and restrict support to bug fixing and emergency updates. Changes become increasingly difficult and expensive due to lack of expertise or decaying architecture due to software aging. After a product is no longer maintained, and does not receive even this limited level of updating, some vendors will seek to extract revenue from the software as long as possible, even though the product is likely to become increasingly avoided. Eventually, the software will be withdrawn from the market, although it may remain in use. During this process, the software becomes a legacy system.[13]

Change cycle

The first step in the change cycle is receiving a change request from a customer and analyzing it to confirm the problem and decide whether to implement the change.[14] This may require input from multiple departments; for example, the marketing team can help evaluate whether the change is expected to bring more business.[15] Software development effort estimation is a difficult problem, including for maintenance change requests,[16] but the request is likely to be declined if it is too expensive or infeasible.[17] If it is decided to implement the request, it can be assigned to a scheduled release and implemented.[17]

Understanding existing code is an essential step before modifying it.[2] The rate of understanding depends both on the code base as well as the skill of the programmer.[18] Following coding conventions such as using clear function and variable names that correspond to their purpose makes understanding easier.[19] Use of conditional loop statements only if the code could execute more than once, and eliminating code that will never execute can also increase understandability.[20] Experienced programmers have an easier time understanding what the code does at a high level.[21] Software visualization is sometimes used to speed up this process.[22]

Modification to the code may take place in any way. On the one hand, it is common to haphazardly apply a quick fix without being granted enough time to update the code documentation.[23] On the other hard structured iterative enhancement can begin by changing the top-level requirements document and propagating the change down to lower levels of the system.[24] Modification often includes code refactoring (improving the structure without changing functionality) and restructuring (improving structure and functionality at the same time). [25] Unlike commercial software, free and open source software change cycles are largely restricted to coding and testing, with minimal documentation. Open-source software projects instead rely on mailing lists and a large number of contributors to understand the code base and fix bugs efficiently.[26]

An additional problem with maintenance is that nearly every change to code will introduce new bugs or unexpected ripple effects, which require another round of fixes.[2] Testing can consume the majority of maintenance resource for safety-critical code, due to the need to revalidate the entire software if any changes are made.[27] Revalidation may include code review, regression testing with a subset of unit tests, integration tests, and system tests.[25] The goal of the testing is to verify that previous functionality is retained, and the new functionality has been added. [28]

Categories of software maintenance

The key purpose of software maintenance is ensuring that the product continues to meet usability requirements. At times, this may mean extending the product's capabilities beyond what was initially envisioned.[29]

According to the ISO/IEC 14764 specification, software maintenance can be classified into four types:[30]

  • Corrective maintenance: modification of software to fix a bug or other failure to meet requirements, typically reported by a customer.[30][31]
  • Preventive maintenance: forward-looking modification of a software product after delivery to ensure it continues to meet requirements or fix problems that have not manifested yet.[32][30] This type of maintenance is performed especially on systems that are required to be highly safe or available.[32] Software rejuvenation is one form of preventative maintenance to clean up state and prevent future problems.[32]
  • Adaptive maintenance: modification of a software product performed after delivery to keep a software product usable in a changed or changing environment.[30][32]
  • Perfective maintenance: enhancement of a software product after delivery to improve qualities such as user experience, processing efficiency, and maintainability.[32][33] Perfective maintenance is necessary if other types of maintenance are carried out, because modification of an existing code base will otherwise increase complexity and cause the existing structure to deteriorate.[33] Perfective maintenance may include rewriting documentation, code refactoring, and performance tuning.[32]

According to some estimates, enhancement (the latter two categories) comprises some 80 percent of software maintenance.[34]

Maintainability

Main article: Maintainability

Maintainability is the quality of software enabling it to be easily modified without breaking existing functionality.[30] According to the ISO/IEC 14764 specification, activity to ensure software maintainability prior to release counts as part of software maintenance.[5] Many software development organizations neglect maintainability, even though it will increase long-term costs.[35] Technical debt is incurred when programmers, often out of laziness or urgency to meet a deadline, choose quick and dirty solutions rather than build maintainability into their code.[36] A common cause is underestimates in software development effort estimation, leading to insufficient resources allocated to development.[37]One important aspect is having a large amount of automated software tests that can detect if existing functionality is compromised by a change.[30]

A challenge with maintainability is that many software engineering courses do not emphasize it, and give out one-and-done assignments that have clear and unchanging specifications.[38] Software engineering courses do not cover the systems as complex as occur in the real world.[39] Development engineers who know that they will not be responsible for maintaining the software do not have an incentive to build in maintainability.[2]

Workforce

Maintenance is often considered an unrewarding job for software engineers, who, if assigned to maintenance, were more likely to quit.[40][41] It often pays less than a comparable job in software development.[41] The task is often assigned to temporary workers or lesser-skilled staff,[2][42] although maintenance engineers are also typically older than developers, partly because they must be familiar with outdated technologies.[42] Companies started separate teams for maintenance, which led to outsourcing this work to a different company, and by the turn of the twenty-first century, sometimes offshoring it to a different part of the world—whether as part of the original company or a separate entity.[43][10] Reasons for offshoring include taking advantage of lower labor costs, enabling around-the-clock support, reducing time pressure on developers, and to move support closer to the market for the product.[44] Downsides of offshoring include communication barriers in the form of such factors as time zone and organizational disjunction and cultural differences.[10] Despite many employers considering maintenance lower-skilled work and the phase of software development most suited to offshoring,[10][45] it requires close communication with the customer and rapid response, both of which are hampered by these communication difficulties.[10] In 2008, around 900,000 of the 1.3 million software engineers and programmers working in the United States were doing maintenance, and that number was rising despite increasing offshoring.[46]

Alternatives to maintenance

In software engineering, the term legacy system does not have a fixed meaning, but often refers to older systems which are large, difficult to modify, and also necessary for current business needs. Often legacy systems are written in obsolete programming languages, lack documentation, have a deteriorating structure after years of changes, and depends on experts to keep it operational.[47] When dealing with these systems, at some point so much technical debt accumulates that maintenance is not be practical or economical.[13] Other choices include:

  • Freezing—do no more work on the legacy system.[48]
  • Outsourcing functionality of the legacy system to a different company, especially if it is not considered a core business function.[48]
  • Discarding the existing legacy system and redeveloping a new application from scratch to fulfill the same purpose as the legacy system.[48]
  • Wrapping the legacy application in an abstraction layer to simplify outdated interfaces[48]
  • Migrating the legacy system to a new platform, which can reduce the expense of new software development by enabling reuse of the implementation, design, specification, and requirements of the legacy system.[49]

Research

Despite taking up the lion's share of software development resources, maintenance is the least studied phase of software development.[50][51] Much of the literature has focused on how to develop maintainable code from the outset, with less focus on motivating engineers to make maintainability a priority.[52] As of 2020, automated solutions for code refactoring to reduce maintenance effort are an active area of research,[53] as is machine-learning enhanced maintainability assessment.[54]

References

  1. ^ a b Tripathy & Naik 2014, p. 25.
  2. ^ a b c d e f Offutt, Jeff (January 2018). "Overview of Software Maintenance and Evolution". George Mason University Department of Computer Science. Retrieved 5 May 2024.
  3. ^ Tripathy & Naik 2014, p. 4.
  4. ^ Tripathy & Naik 2014, pp. 5–6.
  5. ^ a b Tripathy & Naik 2014, p. 26.
  6. ^ Madhusudhan et al. 2017, p. 761.
  7. ^ Varga 2018, p. 3.
  8. ^ a b c Tripathy & Naik 2014, p. 7.
  9. ^ Varga 2018, p. 6.
  10. ^ a b c d e Ulziit et al. 2015, p. 764.
  11. ^ a b Reifer 2012, p. 22.
  12. ^ Reifer 2012, p. 21.
  13. ^ a b Tripathy & Naik 2014, p. 89.
  14. ^ Madhusudhan et al. 2017, p. 763.
  15. ^ Tripathy & Naik 2014, p. 120.
  16. ^ Madhusudhan et al. 2017, p. 762.
  17. ^ a b Tripathy & Naik 2014, p. 123.
  18. ^ Tripathy & Naik 2014, p. 296.
  19. ^ Tripathy & Naik 2014, pp. 296–297.
  20. ^ Tripathy & Naik 2014, p. 309.
  21. ^ Tripathy & Naik 2014, p. 297.
  22. ^ Tripathy & Naik 2014, pp. 318–319.
  23. ^ Tripathy & Naik 2014, pp. 85–86.
  24. ^ Tripathy & Naik 2014, p. 86.
  25. ^ a b Tripathy & Naik 2014, p. 94.
  26. ^ Tripathy & Naik 2014, p. 59.
  27. ^ Reifer 2012, p. 5.
  28. ^ Tripathy & Naik 2014, p. 98.
  29. ^ Varga 2018, p. 4.
  30. ^ a b c d e f Varga 2018, p. 5.
  31. ^ Tripathy & Naik 2014, pp. 26–27.
  32. ^ a b c d e f Tripathy & Naik 2014, p. 27.
  33. ^ a b Varga 2018, pp. 5–6.
  34. ^ Varga 2018, p. 5 fn 4.
  35. ^ Varga 2018, p. 12.
  36. ^ Varga 2018, pp. 6–7.
  37. ^ Varga 2018, p. 7.
  38. ^ Varga 2018, pp. 7–8.
  39. ^ Varga 2018, p. 9.
  40. ^ Madhusudhan et al. 2017, p. 764.
  41. ^ a b Reifer 2012, p. 7.
  42. ^ a b Reifer 2012, p. 8.
  43. ^ Rahman et al. 2024, p. 1.
  44. ^ Ulziit et al. 2015, p. 763.
  45. ^ Reifer 2012, p. 2.
  46. ^ Reifer 2012, p. 1.
  47. ^ Tripathy & Naik 2014, pp. 187–188.
  48. ^ a b c d Tripathy & Naik 2014, p. 188.
  49. ^ Tripathy & Naik 2014, pp. 188–189.
  50. ^ Madhusudhan et al. 2017, p. 759.
  51. ^ Ulziit et al. 2015, p. 766.
  52. ^ Reifer 2012, pp. 4–5.
  53. ^ Baqais & Alshayeb 2020, p. 459.
  54. ^ Alsolai & Roper 2020, p. 106214.

Sources

  • Alsolai, Hadeel; Roper, Marc (2020). "A systematic literature review of machine learning techniques for software maintainability prediction". Information and Software Technology. 119: 106214. doi:10.1016/j.infsof.2019.106214.
  • Baqais, Abdulrahman Ahmed Bobakr; Alshayeb, Mohammad (2020). "Automatic software refactoring: a systematic literature review". Software Quality Journal. 28 (2): 459–502. doi:10.1007/s11219-019-09477-y.
  • Madhusudhan, V.; Suma, V.; Rao, Jawahar J. (2017). Software Maintenance: From the Perspective of Effort and Cost Requirement. Proceedings of the International Conference on Data Engineering and Communication Technology. Springer. pp. 759–768. ISBN 978-981-10-1678-3.
  • Rahman, Hanif Ur; da Silva, Alberto Rodrigues; Alzayed, Asaad; Raza, Mushtaq (2024). "A Systematic Literature Review on Software Maintenance Offshoring Decisions". Information and Software Technology. 172: 107475. doi:10.1016/j.infsof.2024.107475.
  • Reifer, Donald J. (2012). Software Maintenance Success Recipes. CRC Press. ISBN 978-1-4398-5167-8.
  • Tripathy, Priyadarshi; Naik, Kshirasagar (2014). Software Evolution and Maintenance: A Practitioner's Approach. John Wiley & Sons. ISBN 978-0-470-60341-3.
  • Ulziit, Bayarbuyan; Warraich, Zeeshan Akhtar; Gencel, Cigdem; Petersen, Kai (2015). "A conceptual framework of challenges and solutions for managing global software maintenance". Journal of Software: Evolution and Process. 27 (10): 763–792. doi:10.1002/smr.1720.
  • Varga, Ervin (2018). Unraveling Software Maintenance and Evolution: Thinking Outside the Box. Springer. ISBN 978-3-319-71303-8.
Retrieved from "https://en.wikipedia.org/w/index.php?title=Software_maintenance&oldid=1222992826"