Software Maintenance is more Important than the Actual Coding, here is why:

Its Important:

In software development, maintenance consumes at least 50% of the total lifetime costs of software projects, while coding takes between 10-15%. However we find a lot of books talk about software development, algorithms and data structures but just a few ones talk about maintaining software.

Yeah it all sounds good and fancy but ain’t nobody got time for that! The management and stake holders might not care about later or about the long term benefits of creating a maintainable software, sometimes the short term benefits is the main reason for them making decisions to allocate resources in the tasks that they think are more important and the ones that might have immediate return.

Microsoft had a painful time maintaining versions of Windows XP while that wasn’t profitable for them anymore.

Lets categorize software into two categories:

When talking about maintenance, we can categorize Software into two categories, each of these two categories might have a different approach for maintenance.

1. Strategic software: Software that is all the company is about and the one that generates the direct revenue, for example, for Facebook, their strategic software is Facebook.
2. Operational Software: Software that is used by the company to run its business.

Be Practical about it:

Lets be honest and practical, sometimes you fight to work on some Operational Software because the management decided to allocate most of the resources to the Strategic one. So for building a maintainable software, you can:

• Get the chance to adopt the best practices for maintaining a Strategic Software
• While for the Operational ones you might want to sneak in the technique while nobody is looking and make use of the limited resources.

Maintaining Software can come in the form of:

1. Corrective Maintenance and Bug fixes: all Software have bugs.
2. Adaptive Maintenance: because things outside the software change.
3. Preventive Maintenance: prevention is better than cure.
4. Perfective Maintenance: because things can always be improved.

Cutting Corners on Maintenance Works in the Short Term:

If you just focus on producing new features and not to take into account maintainability, you can get away with that in the short term but not the long term, and this might be so tempting because:

1. You may be gone –it will be somebody else’s problem
2. It frees up time and resources to do things that seem more important

Question: Enough Of Being Negative, How to build a maintainable Software:

Answer: Reinventing the Software Life Cycle

As a software developer, I assume you already know the Software Life Cycle, when talking about maintaining a software, You can incorporate maintenance into every phase of the software life-cycle and not only the last phase

Agile Vs Waterfall:

Mentioning the life cycle doesn't mean that I'm encouraging waterfall, agile practices go through all the life cycle phases but in shorter sprints, you can check my article here about agile

1- Maintenance in Requirements phase:

• Lets just say that Requirements documentation are extremely important, you can't have your code as the source of truth, but rather having requirements that developers can refer to and can test against.
• If you have a requirements document, any difference between the requirements document and the functionality can be considered as a bug or the document is not update. But still its a good starting point.
• Requirements can server as a starting point for new developers.
• Having requirements doesn't mean you are not agile, I'm totally in favor of agile practices but that doesn't mean you can just cut corners and use that as an excuse to not have requirements.
• At the point of writing the code, you might feel requirement are not important and you can just ask developers or product owner, but in the long run, these people might be gone.

2 - Maintenance in Design phase phase:

• Again, being agile doesn't mean you don't take the time to come up with a design for you software, If you iterate over garbage, you just get highly refined garbage.
• The reason that Design and Design time is important in maintainability is:

- Faster coding

- Less refactoring

- Faster testing - fewer bugs

- Lower maintenance costs

• A Good Requirements Doc Includes :

- Features we must have

- Features we really want

- Features that would be nice to have

Again, I'm aware that requirements changes, but then again there could be some sort of the documentation, good design makes it easy to cater for future features and makes maintainability easier.

Faster coding at the expense of design and architecture is almost always the wrong choice

• Document the Design itself, that will make as a reference and for future developers that will maintain the software

3- Maintenance in Coding phase:

Its clear that clean code and clear code help other developers read the code you committed, in the case of a bug or improvement, having your code all messy and dirty won't help fix that bug in a short amount of time. You can refer to this article I wrote awhile back about Clean Code : Your One Stop Clean Code Guidelines

• Make your code very simple
• Don't write comment that explains what the code does, it would be helpful sometimes why you wrote this code.

4- Maintenance in Testing Phase:

• You can't talk about building maintainable software with talking about tests. Your test cases govern that whatever code changes or adding features doesn't break existing functionality.
• Having different type of tests insures gives you more confidence.
• You might have different kind of tests and your test might be scattered. I have been to some scenarios where there are some performance/ benchmark tools that have been developed but not documents. All tests must be documented.
• Be careful when you have automatic updates in your software, because once patched to the release branch and became available, you might break existing functionalities.
• Be careful in web apps, deploying changes means instant changes to all users!

Salesforce runs all customer unit tests – over 60 million as of early 2016

5 - Maintenance in Maintenance phase:

This category involves a lot of work and might get a but overwhelming, but again, it will completely pay off in the long run.

Maintenance involves:

• Bug tracking,Feature tracking,Prioritization
• Crisis management,Disaster recovery, Backup Servers, Data backups
• Monitoring and Analytics
• Security audits, Logging, Penetration test
• Feedback, Usage data, Environmental Data, Customer outreach

Who should maintain? the original developers or other developers ?

That is a tough question and each has its pros and cons, if it is being maintained by the original developers then maintenance is gonna be efficient since they know the code, and no training or knowledge transfer is needed but at the same time it might get boring for them and they might start looking elsewhere.

If you want to hire Maintenance Developers, the need to be:

• Careful and precise
• Perseverance –great debugging skills
• Patient and thorough

I hope by now you have an idea about the importance of building a maintainable software and how to actually build it.