This is a series about the SOLID principles introduced by Uncle Bob (Robert C. Martin). SOLID is a set of design principles that help us write code that is easier to understand, maintain, and evolve over time.
SOLID consists of five principles:
- S - Single Responsibility Principle
- O - Open Closed Principle
- L - Liskov Substitution Principle
- I - Interface Segregation Principle
- D - Dependency Inversion Principle
Each of these principles tries to solve a different kind of design problem, but they all share the same goal:
helping us write code that stays manageable as the system grows.
Why I’m Writing This Series
This article series is created while I’m working on my other series:
What I’m Learning About Writing Better Structured Code
While writing that series, I realized something. Many of the ideas I want to explain are closely related to SOLID. But explaining them properly requires a deeper discussion about these principles themselves.
So instead of trying to squeeze everything into that series, I decided to write a more focused set of articles about SOLID. Later, I can reference these articles whenever the topic appears again.
A Small Personal Story
This series is also a bit personal for me.
Around three years ago, I wrote two article series on Medium about SOLID:
Looking back at them now, I can see that some parts were weak, some parts were missing important context, and some parts were simply wrong.
But honestly, that realization is actually the fun part. It means that over the past few years I’ve gone through a lot of learn, unlearn, and relearn moments. When I read those old articles now, I can clearly see how surface-level my understanding was back then.
And that also means I’ve improved.
This series is my attempt to revisit SOLID again, with a clearer understanding and better explanations.
Top comments (0)