Why OOP Still Rules: Composition, SOLID, and Refactoring Insights

Origin

Recently I was fortunate to lead a project refactor with ample time and space. The system is complex and touches many business teams, so writing sloppy code would mean overtime fixing bugs. I therefore record assorted thoughts as they come, without worrying about structure.

Object‑Oriented Design Remains Mainstream

Understanding OOP is more important than memorizing textbook terms like encapsulation, inheritance, and polymorphism. Practical insights matter more, such as:

What are "Inversion of Control" and "Dependency Injection" and how do they guide real code design?

What are the SOLID principles, which are easy to apply, and which are deceptively hard?

The World Is Stateful, So Is Our Code

This explains why OOP is popular: many dirty states can be hidden behind classes, limiting their impact.

What Is "Composition" and Why "Composition Over Inheritance"?

Many find the phrase vague, similar to "high cohesion, low coupling". The Decorator pattern is a classic example of composition, but the deeper meaning often remains unclear.

Inheritance Isn't All Bad; Multiple Inheritance Should Be Avoided

Some articles pit composition against inheritance, claiming inheritance is inferior. In reality, both are tools for different scenarios, like using a fork or chopsticks to eat. Over‑engineered Java code with excessive interfaces and deep hierarchies leads to "over‑engineering" and reduces developer joy.

Design Patterns Are Useful

Forcing design patterns can be harmful, but using the right ones—such as Factory Method and Template Method—makes code pleasant. The Template Method pattern, in particular, fit many business scenarios and accelerated bug fixes.

OOP vs FP

The author knows a bit of OOP but little about functional programming. Comparing the two often leads to biased conclusions. Both are valid approaches for different contexts; combining them wisely solves problems best.

Layered Thinking

All software is layered, which reduces cognitive load and supports large systems. Concepts like modularization and layering are essentially the same, but over‑layering adds unnecessary complexity. A balanced, experience‑driven approach is key.

"Refactoring" and "Clean Code"

Two influential books have repeatedly shaped the author's thinking, revealing subtle insights with each reread.