Get In Touch
606 Tower A Plot, I-Thum Tower, Sector 62, Noida, Uttar Pradesh, IN
Ph: +91 8383.033.985
Work Inquiries
Ph: +91 8383.033.985

The 5 Strong Rules Defined


In the present day I want to discuss SOLID, the primary 5 ideas of object-oriented programming that we discover important for constructing working software program. In case you didn’t realize it, in laptop programming, the SOLID ideas acronym was launched by Michael Feathers for 5 ideas that had been outlined by Robert C. Martin within the early 2000s.

As you already know, to get a working software program, we must always have a low coupling, excessive cohesion and robust encapsulation, which is one thing that the SOLID ideas assist us receive. The concept is that, by making use of these ideas collectively, you’ll be able to write higher high quality code that’s sturdy. The system created turns into simple to keep up, to reuse and to increase over time. Mainly, SOLID ideas assist software program builders to attain scalability and keep away from that your code breaks each time you face a change.

OK, so let's begin with the fundamentals, SOLID stands for:

S – Single-responsibility precept

O – Open-closed precept

L – Liskov substitution precept

I – Interface segregation precept

D – Dependency Inversion Precept

Let's take a look at every precept individually to know why SOLID can assist builders to construct high quality software program.

The SOLID Rules

1.Single-responsibility precept

“There must be by no means a couple of motive for a category to alter.”

As you may see, this precept states that an object / class ought to solely have one duty and that it must be fully encapsulated by the category. Right here, after we discuss a duty, we imply a motive to alter. This precept will result in a stronger cohesion within the class and looser coupling between dependency lessons, a greater readability and a code with a decrease complexity.

It’s far more obscure and edit a category when it has numerous tasks. So if now we have a couple of motive to alter, the performance will probably be cut up into two lessons and every will deal with its personal duty.

We care about separating the functionalities as a result of every duty is an entry of change. When a category has greater than a single duty, these tasks change into coupled and this coupling can result in a fragile code base that’s troublesome to refactor when your necessities emerge.

2. Open-closed precept

“Software program entities (lessons, modules, features, and so forth.) must be open for extension, however closed for modification.”

Right here, the concept is that an entity permits its conduct to be prolonged however by no means by modifying its supply code. Any class (or no matter you write) must be written in such a approach that it may be used as is. It may be prolonged if want be, however it might probably by no means be modified. You possibly can contemplate this when you find yourself writing your lessons. Use the category in any approach you want, however modifying its conduct comes by including new code, by no means by modifying the outdated. The identical precept could be utilized for modules, packages, libraries.

By making use of the open-closed precept you’re going to get a unfastened coupling, you’ll enhance readability and eventually, you can be lowering the danger of breaking current performance.

3. Liskov substitution precept

“subtypes have to be substitutable for his or her base varieties”

Because it's title says it, Likov's Substitution Precept was outlined by Barbara Liskov . The concept right here is that objects must be replaceable by cases of their subtypes, and that with out affecting the functioning of your system from a shopper's standpoint. Mainly, as an alternative of utilizing the precise implementation, it’s best to at all times be capable of use a base class and get the end result you had been ready for. Usually after we need to characterize an object, we mannequin our lessons based mostly on its properties and as an alternative of that, we must always really be placing extra our deal with the behaviors.

This precept mainly confirms that our abstractions are appropriate and helps us get a code that’s simply reusable and sophistication hierarchies which might be very simply understood.

What many say is that Liskov's Substitution Precept has a really robust relation with the earlier precept, the open-closed precept. Robert C. Martin even says that “a violation of LSP is a latent violation of OCP”.

4. Interface segregation precept

“Courses that implement interfaces, shouldn’t be pressured to implement strategies they don’t use.”

Right here, it's about write interfaces. So what’s said? Mainly, as soon as an interface is changing into too massive / fats, we completely want to separate it into small interfaces which might be extra particular. And interface will probably be outlined by the shopper that can use it, which implies that shopper of the interface will solely know in regards to the strategies which might be associated to them.

Truly, in the event you add strategies that shouldn't be there, the lessons implementing the interface must implement these strategies as effectively. That’s the reason; shopper shouldn't be pressured to depend upon interfaces that they don't use. ISP is meant to maintain a system decoupled and thus simpler to refactor, change, and deploy.

5. Dependency Inversion Precept

“Excessive degree modules shouldn’t depend upon low degree modules reasonably each ought to depend upon abstraction. Abstraction shouldn’t depend upon particulars; reasonably element ought to depend upon abstraction.”

Final of the SOLID ideas however not least, this precept is primarily involved with lowering dependencies amongst the code modules. Mainly, the Dependency Inversion Precept will probably be of an amazing assist in terms of understanding appropriately tie your system collectively.

In case your implementation element will depend upon the higher-level abstractions, it would show you how to to get a system that’s coupled appropriately. Additionally, it would affect the encapsulation and cohesion of that system.


When growing any software program, there are two ideas which might be crucial: cohesion (when totally different components of a system will work collectively to get higher outcomes than if every half can be working individually) & coupling (could be seen as a level of dependence of a category, methodology or every other software program entity).

Coupling is normally current in lots of code and as I discussed earlier, the optimum state of affairs can be to have a low coupling and a excessive cohesion. With this temporary introduction to the 5 SOLID ideas, you need to have understood that they assist us in terms of that.

There are such a lot of ideas in software program engineering and I’d suggest that earlier than writing a code, it’s best to do your analysis, learn and attempt to perceive the ideas. Though it could seem to be so much, SOLID turns into part of you and your code through the use of it constantly and adapting its pointers.

Supply by Lea Maya Karam

Post a comment

Your email address will not be published. Required fields are marked *