Getting a solid grasp of SOLID

For this week’s blog, I have decided to go over the SOLID set of design principles. The blog article “SOLID design principles: Building stable and flexible systems” by Anna Monus describes SOLID and gives solid examples of each design principle with code and UML diagrams.

Single responsibility

Each class should only have a single responsibility, such as handling data or executing logic. While this increases the number of classes in a program, this will allow easier modification of the code and code clarity.


Classes should be open to extension and closed to modification. This means that new features should be introduced through extension and not through modifying existing code. The open/closed principle allows programs to expand with new features without breaking the old.

Liskov substitution

Named for its creator Barbara Liskov, the Liskov substitution principle states that a subclass should be able to replace its superclass without breaking the properties of the program. This means that a subclass shouldn’t change its superclass’ characteristics, such as return types. Following this principle will allow anything that depends on the parent class to use the subclass as well.

Interface segregation

Interface segregation states that classes should not have to implement unused methods from an interface. The solution is to divide the interface so that classes can implement only the desired methods. I found this principle to be easier understood from a visual example and I found the article’s UML diagram for interface segregation useful for this.

Dependency inversion

High and low-level modules should depend on abstractions. It is common to think that high-level classes should depend on low-level classes, but this makes expanding the code difficult so it’s best to have a level of abstraction between the two levels. The article’s UML example for this principle shows how the abstraction level allows for easy expansion.

The SOLID principles are important for code architecture as it makes code expansion simple and easy to understand. I have found myself applying SOLID principles to a project I have been playing with, a simple GUI animation. Originally, I had drawn objects handling their own draw and movement methods, but by using the single responsibility principle I separated the movement-based code to its own class and used composition between classes. This allowed for me to be able to use the movement code (contains position, velocity, and acceleration values and methods) for all the different objects that I make. I also made use of the O, L, and D of SOLID to handle the drawn object hierarchy allowing my frame class to depend on an abstraction of all my drawn objects. I use a loop to cycle through all drawn objects in a linked list that’s type is an abstraction of all drawn objects. I can tell that the structure of the code has made adding new functionality easy and intuitive.

Article Link:

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website with
Get started
%d bloggers like this: