9 Common Code Smells and How to Fix Them for Cleaner, Safer Software

Code Style and Readability

Inconsistent naming (mixing camelCase, snake_case, PascalCase) and overly long functions make code hard to read. Example of bad naming:

int a, b, c; // no descriptive names
float f; // unclear purpose

Improved version uses meaningful identifiers:

int num1, num2, result; // clear purpose
float price; // descriptive

Long lines (>50 characters) and missing spacing also reduce clarity; applying PEP 8 formatting resolves these issues.

Comments

Missing, outdated, or incorrect comments hinder understanding. A bad example: int num1, num2; // define two variables Correct practice is to write concise, accurate comments that explain *why* something is done, not *what* the code already shows.

Error Handling and Exceptions

Common mistakes include ignoring errors, overusing try...except, and catching overly broad exceptions. Bad code:

def divide(x, y):
    return x / y

Improved version handles division‑by‑zero explicitly:

def divide(x, y):
    try:
        return x / y
    except ZeroDivisionError:
        return 'Cannot divide by zero!'

A better approach is to validate inputs before raising exceptions, avoiding unnecessary try‑except for normal control flow.

Reuse and Modularity

Code duplication and tightly coupled classes increase maintenance cost. Example of duplicated logic:

def calculate_area_of_rectangle(length, width):
    return length * width

def calculate_volume_of_cuboid(length, width, height):
    return length * width * height

Refactor by extracting shared calculations:

def calculate_area_of_rectangle(length, width):
    return length * width

def calculate_volume(length, width, height):
    return calculate_area_of_rectangle(length, width) * height

Similarly, extracting email‑sending logic into a dedicated EmailSender class decouples responsibilities.

Hard Coding

Embedding literal constants (e.g., if score > 60) or excessive global variables makes future changes error‑prone. Replace magic numbers with named constants or enums:

PASS_SCORE = 60
if score > PASS_SCORE:
    # do something

Avoid global state by passing parameters and returning results instead of mutating module‑level variables.

Testing and Debugging

Lack of unit tests, boundary tests, and testability leads to fragile code. Bad example without tests:

def add_number(a, b):
    return a + b

Proper unit test using unittest:

import unittest

def add_number(a, b):
    return a + b

class TestAdd(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add_number(2, 3), 5)

if __name__ == '__main__':
    unittest.main()

Boundary testing (e.g., even/odd checks) and designing functions for deterministic inputs improve test coverage.

Performance Optimization

Over‑optimizing (e.g., using functools.reduce for a simple sum) harms readability. Prefer built‑in, clear solutions:

def sum(numbers):
    return sum(numbers)

Choosing appropriate data structures, such as set for duplicate detection, reduces time complexity.

Security

Improper input validation can cause SQL injection. Bad code:

query = f"SELECT * FROM users WHERE username = '{username}'"
cursor.execute(query)

Secure version uses parameterized queries:

query = "SELECT * FROM users WHERE username = ?"
cursor.execute(query, (username,))

Storing passwords with weak hashes (MD5) is unsafe; use strong algorithms like bcrypt. Permission checks should verify authentication and role before performing privileged actions.

Version Control and Collaboration

Poor commit messages and lack of backups hinder teamwork. Instead of vague messages like git commit -m "Fixed a bug", provide context:

git commit -m "Fixed grade calculation bug for scores below 60 in calculate_score()"

Use Git for history, create backups before deletions, and push changes to remote repositories.

Conclusion

Clean code is like good prose: it should be elegant, maintainable, and safe. By addressing naming, comments, error handling, modularity, constants, testing, performance, security, and version control, developers can produce high‑quality software that stands the test of time.