At the sight of legacy code, developers fall to their knees under an imaginary rain in the middle of the road screaming why me. Well, that’s just to add drama, but really, developers have enough horror stories to tell about their frustrating experience with legacy code. Sometimes, it takes a few days to work with legacy code, and other times, it takes months for developers to unravel legacy code and work with it. That leads us to this article; how you can effectively work with legacy code. But first, what is legacy code, and how can you know when you come across legacy code?
What is Legacy Code?
Some say legacy code is inherited code meaning the code you didn’t write. Some say legacy code is obsolete code, which may be code you inherited or wrote but is no longer functional. Another group says that legacy code is untested code. While these definitions are slightly different, the universal truth about legacy code is that it is code you don’t understand. Tested or untested, inherited, obsolete, or whether you wrote it and can’t remember why or what it should do, legacy code is an existing code you don’t fully understand. So, let’s define legacy code as any written code regardless of how long ago they wrote it or who wrote it that you don’t know how to add to or change because you don’t understand it.
So, when you join a company, you will probably work on an existing codebase hence whatever code you find challenging to work on is legacy code.
Six Proven Hacks to Effectively Work With Legacy Code
When you come across a legacy code, please don’t fall to your knees under an imaginary rain. Instead, try one or more of these proven hacks.
Test Legacy Code
One of the reasons why some people consider legacy code to be untested code is because they believe that developers won’t have any problem working with tested code. And they are correct to some extent. Testing a code lets you see its purpose, giving you a better understanding of the code, how it works and how you can change it or add to it. So, start by testing legacy code using unit tests and characterization tests, or test the code with a code analyzing tool.
Testing the code is not a guaranteed solution to understanding legacy code better, but you have to try to know.
You might be familiar with the saying; good code doesn’t need documentation. Sadly, that’s a myth, and we are grateful that we are over those days when people commit to the saying. Now, you will find comments in the code and supporting documentation about the code that explains what it does. The problem, however, is that many developers don’t read the supporting documentation when they inherit legacy code.
When you inherit a codebase, ensure to read its supporting document to understand the code better and to avoid changing the code in a way that derails from the original purpose of the code. You can also talk to older developer team members to learn more about the codebase.
Don’t Be Quick to Rewrite Legacy Code
As a new team member, you want to show your value, so you go through the codebase and notice something you think needs modification. Pause, and don’t do anything about it. You may be right about the code needing improvement, but what if you rewrite it and it changes its functionality or introduces new bugs? Now, what?
Don’t be quick to rewrite inherited code without understanding everything about it. Not to mention that you may not be able to finish what you start, especially if it’s an old codebase, then you will remember that no one asked you to rewrite the code in the first place. Instead, collaborate with older developer team members to get their insights before you rewrite anything.
Refactoring is a Better Alternative to Rewriting
Instead of rewriting a legacy code, refactor the code gradually. Refacing the code lets you modify the code structure without affecting its original functionality. You get to clean the code and avoid errors. Before refactoring legacy code, ensure that it has unit tests, and remember, you can run the tests yourself.
Prepare for failure. If refactoring doesn’t help, you can go back to the previous structure of the code. You can practice continuous integration, where you test every time you change the code and commit it to a central repository. Also, ensure to test the code after refactoring to keep up with your changes.
Lastly, don’t rush the changes. Instead, refactor gradually, and avoid making functional changes when refactoring in a review cycle. It is easier to review isolated changes in the code than to review a bunch of hidden modifications in the long lines of code.
Avoid Complicating Legacy Code
You may have inherited confusing legacy code, don’t make it worse for yourself and anyone that will work with the codebase in the future. Ensure the new code you add to the legacy code is clean and its purpose is clear. You can add comments in the code explaining your code or explain more about your code in the code documentation.
Patience is Key
Patience is a much-needed skill for working with legacy code, so avoid rushing to modify the code. Keep working on the code and you will know what to do eventually. Your developer experience will come in handy when you have to work with legacy code, which is why it might take you longer to understand the code. You should also know that there are times when you have to work on legacy code, and there are times when you have to leave it alone.
Over to You
Finally, another truth about legacy code is that it is subjective. Two developers might come across a codebase for the first time, and after inspecting it, developer A might consider it to be legacy, while developer B might consider it to be only inherited code. Developer A considers it legacy code because the code is unfamiliar and they don’t know what to do with it, while developer B considers it only inherited code because they understand the code and know what to do with it. So, don’t beat yourself up about a legacy code.