Delete Your Obsolete Code

Every active codebase contains two types of code: active and obsolete. Active code includes variables and functions that deliver a project’s solution. Obsolete code is everything else: the unused variables and functions that don’t help solve the unique problems of a project. 

Codebases must only contain the code needed to deliver the expected functionality and nothing more.

Problems with Obsolete Code

Obsolete code causes a variety of problems for developers and end users.

Decreased Readability

It should be clear how a variable, function, object, etc. is being used and what purpose it solves. Obsolete code decreases the readability of a codebase and consequently makes it harder for developers to understand how the code works. 

This can require more time to maintain and update the codebase to meet the project needs, and can also reduce the confidence a development team has when making changes.

Increased Complexity

Leaving obsolete code in place requires developers to build work-around solutions, adding an unneeded layer of complexity to the codebase. This can cause unexpected output and functionality. 

As a project’s complexity grows, so does the difficulty in maintaining the project code. The codebase will become brittle, and a project team will be unable to maintain it to meet changing requirements.

Unknown Vulnerabilities

All code that is accessible in a codebase will be used, regardless of whether it’s active or obsolete. Executing obsolete code causes unexpected results and opens up vulnerabilities. By accidentally calling an obsolete function, a developer might produce incorrect data, and attackers might execute obsolete code and expose sensitive information.

Deleting Obsolete Code

The safest way to prevent problems caused by obsolete code from occurring is by deleting it. Not by working around it, not by commenting it out, but by deleting it.  

While it can be difficult to delete obsolete code with confidence, developers can use various techniques to build code deletion confidence including code linting, commenting on code, committing early and often, and testing frequently. 

Code Linting

Most integrated development environments (IDE’s) provide code linting capabilities, and most programming languages and frameworks have plugins for extra linting capabilities.  

Implementing a code linter helps developers identify obsolete code by providing alerts for unused variables in a function, or showing the reference tree for a function, or lack thereof.

Code Comments

Writing descriptive and informative code comments increases the readability of the code. This helps other developers understand the code workflow and purpose. 

Building the habit of documenting code makes it easier to review and refactor. This allows developers to identify duplicate and obsolete code.

Commit Early, Commit Often

When using a code repository such as Git, it’s helpful to commit often as a way to keep track of changes in the codebase. This makes it easier to track down when code was added or deleted. 

Developers can feel confident in their ability to restore deleted code if needed, by reviewing the commit messages. Reviewing commit messages is much easier than scanning files for blocks of commented out code and uncommitting them.

Test, Test, Test

Any changes that occur on a codebase need to be tested. Testing can happen in many forms, from functional unit tests to manual smoke testing and automated regression tests. 

With testing in place, developers can be confident in the code changes that they’ve made. Tests provide assurances that deleted code was obsolete and does not cause unexpected results.

Confidently Delete Your Obsolete Code

When development teams take the time to refactor their codebase and delete obsolete code, they see many positive results. The codebase is not overly complex, easier to read, and maintains and contains a smaller number of vulnerabilities. 

After obsolete code is deleted, the codebase contains only the code needed to meet requirements and nothing more. Development teams are then able to focus efforts on maintaining the active code that meets a project’s needs.