What are the most common code smells to look out for when refactoring?

2 Duplicated code

Another common code smell is duplicated code, which occurs when you have the same or similar code in multiple places. Duplicated code is a source of errors, inconsistencies, and maintenance headaches. It also violates the DRY principle, which stands for Don't Repeat Yourself. To refactor duplicated code, you can use techniques such as extracting common methods, creating abstract classes or interfaces, applying the strategy pattern, and using inheritance or composition.

3 Large classes

A large class is a class that has too many responsibilities, methods, fields, or dependencies. Large classes are hard to reuse, test, and modify. They also tend to violate the single responsibility principle and the open-closed principle, which states that classes should be open for extension but closed for modification. To refactor large classes, you can use techniques such as extracting subclasses, extracting components, applying the bridge pattern, and using dependency injection.

4 Feature envy

Feature envy is a code smell that occurs when a method accesses the data or behavior of another class more than its own. Feature envy indicates that the method belongs to a different class or that the classes are not well-designed. Feature envy reduces cohesion, increases coupling, and breaks encapsulation. To refactor feature envy, you can use techniques such as moving the method, extracting the method, introducing a foreign method, or applying the mediator pattern.

5 Switch statements

Switch statements are a code smell that occurs when you have a long or complex switch or if-else statement that checks the type or value of an object and performs different actions accordingly. Switch statements are hard to extend, modify, and test. They also violate the open-closed principle and the polymorphism principle, which states that objects of different types should be treated uniformly by their common interface. To refactor switch statements, you can use techniques such as replacing the switch with polymorphism, replacing the conditional with state or strategy, or applying the visitor pattern.

6 Primitive obsession

Primitive obsession is a code smell that occurs when you use primitive data types such as strings, numbers, or booleans to represent complex concepts or behaviors. Primitive obsession leads to poor readability, validation, and abstraction. It also violates the abstraction principle, which states that you should hide the implementation details and expose only the essential features of an object. To refactor primitive obsession, you can use techniques such as introducing value objects, replacing type codes with subclasses or enums, or applying the money pattern.