A quick guide on S.O.L.I.D
Tags: coding, productivity, solidprinciples
Published: 2024-05-12 18:06:38

Introduced by Robert C. Martin, S.O.L.I.D is an acronym representing a series of five principles that guide software developers in creating effective, maintainable, and scalable code. Embracing these principles can transform an average codebase into a professional developer's masterpiece. This blog delves into each principle, highlighting their significance and how they interlink to refine development practices. S.O.L.I.D stands as the linchpin of modern coding standards, paving the way for software that stands the test of time.

![SOLID](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9y5x710saemkxph732f6.png)

## **1) S: Single Responsibility Principle (SRP)**

The Single Responsibility Principle (SRP) is a rule that says each part of a computer program should only do one thing. This helps make the program easier to understand and maintain. It encourages programmers to break their code into smaller pieces that each have a specific job. By following this principle, developers can make their code more readable and avoid complicated and tangled code. SRP is not only a practical approach but also a philosophy that values simplicity and clarity in coding.

`Consider the examples below:`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dfszroo1igamk4ecbxg9.png)

The `EmailSender` class violates the rule as according to SRP, a class should have only one reason to change, but in this case, if there is a change in the way emails are sent or in the way email details are logged, both methods in the class would need to be modified.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7diey5h8uz5p1cspjkoc.png)

the responsibilities of sending emails and logging email details are separated into two different classes: `EmailSender` and `EmailLogger`. Each class has a single responsibility, adhering to the SRP. Therefore, if a change occurs, only the respective class needs to be modified, reducing the impact of changes and improving maintainability.

## 2) O: Open-Closed Principle (OCP)

When designing software, it's important to make it flexible and easy to extend without having to make big changes. That's where the Open-Closed Principle comes in. It's like putting a protective shield around your code, keeping its original design safe while still allowing room for new ideas and improvements.

The Open-Closed Principle helps your software grow and adapt over time. It prepares your code for the future, where changes can be made smoothly and without breaking everything that's already working.

- software entities should be open for extension but closed for modification.

`Consider the examples below:`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ss2jcuohn0th05m9nsja.png)

In this example, the render method violates the OCP because it is not closed for modification. If a new shape is added, such as a Rectangle, the render method needs to be modified to handle the new shape. This violates the principle of open for extension but closed for modification.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/84x3e01xw90vbf1vb3jl.png)

the `ShapeRenderer `class follows the OCP. It depends on the `Shape` interface, which is open for extension. Any new shape can be added by implementing the `Shape` interface and providing its own implementation of the `render` method. The `ShapeRenderer` class does not need to be modified to handle new shapes, making it closed for modification.

## 3) L: Liskov Substitution Principle (LSP)

The Liskov Substitution Principle is like a set of rules that keeps object-oriented programming in balance. It ensures that we can use a subtype (a specialized version of an object) in place of its parent type without causing any problems. This helps us maintain the correctness of our programs and keep everything running smoothly.

The principle emphasizes that subtypes should meet the expectations set by their parent types, so they can be used interchangeably. This makes it easier to work with different versions or variations of objects, without worrying about breaking anything or causing errors.

By following the LSP, we ensure that our code behaves consistently across different implementations. It helps us design classes and inherit from parent classes in a way that enhances functionality and builds trust within the overall structure of our code.

- objects of a superclass should be replaceable with objects of the subclass without affecting the correctness of the program.

The LSP plays a crucial role in good class design, supporting the flexibility and versatility of object-oriented programming.

`-> Consider the example below:
`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0r8c0k0der27329evga1.png)

In this example, both `Rectangle` and `Square `are subclasses of Shape. They both override the `calculateArea() `method to calculate the area specific to their shape. According to LSP, we can use an object of type `Rectangle` or `Square` wherever an object of type `Shape` is expected, without affecting the correctness of the program.

## 4) I: Interface Segregation Principle (ISP)

The Interface Segregation Principle is a coding rule that encourages the creation of simple and focused interfaces. Instead of having one big interface that does too many things, ISP suggests having smaller interfaces that meet the specific needs of different parts of the code.

ISP promotes customization and avoids using a one-size-fits-all approach. By designing interfaces that match the requirements of each part of the code, we can reduce complexity, improve efficiency, and ensure that classes only deal with the methods they really need.

`-> Consider the examples below:`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v94xt6ipjqmshm1lwxvj.png)

In this example, the `Printer` interface violates the ISP because it includes methods for scanning and faxing, which are not relevant to all clients. The `OfficePrinter` class implements the `Printer` interface and provides implementations for all the methods. However, the `Client` class only needs the print method, but it is forced to depend on the entire `Printer` interface.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6pwzs0m0uwgi8j0g5ili.png)

the ISP is followed by splitting the original `Printer` interface into three separate interfaces: `Printer`, `Scanner`, and `FaxMachine`. Each interface contains only the methods that are relevant to its specific functionality. The `OfficePrinter`, `OfficeScanner`, and `OfficeFaxMachine` classes implement the respective interfaces. The Client class can now depend on the specific interfaces it needs, allowing for more flexibility and avoiding unnecessary dependencies.

## 5) D: Dependency Inversion Principle (DIP)

DIP suggests that instead of having high-level modules depend directly on low-level modules, we should create an abstraction layer between them.

By using an abstraction layer, we can make our code more modular and easier to maintain. We can swap out different implementations of low-level modules without affecting the high-level modules. This allows us to change our code more easily without breaking everything else.

DIP helps us focus on the big picture of our software design, rather than getting bogged down in the details of each module.

- Create software that is more resilient, scalable, and easier to update over time.

`-> Example 1: Violating the Dependency Inversion Principle (DIP)
`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/38bi09w3wco038phblve.png)

In this example, the high-level module (`NotificationService`) directly depends on the low-level module (`EmailSender`). This violates the DIP because the high-level module should depend on abstractions, not concrete implementations.

`-> Example 2: Following the Dependency Inversion Principle (DIP)
`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i6stf55l8v29skxcmjci.png)

In this example, the high-level module (`NotificationService`) depends on the abstraction (`MessageSender`) instead of the concrete implementation (`EmailSender`). This follows the DIP because the high-level module depends on abstractions, allowing for flexibility and easier maintenance.

`Some use cases for DIP -> Database Connection / File Storage / Messaging System`

## Benefits of applying S.O.L.I.D principles

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xxuqz1zkxnlf5itiryye.png)

However, it's important to know that the road toward mastering S.O.L.I.D principles is not devoid of obstacles. Developers can sometimes drift into the realm of overengineering, where the pursuit of perfection leads to unnecessarily complex designs. The improper application of these principles can also lead to their efficacy being undermined—an understandable but avoidable tumbling block.

Furthermore, entrenched habits and resistance to change can stall the adoption of S.O.L.I.D principles in a team setting. It's essential to navigate these challenges with an open mind and an adaptive approach, ensuring that the principles serve the project and not the other way around.

## Conclusion

Having navigated the intricate principles of S.O.L.I.D, the discerning developer stands at the threshold of a development renaissance. Commanding these precepts leads not only to well-architected software but also cultivates an ethos of clarity, foresight, and coordination within development teams.

By internalizing S.O.L.I.D, coding professionals set into motion a chain of methodologies that resonate with robust design, resulting in systems marked by their resilience, flexibility, and collaborative potential. In embracing these principles, we stride toward a future where the quality of code aligns with the loftiest of software engineering aspirations.

## Resources for further learning

If you are willing to learn more about the principles of S.O.L.I.D feel free to check out on the below articles/discussion/blogs :-

1. Read "Clean Architecture" by Robert C. Martin to delve deeper into principles of robust software design.

2. Enroll in the "S.O.L.I.D Principles" course on Udemy for practical, hands-on learning experiences.

3. Engage with the development community through forums and discussions to exchange knowledge and insights.

4. Explore "S.O.L.I.D Principles: The Definitive Guide" by Simon Brown to gain a thorough understanding with real-world 
applications.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0ps7i5sgpp4yuyzexgmy.png)

[_Thank you for reading and following to the end. You can read more by clicking here_](https://dev.to/aish2004gupta)