SOLID Design Rules In Kotlin | by Abhishek Saxena | Dec, 2022 | Ping Tech

very practically SOLID Design Rules In Kotlin | by Abhishek Saxena | Dec, 2022 will cowl the newest and most present help as regards the world. means in slowly so that you comprehend competently and appropriately. will mass your information skillfully and reliably

Photograph by Med Badr Chemmaoui on Unsplash

B.Earlier than we bounce into the subject of SOLID design rules, you want to perceive why we’d like them within the first place. In case you’re listening to the time period SOLID for the primary time, sit again as you may be studying a complete new approach to design your lessons.

Let me attempt to reply a very powerful query.

What number of of you’ve been slowed down by actually dangerous code? All of us sooner or later.

If we all know that dangerous code slows us down, why can we write dangerous code?
We do it as a result of we needed to go quick… and we let that sink in.

As Uncle Bob says, Robert C. Martin

You do not go quick in a rush.

You do not go quick simply making it work and releasing it as quick as you possibly can.

Do you wish to go quick? You probably did a very good job.

You sit down fastidiously, take into consideration the issue, write just a little, clear it up, and repeat. So that you go quick.

What are the signs of dangerous code?

  • Code rigidity
    Code that has dependencies in so many instructions that it can’t make a change in isolation.
    You alter part of the code and it breaks the calling/dependent class and you must repair it there. Ultimately, due to that one change, you find yourself making adjustments to 10 completely different lessons.
  • code fragility
    Once you make a change and an unrelated piece of code breaks.
  • tight coupling
    Happens when a category depends upon one other class.

In case you can relate to any of the above points, then this text is for you!

On this article, we are going to discover ways to overcome these issues utilizing SOLID design rules.

We’d like them to put in writing.

  • versatile code
  • Maintainable Code
  • comprehensible code
  • The code can tolerate adjustments

SOLID is an acronym that stands for five design rules.

  • S — Single Accountability Precept (SRP)
  • O — Open/Closed Precept (OCP)
  • L — Liskov Substitution Precept (LSP)
  • I — Interface Segregation Precept (ISP)
  • D — Dependency Inversion Precept (DIP)

A module will need to have one and just one purpose to vary.

What’s a module?

The only definition is only a supply file.

Nonetheless, some languages ​​and growth environments don’t use supply recordsdata to comprise their code. In these instances, a module is only a cohesive set of features and knowledge buildings.

Supply: Clear Structure, Robert C. Martin

Earlier than we perceive how SRP is adopted/applied/used, we have to perceive how it’s not used.

SRP Violation

Can you notice the violation?

The violation is that the Order You deal with multiple accountability which implies you’ve multiple purpose to vary.


Create a Order who’s accountable for sustaining the order knowledge.

To create OrderNotificationSender which is accountable for sending replace notifications to the person.

To create OrderInvoiceGenerator which is accountable for producing the order bill.

To create OrderRepository which is accountable for storing the order within the database.

We’ve extracted completely different duties from the Order class into separate lessons and every class has a single accountability.

Optionally, you possibly can even go a step additional and create a OrderFacade which delegates duties to particular person lessons.

As we will see that every class has just one accountability, thus following the Single accountability precept.

The OCP was coined in 1988 by Bertrand Meyer as

A software program artifact should be open for extension however closed for modification.

In different phrases, the habits of a software program artifact must be extensible with out having to change that artifact.

Supply: Clear Structure, Robert C. Martin

OCP Violation

To know OCP violation, let’s take an instance of a notification service which sends several types of notifications: push notifications and e mail notifications to recipients.

For instance I get a brand new requirement and now we assist SMS notifications, which it means i’ve to replace the Notification enumeration and the NotificationService to assist SMS notifications.

So he Notification Y NotificationService it is going to be like this

Because of this each time we alter the notification sort, we should replace the NotificationService to assist the change.

It is a clear violation of the OCP. Let’s have a look at how one can adjust to the OCP.


create an interface Notification.

Create the implementations Notification of every sort – PushNotificationY EmailNotification.

To create NotificationService.

Now you NotificationService follows OCP as you possibly can add/take away several types of notifications with out modifying the NotificationService.

To create SMSNotification which implements Notification.

As you possibly can see, I’ve added SMSNotification unmodified NotificationService thus following the Open/closed precept.

Marginal be aware:

That is the one precept that’s actually tough to comply with and one can’t totally fulfill it alone in a great world.

Since 100% closure can’t be achieved, closure should be strategic.

In 1988, Barbara Liskov wrote the next as a approach to outline subtypes.

Sure for every object o1 of sort S there’s an object o2 of sort you such that for all packages P outlined by way of youthe habits of P doesn’t change when o1 is changed by o2 then S is a subtype of you.

In different phrases, it implies that the kid sort ought to be capable of substitute the father or mother with out altering the habits of this system.

Let’s attempt to perceive the precept by trying on the violation of the notorious Sq./Rectangle drawback.

LSP Violation

We all know {that a} rectangle is a 4-sided polygon the place reverse sides are equal and 90°.

A sq. could be outlined as a particular sort of rectangle that has all sides of the identical size.

If squares and rectangles adopted LSP, then we must always be capable of substitute one with the opposite.

Please be aware: The Sq. and the Rectangle they’re written in Java, as Kotlin code would clearly present the violation with out me testing it

Create a Rectangle

To create Sq.

To create Driver to run the move.

Within the above code, Driver we will clearly see that Rectangle Y Sq. they can not substitute one another. Due to this fact, LSP is clearly violated.

Not at all will the above drawback comply with LSP. So, for the LSP answer/instance, we’ll take a look at one other drawback.

LSP Instance

Allow us to think about a Waste Administration Service that processes several types of waste — Natural waste and Plastic waste.

To create Waste Interface

To create OrganicWaste Y PlasticWaste which implements Waste Interface.

To create WasteManagementService

To create LSPDriver

Within the LSPDriver we will clearly see that we will substitute several types of waste, i.e. Natural and Plastic, with one another with out affecting the habits of this system. Following the Liskov substitution precept.

The interface segregation precept states that builders shouldn’t be pressured to depend upon interfaces they don’t use.

In different phrases, the category that implements the interface shouldn’t be pressured to make use of strategies it does not want.

ISP violation

Suppose we’re making a UI library which has elements and the elements can have completely different UI interactions like click on occasions: single click on and lengthy click on.

we have now an interface OnClickListener which has completely different click on behaviors, for a UI element to have this habits it should implement the OnClickListener Interface.

To create OnClickListener

To create CustomUIComponent

We will clearly see that the CustomUICompoenent is pressured to cancel onLongClick technique although in keeping with the necessities we do not need the CustomUICompoenent to have lengthy click on habits.

It is a clear violation of the LSP.


This answer is easy, we will separate the OnClickListener interface into two completely different interfaces: OnClickListener Y OnLongClickListenerthey deal with single click on habits and lengthy click on habits respectively.

To create OnClickListener

To create OnLongClickListener

To create CustomUICompoenent which implements OnClickListener

Now him CustomUIComponent you aren’t required to cancel onLongClick technique. Therefore, following the Interface segregation precept.

the Dependency inversion precept states that essentially the most versatile methods are these through which code dependencies refer solely to abstractions, not concretizations.

To know this precept, it’s essential to know what I imply after I say that Class A depends upon Class B.

Let’s go a bit out of the best way to grasp the above line.

For instance I’ve two lessons. ClassA Y ClassBthe code is written as follows

You may see on line 9 that an object of ClassA is created and on line 10 the strategy doSomething() is called. What ClassB want an object ClassA to operate appropriately, we will say that ClassA depends upon ClassB.

With the assistance of DIP, we are going to reverse this dependency.

The above diagram reveals DIP in motion, since we have now reversed the dependency between ClassA Y ClassBthe identical could be seen within the above diagram.

Now let’s examine the instance to grasp DIP.

An instance the place lessons depend upon one another

as an example we have now a NotificationService which sends just one sort of notification i.e. e mail notifications as it’s carefully associated to the EmailNotification class.

To create EmailNotification

To create NotificationService

To create NotificationDriver

The issue is NotificationServicedepends upon EmailNotification to ship notifications. That is the place dependency is available in.

We’ve to take away the dependency in such a means that NotificationService it doesn’t depend upon the kind of notification and may be capable of ship several types of notifications.


The answer is sort of easy, since we have now already solved this drawback once we mentioned OCP.

To NotificationService to be unbiased of the notification sort, then it ought to depend upon the summary class or an interface as a substitute of the concrete class, i.e. EmailNotification.

To create Notification Interface.

Create the notification sort — EmailNotification Y SmsNotification

To create NotificationService

To create NotificationDriver

You may see that the NotificationService now it depends upon the Notification interface as a substitute of implementation, i.e. e mail servicewe will simply interchange the implementation of the Notification make the system extra versatile. Following the Dependency inversion precept.

All SOLID rules could be outlined on a single line as follows.

SRP: Each software program module will need to have one, and just one, purpose to vary.

OCP – Software program methods should be straightforward to vary, they should be designed to permit the habits of these methods to be modified by including new code, fairly than altering present code.

LSP: To construct a software program system from interchangeable elements, these elements should adhere to a contract that permits these elements to be substituted for each other.

ISP: Software program designers ought to keep away from being depending on issues they do not use.

DIP: The code that implements the high-level coverage should not depend upon the low-level particulars.

Supply: Clear Structure, Robert C. Martin

I want the article about SOLID Design Rules In Kotlin | by Abhishek Saxena | Dec, 2022 provides acuteness to you and is helpful for calculation to your information

SOLID Design Principles In Kotlin | by Abhishek Saxena | Dec, 2022