SOLID & Ruby in 5 short examples
In this article we’re going to explore the following topics:
- Single responsibility principle
- Open/closed principle
- Liskov substitution principle
- Interface segregation principle
- Dependency inversion principle
Introduction
SOLID is an acronym that stands for a set of principles to help developers to produce long-term maintainable source code that uses an object oriented programming language.
DISCLAIMER: as it’s just a set of principles, obviously it won’t replace your common sense.
This said, let’s detail each principle with a simple and short example.
PS: Due to duck typing design, Interface Segregation and Dependency Inversion principle are not relevant in Ruby.
Otherwise, I provide interesting resources in both sections about these principles for the most curious developers.
Single Responsibility principle
This principle is based on the fact that a class should be responsible of only one aspect of a program. By responsible we mean that the class can be impacted by a change in only one aspect of the program.
If a change occurs on the way to log — for example, logging in a file instead of a simple one puts
— then only the Logger
class must be impacted as it’s the only class that is responsible for logging.
Open/Closed principle
This principle is based on the fact that a class should be open for extension and closed for modification.
This means that is preferable to derivate from the class that you want to use than modify it directly
Here, the Array
class remains unchanged when the Collection
class — as a specialization of Array
— still gets the properties of an array.
So this pattern, allows you to add a set of functionalities and modify Array
’s existing methods without impacting all the other instances of Array
.
Liskov Substitution principle
This principle is based on the fact that a derived class must be substitutable by its base class
In this example, the RoleLogger#print_role
method takes a role
argument.
In our case the Admin
and User
classes derivate from Role
.
We can easily interchange these classes without breaking the expected behavior of the RoleLogger#print_role
method.
Interface Segregation principle
The Interface Segregation Principle (1996)
Dependency Inversion principle
The Dependency Inversion Principle (1996)
To go further
You can follow us on Twitter as we’re very active on this platform.
Indeed, we post elaborate code examples every day.
Also, I created RubyCademy Weekly which is a weekly newsletter.
Uncover crucial knowledge I wish I had when starting my career as a Rails developer!
This newsletter provides valuable Ruby tips, essential concepts, and patterns.
I deep dive into ADVANCED TOPICS with multiple CASE STUDIES!
Join us and get access to our exclusive content!
>>> RubyCademy Weekly <<<
💚