Artikel ini membahas tentang enkapsulasi, mulai dari contoh masalah yang membutuhkan enkapsulasi, apa pengertiannya, apa saja manfaatnya, serta bagaimana implementasinya di Python

Contoh Masalah yang Membutuhkan Enkapsulasi

Bayangkan misalkan kita sedang membuat sebuah program untuk mengelola data bank. Dalam program tersebut, kita memiliki class BankAccount yang menyimpan informasi penting seperti saldo akun. Tentu saja, saldo akun ini adalah informasi sensitif yang tidak boleh dimanipulasi secara langsung dari luar class karena bisa menimbulkan masalah keamanan.

Sebagai contoh, jika seseorang bisa mengakses atau mengubah saldo akun secara langsung, maka integritas data bisa terganggu. Ini bisa menyebabkan saldo menjadi negatif atau terjadi perubahan tanpa izin yang dapat membahayakan sistem keuangan.

Perhatikan contoh kode program Python berikut ini

class BankAccount:
    def __init__(self, pemilik, saldo_awal):
        self.pemilik = pemilik
        self.saldo = saldo_awal

   # Metode untuk menambah saldo
    def deposit(self, jumlah):
        if jumlah > 0:
            self.saldo += jumlah
            print(f"Saldo bertambah: {jumlah}, Saldo sekarang: {self.saldo}")
        else:
            print("Jumlah deposit harus positif!")

    # Metode untuk menarik saldo
    def withdraw(self, jumlah):
        if jumlah > 0 and jumlah <= self.saldo:
            self.saldo -= jumlah
            print(f"Berhasil menarik: {jumlah}, Saldo sekarang: {self.saldo}")
        else:
            print("Penarikan gagal: saldo tidak mencukupi atau jumlah tidak valid")

# Contoh Penggunaan
akun = BankAccount("Budi", 1000)
akun.deposit(500)        # Menambah saldo menjadi 1500
akun.withdraw(1000)      # Menarik saldo menjadi 500

# mengeset saldo menjadi minus
akun.saldo = -100000 

Dari contoh di atas tampak bahwa atribut saldo dapat langsung diakses dan diubah nilainya menjadi minus. Seharusnya hal ini tidak dibolehkan secara sistem, karena data yang diassign ke dalam saldo tidaklah valid. Untuk itu perlu mekanisme guna mencegah supaya atribut saldo ini tidak bisa langsung diakses. Di sinilah pentingnya penerapan enkapsulasi.

Pengertian Enkapsulasi

Enkapsulasi adalah salah satu prinsip utama dalam Pemrograman Berorientasi Objek (PBO) yang bertujuan untuk membatasi akses langsung ke data pada atribut dalam sebuah objek dan hanya memperbolehkan akses melalui method tertentu yang telah disediakan.

Konsep enkapsulasi memungkinkan untuk:

• Menyembunyikan detail implementasi (data dan logika) dari luar class.
• Membatasi akses langsung ke atribut
• Menjaga data tetap konsisten dan aman dengan validasi internal.

Prosedur Penerapan Enkapsulasi di Python

Untuk menerapkan enkapsulasi dalam Python, kita dapat menggunakan pendekatan berikut:

1. Gunakan prefix double underscore (__) untuk mendefinisikan atribut atau metode sebagai private (hanya boleh diakses oleh class itu sendiri).
2. Sediakan method getter dan setter untuk mengakses atau memanipulasi atribut private secara aman. Method getter digunakan untuk mengakses nilai atribut yang disembunyikan tersebut. Adapun method setter digunakan untuk mengassign nilai kepada atribut yang disembunyikan.

Contoh Penerapan Enkapsulasi dalam Python

Sekarang, mari kita selesaikan masalah pada contoh kasus di awal dengan menerapkan enkapsulasi:

Masalah:

Saldo akun dalam BankAccount bisa diubah dari luar class, sehingga rawan dimanipulasi dan menyebabkan kerugian.

Solusi dengan Enkapsulasi:

1. Sembunyikan atribut saldo dengan modifier private (__).
2. Buat metode get_saldo() dan set_saldo() untuk membaca dan mengubah saldo dengan validasi.

Berikut adalah implementasi dalam Python:

class BankAccount:
    def __init__(self, pemilik, saldo_awal):
        self.pemilik = pemilik
        self.__saldo = saldo_awal

    # Method getter untuk membaca saldo (tanpa bisa diubah langsung)
    def get_saldo(self):
        return self.__saldo
    
    # Method setter untuk memperbarui saldo dengan validasi
    def set_saldo(self, jumlah):
        if jumlah < 0:
            print("Jumlah saldo tidak boleh negatif!")
        else:
            self.__saldo = jumlah
            print(f"Saldo berhasil diperbarui menjadi: {self.__saldo}")

    # Metode untuk menambah saldo
    def deposit(self, jumlah):
        if jumlah > 0:
            self.__saldo += jumlah
            print(f"Saldo bertambah: {jumlah}, Saldo sekarang: {self.__saldo}")
        else:
            print("Jumlah deposit harus positif!")

    # Metode untuk menarik saldo
    def withdraw(self, jumlah):
        if jumlah > 0 and jumlah <= self.__saldo:
            self.__saldo -= jumlah
            print(f"Berhasil menarik: {jumlah}, Saldo sekarang: {self.__saldo}")
        else:
            print("Penarikan gagal: saldo tidak mencukupi atau jumlah tidak valid")

# Contoh Penggunaan
akun = BankAccount("Budi", 1000)
print(akun.get_saldo())  # Output: 1000

akun.set_saldo(2000)     # Update saldo
akun.deposit(500)        # Menambah saldo
akun.withdraw(1000)      # Menarik saldo

# Akses langsung ke atribut __saldo akan error
# print(akun.__saldo)   # AttributeError: 'BankAccount' object has no attribute '__saldo'

Berikut ini beberapa penjelasan kode:

1. __saldo adalah atribut private yang tidak bisa diakses langsung dari luar class.
2. get_saldo() adalah method getter untuk membaca saldo.
3. set_saldo() adalah method setter yang memvalidasi nilai sebelum memperbarui saldo.
4. deposit() dan withdraw() adalah metode untuk memanipulasi saldo dengan aturan tertentu.

Dengan cara ini, data menjadi lebih aman karena hanya bisa dimanipulasi melalui metode yang telah ditentukan.

Manfaat Enkapsulasi

Berdasarkan penjelasan di atas, kita bisa memahami bahwa penerapan enkapsulasi memberikan banyak manfaat, antara lain:

• Perlindungan Data: Data sensitif hanya bisa diakses melalui method tertentu.
• Validasi Data: Mencegah data yang tidak valid masuk ke dalam atribut.
• Keamanan dan Konsistensi: Data tetap aman dan konsisten karena akses langsung dibatasi.

Pada artikel ini, kita akan membahas prinsip kelima dalam SOLID, yaitu Dependency Inversion Principle (DIP).

Apa Itu Prinsip SOLID?

Prinsip SOLID adalah kumpulan dari lima prinsip desain dalam pemrograman berorientasi objek (OOP) yang bertujuan untuk membuat kode menjadi lebih mudah dipelihara, diperluas, dan scalable. Prinsip ini pertama kali diperkenalkan oleh Robert C. Martin (Uncle Bob) pada awal tahun 2000-an dan menjadi fondasi utama dalam pengembangan perangkat lunak modern yang bersifat modular dan berbasis kontrak.

Prinsip SOLID terdiri dari lima konsep utama:

1. Single Responsibility Principle (SRP): Setiap class harus memiliki satu tanggung jawab saja.
2. Open/Closed Principle (OCP): Kode harus terbuka untuk dikembangkan, tetapi tertutup untuk modifikasi.
3. Liskov Substitution Principle (LSP): Objek turunan harus bisa menggantikan objek induknya tanpa mengubah perilaku yang diharapkan.
4. Interface Segregation Principle (ISP): Developer tidak boleh dipaksa untuk mengimplementasikan interface yang tidak mereka gunakan.
5. Dependency Inversion Principle (DIP): Class-level dependency harus diarahkan ke abstraksi, bukan ke implementasi konkret.

Prinsip SOLID sangat penting karena membantu developer dalam menulis kode yang clean, mudah dibaca, dan mudah dikelola. Dengan menerapkan prinsip ini, kode menjadi lebih fleksibel terhadap perubahan, lebih mudah untuk dikembangkan tanpa memodifikasi kode yang sudah ada, dan lebih terstruktur untuk pengembangan perangkat lunak berskala besar.

Selain itu, Prinsip SOLID juga membantu dalam mengurangi ketergantungan antar komponen, sehingga perubahan pada satu bagian kode tidak akan secara langsung mempengaruhi bagian kode lainnya.

Selain itu, dengan desain yang lebih modular, kode menjadi lebih mudah untuk diuji (testable) dan mempermudah proses debugging serta maintenance. Dengan menerapkan SOLID, developer juga dapat membangun sistem yang lebih tahan terhadap perubahan dan memiliki performa yang lebih stabil dalam jangka panjang.

Dependency Inversion Principle (DIP)

Dependency Inversion Principle (DIP) adalah prinsip kelima dalam konsep SOLID yang menyatakan bahwa modul tingkat tinggi (high-level module) tidak boleh bergantung langsung pada modul tingkat rendah (low-level module). Sebaliknya, keduanya harus bergantung pada abstraksi.

Prinsip DIP bertujuan untuk mengurangi ketergantungan antar komponen dalam kode dan meningkatkan fleksibilitas serta modularitas sistem. Dalam pengembangan perangkat lunak, modul tingkat tinggi biasanya berisi logika bisnis utama, sementara modul tingkat rendah berisi detail implementasi seperti pengambilan data dari database, pengiriman notifikasi, atau interaksi dengan API eksternal.

Jika modul tingkat tinggi bergantung langsung pada detail implementasi dari modul tingkat rendah, maka setiap perubahan pada implementasi di level rendah dapat menyebabkan perubahan besar di level tinggi, yang akan mempersulit proses pengembangan dan pemeliharaan kode.

Dengan menggunakan abstraksi sebagai penghubung antar modul, developer dapat mengganti atau memodifikasi implementasi low-level tanpa mempengaruhi logika utama di high-level module, sehingga kode menjadi lebih fleksibel dan mudah diperbarui.

Contoh Kode yang Salah (Pelanggaran DIP)

Java

class LayananNotifikasi {
    public void kirimNotifikasi(String pesan) {
        System.out.println("Mengirim notifikasi: " + pesan);
    }
}

class Aplikasi {
    private LayananNotifikasi layanan;

    public Aplikasi() {
        layanan = new LayananNotifikasi(); // Ketergantungan langsung ke kelas konkret
    }

    public void proses() {
        layanan.kirimNotifikasi("Pesan baru dari aplikasi");
    }
}

Python

class LayananNotifikasi:
    def kirim_notifikasi(self, pesan):
        print(f"Mengirim notifikasi: {pesan}")

class Aplikasi:
    def __init__(self):
        self.layanan = LayananNotifikasi()  # Ketergantungan langsung ke class konkret
    
    def proses(self):
        self.layanan.kirim_notifikasi("Pesan baru dari aplikasi")

# Membuat objek dan menjalankan proses
app = Aplikasi()
app.proses()

Masalah pada Kode di Atas:

Apabila dilihat, class Aplikasi bergantung langsung pada LayananNotifikasi, maka:

• Jika kita ingin mengganti metode pengiriman notifikasi (misalnya melalui email atau SMS), maka kita harus mengubah kode di Aplikasi. Tentu saja hal ini melanggar prinsip OCP.
• Sulit untuk diuji, karena kita harus membuat obyek/instance dari LayananNotifikasi.
• Kode menjadi kurang fleksibel dan sulit dikembangkan.

Lumayan juga dampaknya ya jika class Aplikasi bergantung langsung pada class LayananNotifikasi.

OK sekarang kita perbaiki struktur kode programnya dengan menerapkan DIP.

Contoh Kode yang Benar (Mengikuti DIP)

Untuk memperbaiki pelanggaran tersebut, kita bisa membuat interface (abstraksi) untuk LayananNotifikasi. Selanjutnya menghubungkan Aplikasi ke interface, bukan ke class yang konkret.

Java

interface LayananNotifikasi {
    void kirimNotifikasi(String pesan);
}

class LayananEmail implements LayananNotifikasi {
    public void kirimNotifikasi(String pesan) {
        System.out.println("Mengirim Email: " + pesan);
    }
}

class Aplikasi {
    private LayananNotifikasi layanan;

    public Aplikasi(LayananNotifikasi layanan) {
        this.layanan = layanan;
    }

    public void proses() {
        layanan.kirimNotifikasi("Pesan baru dari aplikasi");
    }
}

public class Main {
    public static void main(String[] args) {
        LayananNotifikasi layanan = new LayananEmail();
        Aplikasi app = new Aplikasi(layanan);
        app.proses();
    }
}

Python

from abc import ABC, abstractmethod

class LayananNotifikasi(ABC):
    @abstractmethod
    def kirim_notifikasi(self, pesan):
        pass

class LayananEmail(LayananNotifikasi):
    def kirim_notifikasi(self, pesan):
        print(f"Mengirim Email: {pesan}")

class Aplikasi:
    def __init__(self, layanan):
        self.layanan = layanan
    
    def proses(self):
        self.layanan.kirim_notifikasi("Pesan baru dari aplikasi")

# Membuat objek dari LayananEmail
layanan = LayananEmail()
app = Aplikasi(layanan)
app.proses()

Dengan menerapkan DIP, kode yang sebelumnya memiliki ketergantungan langsung pada detail implementasi di level rendah diubah agar hanya bergantung pada abstraksi. Dalam hal ini, modul tingkat tinggi (high-level module) hanya akan berinteraksi dengan interface atau abstract class, sehingga tidak terikat dengan implementasi konkret di level rendah.

Perbaikan tersebut memungkinkan developer dengan mudah mengganti atau memperbarui detail implementasi tanpa harus memodifikasi logika utama. Selain itu, proses pengujian menjadi lebih mudah karena pengembang dapat membuat mock atau stub dari interface tanpa harus berurusan dengan detail implementasi. Dengan demikian, kode menjadi lebih modular dan reusable, karena pengembangan fitur baru atau penggantian teknologi dapat dilakukan tanpa mengganggu struktur utama kode. Perbaikan ini juga meningkatkan skalabilitas sistem karena komponen dapat diatur ulang atau diperbarui tanpa menimbulkan efek domino pada sistem secara keseluruhan.

Strategi Implementasi DIP

Untuk menerapkan Dependency Inversion Principle dengan baik, seorang pengembang perlu membuat abstraksi dalam bentuk interface atau abstract class yang berfungsi sebagai penghubung antara modul tingkat tinggi dan modul tingkat rendah. Hal ini disebabkan karena secara prinsip modul tingkat tinggi tidak boleh membuat obyek/instance langsung dari class konkret, melainkan harus menerima dependensi dari luar.

Ketergantungan pada class konkret harus digantikan dengan ketergantungan pada abstraksi, sehingga implementasi detail di modul tingkat rendah dapat dengan mudah diganti atau diperbarui tanpa mempengaruhi modul tingkat tinggi.

Kapan Class Butuh DIP?

Class yang membutuhkan Dependency Inversion Principle biasanya memiliki ketergantungan langsung pada class konkret di level bawah, yang menyebabkan kode menjadi rapuh terhadap perubahan. Jika suatu class sering kali mengalami perubahan hanya karena ada modifikasi pada detail implementasi di level rendah, maka ini adalah indikasi kuat bahwa class tersebut perlu dipisahkan dari ketergantungan langsung dengan menggunakan abstraksi.

Class yang sulit untuk diuji karena memiliki banyak ketergantungan pada class konkret juga memerlukan penerapan DIP.

Selain itu, class yang memiliki banyak ketergantungan yang sulit dikonfigurasi ulang atau sulit untuk diganti juga merupakan kandidat yang ideal untuk penerapan DIP.

Artikel ini membahas secara mendalam tentang prinsip ISP dalam SOLID.

Apa Itu Prinsip SOLID?

Prinsip SOLID adalah kumpulan dari lima prinsip desain dalam pemrograman berorientasi objek (OOP) yang bertujuan untuk membuat kode menjadi lebih mudah dipelihara, diperluas, dan scalable. Prinsip ini pertama kali diperkenalkan oleh Robert C. Martin (Uncle Bob) pada awal tahun 2000-an dan menjadi landasan dalam pengembangan perangkat lunak modern.

Prinsip SOLID terdiri dari lima konsep utama:

1. Single Responsibility Principle (SRP): Setiap class harus memiliki satu tanggung jawab saja.
2. Open/Closed Principle (OCP): Kode harus terbuka untuk perluasan, tetapi tertutup untuk modifikasi.
3. Liskov Substitution Principle (LSP): Objek turunan harus bisa menggantikan objek induknya tanpa mengubah perilaku yang diharapkan.
4. Interface Segregation Principle (ISP): Tidak boleh ada paksaan untuk mengimplementasikan interface yang tidak digunakan.
5. Dependency Inversion Principle (DIP) → Ketergantungan harus diarahkan pada abstraksi, bukan pada implementasi konkret.

Mengapa Perlu Prinsip SOLID?

Mengapa sih kok perlu prinsip SOLID ini segala dalam coding menggunakan OOP? Iya dong, karena hasil codingan kita kan ke depannya tidak hanya digunakan dan dikembangkan kita sendiri? Bisa jadi codingan kita kelak akan digunakan dan dikembangkan oleh orang lain, bahkan oleh tim pengembang.

Dengan demikian perlu semacam penyamaan persepsi dan standarisasi yang disepakati bersama yang tujuan utamanya untuk memudahkan dalam pengembangan kode ke depannya, melalui sebuah prinsip tertentu.

Secara umum, beberapa alasan dan manfaat prinsip SOLID ini antara lain:

• Mengurangi ketergantungan antar komponen
• Meningkatkan fleksibilitas kode
• Mempermudah proses perbaikan dan pengembangan
• Mengurangi potensi bug dan error akibat perubahan kode
• Meningkatkan kemudahan untuk menguji (testability)

Intinya bahwa prinsip SOLID membantu developer untuk menulis kode yang lebih bersih, mudah dibaca, dan lebih mudah dikelola dalam jangka panjang.

Interface Segregation Principle (ISP)

Prinsip Interface Segregation menyatakan bahwa sebuah antarmuka (interface) tidak boleh memaksa klien untuk mengimplementasikan metode yang tidak mereka butuhkan.

Artinya, sebuah interface harus dibuat sesuai kebutuhan klien dengan metode yang relevan saja, sehingga klien tidak dibebani dengan metode yang tidak mereka butuhkan.

Jika sebuah interface memiliki terlalu banyak method yang tidak relevan bagi pengembang, maka:

• Akan muncul method kosong pada implementasi klien.
• Jika ada perubahan pada method yang tidak digunakan, codingan pengembang bisa ikut terdampak.
• Kode menjadi sulit untuk dipelihara karena pengembang dipaksa mematuhi kontrak yang tidak diperlukan (efek penggunaan interface).

Contoh Kode yang Salah (Pelanggaran ISP)

Berikut adalah contoh kasus pelanggaran Interface Segregation Principle dalam Java dan Python:

Java – Interface Terlalu Luas Cakupannya

// Interface yang melanggar ISP karena terlalu besar
interface Pekerjan {
    void kerja();
    void makan();
}

class Robot implements Pekerja {
    @Override
    public void kerja() {
        System.out.println("Robot sedang bekerja");
    }

    @Override
    public void makan() {
        // Robot tidak perlu makan, tetapi terpaksa mengimplementasikan metode ini
        throw new UnsupportedOperationException("Robot tidak makan");
    }
}

Python – Interface Terlalu Luas Cakupannya

from abc import ABC, abstractmethod

class Pekerja(ABC):
    @abstractmethod
    def kerja(self):
        pass
    
    @abstractmethod
    def makan(self):
        pass

class Robot(Pekerja):
    def kerja(self):
        print("Robot sedang bekerja")
    
    def makan(self):
        raise NotImplementedError("Robot tidak makan")

Pada contoh di atas, class Robot terpaksa mengimplementasikan metode makan() meskipun robot tidak memiliki kemampuan untuk makan. Ini adalah pelanggaran ISP karena Robot dipaksa untuk mengikuti kontrak yang tidak diperlukan.

Contoh Kode yang Benar (Mengikuti ISP)

Untuk memperbaiki pelanggaran ISP, kita bisa memisahkan interface menjadi antarmuka yang lebih kecil dan spesifik.

Java – Interface yang Dipisah

// Interface yang terpisah sesuai tanggung jawab
interface DapatBekerja {
    void kerja();
}

interface DapatMakan {
    void makan();
}

class Manusia implements DapatBekerja, DapatMakan {
    @Override
    public void kerja() {
        System.out.println("Manusia sedang bekerja");
    }

    @Override
    public void makan() {
        System.out.println("Manusia sedang makan");
    }
}

class Robot implements DapatBekerja {
    @Override
    public void kerja() {
        System.out.println("Robot sedang bekerja");
    }
}

Python – Interface yang Dipisah

from abc import ABC, abstractmethod

class DapatBekerja(ABC):
    @abstractmethod
    def kerja(self):
        pass

class DapatMakan(ABC):
    @abstractmethod
    def makan(self):
        pass

class Manusia(DapatBekerja, DapatMakan):
    def kerja(self):
        print("Manusia sedang bekerja")

    def makan(self):
        print("Manusia sedang makan")

class Robot(DapatBekerja):
    def work(self):
        print("Robot sedang bekerja")

Dengan memisahkan interface menjadi DapatBekerja dan DapatMakan, setiap class hanya perlu mengimplementasikan metode yang relevan dengan kebutuhannya. Sehingga, Robot hanya mengimplementasikan Workable, sehingga tidak ada implementasi metode yang tidak perlu.

Strategi Implementasi ISP

Untuk menerapkan Interface Segregation Principle, bisa melalui strategi berikut:

Untuk menerapkan Interface Segregation Principle (ISP) dengan efektif, pendekatan utama yang perlu dilakukan adalah dengan memecah interface berdasarkan tanggung jawab spesifik. Sebuah interface harus dirancang agar memiliki metode yang berkaitan erat satu sama lain dan tidak saling tumpang tindih. Jika sebuah interface memiliki terlalu banyak metode dengan fungsi yang tidak saling berhubungan, maka interface tersebut perlu dipecah menjadi beberapa interface yang lebih kecil dan lebih terfokus. Dengan demikian, setiap class yang mengimplementasikan interface hanya perlu menerapkan metode yang memang relevan dengan kebutuhannya.

Selain itu, penggunaan multiple inheritance atau multiple interface dapat menjadi solusi jika sebuah class memerlukan kombinasi dari beberapa tanggung jawab yang berbeda. Strategi ini memungkinkan class untuk mengimplementasikan metode dari beberapa interface tanpa terikat pada satu kontrak besar yang berisi metode yang tidak diperlukan.

Penting juga untuk memastikan bahwa tidak boleh ada pengembang yang dipaksa untuk mengimplementasikan metode yang tidak digunakan. Jika dalam implementasi ditemukan metode kosong atau berisi raise NotImplementedError, maka ini merupakan indikasi kuat bahwa interface perlu dipisah menjadi bagian yang lebih kecil dan lebih spesifik. Dengan merancang interface yang ramping dan modular, kode akan menjadi lebih fleksibel, mudah diperluas, dan lebih mudah dipelihara dalam jangka panjang.

Apa Itu SOLID Principles?

SOLID adalah kumpulan lima prinsip desain dalam Object-Oriented Programming (OOP) yang bertujuan untuk membuat kode lebih mudah dibaca, dipelihara, dan diperluas tanpa menyebabkan perubahan besar yang dapat merusak sistem. SOLID terdiri dari:

1. S – Single Responsibility Principle (SRP)
2. O – Open-Closed Principle (OCP)
3. L – Liskov Substitution Principle (LSP)
4. I – Interface Segregation Principle (ISP)
5. D – Dependency Inversion Principle (DIP)

Mengapa SOLID Principles Penting?

Penerapan SOLID Principles membantu dalam membangun sistem perangkat lunak yang lebih modular, fleksibel, dan mudah diuji. Dengan menerapkan prinsip-prinsip ini, kita dapat mengurangi kompleksitas kode, meningkatkan skalabilitas, dan menghindari berbagai masalah umum dalam pengembangan perangkat lunak, seperti kode yang terlalu tergantung satu sama lain atau sulit diperbaiki.

Apa Itu Liskov Substitution Principle (LSP)?

Liskov Substitution Principle (LSP) menyatakan bahwa subclass harus dapat menggantikan superclass tanpa mengubah perilaku atau behavior atau method yang diharapkan dari program. Dengan kata lain, jika suatu kelas induk (superclass) dapat digunakan dalam suatu konteks, maka semua kelas turunannya juga harus dapat digunakan dalam konteks yang sama tanpa menyebabkan error atau perubahan yang tidak terduga.

Mengapa Liskov Substitution Principle Penting?

Tanpa LSP, subclass dapat mengubah perilaku dasar yang diharapkan dari superclass, yang dapat menyebabkan bug tersembunyi dan membuat kode menjadi sulit dipahami serta dipelihara. Dengan menerapkan LSP, kode menjadi lebih konsisten, dapat diuji dengan mudah, dan lebih fleksibel dalam pengembangan jangka panjang.

Contoh Bad Practice (Melanggar LSP)

Mari kita lihat contoh kode dalam Java dan Python yang melanggar prinsip Liskov Substitution.

Java (Melanggar LSP)

class Bird {
    void fly() {
        System.out.println("Burung bisa terbang");
    }
}

class Penguin extends Bird {
    void fly() {
        throw new UnsupportedOperationException("Penguin tidak dapat terbang");
    }
}

Masalah: Jika kode kita mengasumsikan bahwa semua objek dari kelas Bird bisa terbang, tetapi objek dari Penguin tidak bisa, maka ini melanggar LSP. Jika ada kode yang mengandalkan fly(), maka saat menerima objek Penguin, akan terjadi error.

Python (Melanggar LSP)

class Bird:
    def fly(self):
        print("Burung bisa terbang")

class Penguin(Bird):
    def fly(self):
        raise Exception("Penguin tidak bisa terbang")

Masalah: Sama seperti contoh Java, Penguin tidak bisa terbang tetapi tetap mewarisi metode fly(). Ini dapat menyebabkan bug jika kode lain mengasumsikan bahwa semua Bird bisa terbang.

Contoh Good Practice (Mengikuti LSP)

Untuk memperbaiki masalah di atas, kita perlu memastikan bahwa subclass tidak mengubah kontrak yang didefinisikan oleh superclass.

Java (Mengikuti LSP)

class Bird {}

class FlyingBird extends Bird {
    void fly() {
        System.out.println("This bird is flying");
    }
}

class Sparrow extends FlyingBird {}

class Penguin extends Bird {}

Sekarang, hanya burung yang bisa terbang yang memiliki metode fly(). Penguin tidak perlu mewarisi metode ini dan tidak akan menyebabkan error.

Python (Mengikuti LSP)

class Bird:
    pass

class FlyingBird(Bird):
    def fly(self):
        print("This bird is flying")

class Sparrow(FlyingBird):
    pass

class Penguin(Bird):
    pass

Nah.. Sekarang, Penguin tidak lagi memiliki metode fly(), sehingga kode tetap konsisten dengan LSP.

Manfaat dari Penerapan Liskov Substitution Principle

Dengan menerapkan LSP, kita mendapatkan berbagai manfaat sebagai berikut:

• Menghindari error yang tidak terduga akibat subclass yang tidak kompatibel dengan superclass.
• Memastikan bahwa semua subclass dapat digunakan tanpa mempengaruhi perilaku yang diharapkan dari superclass.
• Mempermudah pengujian karena kita tahu bahwa semua subclass akan bekerja dengan cara yang sama seperti superclass.

Ciri-ciri Class yang Perlu Menerapkan LSP

Tidak semua class harus diuji terhadap LSP, akan tetapi class yang memiliki ciri berikut sebaiknya mematuhi prinsip ini: (1) Class yang digunakan sebagai dasar untuk inheritance (misalnya Animal, Vehicle, Shape); (2) Class yang sering digunakan dalam polimorfisme (misalnya dalam desain berbasis antarmuka); (3) Class yang memiliki metode yang bisa berbeda implementasinya pada subclass; (4) Class yang sering digunakan dalam berbagai konteks sistem yang berbeda

Pada artikel berikutnya, kita akan membahas prinsip keempat dalam SOLID: Interface Segregation Principle (ISP). Pastikan Anda mengikuti blog ini agar tidak ketinggalan pembahasannya!

Apa Itu SOLID Principles?

SOLID adalah lima prinsip desain dalam Object-Oriented Programming (OOP) yang bertujuan untuk membuat kode lebih mudah dibaca, dipelihara, dan diperluas tanpa menyebabkan perubahan besar pada kode yang sudah ada. SOLID sendiri adalah akronim dari:

1. S – Single Responsibility Principle (SRP)
2. O – Open-Closed Principle (OCP)
3. L – Liskov Substitution Principle (LSP)
4. I – Interface Segregation Principle (ISP)
5. D – Dependency Inversion Principle (DIP)

Mengapa SOLID Principles Penting?

SOLID Principles sangat penting dalam pengembangan perangkat lunak karena membantu menciptakan kode yang lebih terstruktur, modular, dan mudah dipelihara. Dengan menerapkan prinsip-prinsip ini, pengembang dapat menghindari kode yang terlalu kompleks dan sulit untuk diperbarui. Selain itu, SOLID Principles mempermudah kolaborasi dalam tim, karena kode yang mengikuti prinsip ini lebih mudah dipahami oleh berbagai anggota tim. Tidak hanya itu, prinsip ini juga meningkatkan efisiensi pengujian dan debugging, karena setiap bagian kode memiliki tanggung jawab yang jelas dan tidak bercampur dengan bagian lain. Dengan menjaga kode tetap fleksibel dan stabil, SOLID Principles membantu memastikan bahwa perangkat lunak dapat berkembang tanpa menyebabkan banyak perubahan yang tidak perlu, sehingga mengurangi risiko bug dan meningkatkan produktivitas pengembang.

Apa Itu Open-Closed Principle (OCP)?

Open-Closed Principle menyatakan bahwa kode harus bersifat terbuka untuk ekstensi (pengembangan/perluasan), akan tetapi tertutup untuk modifikasi. Artinya, kita harus bisa menambahkan fitur baru tanpa harus mengubah kode yang sudah ada.

Mengapa Open-Closed Principle Penting?

Tanpa OCP, kita akan sering mengubah kode lama setiap kali ada fitur baru, yang dapat menyebabkan bug tak terduga. Dengan menerapkan OCP, kita dapat memperluas sistem tanpa menyentuh kode lama, sehingga mengurangi risiko kesalahan.

Contoh Bad Practice (Melanggar OCP)

Mari kita lihat contoh Java dan Python di mana prinsip Open-Closed dilanggar.

Java (Melanggar OCP)

class PaymentProcessor {
    void processPayment(String type) {
        if (type.equals("CreditCard")) {
            System.out.println("Memproses pembayaran Credit Card");
        } else if (type.equals("PayPal")) {
            System.out.println("Memproses pembayaran PayPal");
        }
    }
}

Masalah: Jika kita ingin menambahkan metode pembayaran baru (misalnya Bitcoin), kita harus mengedit kelas ini. Ini melanggar OCP karena memodifikasi kode lama setiap kali ada fitur baru.

Python (Melanggar OCP)

class PaymentProcessor:
    def process_payment(self, method):
        if method == "credit_card":
            print("Memproses pembayaran Credit Card")
        elif method == "paypal":
            print("Memproses pembayaran PayPal")

Masalah: Jika ingin menambahkan metode pembayaran lain, kita harus mengubah kode dalam process_payment, yang bisa berisiko menyebabkan bug.

Contoh Good Practice (Mengikuti OCP)

Mari kita lihat bagaimana menggunakan OCP dengan baik dengan cara membuat abstraksi agar kode mudah diperluas tanpa mengubah yang sudah ada.

Java (Mengikuti OCP)

interface PaymentMethod {
    void pay();
}

class CreditCardPayment implements PaymentMethod {
    public void pay() {
        System.out.println("Memproses pembayaran Credit Card");
    }
}

class PayPalPayment implements PaymentMethod {
    public void pay() {
        System.out.println("Memproses pembayaran PayPal");
    }
}

class PaymentProcessor {
    void processPayment(PaymentMethod method) {
        method.pay();
    }
}

Sekarang, jika kita ingin menambahkan metode pembayaran lain, kita hanya perlu membuat class baru tanpa mengubah PaymentProcessor!

Python (Mengikuti OCP)

from abc import ABC, abstractmethod

class PaymentMethod(ABC):
    @abstractmethod
    def pay(self):
        pass

class CreditCardPayment(PaymentMethod):
    def pay(self):
        print("Memproses pembayaran Credit Card")

class PayPalPayment(PaymentMethod):
    def pay(self):
        print("Memproses pembayaran PayPal")

class PaymentProcessor:
    def process_payment(self, method: PaymentMethod):
        method.pay()

Keterangan: Dalam Python, untuk membuat abstract class dibutuhkan modul ABC (abstract base classes)

Dengan pendekatan ini, kita bisa menambahkan metode pembayaran baru hanya dengan membuat class baru, tanpa menyentuh PaymentProcessor.

Manfaat dari Penerapan Open-Closed Principle

Apa sih manfaatnya OCP? Dengan menerapkan OCP, paling tidak kita mendapatkan beberapa manfaat berikut:

• Mempermudah penambahan fitur baru tanpa merusak kode lama.
• Mengurangi risiko bug akibat perubahan pada kode lama.
• Membuat kode lebih bersifat modular dan mudah diperluas.
• Memudahkan testing dan maintenance.

Nah.. banyak kan manfaatnya?

Ciri-ciri Class yang Perlu Menerapkan OCP

Apa semua class memerlukan OCP ini? Tentu tidak.. Tidak semua class membutuhkan OCP, akan tetapi class yang memiliki ciri berikut sebaiknya menerapkan prinsip ini:

• sering diperbarui dengan fitur baru (misalnya sistem pembayaran, laporan, dan sistem rekomendasi)
• memiliki banyak kondisi if-else atau switch-case untuk menangani banyak tipe operasi
• memiliki dependensi (ketergantungan) tinggi terhadap logika bisnis yang sering berubah
• sering mengalami perubahan untuk mengakomodasi permintaan baru

Open-Closed Principle (OCP) memastikan bahwa kode terbuka untuk perluasan (ekstensi), akan tetapi tertutup untuk modifikasi. Dengan menerapkan prinsip ini, kita dapat menambahkan fitur baru tanpa mengubah kode lama, sehingga kode lebih stabil, modular, dan mudah dipelihara.

Pada artikel berikutnya, kita akan membahas prinsip ketiga dalam SOLID yaitu Liskov Substitution Principle (LSP). Pastikan Anda mengikuti blog ini agar tidak ketinggalan pembahasannya!

Pada artikel pertama di blog ini, kita akan membahas prinsip pertama dalam SOLID yaitu: Single Responsibility Principle (SRP).

Apa Itu SOLID Principles?

SOLID adalah lima prinsip desain dalam Object-Oriented Programming (OOP) yang bertujuan untuk membuat kode lebih mudah dibaca, dipelihara, dan diperluas tanpa menyebabkan perubahan besar pada kode yang sudah ada. SOLID sendiri adalah akronim dari:

1. S – Single Responsibility Principle (SRP)
2. O – Open-Closed Principle (OCP)
3. L – Liskov Substitution Principle (LSP)
4. I – Interface Segregation Principle (ISP)
5. D – Dependency Inversion Principle (DIP)

Apa Itu Single Responsibility Principle (SRP)?

Single Responsibility Principle menyatakan bahwa setiap kelas harus memiliki satu tanggung jawab utama. Artinya, sebuah kelas hanya boleh memiliki satu alasan untuk berubah. Jika sebuah kelas memiliki lebih dari satu tanggung jawab, maka kode tersebut akan sulit untuk dikelola dan dipelihara.

Kenapa SRP Itu Penting?

Tanpa menerapkan SRP, sebuah kode program akan menjadi monolitik, sulit diperbaiki, dan lebih rentan terhadap bug. Dengan SRP, kita mendapatkan keuntungan berikut:

1. Kode lebih mudah dibaca dan dipahami
2. Lebih mudah untuk diuji secara unit testing
3. Meminimalisir efek domino saat ada perubahan
4. Kode menjadi lebih modular dan fleksibel

Contoh Pelanggaran SRP (Bad Practice)

Mari kita lihat contoh koding dalam bahasa Java dan Python di mana SRP dilanggar. Bayangkan kita memiliki kelas Report yang bertanggung jawab untuk menghasilkan laporan, mencetak laporan, dan menyimpan laporan ke database:

Java:

class Report {
    void generatePDF() {
        // Logika untuk membuat laporan dalam format PDF
    }

    void printReport() {
        // Logika untuk mencetak laporan
    }

    void saveToDatabase() {
        // Logika untuk menyimpan laporan ke database
    }
}

Python:

class Report:
    def generate_pdf(self):
        # Logika untuk membuat laporan dalam format PDF
        pass
    
    def print_report(self):
        # Logika untuk mencetak laporan
        pass
    
    def save_to_database(self):
        # Logika untuk menyimpan laporan ke database
        pass

Masalah: Kelas Report menangani lebih dari satu tanggung jawab. Jika ada perubahan pada cara mencetak laporan, maka kita juga berisiko memodifikasi bagian lain yang tidak terkait, seperti penyimpanan ke database. Ini bertentangan dengan prinsip SRP.

Cara Memperbaiki dengan SRP (Good Practice)

Untuk menerapkan Single Responsibility Principle, kita harus memisahkan tanggung jawab ke dalam kelas-kelas yang lebih spesifik.

Java:

class ReportGenerator {
    void generatePDF() {
        // Logika untuk membuat laporan dalam format PDF
    }
}

class ReportPrinter {
    void printReport() {
        // Logika untuk mencetak laporan
    }
}

class ReportSaver {
    void saveToDatabase() {
        // Logika untuk menyimpan laporan ke database
    }
}

Python:

class ReportGenerator:
    def generate_pdf(self):
        # Logika untuk membuat laporan dalam format PDF
        pass

class ReportPrinter:
    def print_report(self):
        # Logika untuk mencetak laporan
        pass

class ReportSaver:
    def save_to_database(self):
        # Logika untuk menyimpan laporan ke database
        pass

Apa Keuntungan Penerapan SRP?

Setelah SRP diterapkan, apa saja sih keuntungannya?

• Jika ada perubahan pada cara mencetak laporan, maka kita hanya perlu mengubah ReportPrinter, tanpa menyentuh ReportGenerator atau ReportSaver.
• Kode menjadi lebih mudah untuk diuji karena setiap kelas memiliki tanggung jawab yang jelas.
• Lebih fleksibel jika ke depannya kita ingin menambahkan fitur lain, seperti menyimpan laporan dalam format XML atau yang lainnya.

Apa Ciri Class yang Perlu Diterapkan SRP?

Apakah semua class dalam sebuah project perlu diterapkan SRP ini? Tentu saja tidak! Berikut ini adalah beberapa ciri-cirinya:

1. Class yang Memiliki Lebih dari Satu Tanggung Jawab
   
   Jika sebuah class memiliki lebih dari satu tugas utama, kemungkinan besar ia melanggar SRP. Tanda-tanda class ini adalah nama class terlalu umum atau mencakup banyak fungsi (misalnya OrderManager, UserHandler, ReportProcessor), atau class menangani banyak aspek dalam sistem, seperti mengolah data, menyimpan ke database, dan mencetak laporan.
2. Class yang Sering Berubah karena Alasan Berbeda
   
   Jika sebuah class sering berubah karena berbagai alasan, itu pertanda bahwa ia menangani lebih dari satu tanggung jawab. Tanda-tanda class ini adalah saat ada perubahan kecil, banyak bagian class yang harus diedit.
3. Class yang Memiliki Nama yang Terlalu Umum atau “God Class“
   
   Jika class memiliki nama seperti Manager, Handler, Processor, itu sering kali tanda bahwa class ini menangani banyak hal sekaligus. Tanda-tanda class ini adalah bahwa nama class sulit menggambarkan satu tanggung jawab spesifik, serta mengontrol banyak aspek sistem sekaligus.

Contoh Penerapan SRP dalam Proyek

Sekarang kita lihat bagaimana penerapan SRP ini ke dalam sebuah proyek. Misalkan kita ada proyek untuk membuat program Java dan Python untuk menghitung luas dan keliling dari beberapa bangun datar seperti persegi, persegi panjang, dan lingkaran.

Belum Menerapkan SRP (Bad Practice)

Di contoh kode program dengan Java ini, satu class menangani perhitungan luas, keliling, dan juga input/output, sehingga sulit untuk diperluas dan diuji.

import java.util.Scanner;

class ShapeCalculator {
    Scanner scanner = new Scanner(System.in);

    void calculate() {
        System.out.println("Pilih bangun datar: 1. Persegi  2. Persegi Panjang  3. Lingkaran");
        int choice = scanner.nextInt();

        switch (choice) {
            case 1:
                System.out.print("Masukkan sisi persegi: ");
                double sisi = scanner.nextDouble();
                System.out.println("Luas: " + (sisi * sisi));
                System.out.println("Keliling: " + (4 * sisi));
                break;
            case 2:
                System.out.print("Masukkan panjang: ");
                double panjang = scanner.nextDouble();
                System.out.print("Masukkan lebar: ");
                double lebar = scanner.nextDouble();
                System.out.println("Luas: " + (panjang * lebar));
                System.out.println("Keliling: " + (2 * (panjang + lebar)));
                break;
            case 3:
                System.out.print("Masukkan jari-jari lingkaran: ");
                double r = scanner.nextDouble();
                System.out.println("Luas: " + (Math.PI * r * r));
                System.out.println("Keliling: " + (2 * Math.PI * r));
                break;
            default:
                System.out.println("Pilihan tidak valid.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ShapeCalculator calculator = new ShapeCalculator();
        calculator.calculate();
    }
}

atau jika dalam Python sebagai berikut

import math

class ShapeCalculator:
    def calculate(self):
        print("Pilih bangun datar: 1. Persegi  2. Persegi Panjang  3. Lingkaran")
        choice = int(input("Masukkan pilihan: "))

        if choice == 1:
            sisi = float(input("Masukkan sisi persegi: "))
            luas = sisi * sisi
            keliling = 4 * sisi
        elif choice == 2:
            panjang = float(input("Masukkan panjang: "))
            lebar = float(input("Masukkan lebar: "))
            luas = panjang * lebar
            keliling = 2 * (panjang + lebar)
        elif choice == 3:
            r = float(input("Masukkan jari-jari lingkaran: "))
            luas = math.pi * r * r
            keliling = 2 * math.pi * r
        else:
            print("Pilihan tidak valid.")
            return

        print(f"Luas: {luas}")
        print(f"Keliling: {keliling}")

if __name__ == "__main__":
    calculator = ShapeCalculator()
    calculator.calculate()

Masalah dari kode program di atas adalah Class ShapeCalculator menangani banyak hal yaitu terkait dengan pengambilan input, perhitungan luas dan keliling, dan menampilkan output. Hal ini mengakibatkan sulit diuji karena semua fungsionalitas bercampur. Selain itu hal ini juga membuat kode program tidak fleksibel, jika ingin menambahkan bangun datar lain, maka harus mengedit kode utama.

Setelah Menerapkan SRP (Good Practice)

Sekarang kita akan memisahkan tanggung jawab menjadi beberapa class agar lebih modular, fleksibel, dan mudah diuji.

import java.util.Scanner;

// Abstraksi untuk semua bangun datar
interface Shape {
    double calculateArea();
    double calculatePerimeter();
}

// Implementasi Persegi
class Square implements Shape {
    private double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double calculateArea() {
        return side * side;
    }

    @Override
    public double calculatePerimeter() {
        return 4 * side;
    }
}

// Implementasi Persegi Panjang
class Rectangle implements Shape {
    private double length, width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * (length + width);
    }
}

// Implementasi Lingkaran
class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

// Class khusus untuk mengambil input dari user
class ShapeInput {
    private Scanner scanner = new Scanner(System.in);

    public Shape getShape() {
        System.out.println("Pilih bangun datar: 1. Persegi  2. Persegi Panjang  3. Lingkaran");
        int choice = scanner.nextInt();

        switch (choice) {
            case 1:
                System.out.print("Masukkan sisi persegi: ");
                return new Square(scanner.nextDouble());
            case 2:
                System.out.print("Masukkan panjang: ");
                double length = scanner.nextDouble();
                System.out.print("Masukkan lebar: ");
                double width = scanner.nextDouble();
                return new Rectangle(length, width);
            case 3:
                System.out.print("Masukkan jari-jari lingkaran: ");
                return new Circle(scanner.nextDouble());
            default:
                System.out.println("Pilihan tidak valid.");
                return null;
        }
    }
}

// Class khusus untuk menampilkan hasil (SRP)
class ShapePrinter {
    public static void printShapeInfo(Shape shape) {
        if (shape != null) {
            System.out.println("Luas: " + shape.calculateArea());
            System.out.println("Keliling: " + shape.calculatePerimeter());
        }
    }
}

// Class utama
public class Main {
    public static void main(String[] args) {
        ShapeInput shapeInput = new ShapeInput();
        Shape shape = shapeInput.getShape();
        ShapePrinter.printShapeInfo(shape);
    }
}

dan berikut ini adalah versi Python

import math

# Abstraksi untuk semua bangun datar
class Shape:
    def calculate_area(self):
        pass

    def calculate_perimeter(self):
        pass


# Implementasi Persegi
class Square(Shape):
    def __init__(self, side):
        self.side = side

    def calculate_area(self):
        return self.side * self.side

    def calculate_perimeter(self):
        return 4 * self.side


# Implementasi Persegi Panjang
class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def calculate_area(self):
        return self.length * self.width

    def calculate_perimeter(self):
        return 2 * (self.length + self.width)


# Implementasi Lingkaran
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return math.pi * self.radius * self.radius

    def calculate_perimeter(self):
        return 2 * math.pi * self.radius


# Class khusus untuk mengambil input dari user
class ShapeInput:
    @staticmethod
    def get_shape():
        print("Pilih bangun datar: 1. Persegi  2. Persegi Panjang  3. Lingkaran")
        choice = int(input("Masukkan pilihan: "))

        if choice == 1:
            side = float(input("Masukkan sisi persegi: "))
            return Square(side)
        elif choice == 2:
            length = float(input("Masukkan panjang: "))
            width = float(input("Masukkan lebar: "))
            return Rectangle(length, width)
        elif choice == 3:
            radius = float(input("Masukkan jari-jari lingkaran: "))
            return Circle(radius)
        else:
            print("Pilihan tidak valid.")
            return None


# Class khusus untuk menampilkan hasil (SRP)
class ShapePrinter:
    @staticmethod
    def print_shape_info(shape):
        if shape:
            print(f"Luas: {shape.calculate_area()}")
            print(f"Keliling: {shape.calculate_perimeter()}")


# Class utama
if __name__ == "__main__":
    shape = ShapeInput.get_shape()
    ShapePrinter.print_shape_info(shape)

Dari perubahan tersebut, kita bisa merasakan benefitnya kan? Benefit yang pertama adalah kode lebih modular, di mana setiap class hanya memiliki satu tanggung jawab utama. Benefit ke dua yaitu mudah diperluas. Jika ingin menambahkan segitiga, cukup buat class Triangle yang mengimplementasikan Shape tanpa mengubah kode lain. Benefit ke tiga adalah mudah diuji, di mana kita bisa menguji class Square, Rectangle, dan Circle secara terpisah tanpa perlu melibatkan input/output.

Bisa dipahami dengan mudah ya penjelasannya? Pada artikel berikutnya, kita akan membahas prinsip ke dua dalam SOLID yaitu Open/Closed Principle (OCP). Pastikan Anda mengikuti blog ini agar tidak ketinggalan pembahasannya.

Salah satu jenis ANOVA adalah ANOVA satu arah (one-way ANOVA), yaitu jenis analisis variansi yang paling sederhana, di mana kita akan membandingkan rata-rata antara tiga kelompok atau lebih pada satu faktor atau satu variabel bebas. Faktor atau variabel bebas ini juga sering disebut sebagai “faktor perlakuan” karena itu adalah apa yang dimanipulasi dalam eksperimen.

Melalui tutorial ini akan dibahas bagaimana cara melakukan uji ANOVA satu arah menggunakan salah satu software populer dalam statistika, yaitu MINITAB.

Contoh Kasus

Seorang ahli gizi telah menciptakan metode X yang telah diformulasikannya untuk menurunkan berat badan. Selanjutnya dia ingin mengetahui, apakah metode X yang telah dikembangkannya itu benar-benar efektif untuk menurunkan berat badan, ataukah sama saja pengaruhnya dibandingkan metode lain yang telah dikembangkan orang. Untuk itu dia melakukan pengujian untuk mengetahui hal ini.

Langkah pengujian yang dilakukannya adalah memilih metode penurunan berat badan lain yang telah dikembangkan orang, katakanlah metode A, B, dan C. Selanjutnya keempat metode tersebut (X, A, B, C) diterapkan kepada sampel 44 orang yang berbeda selama sebulan. Setelah sebulan, diperoleh data penurunan berat badan ke empat metode tersebut (dalam Kg) sebagai berikut.

Nah, bagaimana melakukan uji statistik untuk melihat apakah metode X yang dikembangkan di ahli gizi memiliki efektifitas yang berbeda dibandingkan metode lain, ataukah sama saja?

Pembahasan

Contoh kasus di atas termasuk uji ANOVA satu arah disebabkan karena hanya ada satu faktor atau variabel bebas saja yang digunakan, yaitu metode penurunan berat badan. Variabel bebas ini terdapat 4 kelompok, yaitu metode X, A, B, dan C. Dalam hal ini, penurunan berat badan menjadi variabel terikatnya.

Bagaimana cara melakukan uji ANOVA satu arah menggunakan Minitab? Berikut ini langkah-langkahnya.

Langkah 1 – Entri Data

Masukkan data tabel di atas ke dalam worksheet Minitab. Untuk memasukkan data di atas, terdapat dua buah cara. Cara pertama adalah membedakan data antar kolom. Melalui cara ini, data dientrikan ke dalam 4 buah kolom yang berbeda dengan nama kolom yang berbeda pula. Dalam contoh ini, nama kolom diberi nama sesuai metode penurunan berat badannya.

Dalam tutorial ini hanya akan dibahas penggunaan Minitab versi 21.

Adapun cara entri yang kedua akan dijelaskan di bagian akhir tutorial.

Langkah 2 – Menentukan Uji Hipotesis

Sebelum melakukan uji ANOVA satu arah ini, terlebih dahulu kita perlu identifikasi hipotesis pengujiannya.

• Hipotesis null: tidak ada perbedaan mean data penurunan berat badan yang signifikan dari keempat metode
• Hipotesis alternatif: ada perbedaan mean data penurunan berat badan yang signifikan dari keempat metode

Langkah 3 – Uji Hipotesis

Setelah kita definisikan hipotesisnya, langkah berikutnya adalah melakukan uji hipotesis dengan ANOVA satu arah. Untuk melakukan ini caranya adalah klik menu STAT – ANOVA – ONE WAY.

Langkah berikutnya pada kotak dialog, pilih “Response data are in a separate columns for each factor level“, kemudian pada bagian Responses pilih semua nama kolom dari keempat metode. Lalu klik tombol SELECT.

Setelah keempat kolom dari keempat metode penurunan berat badan tersebut dimasukkan ke dalam kotak Responses, selanjutnya klik tombol COMPARISONS untuk menentukan metode dalam membandingkan mean dari ketiga metode.

Misalkan metode perbandingan mean yang akan digunakan adalah Tukey, maka pilih opsi tersebut pada kotak yang disediakan. Kita juga bisa mencoba menggunakan metode yang lain (Fisher atau Dunnet), dan hasilnya pun akan sama.

Terakhir, klik pada tombol OK.

Langkah 4 – Baca Output

Selanjutnya Minitab akan menampilkan beberapa output berupa hasil uji statistiknya. Perhatikan tampilan berikut ini.

Gambar di atas menunjukkan hipotesis yang diuji, yaitu hipotesis nullnya semua mean penurunan berat badan semuanya sama (tidak berbeda secara signifikan), dan hipotesis alternatifnya tidak semua mean penurunan berat badan sama (ada perbedaan secara signifikan). Uji hipotesis dilakukan pada taraf signifikansi (alpha) sebesar 5%.

Informasi di atas menunjukkan banyaknya faktor dan level. Banyaknya faktor (variabel bebas) dalam kasus ini adalah 1, yaitu metode penurunan berat badan, dengan 4 level (kelompok) yaitu X, A, B, dan C.

Selanjutnya tampilan di atas menunjukkan uji statistiknya. Perhatikan nilai P-Value. Berdasarkan hasil uji statistik diperoleh nilai P-Value nya adalah 0.005. Nilai ini lebih kecil dari nilai alpha (taraf signifikansi) default dari uji hipotesis, yaitu sebesar 5% atau 0.05. Secara teori, jika nilai P-Value lebih kecil dari alpha, maka hipotesis null ditolak. Artinya dalam kasus ini disimpulkan ada perbedaan mean data penurunan berat badan yang signifikan dari keempat metode.

Pertanyaan berikutnya adalah, jika memang terdapat perbedaan signifikan terhadap mean data penurunan berat badan dari keempat metode, maka metode manakah yang berbeda tersebut? Untuk menjawab hal ini, lihat tampilan berikut ini.

Berdasarkan hasil di atas, kita bisa melihat bahwa metode A, X, dan B dianggap dalam kelompok yang sama, memiliki perbedaan mean yang tidak signifikan. Artinya ketiga metode ini memiliki keefektifan yang relatif sama dalam menurunkan berat badan. Sedangkan metode C ini juga relatif memiliki perbedaan mean yang tidak signifikan dengan metode B. Artinya kedua metode ini juga memiliki keefektifan yang relatif sama.

Dengan demikian, dapat disimpulkan bahwa metode X yang telah dikembangkan si ahli gizi memiliki keefektifan yang relatif sama dengan metode A dan B dalam menurunkan berat badan. Namun, masih lebih efektif dibandingkan metode C.

Alternatif Cara Entri Data

Selain cara entri data di Minitab di atas, data penurunan berat badan dapat pula dilakukan dengan tidak membedakannya pada kolom yang berbeda. Cukup dengan dua kolom saja. Kolom pertama berisi data penurunan berat badannya (variabel terikatnya), dan kolom kedua berisi data metode penurunan berat badannya (variabel bebasnya).

Pada contoh di atas, kolom penurunan berat badannya diberi nama Y, dan kolom metodenya diberi nama Metode. Pada kolom metode diberi label 0, 1, 2, 3. Nilai 0 maksudnya adalah metode X, 1 untuk metode A, 2 untuk metode B, dan 3 untuk metode C. Hal ini dilakukan karena dalam Minitab data yang dientri harus numerik.

Selanjutnya untuk melakukan uji hipotesis, caranya sama yaitu klik STAT – ANOVA – ONE WAY, hanya perbedaannya pada pengisian kotak dialognya. Isikan seperti ini.

Pastikan memilih ‘Response data are in one column for all factor levels‘. Pada bagian Response isikan Y (sebagai variabel terikatnya), dan pada Factor isikan Metode (sebagai variabel bebasnya). Selanjutnya langkah berikutnya sama seperti sebelumnya.

Mudah bukan melakukannya? Selamat belajar dan mencoba, semoga bermanfaat

Pada artikel ini akan saya coba untuk memberikan sebuah pembahasan bagaimana melakukan query multitable di MySQL, yang akan dituangkan ke dalam sebuah studi kasus. Studi kasus yang saya angkat adalah sebuah database Car Dealer, dengan 10 buah tabel di dalamnya beserta sejumlah record di setiap tabel. Selanjutnya dari database tersebut saya akan tentukan 10 buah pertanyaan yang nantinya akan dijawab melalui hasil query.

Menyiapkan Database

Untuk keperluan studi kasus ini, pertama kita siapkan databasenya. Buatlah sebuah database di MySQL dengan nama: dbcardealer.

Selanjutnya unduh file MySQL dump berikut ini

Apabila file tersebut diekstrak, maka akan diperoleh sebuah file cardealer_new.sql.

Langkah berikutnya silakan import file tersebut ke dalam database dbcardealer. Anda bisa melakukan hal ini melalui phpMyAdmin atau tool lainnya.

Struktur Tabel Database

Setelah proses import tabel dan record sukses, akan terbentuk 10 buah tabel sebagai berikut beserta relasi antar tabelnya.

Database tersebut merepresentasikan sebuah perusahaan yang menyediakan layanan penjualan mobil dan layanan purna jual berupa service mobil. Perusahaan tersebut hanya menerima service dari mobil yang pernah dijualnya.

Berikut ini adalah penjelasan masing-masing tabelnya:

• Tabel car: berisi data-data mobil yang sedang dijual atau pernah dijualnya
• Tabel customer: berisi data-data pelanggan yang pernah membeli mobil
• Tabel salesperson: berisi data para sales yang melayani penjualan mobil
• Tabel salesinvoice: berisi transaksi penjualan mobil
• Tabel parts: berisi data spare part yang disediakan oleh perusahaan untuk keperluan service
• Tabel service: berisi data jenis layanan service yang ditawarkan
• Tabel mechanic: berisi data tenaga mekanik yang akan menangani service
• Tabel serviceticket: berisi data transaksi service yang pernah ditangani perusahaan
• Tabel servicemechanic: berisi data tenaga mekanik yang pernah menangani service tertentu
• Tabel partsused: berisi data sparepart yang pernah digunakan pada penanganan service tertentu

Problem Statements

Selanjutnya dari database di atas, kita akan mendapatkan informasi-informasi sebagai berikut:

• Siapa nama customer yang paling sering melakukan service?
• Berapa besar total biaya jasa mekanik service untuk service ticket ID: 2?
• Berapa besar total biaya sparepart dari service ticket ID: 2?
• Berapa total profit dari penjualan sparepart dari service ticket ID: 2?
• Tampilkan 5 besar waktu (bulan dan tahun) terjadi service paling banyak!
• Siapa nama mekanik service yang paling banyak mendapat rate ‘Poor’ dari customer?
• Siapa nama customer yang paling banyak memberi rate ‘Poor’ pada mekaniknya?
• Tampilkan merek mobil yang jumlah servicenya lebih dari 20 kali!
• Berapa rata-rata lama penyelesaian waktu service (dalam hari) setiap bulannya selama tahun 2018?
• Buatlah rekap profit per bulan perusahaan dari hasil penjualan sparepart selama tahun 2018!

Solusi Permasalahan

Siapa nama customer yang paling sering melakukan service?

Untuk menjawab pertanyaan ini, kita akan membuat rekap jumlah berapa kali setiap customer pernah melakukan service. Dari data rekap ini nantinya kita sort secara descending. Costumer yang paling banyak melakukan service akan tampak pada data urutan pertama dari rekapnya.

Data rekap akan kita dapatkan dengan memberikan query pada tabel: customer, dan serviceticket. Tabel customer untuk mendapatkan data nama customernya, dan tabel serviceticket untuk melihat data customer yang pernah melakukan service. Kedua tabel ini berelasi pada field costumerID (lihat gambar relasi antar tabel)

Adapun querynya adalah sebagai berikut.

SELECT customer.LastName, count(*) as JumService
FROM customer, serviceticket
WHERE customer.CustomerID = serviceticket.CustomerID
GROUP BY customer.CustomerID
ORDER BY JumService DESC

Untuk membuat rekap jumlah berapa kali service per customer, caranya cukup menggunakan function count(*) yang nantinya digroup berdasarkan customerID nya. Di sini customerID dijadikan acuan dalam grouping karena sifatnya yang unik dari setiap customer.

Hasil dari query di atas adalah sebagai berikut

Berdasarkan hasil query tersebut, tampaklah informasi bahwa yang paling sering melakukan service adalah customer dengan nama Eko.

Berapa besar total biaya jasa mekanik service untuk service ticket ID: 2?

Untuk menjawab pertanyaan tersebut, terlebih dahulu kita tentukan tabel mana kita akan bekerja. Tabel yang akan dipilih untuk diberikan query adalah tabel: service, dan servicemechanic. Tabel service digunakan untuk mendapatkan data tarif service per jam nya, dan tabel servicemechanic untuk mendapatkan data jenis service apa saja yang dilakukan pada service ticket ID = 2. Dalam hal ini pada sebuah service ticket ID dapat dimungkinkan dilakukan beberapa layanan service yang dilakukan oleh beberapa mekanik yang berbeda. Kedua tabel ini berelasi melalui kolom ServiceID.

Setelah didapatkan data layanan service apa saja yang dilakukan pada service ticket ID = 2, dan tarif service perjamnya, selanjutnya tinggal dikalikan dan akhirnya dijumlahkan dengan SUM() untuk mendapatkan total tarifnya. Berikut ini querynya.

SELECT SUM(service.HourlyRate * servicemechanic.Hours) as TotalFee
FROM service, servicemechanic
WHERE service.ServiceID = servicemechanic.ServiceID 
		  AND servicemechanic.ServiceTicketID = '2'

Hasil dari query di atas diperoleh IDR 5.130.000

Berapa besar total biaya sparepart dari service ticket ID: 2?

Untuk menjawab pertanyaan ini, teknik penyelesaiannya mirip dengan pertanyaan sebelumnya. Hanya perbedaannya kita akan mencari data sparepart apa saja yang diperlukan pada service ticket ID = 2, kemudian melookup harga jualnya ke konsumen. Tabel yang akan digunakan untuk query adalah: partsused, dan parts. Tabel partsused nantinya untuk mendapatkan data sparepart yang digunakan pada service ticket ID tertentu, dan tabel parts untuk mendapatkan harga jual sparepartnya (kolom RetailPrice). Selanjutnya harga jual sparepart per buah ini dikalikan dengan banyaknya sparepart yang digunakan (kolom NumberUsed). Terakhir tinggal dijumlah total dengan SUM().

Antara tabel partsused dengan tabel parts berelasi melalui kolom PartsID.

Query yang diberikan untuk menjawab pertanyaan di atas adalah sebagai berikut.

SELECT SUM(partsused.NumberUsed * parts.RetailPrice) as TotalCost
FROM partsused, parts
WHERE partsused.PartsID = parts.PartsID 
		  AND partsused.ServiceTicketID = '2'

Hasil dari query di atas diperoleh jawaban IDR 6.240.000

Berapa total profit dari penjualan sparepart dari service ticket ID: 2?

Untuk menjawab pertanyaan ini, cukup memodifikasi dari query sebelumnya. Profit dari setiap penjualan sparepart dapat diperoleh dengan mencari selisih antara harga jual sparepart (RetailPrice) dengan harga beli sparepart (PurchasePrice) kemudian dikalikan dengan banyaknya quantity sparepartnya.

Query yang diberikan adalah sebagai berikut.

SELECT SUM(partsused.NumberUsed * (parts.RetailPrice - parts.PurchasePrice)) as TotalProfit
FROM partsused, parts
WHERE partsused.PartsID = parts.PartsID 
		  AND partsused.ServiceTicketID = '2'

Hasil query diperoleh total profitnya adalah IDR 1.722.000

Tampilkan 5 besar waktu (bulan dan tahun) terjadinya transaksi service paling banyak!

Untuk menjawab pertanyaan ini, kita hanya cukup menggunakan satu tabel saja untuk bekerja, yaitu tabel serviceticket. Dalam tabel ini terdapat data kapan transaksi service dilakukan (kolom DateReceived). Dalam hal ini kita akan membuat rekap jumlah transaksi berdasarkan tahun dan bulannya. Untuk waktu nanti kita akan susun dalam format YYYY-MM. Selanjutnya rekap data akan disort secara descending dan hanya akan ditampilkan 5 terbesar saja.

SELECT CONCAT(YEAR(serviceticket.DateReceived), "-", MONTH(serviceticket.DateReceived)) AS yearmonth, count(*) as Jumlah
FROM serviceticket
GROUP BY yearmonth
ORDER BY Jumlah DESC
LIMIT 0, 5

Function CONCAT() digunakan untuk menggabungkan string YEAR, “-“, dan MONTH sehingga menjadi format YYYY-MM. Adapun perintah LIMIT 0, 5 digunakan untuk membatasi tampilan 5 data saja dimulai dari data pertama (index ke-0).

Hasil query akan diperoleh jawaban sebagai berikut.

Siapa nama mekanik service yang paling banyak mendapat rate ‘Poor’ dari customer?

Pertanyaan di atas dapat dijawab dengan memberikan query yang melibatkan tabel: mechanic, dan servicemechanic. Tabel mechanic untuk mendapatkan nama mekaniknya, dan tabel servicemechanic untuk mendapatkan data transaksi service yang pernah dilakukan. Data pada tabel servicemechanic ini nantinya kita filter hanya yang mendapat rate ‘Poor’ saja. Selanjutnya kita buat rekap jumlah rate ‘Poor’ untuk setiap mechanic berdasarkan MechanicID dan terakhir kita sort descending.

Adapun kedua tabel berelasi pada kolom MechanicID.

Query yang kita berikan adalah adalah sebagai berikut.

SELECT mechanic.LastName, count(*) as JumPoor
FROM mechanic, servicemechanic
WHERE mechanic.MechanicID = servicemechanic.MechanicID
      AND servicemechanic.Rate = 'Poor'
GROUP BY mechanic.MechanicID
ORDER BY JumPoor DESC

Output dari query di atas adalah

Berdasarkan hasil tersebut, tampak bahwa mekanik bernama Amir lah yang paling banyak mendapat rate ‘Poor’.

Siapa nama customer yang paling banyak memberi rate ‘Poor’ pada mekaniknya?

Pertanyaan ini merupakan pengembangan dari pertanyaan sebelumnya. Tabel yang dipilih untuk menjawab pertanyaan ini adalah: customer, servicemechanic, dan serviceticket. Tabel customer untuk mendapatkan data nama customer. Tabel servicemechanic untuk mendapatkan data mekanik yang mendapat rate ‘Poor’. Serta tabel serviceticket untuk merelasikan antara data service dengan data costumer. Tabel customer dan serviceticket berelasi melalui kolom CustomerID. Adapun tabel serviceticket dan servicemechanic berelasi melalui kolom ServiceTicketID.

Data hasil relasi ketiga tabel di atas nantinya akan dihitung rekapnya berdasarkan customernya, dan selanjutnya disorting secara descending untuk mendapatkan nama customer yang paling banyak memberikan rate ‘Poor’ kepada mekaniknya.

Query SQL yang diberikan adalah sebagai berikut.

SELECT customer.LastName, count(*) as JumRatePoor
FROM customer, servicemechanic, serviceticket
WHERE customer.CustomerID = serviceticket.CustomerID
      AND servicemechanic.ServiceTicketID = serviceticket.ServiceTicketID
      AND servicemechanic.Rate = 'Poor'
GROUP BY customer.CustomerID
ORDER BY JumRatePoor DESC

Hasil dari query tersebut adalah:

Berdasarkan hasil di atas, tampak bahwa customer yang paling banyak memberikan rate Poor adalah Eko.

Tampilkan merek mobil yang jumlah servicenya lebih dari 20 kali!

Tabel yang akan dipilih untuk menjawab pertanyaan ini adalah: car, dan serviceticket. Tabel car untuk mendapatkan merek mobilnya (kolom MAKE), dan tabel serviceticket untuk menghitung jumlah service yang pernah terjadi. Tabel car dan serviceticket berelasi melalui kolom CarID.

Adapun untuk membatasi tampilan hasil query yaitu hanya yang jumlah servicenya lebih dari 20 kali, kita akan gunakan HAVING. Filter dengan HAVING ini dilakukan karena jumlah service ini dihitung melalui rekap dari pengunaan aggregate function COUNT().

Berikut ini adalah query SQL nya:

SELECT car.Make, count(*) as JumService
FROM car, serviceticket
WHERE car.CarID = serviceticket.CarID
GROUP BY car.Make
HAVING JumService > 20
ORDER BY JumService DESC

Sehingga diperoleh informasi merek mobil yang pernah diservice lebih dari 20 kali adalah sbb:

Berapa rata-rata lama penyelesaian waktu service (dalam hari) setiap bulannya selama tahun 2018?

Jawaban dari pertanyaan ini cukup diperoleh dari tabel serviceticket. Hal yang perlu dicari terlebih dahulu adalah lamanya durasi antara tanggal mulai service dilakukan sampai dengan tanggal diserahkannya kembali mobil ke customer. Untuk menghitung durasi dari dua tanggal ini dapat menggunakan function DATEDIFF(). Selanjutnya durasi ini nantinya akan dicari reratanya dengan AVG() dikelompokkan berdasarkan angka bulan dari tahun 2018.

Adapun bentuk query SQL untuk implementasi ide di atas adalah sbb:

SELECT MONTH(serviceticket.DateReceived) as Bulan, AVG(DATEDIFF(serviceticket.DateReturnedToCustomer, serviceticket.DateReceived)) as AvgService
FROM serviceticket
WHERE YEAR(serviceticket.DateReceived) = '2018'
GROUP BY Bulan
ORDER BY Bulan ASC

Akhirnya diperoleh hasil rerata durasi lama service tiap bulan di tahun 2018 sbb:

Buatlah rekap profit per bulan perusahaan dari hasil penjualan sparepart selama tahun 2018!

Untuk mendapatkan besar total profit penjualan sparepart tiap bulannya adalah dengan menghitung profit per item sparepart yaitu mencari selisih harga jual (RetailPrice) dengan harga beli (PurchasePrice) dari tabel parts. Selanjutnya profit per item sparepart ini dikalikan dengan besar quantity nya dari kolom NumberUsed dari tabel partsused untuk mendapatkan total profit dari satu buah item. Total profit per item ini nantinya dijumlah total di setiap bulannya dengan SUM() dikelompokkan berdasarkan bulannya. Waktu pelaksanaan service diambil dari tabel serviceticket. Sehingga untuk menjawab pertanyaan ini dibutuhkan tiga tabel, yaitu: serviceticket, parts, dan partsused.

Antara tabel serviceticket dan partsused berelasi melalui kolom ServiceTicketID, dan antara tabel parts dan partsused berelasi melalui kolom PartsID.

Berikut ini adalah query SQL nya:

SELECT MONTH(serviceticket.DateReceived) as Bulan, SUM(partsused.NumberUsed * (parts.RetailPrice-parts.PurchasePrice)) as TotalProfit
FROM serviceticket, parts, partsused
WHERE serviceticket.ServiceTicketID = partsused.ServiceTicketID
      AND parts.PartsID = partsused.PartsID
      AND YEAR(serviceticket.DateReceived) = '2018'
GROUP BY Bulan
ORDER BY Bulan ASC

dan.. akhirnya didapatlah total profit penjualan sparepart per bulan selama tahun 2018.

Artikel ini khusus akan membahas bagaimana melakukan sorting data list berbentuk multidimensi di Python, yang akan dipadu dengan teknik pembacaan data dari sebuah file.

Karakteristik List di Python

Sebagai sebuah struktur data dinamis, list memiliki beberapa karakteristik yaitu:

• Bersifat mutable: struktur datanya bisa diubah (ditambah, dihapus, disort, disisipkan)
• Untuk akses data dalam list menggunakan sistem indexing yang dimulai dari 0, 1, 2, dst
• Data yang disimpan dalam list tidak harus bertipe data sama
• Elemen data dalam sebuah list dapat berupa list juga

Jika sebuah list berisi data berupa list juga, maka akibatnya akan terbentuk sebuah list multidimensi seperti contoh berikut ini.

myList = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Contoh di atas akan terbentuk sebuah list dengan dimensi 3×3, yang terdiri dari 3 baris dan 3 kolom.

Misalkan kita memiliki sebuah list multidimensi berukuran mxn, bagaimana cara melakukan sorting berdasarkan key dari kolom tertentu? Sebagai contoh misalkan kita memiliki sebuah list berisi serangkaian data NIM, Nama Mhs, dan Nilai sbb:

data = [["M01", "Mr. A", 78], ["M02", "Mr. B", 89 ], ["M03", "Mr. C", 57]]

Bagaimana cara kita melakukan sorting list data tersebut berdasarkan nilai mahasiswanya secara ascending atau descending? Hal ini yang akan kita bahas pada artikel ini.

Problem Statement

Untuk menjawab permasalahan di atas, kita akan mencoba mengimplementasikannya dalam sebuah studi kasus. Misalkan kita memiliki sebuah file (mydata.txt) yang tersimpan di direktori D:\ berisi data sbb:

K3512301#Mr. X#80
K3512302#Mr. Y#50
K3512303#Mr. Z#65

Selanjutnya kita ingin membuat program Python untuk membaca semua data dari file tersebut, dan menampilkan outputnya dalam bentuk data yang telah terurut (sorted) secara descending berdasarkan nilainya. Sehingga harapannya akan muncul tampilan berikut ini.

NIM: K3512301 , Name: Mr. X , Grade: 80
NIM: K3512303 , Name: Mr. Z , Grade: 65
NIM: K3512302 , Name: Mr. Y , Grade: 50

Solusi Permasalahan

Untuk membuat program penyelesaian masalah di atas, kita mulai dari proses membuka file mydata.txt nya terlebih dahulu dengan function open() dengan mode read (r). Oya supaya tidak lupa, sekalian ditambah perintah untuk menutup filenya dengan close().

# membuka file dengan mode read (r)
myFile = open("d:\data.txt", "r")

# menutup file
myFile.close()

Langkah berikutnya adalah membaca semua isi file dengan teknik pembacaan secara baris per baris menggunakan method readlines().

# membuka file dengan mode read (r)
myFile = open("d:\data.txt", "r")

# membaca isi file baris perbaris 
dataAll = myFile.readlines() 

# menutup file
myFile.close()

Apabila dataAll ini diberikan perintah print(dataAll) maka akan diperoleh sebuah list berisi data perbaris file, yaitu:

['K3512301#Mr. X#80\n', 'K3512302#Mr. Y#50\n', 'K3512303#Mr. Z#65\n']

Perhatikan di dalam listnya! Pada data nilai akan terdapat tambahan karakter newline \n. Karakter ini nantinya akan kita hapus dengan teknik tertentu. Dengan demikian kita dapatkan sebuah list dengan 3 buah data di dalamnya, sesuai dengan banyaknya baris dalam file.

Langkah berikutnya adalah memecah setiap data yang ada dalam list untuk mendapatkan NIM, Nama, dan Nilai masing-masing. Sebagai contoh untuk data 'K3512301#Mr. X#80\n' kita akan ambil NIM nya yaitu 'K3512301', nama mahasiswanya 'Mr. X', dan nilainya 80. Proses ini akan dilakukan berulang-ulang untuk setiap data. Sehingga ini nanti akan dilakukan dengan sebuah looping. Namun sebelum kita melakukan hal tersebut, terlebih dahulu kita siapkan sebuah list (empty list), misalkan kita beri nama myData, untuk menyimpan hasil pecahan data tersebut.

# membuka file dengan mode read (r)
myFile = open("d:\data.txt", "r")

# membaca isi file baris perbaris 
dataAll = myFile.readlines() 

# inisialisasi data list
myData = []

# menutup file
myFile.close()

OK sekarang kita akan membuat kode untuk memecah data (data splitting) untuk mendapatkan NIM, Nama, dan Nilai kemudian hasil pecahannya akan kita tambahkan ke dalam list myData. Untuk memecah data guna mendapatkan data NIM, Nama, dan Nilai kita bisa menggunakan method split('#').

Oya untuk menghilangkan tanda \n yang ada di data nilai bagaimana? kita bisa menghilangkannya dengan method replace("\n", "") yaitu mengganti tanda \n dengan blank character. Setelah tanda \n ini dihilangkan, sebaiknya data nilai kita convert ke dalam tipe data integer menggunakan int() supaya nantinya bisa digunakan sebagai acuan proses sortingnya. Konversi ke integer ini perlu dilakukan karena data nilai ini masih bertipe data string.

Selanjutnya misalkan data NIM, Nama, dan Nilai sudah diperoleh dari proses pemecahan data (data splitting), langkah berikutnya adalah menambahkan data ini ke dalam list myData menggunakan method append(). Namun ketiga data tersebut harus dikonstruksi ke dalam list dulu untuk memudahkan proses sorting. Hal ini bisa dilakukan dengan memberikan perintah append([nim, nama, nilai]).

# membuka file dengan mode read (r)
myFile = open("d:\data.txt", "r")

# membaca isi file baris perbaris 
dataAll = myFile.readlines() 

# inisialisasi data list
myData = []

# untuk setiap data pada dataAll lakukan...
for data in dataAll:
    # menghapus \n
    data = data.replace("\n", "")
    # memecah data berdasarkan tanda #
    splitData = data.split("#")
    # menambahkan data hasil pecahan ke dalam list myData, dengan
    # splitData[0] adalah data nim
    # splitData[1] adalah data nama
    # splitData[2] adalah data nilai
    myData.append([splitData[0], splitData[1], int(splitData[2])])

# menutup file
myFile.close()

Dari program di atas, apabila myData ditampilkan datanya dengan print(myData) maka akan diperoleh struktur list multidimensi berukuran 3×3 sebagai berikut

[['K3512301', 'Mr. X', 80], ['K3512302', 'Mr. Y', 50], ['K3512303', 'Mr. Z', 65]]

Langkah terakhir adalah kita akan melakukan sorting myData berdasarkan nilainya secara descending. Dalam hal ini posisi data nilai ada di index ke-2 dari setiap data listnya. Untuk melakukan sorting descending berdasarkan data index ke-2 kita bisa gunakan perintah sort(key=itemgetter(2), reverse=True). Namun untuk bisa menggunakan perintah itemgetter() terlebih dahulu kita harus mengimportnya dengan perintah: import library from operator import itemgetter.

#import library
from operator import itemgetter

# membuka file dengan mode read (r)
myFile = open("d:\data.txt", "r")

# membaca isi file baris perbaris 
dataAll = myFile.readlines() 

# inisialisasi data list
myData = []

# untuk setiap data pada dataAll lakukan...
for data in dataAll:
    # menghapus \n
    data = data.replace("\n", "")
    # memecah data berdasarkan tanda #
    splitData = data.split("#")
    # menambahkan data hasil pecahan ke dalam list myData, dengan
    # splitData[0] adalah data nim
    # splitData[1] adalah data nama
    # splitData[2] adalah data nilai
    myData.append([splitData[0], splitData[1], int(splitData[2])])

# sorting data ascending berdasarkan nilai (index ke-2)
myData.sort(key=itemgetter(2), reverse=True)

# menutup file
myFile.close()

Setelah selesai melakukan sorting descending berdasarkan nilai, selanjutnya kita bisa tampilkan data myData nya.

#import library
from operator import itemgetter

# membuka file dengan mode read (r)
myFile = open("d:\data.txt", "r")

# membaca isi file baris perbaris 
dataAll = myFile.readlines() 

# inisialisasi data list
myData = []

# untuk setiap data pada dataAll lakukan...
for data in dataAll:
    # menghapus \n
    data = data.replace("\n", "")
    # memecah data berdasarkan tanda #
    splitData = data.split("#")
    # menambahkan data hasil pecahan ke dalam list myData, dengan
    # splitData[0] adalah data nim
    # splitData[1] adalah data nama
    # splitData[2] adalah data nilai
    myData.append([splitData[0], splitData[1], int(splitData[2])])

# sorting data ascending berdasarkan nilai (index ke-2)
myData.sort(key=itemgetter(2), reverse=True)

# print output myData
for data in myData:
    print("NIM:",data[0],", Name:", data[1],", Grade:",data[2])

# menutup file
myFile.close()

OK itu dia ide penyelesaian dan implementasi kode program Python untuk masalah yang diberikan. Mudah bukan membuatnya? Dengan menggunakan perintah sort() kita bisa melakukan sorting multidimensi di Python, namun terlebih dahulu kita tentukan key yaitu index mana yang akan dijadikan acuan sortingnya menggunakan itemgetter().

Pengertian Teknik ‘Clean Code’

Teknik “clean code” dalam pemrograman mengacu pada praktik menulis kode yang mudah dibaca, dimengerti, dan dikelola oleh pengembang lain (atau bahkan oleh penulis kode itu sendiri di masa depan). Ini bukan hanya tentang membuat kode bekerja, tetapi tentang menulis kode yang “bersih” dan efisien dalam struktur dan gayanya.

Berikut adalah beberapa aspek utama dari teknik “clean code”:

1. Keterbacaan: Kode harus ditulis dengan cara yang memudahkan orang lain untuk membaca dan memahaminya. Ini mencakup pemilihan nama variabel yang deskriptif, penggunaan komentar yang bermakna, dan struktur yang logis.
2. Konsistensi: Menggunakan konvensi penamaan yang konsisten, gaya format, dan pendekatan pemrograman di seluruh kode.
3. Singkat tapi Jelas: Hindari kode yang berlebihan atau tidak perlu, tetapi pastikan kode tetap jelas dan mudah dimengerti.
4. DRY (Don’t Repeat Yourself): Jika ada blok kode atau logika yang berulang di beberapa tempat, pertimbangkan untuk mengabstraksinya menjadi fungsi atau metode tersendiri.
5. Pemisahan Tanggung Jawab: Setiap fungsi atau kelas harus memiliki satu tujuan atau tanggung jawab. Ini sering disebut sebagai prinsip “Single Responsibility”.
6. Mudah Diperluas: Kode harus ditulis dengan cara yang memudahkan penambahan atau perubahan fitur di masa depan tanpa mengganggu bagian lain dari sistem.
7. Penggunaan Komentar dengan Bijak: Komentar harus digunakan untuk menjelaskan mengapa suatu pendekatan diambil atau untuk menjelaskan bagian kode yang kompleks. Namun, kode itu sendiri harus sejelas mungkin sehingga meminimalkan kebutuhan akan komentar.
8. Mengikuti Standar dan Konvensi: Setiap bahasa pemrograman atau kerangka kerja biasanya memiliki standar atau konvensi tertentu yang dianjurkan. Mengikuti standar ini dapat membantu menjaga konsistensi dan keterbacaan kode.

Secara keseluruhan, tujuan dari “clean code” adalah untuk memastikan bahwa kode tidak hanya fungsional, tetapi juga terstruktur dengan baik, efisien, dan mudah dikelola. Ini penting untuk memastikan keberlanjutan proyek, kolaborasi yang efektif antar pengembang, dan kualitas produk perangkat lunak yang tinggi.

Manfaat Teknik ‘Clean Code’

Teknik ‘clean code’ dalam pemrograman membawa sejumlah manfaat penting, antara lain:

1. Keterbacaan (Readability): Kode yang bersih mudah dibaca dan dimengerti. Ini memudahkan pengembang lain untuk memahami alur dan logika dari kode tersebut tanpa harus menghabiskan banyak waktu.
2. Pemeliharaan (Maintainability): Kode yang bersih dan terstruktur dengan baik lebih mudah untuk dikelola dan diperbarui. Perubahan dan penambahan fitur baru menjadi lebih cepat dan efisien.
3. Kurangnya Kesalahan (Fewer Bugs): Dengan struktur yang jelas dan penamaan yang deskriptif, potensi untuk kesalahan atau bug berkurang. Kode yang bersih cenderung memiliki lebih sedikit kesalahan daripada kode yang berantakan atau rumit.
4. Kolaborasi yang Efektif: Saat bekerja dalam tim, kode yang bersih memudahkan anggota tim lain untuk berkolaborasi, memberikan umpan balik, atau menambahkan kode mereka sendiri.
5. Efisiensi Waktu: Meskipun mungkin memerlukan waktu tambahan di awal untuk menulis kode yang bersih, investasi ini akan membuahkan hasil dalam jangka panjang dengan mengurangi waktu yang diperlukan untuk debugging dan pemeliharaan.
6. Ketergantungan yang Rendah (Low Coupling): Prinsip clean code mendorong desain yang memiliki ketergantungan yang rendah antar komponen, yang berarti perubahan pada satu bagian kode tidak akan memiliki dampak besar pada bagian lain dari kode.
7. Dokumentasi Implisit: Kode yang bersih dan deskriptif seringkali menjelaskan dirinya sendiri, mengurangi kebutuhan untuk dokumentasi eksternal yang berlebihan.
8. Keseragaman (Consistency): Mengikuti standar dan konvensi tertentu dalam menulis kode memastikan keseragaman di seluruh kode, yang memudahkan pembacaan dan pemahaman.
9. Meningkatkan Kualitas Produk: Secara keseluruhan, kode yang bersih meningkatkan kualitas produk perangkat lunak, mengurangi insiden kesalahan, dan meningkatkan kepuasan pengguna.
10. Kepuasan Profesional: Menulis kode yang bersih dan rapi memberikan kepuasan tersendiri bagi pengembang. Ini mencerminkan profesionalisme dan dedikasi terhadap kualitas kerja.

Penerapan ‘Clean Code’ di Python

Dalam bahasa pemrograman Python, ada beberapa teknik dan konvensi yang dianjurkan untuk mencapai tujuan ini. Artikel ini akan membahas beberapa teknik tersebut beserta contoh-contohnya.

1. Penamaan yang Jelas

Prinsip: Gunakan nama variabel, fungsi, dan kelas yang deskriptif dan jelas.

Contoh:

• Buruk: def p(x, y):
• Baik: def hitung_luas_persegi_panjang(panjang, lebar):

2. Hindari Kode yang Berulang (DRY – Don’t Repeat Yourself)

Prinsip: Jika Anda menemukan diri Anda menulis kode yang sama di beberapa tempat, pertimbangkan untuk membuat fungsi atau kelas.

Contoh:

• Buruk:

  x = x * 10
  y = y * 10
  z = z * 10

• Baik:

  def perkalian_sepuluh(angka):
      return angka * 10

  x = perkalian_sepuluh(x)
  y = perkalian_sepuluh(y)
  z = perkalian_sepuluh(z)

3. Gunakan Spasi dengan Konsisten

Prinsip: Di Python, indentasi adalah bagian penting dari sintaks. Gunakan 4 spasi untuk setiap level indentasi.

Contoh:

• Buruk:

  def fungsi():
  hasil = 10
      return hasil

• Baik:

  def fungsi():
      hasil = 10
      return hasil

4. Hindari Kode yang Terlalu Panjang

Prinsip: Batasi panjang baris kode. PEP 8, panduan gaya Python, merekomendasikan batas 79 karakter untuk kode dan 72 untuk komentar.

Contoh:

• Buruk:

  hasil = fungsi_satu(argument_satu, argument_dua, argument_tiga, argument_empat, argument_lima)

• Baik:

  hasil = fungsi_satu(argument_satu, argument_dua, argument_tiga,
                      argument_empat, argument_lima)

5. Gunakan Komentar dengan Bijak

Prinsip: Komentar harus menjelaskan mengapa suatu tindakan diambil, bukan apa yang dilakukan kode tersebut.

Contoh:

• Buruk:

  # Menambahkan 1 ke x
  x += 1

• Baik:

  # Kompensasi untuk kesalahan pembulatan
  x += 1

6. Gunakan Docstrings

Prinsip: Untuk fungsi atau kelas yang lebih kompleks, gunakan docstrings untuk menjelaskan apa yang dilakukan fungsi atau kelas tersebut.

Contoh:

  def hitung_luas(panjang, lebar):
      """
      Menghitung luas persegi panjang.
      Args:
      - panjang (float): Panjang persegi panjang.
      - lebar (float): Lebar persegi panjang.

      Returns:
      float: Luas persegi panjang.
      """
      return panjang * lebar

Kesimpulan

Menulis ‘clean code’ adalah investasi untuk masa depan. Kode yang bersih memudahkan pengembang lain (atau Anda sendiri di masa depan) untuk memahami, memodifikasi, dan memelihara kode tersebut. Dengan mengikuti prinsip-prinsip di atas, Anda dapat meningkatkan kualitas kode Python Anda dan membuatnya lebih “bersih”.