Why working on legacy systems can be a good thing

Oh, the dreaded legacy systems, one of the biggest turn-offs for software developers.

Don't believe me?

Just try to whisper smoothly in the ear of a developer "Legacy systemssss" and see what the reaction will be. I can guarantee that it will not be a good one.

Now with the jokes out of the way, the reality is that the term and what it implies is not well regarded in the software development community and with good reason.

There are a lot of horror stories regarding old systems that no one knows how they work anymore or are to afraid to "touch" them as they don't want to break the house of cards.

Still the bad parts are widely known and I won't go over them in this post. Rather I will focus on the good parts that can come from working with old systems.

So without further ado, let's start:

I.Debugging

Working in old spaghetti code is not fun. Debugging old spaghetti code is horrendous.

Still from big challenges comes great opportunities.

Just because of need, you will learn all of the available tools that you have under your belt when it comes to debugging. And that is a good thing because a lot of debugging concepts are interchangeable across languages and technologies.

II.Battle tested code

Only in old systems you can see code that work without a problem and is over 10 years old. Is it an issue that it's over decade? Not really, as long as it work properly.

The bugs and issues in those types of systems have long been ironed out, at least the important ones.

Depending on how the code was written, you might learn good patterns of writing code defensively. Also how some issues that you might be facing now have been already resolved in other places.

III.Learn the impact of your work to the users

If you are working on an old system, there are very high changes that system is still running and is used by users, otherwise it would be thrown into nothingness.

Because of that, most of the time modifying, or sometimes even adding a new feature might impact existing ones. And because developers are such lucky creatures, more often than not, a modification will break something else in the system.

While this might look like a bad thing, actually it will make you more observant while writing code to only impact what you really need and also much more careful while testing your code. And those are very good traits to have as a developer.

IV.More conscious decisions regarding releases

Nowadays we are used to terms such as continuous deployment, deployment pipelines, multiple environments, containers and others that make our lives much easier in regards to deploying new changes, but more importantly also rolling back changes.

In old system you most probably will not have those luxuries of rolling back changes or creating a hotfix and deploying it in the next few minutes. Or at least it will not comes so easy.

Because of that you will become much more conscious when it comes to creating a release and making it available to the users.

V. It can pay well

While it depends on the technology, becoming an expert in said technology can pay extremely well as there might not be a lot of remaining experts in the field.

The same applies to the industry. Becoming an expert in a niche field could be extremely profitable.

Still before you run off to become an expert in X old technology/industry with dreams of getting rich, keep in mind that also finding a job might be much harder as there is also a real risk of becoming obsolete.

Finally, do I advocate for working in legacy systems?

Well, not really, at least if you have a better opportunity.

Still, I wanted to showcase that legacy systems are not just a guaranteed doom and gloom, there can be good things in it.