SOLID Principles
SOLID people use the SOLID principles
But what are these solid principles?
And why do even use them?
The SOLID principles, initially presented by Robert J. Martin (Uncle Bob) in 2000, were later coined as an acronym by Michael Feathers.
Uncle Bob, known for his books on Clean Code and Clean Architecture, is also involved in the Agile Alliance. These concepts of clean coding, object-oriented architecture, and design patterns are interconnected and complementary.
The Single Responsibility Principle
The Open-Closed Principle
The Liskov Substitution Principle
The Interface Segregation Principle
The Dependency Inversion Principle
1. Single Responsibility Principle (SRP): This principle states that a class should have only one reason to change. It encourages a class to have a single, well-defined responsibility, making it easier to understand, maintain, and modify.
2. Open-Closed Principle (OCP): The OCP suggests that software entities should be open for extension but closed for modification. Instead of altering existing code, you should extend it through inheritance, interfaces, or plugins to add new functionality.
3. Liskov Substitution Principle (LSP): LSP dictates that objects of derived classes should be able to replace objects of the base class without affecting program correctness. It emphasizes the need for strong, consistent contracts between base and derived classes.
4. Interface Segregation Principle (ISP): ISP advises creating specific, client-focused interfaces rather than large, monolithic ones. Clients should not be forced to depend on methods they don’t need. This promotes better encapsulation and avoids unnecessary coupling.
5. Dependency Inversion Principle (DIP): DIP promotes loose coupling by ensuring high-level modules depend on abstractions (interfaces or abstract classes) rather than concrete implementations. It also encourages the use of dependency injection to facilitate flexibility and maintainability in the codebase.
These principles collectively guide developers in creating more maintainable, extensible, and robust software systems by encouraging modular, well-structured code that minimizes code churn and maximizes reusability.
I suggest keeping these principles in mind while designing, writing, and refactoring your code so that your code will be much more clean, extendable, and testable.
