IEEE Standard Glossary of Software Engineering Terminology defines maintainability as:
“The ease with which a software system or component can be modified to correct faults, improve performance or other attributes, or adapt to a changed environment.”
After development, maintenance is a high cost for software. Nobody likes to work or maintain a legacy system because of many reasons like use of an old tech stack, less context of why a certain architectural decision was made, or difficulties faced while fixing bugs and releasing patches.
How much anyone hates it? In spite, an organization has to dedicate resources to maintain a piece of software. Examples of maintenance tasks include migrating to a different platform, fixing bugs, upgrading dependencies, etc.
However, while we develop or design software, we can take measures that will minimize efforts during maintenance. Broadly we can think about 3 design principles to help us create an easy maintenance application.
Operability, Simplicity, and Evolvability
Let’s talk about them one by one.
1. Operability
By operations, we mean tasks related to:
keeping a service upto date
monitoring the health of the service
making adjustments related to future demands like capacity planning
adopting service to new and productive tools for automation, deployment, etc
keeping a check on the security of the service and also maintaining documentation
What are a few things we can do to make operations team life easy?
1. Create easy-to-understand documentation and guides which cover all the corner cases
2. Establish detailed monitoring so that it is easy to debug and fix bugs
3. Use fault-tolerant techniques so that it is possible to take down nodes for maintenance while the system is still working
2. Simplicity
What makes a piece of software complex?
There can be numerous reasons for complexity, including the tight coupling of modules, wrong naming conventions, or choice of terms. Quick fixes or hacks can also create complexity in the long run.
Hidden assumptions taken while developing the system can also be a reason for complexity.
One of the ways to induce simplicity into your system is a good abstraction. Using abstraction, we can hide complex logic behind a simple interface that simplifies client/consumer life.
Abstraction also helps us to write high-quality software as it enables us to follow principles like DRY(don’t repeat yourself).
3. Evolvability
Why do we need to make our software better at adopting changes?
The reason we usually develop software is to satisfy a business need. Now business in which the organization is can change, or new use cases can emerge. Company priorities might change, or your software might require enhancements to handle higher traffic. That is why we need our software to be good at adopting changes. It should be easy to make changes without breaking the older functionalities.
Organizational processes like Agile make it easier for teams to develop software in a frequently changing environment. Using simple tools like tracking tech debt, test-driven development, and refactoring.
Evolvability depends on Simplicity. How good are the abstractions in your system? Will there be any unexpected errors/behavior after adding changes? And Are there enough tools established within your system to debug those random errors?
Ultimately, it all comes down to following the best Software Development practices, which enables us to create and deploy features fast by leveraging the best tools in the market.
Reference
Designing Data-Intensive Applications [DDIA]
Developing maintainable software | Software Sustainability Institute
Maintainability – Wikipedia