Code Smell Catalog

Methods that have grown too long to understand at a glance, typically exceeding 20-30 lines.

A class that knows too much and does too much, concentrating responsibilities that should be distributed.

Using primitive types (strings, ints, booleans) instead of small value objects for domain concepts.

Functions that take so many parameters that callers cannot remember the correct order or meaning.

Groups of data items that repeatedly appear together across multiple classes or method signatures.

Complex switch/case or if/else chains that duplicate type-checking logic across multiple locations.

A subclass that inherits methods and data it does not need or want, violating the Liskov Substitution Principle.

Two or more classes that perform similar functions but have incompatible method names and signatures.

Instance fields that are only set and used in specific circumstances, remaining empty or null the rest of the time.

A single class that must be modified for many different, unrelated reasons.

A single logical change requires small edits scattered across many different classes or files.

Two class hierarchies that mirror each other, so adding a subclass in one requires adding a corresponding subclass in the other.

Identical or near-identical code blocks that appear in multiple locations, requiring synchronized maintenance.

A class that does too little to justify its existence, adding complexity without proportionate value.

A class that contains only fields and getters/setters with no meaningful behaviour of its own.

Code that is never executed: unreachable branches, unused variables, commented-out blocks, and orphaned functions.

Abstractions, parameters, and classes created for anticipated future needs that never materialised.

Excessive comments that compensate for unclear code instead of the code being rewritten to be self-explanatory.

A method that uses data and methods from another class more than from its own class.

Two classes that depend too heavily on each other's internal details, creating a tangled, inseparable pair.

Long chains of method calls like a.getB().getC().getD() that couple the caller to the entire navigation path.

A class that delegates most of its work to another class, adding an unnecessary layer of indirection.