Refactoring Principles, Code Smells, and Practical Techniques for Improving Software Design

Refactoring Principles

Refactoring is the systematic improvement of a software’s internal structure without changing its observable behavior, aiming to increase understandability and reduce modification cost. It is not a separate task to be scheduled; it should happen continuously as the code evolves.

Key motivations include improving design, exposing bugs, and accelerating development by providing a solid, readable foundation.

When to Refactor

Refactoring should be performed whenever new features are added, the existing design hinders change, bugs are being fixed, or during code review. The "Three‑time rule" suggests that after the third similar change, refactoring is warranted.

Common Code Smells

Duplicate Code : identical structures in multiple places should be extracted into a single method or class.

Long or Large Classes : classes with many responsibilities should be split into smaller, cohesive units.

Long Parameter Lists : excessive parameters indicate that data should be encapsulated in an object.

Divergent Change : a class that changes for many unrelated reasons should be divided.

Shotgun Surgery : scattered modifications across many classes signal the need for better abstraction.

Feature Envy : a method that uses another class’s data more than its own should be moved.

Data Clumps : groups of fields that always appear together should become their own object.

Primitive Obsession : overuse of primitive types instead of domain objects should be replaced with proper classes.

Switch Statements : replace with polymorphism where possible.

Parallel Inheritance Hierarchies : avoid duplicating class structures across hierarchies; use composition or shared super‑classes.

Reorganizing Functions

Extract Method : create a new method for a long or unclear code block, name it clearly, and replace the original code with a call.

Inline Method : replace a trivial method call with its body and delete the method.

Inline Temporary Variable : replace a temporary variable with the expression it holds.

double basePrice = anOrder.basePrice();
return (base > 10000);

After inlining:

return (anOrder.basePrice() > 1000);

Replace Algorithm : swap a complex algorithm for a clearer one, e.g., using collections instead of repetitive conditionals.

String foundPerson(String[] people){
    for(int i=0;i

After replacement:

String foundPerson(String[] people){
    List candidates = Arrays.asList("Don","John","Kent");
    for(int i=0;i

Moving Features Between Objects

Move Method : create a similar method in the class that uses the behavior most, delegate or replace the original.

Move Field : relocate a field to the class that uses it most.

Extract Class : split a class that does too many things into separate classes.

Inline Class : merge a trivial class into another when it no longer has a distinct responsibility.

Hide Delegation : provide a façade that hides the delegation chain, reducing client knowledge of internal structure.

Reorganizing Data

Encapsulate Field : make fields private and expose them via getters/setters.

Replace Data Value with Object : turn primitive data (e.g., phone number) into a domain object with behavior.

Replace Magic Numbers with Constants : give meaningful names to literal values.

Simplifying Conditional Expressions

Break complex conditions into separate methods, combine similar tests, or replace conditionals with polymorphic dispatch.

Simplifying Function Calls

Rename unclear functions, add or remove parameters, split functions that both query and modify state, and introduce parameter objects when several parameters always appear together.

Other Refactoring Techniques

Introduce factory methods, move fields or methods up/down the inheritance chain, extract interfaces, collapse inheritance hierarchies, and replace delegation with inheritance when appropriate.

Overall, the goal is to keep code small, focused, and expressive, allowing developers to understand and evolve the system with minimal risk.