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

PROJECT NEWS  > News >  SOLID Design Ideas In Kotlin | by Abhishek Saxena | Dec, 2022 | Pirate Tech

very practically SOLID Design Ideas In Kotlin | by Abhishek Saxena | Dec, 2022 will cowl the most recent and most present suggestion practically the world. entre slowly appropriately you perceive with ease and appropriately. will accrual your data expertly and reliably

Photograph by Med Badr Chemmaoui on Unsplash

B.Earlier than we bounce into the subject of SOLID design rules, it’s essential perceive why we want them within the first place. Should you’re listening to the time period SOLID for the primary time, sit again as you will be studying an entire new approach to design your courses.

Let me attempt to reply crucial query.

What number of of you might have been slowed down by actually unhealthy code? All of us in some unspecified time in the future.

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’ll be able to.

Do you need to go quick? You probably did a great job.

You sit down fastidiously, take into consideration the issue, write a bit of, 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 alter part of the code and it breaks the calling/dependent class and you must repair it there. In the long run, due to that one change, you find yourself making modifications to 10 totally different courses.
  • code fragility
    Whenever you make a change and an unrelated piece of code breaks.
  • tight coupling
    Happens when a category will depend on one other class.

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

On this article, we’ll learn to overcome these issues utilizing SOLID design rules.

We want them to put in writing.

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

SOLID is an acronym that stands for five design rules.

  • S — Single Duty 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 best 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 knowledge 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 notice the violation?

The violation is that the Order You deal with multiple duty which implies you might have multiple purpose to vary.


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

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

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

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

We’ve got extracted totally different obligations from the Order class into separate courses and every class has a single duty.

Optionally, you’ll be able to even go a step additional and create a OrderFacade which delegates obligations to particular person courses.

As we are able to see that every class has just one duty, thus following the Single duty precept.

The OCP was coined in 1988 by Bertrand Meyer as

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

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

Supply: Clear Structure, Robert C. Martin

OCP Violation

To grasp 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 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 will likely be like that

Which means that each time we alter the notification kind, 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 kind – PushNotificationY EmailNotification.

To create NotificationService.

Now you NotificationService follows OCP as you’ll be able to add/take away various kinds of notifications with out modifying the NotificationService.

To create SMSNotification which implements Notification.

As you’ll be able to 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 not absolutely fulfill it alone in an excellent world.

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

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

Sure for every object o1 of kind S there’s an object o2 of kind you such that for all packages P outlined when it comes to 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 kind ought to be capable of change the dad or mum 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. will be outlined as a particular kind 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 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 circulate.

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.

In no way will the above drawback comply with 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 habits of this system. Following the Liskov substitution precept.

The interface segregation precept states that builders shouldn’t be compelled to depend upon 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 parts and the parts can have totally different UI interactions like click on occasions: single click on and lengthy click on.

we’ve got an interface OnClickListener which has totally different click on behaviors, for a UI part to have this habits 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 methodology regardless that in response to the necessities we do not need the CustomUICompoenent to have lengthy click on habits.

It is a clear violation of the LSP.


This resolution is easy, we are able to separate the OnClickListener interface into two totally 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 methodology. 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 grasp this precept, you will need to know what I imply once I say that Class A will depend on Class B.

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

As an instance I’ve two courses. ClassA Y ClassBthe code is written as follows

You’ll be able to see on line 9 that an object of ClassA is created and on line 10 the tactic doSomething() is called. What ClassB want an object ClassA to operate appropriately, we are able to say that ClassA will depend on ClassB.

With the assistance of DIP, we’ll reverse this dependency.

The above diagram reveals DIP in motion, since we’ve got reversed the dependency between ClassA Y ClassBthe identical will be seen within the above diagram.

Now let’s examine the instance to grasp DIP.

An instance the place courses depend upon one another

as an example we’ve got a NotificationService which sends just one kind 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 NotificationServicewill depend on EmailNotification to ship notifications. That is the place dependency is available in.

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


The answer is kind of easy, since we’ve got already solved this drawback once we mentioned OCP.

To NotificationService to be impartial of the notification kind, then it ought to depend upon the summary class or an interface as an alternative of the concrete class, i.e. EmailNotification.

To create Notification Interface.

Create the notification kind — EmailNotification Y SmsNotification

To create NotificationService

To create NotificationDriver

You’ll be able to see that the NotificationService now it will depend on 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, purpose to vary.

OCP – Software program methods have to be straightforward to vary, they have to be designed to permit the habits of these methods to be modified by including new code, reasonably 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 practically SOLID Design Ideas In Kotlin | by Abhishek Saxena | Dec, 2022 provides keenness to you and is beneficial for toting as much as your data

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