Prinsip Pemrograman SOLID
Dalam mengembangkan sebuah sistem dengan paradigma pemrograman berbasis objek sering kali kita menerapkan kode seadanya, yang penting bisa jalan, tidak ada bug di production dan sesuai kaidah.
Tapi pernahkah kalian berpikir untuk membuat kode yang mudah dikembangkan, dimengerti dan dikelola. Didalam pemrograman berbasis objek terdapat prinsip bernama SOLID, yang bertujuan untuk membantu kalian dalam membuat program yang mudah dipahami dan dikelola.
Apa itu SOLID ?
SOLID merupakan kumpulan dari beberapa fundamental yang diwujudkan oleh engineer yang ahli dibidangnya. SOLID membantu kita mengembangkan sebuah perangkat lunak dengan tingkat kekukuhan yang tinggi.
Apakah seseorang yang sudah menguasai dan menggunakan OOP perlu mempelajari SOLID? Tentu saja YA, karena pada dasarnya OOP dan SOLID merupakan 2 (dua) hal yang berbeda. OOP adalah sebuah paradigma untuk menuliskan program yang sudah diadaptasi oleh beberapa bahasa pemrograman, sedangkan SOLID merupakan sebuah fundamental yang sudah disebutkan sebelumnya.
Jika kita mengilustrasikan prinsip SOLID, seperti inilah gambarnya.
Ilustrasi di atas menggambarkan bagaimana sekumpulan bola yang disusun sedemikian rupa dapat menciptakan bentuk yang kukuh. Padahal seperti yang kita ketahui, bola memiliki bentuk yang sangat mudah untuk bergerak. Analogi serupa dapat kita terapkan saat mengetik kode. Dalam mengembangkan sebuah perangkat lunak, jika kita bisa menuliskan kode dengan bentuk dan ukuran yang sama seperti halnya kumpulan bola di atas, kita pun dapat menciptakan sebuah sistem yang kukuh. Dengan terciptanya sistem yang kukuh, kita dapat lebih mudah dan leluasa mengganti komponen dan memperluas sistem tanpa adanya gangguan.
Tujuan SOLID
Kode yang kita buat dapat dengan mudah diekstensi (extended) dan dipertahankan (maintained).
Prinsip SOLID bukanlah suatu hukum atau aturan tertentu yang wajib kita patuhi, melainkan sebuah prinsip yang dimaksudkan untuk membantu kita dalam menuliskan kode yang rapi, seperti:
- Toleran terhadap perubahan,
- Mudah dipahami,
- Komponen dasar dapat digunakan kembali dalam bentuk software system lainnya.
Manfaat Prinsip SOLID
- Prinsip SOLID adalah salah satu pondasi utama dalam mengembangkan kode program agar lebih mudah dimengerti, dikelola, dan dikembangkan.
- Prinsip SOLID mampu diterapkan di banyak bahasa yang berparadigma OOP.
- Banyak perusahaan mensyaratkan pemahaman prinsip SOLID ketika mencari seorang developer.
- Menerapkan prinsip SOLID akan menghindarkan anda dari membuat aplikasi yang mudah memiliki bug karena penerapan desain yang buruk.
SOLID sendiri merupakan akronim dari 5 prinsip. Berikut adalah prinsip-prinsip tersebut :
Single Responsibility Principle
“A Class should be responsible for a single task or a class must have a specific purpose.”
Suatu class tidak diperbolehkan untuk mengerjakan banyak hal. Misalnya di dalam class invoice terdapat fungsi untuk mencetak invoice, akses basis data, dan melakukan perhitungan order. Hal ini sangat bertentangan dengan Single responsibility principle.
Single responsibility principle artinya setiap class wajib hanya memiliki satu tanggung jawab, dan hanya memiliki satu alasan untuk diubah. Contoh class untuk mendefinisikan struktur data hanya akan diubah jika terdapat perubahan pada struktur data, atau class yang mendefinisikan business logic hanya akan diubah jika terjadi perubahan business logic.
Apa tujuan menerapkan Single Responsibility? Ketika kita ingin melakukan perubahan pada sebuah class yang memiliki tanggung jawab yang banyak, perubahan yang akan dilakukan berpotensi untuk mempengaruhi fungsionalitas dan tanggung jawab lain yang saling berkaitan di dalam class tersebut.
Open/Close Principle
“Software entities should be open for extension but closed for modification or the short”
Dengan menerapkan Open-close principle kita harusnya bisa menambahkan fitur baru tanpa harus mengubah kode lama yang sudah ditulis sebelumnya. Hal ini dapat dilakukan dengan melakukan abstraksi yang tepat pada saat perancangan penulisan kode, gunakan interface dan atau abstract classes. Open-closed Principle memaksa kita untuk menulis kode yang modular.
Mengubah kode yang telah ditulis sebelumnya dikhawatirkan akan menimbulkan bug di production. Selain itu, perlu dilakukan pengulangan testing pada kode lama yang seharusnya bisa dihindari jika menerapkan Open-closed Principle.
Liskov Substitution Principle
“Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.”
Konsep ini terkait dengan proses inheritance suatu fungsi atau objek. Dalam Liskov substitution principle, super class harus dapat digantikan dengan objek dari subclass-nya tanpa berefek pada suatu aplikasi. Hal ini dapat dilakukan dengan membuat objek dari subclass yang memiliki perilaku sama dengan superclass, misalnya parameter dan return value yang sama dengan superclass.
Interface Segregation Principle
“A client should not be forced to use an interface if it doesn’t need it.”
Bertujuan untuk mengurangi jumlah ketergantungan sebuah class terhadap interface class yang tidak dibutuhkan.
Dalam pembuatan interface, lebih baik membuat banyak interface dengan fungsi yang spesifik. Hal ini lebih baik daripada membuat satu interface dengan fungsi yang tidak spesifik. Tujuan dari pemisahan interface adalah agar tidak memaksa client menggunakan kode yang tidak diperlukan.
Jika sudah ada interface yang tersedia, jangan menambahkan kode baru di interface. Lebih baik menambah interface baru yang masih berhubungan dengan interface lama, kemudian melakukan implements (implements adalah cara untuk mengimplementasikan interface). Lagi pula satu class dapat melakukan implementasi lebih dari satu interface, jadi manfaatkan itu.
Dependency Inversion Principle
Dalam principle ini terdapat 2 aturan, yaitu:
- High-level modules should not depend on low-level modules, both should depend on abstraction.
- Abstractions should not depend on details. Details should depend on abstractions
Setiap class yang memiliki kompleksitas tinggi tidak boleh bergantung pada class yang memiliki kompleksitas rendah dan untuk melakukan komunikasi setiap class harus melalui abstraksinya (interface).
