Clean Code Refactoring Detection

Identify opportunities to apply Clean Code principles based on Robert C. Martin's guidelines.

Naming

Meaningful Names

Detect: Single-letter variables, abbreviations, temp /data /info suffixes

Refactor: Intention-revealing names that explain purpose

Cookbook: meaningful-names.md

Pronounceable Names

Detect: Unpronounceable abbreviations (genymdhms , modymdhms )

Refactor: Names that can be discussed verbally

Cookbook: meaningful-names.md

Searchable Names

Detect: Magic numbers, single-letter constants

Refactor: Named constants with clear purpose

Cookbook: meaningful-names.md

Functions

Small Functions

Detect: Methods longer than 20 lines, multiple levels of abstraction

Refactor: Extract smaller, single-purpose functions

Cookbook: small-functions.md

Single Responsibility

Detect: Functions doing multiple unrelated tasks

Refactor: One function, one responsibility, one level of abstraction

Cookbook: small-functions.md

Few Arguments

Detect: Functions with more than 3 arguments

Refactor: Parameter objects, builder pattern, method extraction

Cookbook: function-arguments.md

No Side Effects

Detect: Functions that modify global state or input parameters

Refactor: Pure functions, explicit state changes

Cookbook: side-effects.md

Command Query Separation

Detect: Functions that both change state AND return values

Refactor: Separate commands (void) from queries (return value)

Cookbook: command-query-separation.md

Comments

Self-Documenting Code

Detect: Comments explaining "what" instead of code explaining itself

Refactor: Rename variables and extract methods to make intent clear

Cookbook: comments.md

Useful Comments

Detect: Commented-out code, redundant comments, changelog in code

Refactor: Legal/license comments, intent explanation, TODO with tickets

Cookbook: comments.md

Error Handling

Exceptions Over Error Codes

Detect: Methods returning error codes or status flags

Refactor: Throw specific, descriptive exceptions

Cookbook: error-handling.md

Unchecked Exceptions

Detect: Checked exceptions creating coupling

Refactor: Runtime exceptions with meaningful messages

Cookbook: error-handling.md

Don't Return Null

Detect: Methods returning null for error/empty cases

Refactor: Optional<T> , empty collections, Null Object pattern

Cookbook: null-handling.md

Don't Pass Null

Detect: null passed as method argument

Refactor: Overloaded methods, default values, Optional parameters

Cookbook: null-handling.md

Classes

Single Responsibility (SRP)

Detect: Classes with multiple reasons to change, mixed concerns

Refactor: Separate classes for distinct responsibilities

Cookbook: single-responsibility.md

Cohesion

Detect: Methods not using instance variables, unrelated fields

Refactor: Extract related fields/methods into new classes

Cookbook: cohesion.md

Small Classes

Detect: Classes with 200+ lines or 10+ methods

Refactor: Identify hidden responsibilities, extract collaborators

Cookbook: small-classes.md

Code Smells

Long Method

Detect: Methods exceeding 20 lines

Refactor: Extract Method until each does one thing

Cookbook: long-method.md

Primitive Obsession

Detect: Strings for emails/phone/money, parallel arrays

Refactor: Value objects, domain-specific types

Cookbook: primitive-obsession.md

Feature Envy

Detect: Method uses more data from other class than its own

Refactor: Move method to the class it envies

Cookbook: feature-envy.md

Data Clumps

Detect: Same group of parameters passed together repeatedly

Refactor: Parameter object or extract class

Cookbook: data-clumps.md

Divergent Change

Detect: Class changes for unrelated reasons

Refactor: Split class by responsibility

Cookbook: divergent-change.md

Shotgun Surgery

Detect: One change requires many small edits across classes

Refactor: Consolidate related logic into single class

Cookbook: shotgun-surgery.md

Quick Reference Table

Principle Detection Signal Clean Code Solution

Meaningful Names Single-letter vars, abbreviations Intention-revealing names

Small Functions Methods > 20 lines Extract, one level of abstraction

Few Arguments

3 parameters Parameter objects, builder

No Side Effects Modifies global/input state Pure functions

Command Query Sep. Function changes state AND returns Separate commands from queries

Self-Documenting Comments explain "what" Rename, extract methods

Exceptions Error codes, status flags Specific exceptions

Don't Return Null Null for errors/empty Optional, empty collections

Single Responsibility Multiple reasons to change Separate classes

Cohesion Methods don't use instance vars Extract new classes

Long Method

20 lines Extract Method

Primitive Obsession Strings for domain types Value objects

Feature Envy Uses external class data Move method

Data Clumps Repeated parameter groups Parameter object

Boy Scout Rule

Leave the code cleaner than you found it.

Apply opportunistic refactoring:

• Fix one naming issue

• Extract one long method

• Remove one piece of dead code

• Add one missing null check

Cookbook Index

Clean Code recipes with practical examples:

Naming: Meaningful Names

Functions: Small Functions · Function Arguments · Side Effects · Command Query Separation

Comments: Comments

Error Handling: Error Handling · Null Handling

Classes: Single Responsibility · Cohesion · Small Classes

Code Smells: Long Method · Primitive Obsession · Feature Envy · Data Clumps · Divergent Change · Shotgun Surgery