Let’s talk about Software Maintenance


The definition of software maintenance is the following: “Software maintenance is the modification of a software product after delivery to correct faults, to improve performance or other attributes, or to adapt the product to a modified environment” [1].  However, after a brief search in the literature somebody can find some really surprising facts about maintenance in modern software. Some of them are: “software maintenance task is the most expensive part of the life cycle” [1] or  “maintenance accounts for more than 90% of the total cost of software” [2].

This article will try to briefly describe what is software maintenance focusing on maintenance time and costs. Firstly there is a chapter explaining why maintenance is so necessary and which factors affect maintenance time and costs. Then some of the most common solutions in order to reduce maintenance are listed. Finally, a surprising fact about maintenance is presented and there is a discussion about modern development techniques and whether they result in less maintenance time.



Software maintenance is an essential part of software development. Even if we assume that we can design and build a perfect system matching all requirements, maintenance will be necessary sooner or later. The reason for that is that there is nothing unchangeable in the world, especially in the world of software. Designing and developing new software is neither time nor cost effective. So in most cases, the only feasible solution is to maintain existing software.

New hardware technologies are an important challenge for software designers. Software should be constantly modified in order to take full advantage of new and more efficient hardware systems. Moreover, new software technologies make change inevitable. New features or functionalities have to be added in order to make system up-to-date, otherwise even a perfect system will be soon out-dated.

Maintenance is a tough, costly and time-consuming job. As mentioned above maintenance is the most expensive part of program’s life cycle as it could be up to 90% of total costs. However, there are several parameters affecting maintenance time and costs. System size and number of users is one of the most important. Large systems with many users have to be frequently modified and repaired. The cost of failure in such systems would be disastrous, so all necessary operations should be performed in order to guarantee that these large systems are reliable and 99.999% available. System age is another important factor. Older systems need frequent maintenance in order to remain operational and withstand competition. New features have to be added in order to ensure that service provided is of high quality and that they can equally compete with similar systems.


Reducing maintenance

 According to some recent research [2], understanding is one of the most time-consuming maintenance tasks as it may take up to 60% of the total maintenance time. Understanding is the process of trying to identify where a change should be made and how this change should be. The main reason for the –incredibly- high amount of time spent on understanding is lack of documentation. Older systems are usually poorly documented and most of their developers are now retired or not working on these systems any more. So, new engineers waste so much time trying to understand how these systems work. Therefore, good documentation would reduce maintenance time and reduce maintenance costs as a result. Moreover, really good programmers will be able to operate in their full potential as they will focus on finding the optimal solution instead of wasting time trying to read poorly documented code.

Old, unused and dispersed code is also a great problem for maintenance. Most systems, especially the older ones, have large parts of code which are not useful any more. In many cases code is also dispersed in many files and different components making maintenance a really difficult job. So eliminating “dead” code is one of the first steps that should be taken in order to make maintenance less consuming. Reorganising code and grouping files could be also beneficial for maintenance time. In general, less complex and more well-structured code is the key for improved maintainability.


A controversial fact

 Dekleva’s [3] study demonstrated a really surprising and controversial fact about software maintenance. According to his empirical study there is no evidence proving that modern software development techniques have resulted in less maintenance time. On the contrary, in many cases maintenance time has increased over the last decades [2], even though new software development techniques have been introduced. Dekleva acknowledges the fact that maintenance is now easier and requires less effort and that even complex changes in an existing system are now feasible.

Dekleva’s fact sounds strange but it reflects reality. In the 1970’s maintenance accounted for about 50% of a project’s time. Nowadays it is usually up to 90% [2]. Maintenance was always an indispensable part of the software development process and this will not change. All systems need some changes in order to remain operational and maintenance and enhancement of existing systems is usually more effective than building a new system from scratch. But the question is why all these new software development methodologies are useful if they cannot reduce maintenance time and costs?

Modern software methodologies made maintenance easier and more flexible. In the previous decades, older development techniques allowed a limited amount of modifications and changes in software. So the amount of time spent on maintenance was not as high as today just because we could not change much more. Only a few maintenance operations could be done in older systems and most of them were just some minor improvements.

Nowadays, changes are more complex because we have to ability to make major changes in existing systems. Many new features can be added, large parts of the code can be modified and systems designed years ago can be still operational. In this way, Dekleva’s fact should not surprise us but on the contrary should be seen as a really positive fact. Modern development techniques offer a variety of tools and allow us to constantly improve existing systems modifying them according to our needs. In other words, we spend more time on maintenance because modern development techniques have pushed maintenance limits.



Software maintenance is a crucial part of software life cycle. All software systems need constant maintenance in order to remain operational and reliable. Larger and older systems are those which need more maintenance operations and functional enhancements. However, maintenance is a time and cost consuming task. Good code documentation, good code structure and less complex software are some of the most common solutions in order to achieve lower maintenance time and costs. Finally, it was demonstrated that modern development techniques do not reduce maintenance time but this is not a negative fact. Modern techniques allow us to make more complex changes and more crucial modifications keeping software updated.


[1]. “Software maintenance – An overview” –  Carl Allen – http://www.bcs.org/content/ConWebDoc/3063

[2]. How to save on software maintenance costs – Omnext white paper, March 2010

[3]. “The influence of the Information Systems Development Approach on Maintenance” – Sasa M Dekleva – MIS Quarterfly, Vol 16, No 3 – September 1992 – pages 355-372