Future proof software

Abstract

Future proofing code has been proven to be a very important part of creating software. This is because new technologies are being developed at a rapid pace, which in turns requires software to be modified from time to time to still be usable. To make software easier to modify a few things can be done. Making sure that no file ever goes beyond 100 lines is one if these things. Others would be Design patterns, Naming agreements or rules and placing comments throughout written code.

This article discusses:

• The difference between easily modifiable code and difficult code to modify
• The importance of the maintainability of software
• Ways to make software easier to modify

Keywords:

Maintainable code, Design patterns, Naming conventions, Commenting code

Introduction

New technologies have been developed rapidly over the last few years, and this will continue to happen for the foreseeable future. This creates an interesting problem for developers, the code that they write right now might need to be rewritten for new technologies that will be developed in the upcoming years.

This leads to the following topic of Future proofing code. Future proof code should be able to run on new technologies as they come out, without having to rewrite said code. However this is almost impossible to do, this makes creating easily modifiable software a must for the software industry.

Related research

Visser, Rigel, Wijnholds, Eck and Leek describe two types of software in the introduction of their book (Visser et al., 2016), one is slow and a nightmare to modify. The other is quick and easily modified. There are a few differences in how these two pieces of software are made. The nightmarish one is made up from a few files with hundreds of lines of code, the easy one has multiple smaller files with less than a hundred lines of code. This is a big part in Maintaining software, which because of the rapid development in technology is necessary for all developed code.

Malhorta and Lata (2020) state that around 60% of the costs for building software goes into maintaining the software after it has been finished. This shows how important it is to keep maintainability in mind when developing something.

Analysis

Future proofing software is not always fully possible, however it is possible to make software easy to modify. Once existing software is easily modifiable it allows developers to adept it more easily to newly developed technologies. Which in turn allows the software to be somewhat Future proof.

Visser, Rigel, Wijnholds, Eck and leek describe just two types of software, but these are just some of the extremes. Most pieces of software are a combination of the two, certain parts are easily modifiable and other parts are not. From time to time it’s almost impossible to split up code, which in turn leads to larger files. However it is important to notice certain things, as example functions which are duplicated at different places within a codebase. When this happens a solution would be to extract said function from all these places and put it in a singular file, a helper file for example, which in turn will be shared to all the files where the duplicated function was used.

Malhorta and Lata (2020) argue that because of the costs of maintaining software it’s important for researchers to accurately predict the software maintainability in the earlier stages of development. I agree that this is important, because of research like this a few options to make software more maintainable are already used frequently.

One of these options is the use of design patterns, these patterns describe a solution for problems which can be used in different situations. The patterns provide structure to otherwise most likely messy code. Most design patterns are very well documented which makes the code more understandable for programmers who have not yet worked with it.

Another option would be to make either rules or agreements inside a development team about naming variables and functions. If done properly it will allow a developer to know what a variable is used for with just a single glance.

The last option that will be named within this document is commenting. This allows a developer to describe what certain code does and most importantly why it does something in a certain way. Using comments inside code to describe what a function does makes it easier for another developer to rewrite it in case they ever need to.

Conclusions and Recommendations

In conclusion, because of the rapid development of new technologies it’s very important for software to be future proof. This is however not always possible which makes easily modifiable software a must for the software industry. With most software projects around 60% of the budget goes into maintaining the created software. This makes it very important to create maintainable and modifiable software, which can be done in a few ways. The ones described in this article were the following:

• Design patterns
• Agreements or Rules for naming variables and methods
• Commenting code

If these options are used during the development of a software project it should make it more modifiable and in turn more easily maintainable.

It is however still possible that it will take a lot of time and money to rewrite a software project even when all of these options are used. One of the reasons for this could be that the newly developed technology differs a lot from the one used before.

Sources

Visser, J., Rigal, S., Wijnholds, G., Eck, P. V., & Leek, R. V. D. (2016). Building Maintainable Software, C# Edition: Ten Guidelines for Future-Proof Code (1ste ed.). O’Reilly Media.

Malhorta, R., & Lata, K. (2020). A systematic literature review on empirical studies towards prediction of software maintainability. Springer-Verlag GmbH Germany.https://link.springer.com.ezproxy.avans.nl/content/pdf/10.1007/s00500-020-05005-4.pdf