Software maintenance

From Wikipedia, the free encyclopedia
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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

  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[edit]

  • 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=1222646597"