Developing the People Who Develop Your Software
SOLID principles underly good development. They are an expression of three other development principles.
Development Principles:
Embrace SOLID
Embrace SOLID
SOLID principles, as put forth by Robert "Uncle Bob" Martin are a natural extension of the One Thing at a Time, Planning Before Acting, and Keep It Simple principles. If you adhere to those principles, writing SOLID code is a logical outcome. Read below to see how each SOLID principle aligns with the principles I've put forth.
Single-Responsibility Principle
This is where One Thing At A Time and Keep It Simple combine to create clean code. When a class has a single job, it is often simple which enhances its maintainability and testability.
Open-Closed Principle
Here we touch on Planning Before Acting. If we design our classes to embrace the Open-Closed Principle, we’ll be doing much more planning BEFORE we act.
Liskov Substitution Principle
Again, we’re embracing simplicity with this principle. We’re avoiding complex logic to handle subclasses by ensuring that any method that works with a class of type A will work with a subclass that inherits from A.
Interface Segregation Principle
Once again, simplicity is at the heart of this principle. By not requiring clients to implement anything other than just what is needed, we keep things simple and clear. Additionally, by developing the interface first, and writing tests against it, you’re doing a form of planning before acting to create the actual classes.
Dependency Inversion Principle
Once again, we keep things simple by depending on interfaces instead of concrete classes. The interface provides the contract and we don’t have to worry about a specific implementation. This allows us to simplify our thinking when creating the class.