The Hidden Dangers of Over-Commenting in Code

by Michal Zakrzewski November 18, 2023
5 minute read
The Hidden Dangers of Over-Commenting in Code

When we think about writing clean and maintainable code, comments often come to mind as a helpful tool. Comments are traditionally seen as a way to explain complex logic or provide context to the code. However, there's another side to this story: comments can also be "code smells." In this post, we'll explore why relying too much on comments might be indicative of underlying problems in your code.

The Role of Comments in Code Across Various Programming Languages

In programming, irrespective of the language used, comments play a crucial role. Whether it's the // and /* ... */ syntax in languages like Java and C++ or the # in Python, comments are meant to enhance the understanding of code. They are invaluable for explaining complex logic, providing context, or noting areas for future improvement. However, misuse or over-reliance on comments can lead to confusion and maintenance challenges. Excessive, outdated, or redundant comments can obscure rather than clarify, especially in collaborative environments. Furthermore, using comments to compensate for convoluted code often indicates that the code itself needs refactoring for clarity. The key is to strike a balance: use comments to elucidate, not to mask code complexities, ensuring the codebase remains clean and comprehensible for all developers.

When Comments Indicate Problems

1. Over-Reliance on Comments

Problem: Relying too heavily on comments to clarify complex code sections.

// Check if the user is eligible for rewards and the rewards are not expired 
if ((user.getRewardPoints() > 100) && (user.getRewardExpiry().after(new Date()))) { 
// ... 

In this instance, the comment tries to explain a complex conditional statement. While it does provide some insight, it also suggests that the code itself might be too complicated.

Solution: Simplify the code logic.

if (user.isEligibleForRewards()) {
  // ...

Refactoring the condition into a method isEligibleForRewards makes the code more readable and self-explanatory, reducing the need for a comment.

2. Outdated or Misleading Comments

Problem: Comments that no longer align with the code, cause confusion.

// Calculate monthly salary
employee.setAnnualSalary(employee.getHourlyRate() * 40 * 4);

This comment is misleading if the calculation method has changed but the comment hasn't been updated.

Solution: Regular updates and clear code.

Frequent review of comments and updating them to reflect changes in code is essential. Additionally, writing self-explanatory code can often eliminate the need for such comments.

3. Masking Bad Code

Problem: Using comments to justify or explain away poor coding practices.

// Complex calculation because of special cases
int result = a + b; // For now, just summing up

Here, the comment is used as an excuse for not addressing the complexity of the calculation.

Solution: Addressing the root issue.

Instead of leaving a vague comment, it's better to simplify or properly implement the complex calculation.

4. Commented-Out Code

Problem: Keeping large blocks of unused code as comments.

// Old implementation - kept for reference 
// int oldResult = a * b;

This practice clutters the codebase and can lead to confusion about what code is active and what is not.

Solution: Clean code and version control.

Remove such commented-out code. For historical reference, rely on version control systems like Git, which can track changes over time.

5. Redundant Comments

Problem: Comments that are unnecessary as the code is self-explanatory.

i++; // Increment i by 1

Such comments add no value as the code line itself is clear.

Solution: Trust in the code's clarity.

Avoid adding comments for straightforward code lines. Trust the reader's ability to understand basic operations without additional explanation.

Alternatives to Over-Commenting

1. Refactoring for Clarity

The key to reducing reliance on comments is to write code that is inherently clear and easy to understand. This often involves breaking down complex methods into smaller, more manageable functions, each with a single responsibility. For instance, rather than having a large method that performs multiple tasks, it's better to have multiple smaller methods with clear, descriptive names. This approach not only makes the code more readable but also easier to maintain and test.

2. Using Meaningful Names

The names we choose for our variables, methods, and classes can significantly impact the readability of our code. Descriptive and meaningful naming conventions make it easier for someone else (or even yourself at a later date) to understand what the code is intended to do without the need for additional comments. For example, a method name like calculateMonthlySalary() is far more informative than something generic like calculate().

3. Writing Documentation

While inline comments can be helpful, they may not always be the best way to document complex logic. External documentation, such as README files, wikis, or software documentation tools, can provide a more appropriate platform for explaining the broader architecture, complex algorithms, or system integrations. This way, the high-level overview is separate from the code, keeping the latter clean and focused.

4. Code Reviews

Regular code reviews are a critical practice for ensuring code quality. They provide an opportunity for other developers to scrutinize the code for clarity, efficiency, and adherence to best practices. Through code reviews, you can catch instances where a comment is used as a crutch for unclear code and work collaboratively to improve code readability and maintainability.


Comments, while integral to coding, should be used wisely and sparingly. Their overuse can often hint at deeper issues within the code, such as complexity or lack of clarity. By adopting practices like clear refactoring, meaningful naming, external documentation, and regular code reviews, we can significantly enhance the readability and maintainability of our codebases. In doing so, we make our code not just easier for others to understand, but also create a more efficient and streamlined development process.

Copyright © 2024 Michal Zakrzewski