DEV Community: Muhamad Reza Abdul Rohim

Series Belajar Solid Principle - Liskov Substitution Principle (LSP)

Muhamad Reza Abdul Rohim — Sun, 21 Apr 2024 22:51:41 +0000

Hai semuanya!, di series sebelumnya gw udah share apa itu Open Closed Principle, nah kali ini gw akan bahas Liskov Substitution Principle (LSP).

Apa itu Liskov Substitution Principle (LSP)?

Prinsip LSP itu seperti aturan dasar/pattern yang harus diikuti dalam membangun hubungan antar class. Intinya, kita harus desain class-class kita dengan hati-hati supaya bisa disubstitusi tanpa bikin masalah.
Jadi, setiap turunan class minimal harus bisa ngelakuin hal yang sama kayak class dasarnya, bingung? :D, Langsung aja ke contohnya yaa biar ga bingung.

Gw pake contoh studi kasus yang sama dengan artikel sebelum sebelumnya.

Before

Sebelum menggunakan LSP, mungkin kode kita terlihat seperti ini:

class Payment {
    public function checkout($customer) {
        // Proses pembayaran...
        // Kirim notifikasi
        if ($customer->hasWhatsApp()) {
            $this->sendWhatsAppNotification($customer);
        } else {
            $this->sendEmailNotification($customer);
        }
    }

    private function sendWhatsAppNotification($customer) {
        // Mengirim notifikasi ke WhatsApp
    }

    private function sendEmailNotification($customer) {
        // Mengirim notifikasi via email
    }
}

// 
$customer = 'misal data customer...'; 
$payment = new Payment();
$payment->checkout($customer);

Implementasi di atas mungkin tampak baik pada awalnya, tetapi itu melanggar prinsip LSP. Mengapa? Karena class Payment tidak fleksibel dan tidak dapat diperluas jika kita ingin menambahkan cara pengiriman notifikasi lainnya di masa depan.
Selain itu, class diatas mempunyai terlalu banyak tanggung jawab dan kurang terorganisir.

After

Untuk memperbaiki masalah di atas dan menerapkan LSP, kita akan menggunakan abstraksi untuk memisahkan logika notifikasi dari proses pembayaran.

// Abstract class untuk notifikasi
abstract class Notification {
    abstract public function send($customer);
}

// Implementasi notifikasi via WhatsApp
class WhatsAppNotification extends Notification {
    public function send($customer) {
        // Mengirim notifikasi ke WhatsApp
    }
}

// Implementasi notifikasi via email
class EmailNotification extends Notification {
    public function send($customer) {
        // Mengirim notifikasi via email
    }
}

class Payment {
    public function checkout($customer, Notification $notification) {
        // Proses pembayaran...

        // Kirim notifikasi menggunakan abstraksi
        $notification->send($customer);
    }
}

Sekarang, kode kita lebih sesuai dengan prinsip LSP. Mengapa?

Kodenya lebih fleksibel, Jika kita ingin menambahkan metode notifikasi baru di masa depan, kita cukup membuat class baru yang mengimplementasikan abstraksi Notification,misal dimasa depan diharuskan menambahkan fitur notifikasi telegram, tentu dengan design kode diatas kita tinggal menambahkan class Telegram yang mengextends abstract class Notification, tanpa perlu merubah class Payment(Service Class).
Tanggung jawab terkait notifikasi dipisahkan dari proses pembayaran, memperjelas struktur dan readable.
Penggunaan abstraksi memungkinkan kita untuk mengganti atau memperluas perilaku notifikasi tanpa mempengaruhi class lain dalam sistem.

Setelah kita memiliki class Payment yang telah ditingkatkan, kita dapat mengintegrasikannya dengan mudah ke dalam kode kita.

$customer = 'misal data customer...'; 
$payment = new Payment();
$notification = $customer->hasWhatsApp() ? new WhatsAppNotification() : EmailNotification();
$payment->checkout($customer, $notification);

Kesimpulan

Dengan demikian, penggunaan LSP membawa manfaat seperti peningkatan fleksibilitas kode, lebih readable, dan kemampuan untuk mengganti atau memperluas fungsi/behaviour notifikasi tanpa mempengaruhi class lain dalam sistem. Ini memungkinkan developer untuk menghasilkan kode yang lebih modular, mudah dipelihara/maintainable, dan mudah diubah di masa depan.

Series Belajar Solid Principle - Open Close Principle (OCP)

Muhamad Reza Abdul Rohim — Thu, 18 Apr 2024 04:23:10 +0000

Yo guys, Melanjutkan series sebelumnya mengenai Single Responsibility Principle, kali ini gw akan menjelaskan tentang Open Close Principle.

Dalam dunia pemrograman, kita selalu mencari cara untuk membuat kode kita makin mudah untuk dikembangkan dan dimaintain, Salah satu pattern yang bisa kita pakai adalah Open Close Principle (OCP).

Apa Itu OCP?

OCP adalah salah satu pattern/principle yang membentuk SOLID, yang tujuannya membuat kode kita mudah jika ada perubahan, seperti penambahan fitur baru tanpa harus merubah bagian-bagian yang sudah ada.

Sama seperti Series yg sebelumnya, gw akan menggunakan studi kasus proses checkout dan Notifikasi ke pelanggan.

Before

Sebelum menggunakan OCP, mungkin kode kita terlihat seperti ini:

class CheckoutProcess {
    public function checkout($items,$customer) {
        // Proses checkout
        // ...

        // Update status di database
        $this->updateDatabase();

        if(!empty($customer->waNumber))
        {
            // Kirim pesan WhatsApp ke pelanggan
            $this->sendWhatsApp();
        }else{
             // Kirim email ke pelanggan
            $this->sendEmail();
        }
    }

    private function updateDatabase() {
        // Logika untuk memperbarui status di database
        // ...
    }

    private function sendEmail() {
        // Logika untuk mengirim email ke pelanggan
        // ...
    }

    private function sendWhatsApp() {
        // Logika untuk mengirim pesan WhatsApp ke pelanggan
        // ...
    }
}

Meskipun ini mungkin bekerja dengan baik, kekurangan dari codingan diatas adalah setiap kali kita ingin menambahkan method notifikasi baru seperti telegram notification misalnya, maka kita harus merubah class CheckoutProcess, hal ini tidak sesuai dengan OCP.

Implementasi OCP

Diseries sebelumnya kita sudah belajar mengenai SRP (Single Responsibility Principle) maka kita harus memisahkan class sesuai dengan perannya.

<?php 

class DatabaseUpdater {
  public function update($items) {
      // Logika untuk memperbarui status dalam database
  }
} 

interface NotificationService {
  public function notify();
}

class EmailNotification implements NotificationService {
  public function notify() {
      // Logic ngirim email
      // ...
  }
}

class WhatsAppNotification implements NotificationService {
  public function notify() {
      // Logic ngirim  WhatsApp
      // ...
  }
}

class CheckoutProcess {
  private $notificationService;

  public function __construct(DatabaseUpdater $db, NotificationService $notificationService) {
      $this->notificationService = $notificationService;
  }

  public function checkout($items) {
      // Proses checkout
      // ...

      // Update status di database
      $this->db->update($items);

      // Notifikasi ke pelanggan
      $this->notificationService->notify();
  }
}

Dalam implementasi di atas, kita telah memisahkan tanggung jawab masing-masing metode ke dalam class-class terpisah. class CheckoutProcess bertanggung jawab hanya untuk proses checkout dan tidak lagi tergantung pada implementasi langsung dari fungsi-fungsi atau method notification (sendWhatsApp() dan sendEmail()).

Koencinya ada di interface NotificationService
Dengan menggunakan interface, kita dapat dengan mudah menambahkan jenis notifikasi baru tanpa perlu merubah class-class lainnya. Interface ini memastikan bahwa setiap kelas yang berperan sebagai layanan notification (WhatsAppNotification,EmailNotification) harus berisi method notify.

Setelah kita memiliki kelas CheckoutProcess yang dioptimalkan, kita dapat dengan mudah menggunakannya dalam codingan kita, contoh misalkan kita ingin menggunakan fungsi checkout tapi menggunakan whatsapp notifier

$db = new DatabaseUpdater();
$whatsappNotification = new WhatsAppNotification();
$checkoutWithWhatsApp = new CheckoutProcess($db,$whatsappNotification);
$checkoutWithWhatsApp->checkout($items);

Tapi jika kita ingin menggunakan email notifier, tinggal ubah saja WhatsappNotification menjadi EmailNotifcation.

$db = new DatabaseUpdater();
$emailNotification= new EmailNotification();
$checkoutWithEmail= new CheckoutProcess($db,$emailNotification);
$checkoutWithEmail->checkout($items);

Atau combine keduanya:

$db = new DatabaseUpdater();
$customer = 'misalkan berisi data customer';
$notification = !empty(@$customer->waNumber) ? new WhatsAppNotification() : new EmailNotification();
$checkout= new CheckoutProcess($db,$notification);
$checkout->checkout($items);

Dengan cara ini, kita bisa menggunakan CheckoutProcess dengan berbagai jenis notifikasi tanpa harus mengubah kode di dalam class tersebut. misalkan kedepannya client meminta notif ke telegram,sms,slack dan sebagainya.

Kesimpulan

Dengan menerapkan Prinsip Open Close dan Prinsip Single Responsibility, kita membuat kode yang lebih adaptif dan mudah dimaintain. Dengan memisahkan tanggung jawab tiap komponen ke dalam kelas-kelas terpisah, kita memungkinkan penambahan fitur atau perubahan tanpa harus mengubah kode yang sudah ada. Ini meningkatkan fleksibilitas dan mempermudah pengelolaan kode dalam jangka panjang. Karenanya, penting untuk selalu mempertimbangkan prinsip-prinsip SOLID dalam pengembangan perangkat lunak.

Series Belajar Solid Principle - Single Responsibility Principle (SRP)

Muhamad Reza Abdul Rohim — Wed, 17 Apr 2024 13:15:02 +0000

Dalam dunia pengembangan perangkat lunak, SRP merupakan salah satu konsep yang sangat fundamental. SRP adalah bagian dari SOLID Principle.

Dalam artikel ini, gw akan mengulas SRP secara detail dan menerapkannya dalam konteks pengembangan aplikasi menggunakan PHP.
kenapa menggunakan PHP? karena PHP Bahasa Pemrograman Sejuta umat, agar mudah dimengerti oleh khalayak ramai :D.

Apa Itu Single Responsibility Principle (SRP)?

SRP adalah prinsip desain perangkat lunak (Design Pattern) yang menyatakan bahwa sebuah class harus bertanggung jawab atas satu hal saja. Ini membantu menjaga class tetap terfokus, mudah dimengerti, dan mudah diubah.

Contoh kodingan tanpa menerapkan SRP

Mari kita lihat contoh sebelum menerapkan SRP. Misalkan kita memiliki class CheckoutManager dalam sebuah toko online. class ini bertanggung jawab untuk melakukan sejumlah tindakan seperti memperbarui database, mengirim email konfirmasi, dan mengirim pesan WhatsApp kepada pelanggan.

class CheckoutManager {
    public function processCheckout($cartItems, $customerInfo) {
        $this->updateDatabase($cartItems);
        $this->sendEmail($customerInfo);
        $this->sendWhatsAppMessage($customerInfo);
    }

    private function updateDatabase($cartItems) {
        // Logika untuk memperbarui status dalam database
    }

    private function sendEmail($customerInfo) {
        // Logika untuk mengirim email konfirmasi kepada pelanggan
    }

    private function sendWhatsAppMessage($customerInfo) {
        // Logika untuk mengirim pesan WhatsApp konfirmasi kepada pelanggan
    }
}

Penerapan SRP

Sekarang, mari kita terapkan SRP dengan membagi tanggung jawab tersebut ke dalam class class yang lebih spesifik.

Pembaruan Database

class DatabaseUpdater {
    public function update($cartItems) {
        // Logika untuk memperbarui status dalam database
    }
}

Kirim Email

class EmailSender {
    public function send($customerInfo) {
        // Logika untuk mengirim email konfirmasi kepada pelanggan
    }
}

kirim whatsapp

class WhatsAppSender {
    public function send($customerInfo) {
        // Logika untuk mengirim pesan WhatsApp konfirmasi kepada pelanggan
    }
}

Integrasi dengan SRP

Sekarang, kita dapat mengintegrasikan class class tersebut ke dalam CheckoutManager.


class CheckoutManager {
    private $databaseUpdater;
    private $emailSender;
    private $whatsAppSender;

    public function __construct(DatabaseUpdater $databaseUpdater, EmailSender $emailSender, WhatsAppSender $whatsAppSender) {
        $this->databaseUpdater = $databaseUpdater;
        $this->emailSender = $emailSender;
        $this->whatsAppSender = $whatsAppSender;
    }

    public function processCheckout($cartItems, $customerInfo) {
        $this->databaseUpdater->update($cartItems);
        $this->emailSender->send($customerInfo);
        $this->whatsAppSender->send($customerInfo);
    }
}

Dengan menerapkan SRP, kita dapat membuat kode kita lebih terstruktur, mudah dimengerti, dan mudah dikelola. Setiap class sekarang memiliki tanggung jawab yang jelas dan terdefinisi dengan baik, sehingga membantu meningkatkan keberlanjutan dan skalabilitas kode kita 🚀.

Sekian sekilas mengenai SRP. di next artikel gw akan buat artikel mengenai SOLID Princple lainnya yaitu Open Close Principle,Liskov Substitution Principle,Interface Segregation Principle dan Dependency Inversion Principle, so tunggu aja gaes updatenya tengkyu..

Coding Playlist: Albums for Every Mood

Muhamad Reza Abdul Rohim — Tue, 16 Apr 2024 19:08:02 +0000

Hey fellow coders! 🎧👩‍💻 here's a friendly peek into my go-to albums for every coding mood. Let's groove! 🚀

1. The Strokes - Comedown Machine

Picture this: it's a breezy afternoon, and the code is flowing smoothly. That's when I reach for The Strokes' "Comedown Machine". Its chill vibes and dreamy melodies set the perfect ambiance for a relaxed coding session. So kick back, take a sip of your favorite drink, and let the coding journey begin!

2. Bullet for My Valentine - The Poison

But hey, we all have those days when deadlines are looming, and the pressure's on. Enter Bullet for My Valentine's "The Poison". Its high-energy riffs and adrenaline-pumping beats fuel my focus and drive, helping me power through even the toughest coding challenges. So crank up the volume and let's crush those deadlines together!

3. Arctic Monkeys - Whatever People Say I Am, That's What I'm Not

Now, imagine a day when everything's going your way – maybe you just got that well-deserved raise or nailed a particularly tricky bug fix. That's when I cue up Arctic Monkeys' "Whatever People Say I Am, That's What I'm Not". Its infectious energy and catchy tunes perfectly capture the euphoria of success. Go ahead, celebrate your wins – you've earned it!

4. Muse - Absolution

But let's be real – we all have those moments when motivation is at an all-time low, and the couch is calling our name. For those days, there's Muse's "Absolution". Its moody melodies and introspective lyrics provide the soundtrack to my moments of laziness and procrastination. Embrace the chill, recharge your batteries, and remember that even the best of us need a break sometimes.

And there you have it – my friendly coding playlist for every mood. Whether you're feeling chill, under pressure, on top of the world, or just plain lazy, there's an album for every moment. So plug in those headphones, fire up your favorite editor, and let the coding adventures begin! 🎵💻

How to create normalizer to make case in sensitive on ElasticSearch

Muhamad Reza Abdul Rohim — Tue, 06 Jun 2023 18:45:56 +0000

By default if you add field on index elasticsearch with keyword data type, you cannot querying or sorting the field with case insensitive, because it is not supported by default, the solution is you can add normalizer like this using kibana:

PUT your_awesome_index_name
{
  "settings": {
    "analysis": {
      "normalizer": {
        "lowercase_normalizer": {
          "type": "custom",
          "filter": ["lowercase"]
        }
      }
    }
  },
  "mappings": {
      "properties": {
        "name": {
          "type": "keyword",
          "normalizer": "lowercase_normalizer"
        }
      }
  }
}

And now you can querying the index data with case insensitive keyword:

GET your_awesome_index_name/_search
{
  "query": {
    "query_string": {
      "default_field": "name.keyword",
      "query": "*reza*"
    }
  }
}