SOLID Design Ideas In Kotlin | by Abhishek Saxena | Dec, 2022 | Tech Aza

not fairly SOLID Design Ideas In Kotlin | by Abhishek Saxena | Dec, 2022 will lid the most recent and most present counsel roughly the world. admittance slowly so that you comprehend with ease and appropriately. will progress your data precisely and reliably

Photograph by Med Badr Chemmaoui on Unsplash

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

Let me attempt to reply crucial query.

What number of of you have got been slowed down by actually unhealthy code? All of us sooner or later.

If we all know that unhealthy code slows us down, why will we write unhealthy 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 need to go quick? You probably did a superb 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 unhealthy code?

  • Code rigidity
    Code that has dependencies in so many instructions that it can not make a change in isolation.
    You modify part of the code and it breaks the calling/dependent class and it’s important to repair it there. In the long run, due to that one change, you find yourself making modifications 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 is determined by one other class.

In the event 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 want them to write down.

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

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 motive to vary.

What’s a module?

The only definition is only a supply file.

Nonetheless, some languages ​​and improvement environments don’t use supply information to include their code. In these instances, a module is only a cohesive set of capabilities and information buildings.

Supply: Clear Structure, Robert C. Martin

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

SRP Violation

Can you see the violation?

The violation is that the Order You deal with multiple accountability which implies you have got multiple motive to vary.


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

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

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 are able to 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 conduct of a software program artifact must be extensible with out having to switch 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 various kinds of notifications: push notifications and e-mail notifications to recipients.

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

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

Which means each time we modify the notification sort, we must replace the NotificationService to help the change.

This can be a clear violation of the OCP. Let’s examine 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 various kinds 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 observe:

That is the one precept that’s actually tough to observe and one can not totally fulfill it alone in a perfect world.

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

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

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

In different phrases, it signifies that the kid sort ought to be capable of change the guardian with out altering the conduct of this system.

Let’s attempt to perceive the precept by wanting 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. will be outlined as a particular sort of rectangle that has all sides of the identical size.

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

Please observe: 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 are able to clearly see that Rectangle Y Sq. they can not change one another. Due to this fact, LSP is clearly violated.

On no account will the above drawback observe LSP. So, for the LSP resolution/instance, we’ll take a look at one other drawback.

LSP Instance

Allow us to take into account a Waste Administration Service that processes various kinds 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 are able to clearly see that we’re able to changing various kinds of waste, i.e. Natural and Plastic, with one another with out affecting the conduct of this system. Following the Liskov substitution precept.

The interface segregation precept states that builders shouldn’t be compelled to rely on interfaces they don’t use.

In different phrases, the category that implements the interface shouldn’t be compelled 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 now have an interface OnClickListener which has completely different click on behaviors, for a UI element to have this conduct it should implement the OnClickListener Interface.

To create OnClickListener

To create CustomUIComponent

We are able to clearly see that the CustomUICompoenent is compelled to cancel onLongClick technique although in accordance with the necessities we do not need the CustomUICompoenent to have lengthy click on conduct.

This can be a clear violation of the LSP.


This resolution is straightforward, we are able to separate the OnClickListener interface into two completely different interfaces: OnClickListener Y OnLongClickListenerthey deal with single click on conduct and lengthy click on conduct 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 probably the most versatile methods are these during which code dependencies refer solely to abstractions, not concretizations.

To know this precept, you have to know what I imply after I say that Class A is determined by Class B.

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

As an 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 known as. What ClassB want an object ClassA to perform appropriately, we are able to say that ClassA is determined by ClassB.

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

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

Now let’s examine the instance to know DIP.

An instance the place lessons rely on one another

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

To create EmailNotification

To create NotificationService

To create NotificationDriver

The issue is NotificationServiceis determined by EmailNotification to ship notifications. That is the place dependency is available in.

We’ve to take away the dependency in such a manner that NotificationService it doesn’t rely on the kind of notification and may be capable of ship various kinds of notifications.


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

To NotificationService to be impartial of the notification sort, then it ought to rely on the summary class or an interface as an alternative 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 is determined by the Notification interface as an alternative of implementation, i.e. e-mail servicewe are able to simply interchange the implementation of the Notification make the system extra versatile. Following the Dependency inversion precept.

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

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

OCP – Software program methods should be simple to vary, they should be designed to permit the conduct of these methods to be modified by including new code, somewhat than altering current code.

LSP: To construct a software program system from interchangeable elements, these elements should adhere to a contract that enables 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 rely on the low-level particulars.

Supply: Clear Structure, Robert C. Martin

I want the article roughly SOLID Design Ideas In Kotlin | by Abhishek Saxena | Dec, 2022 provides sharpness to you and is helpful for appendage to your data

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