Prinsip Fundamental dalam Software Engineering yang Harus Dipahami!

Hai Sobat BWA!🙌

“Fundamental Principles” dalam software engineering adalah prinsip dasar dalam pemrograman yang digunakan untuk meningkatkan dan memudahkan kita dalam menulis kode. Dengan menerapkan beberapa prinsip-prinsip ini, kita akan mendapatkan banyak manfaat seperti:

  • Meningkatkan Kualitas Kode: Kode yang dihasilkan akan lebih bersih, lebih terstruktur, dan lebih mudah dibaca
  • Mempermudah Pengujian: Kode yang terstruktur dengan baik dan modular lebih mudah untuk diuji. Setiap komponen dapat diuji secara terpisah, yang memungkinkan deteksi bug dan masalah lainnya
  • Mempermudah Pemeliharaan: Kode yang mengikuti prinsip-prinsip dasar ini akan lebih mudah untuk dipelihara dan diperbarui. Perubahan dapat dilakukan dengan lebih cepat dan dengan risiko yang lebih rendah terhadap munculnya bug baru

Dan masih banyak lagi manfaat yang akan didapat dari penerapan prinsip-prinsip ini. Lalu, apa saja sih prinsip dasar dari software engineering tersebut?

Simak artikel berikut sampai habis ya!

1. SoC - Separation of Concerns

james-harrison-vpOeXr5wmR4-unsplash.jpg

SoC merupakan salah satu prinsip di mana suatu program harus dirancang dengan wadah terpisah yang tidak dapat diakses satu sama lain dan setiap komponen kode bekerja secara independen. Separation of Concerns berarti membagi program komputer menjadi bagian-bagian yang berbeda, yang masing-masing menangani aspek-aspek spesifik dari fungsionalitas program. Setiap bagian atau modul tersebut bertanggung jawab atas satu aspek tertentu dari keseluruhan program. Contoh penerapan SoC adalah desain MVC (Model-View-Controller) yang memisahkan antara Model (data), Controller (Logika Aplikasi), dan View (Tampilan). Beberapa manfaat dari penerapan prinsip ini adalah:

  • Pemeliharaan Aplikasi Menjadi Mudah: Dengan memisahkan berbagai aspek, perubahan pada satu bagian kode tidak akan mempengaruhi bagian lainnya, sehingga lebih mudah untuk memperbarui dan memelihara kode
  • Kemudahan Pengujian: Bagian-bagian yang terpisah dapat diuji secara independen sehingga meningkatkan efektivitas pengujian
  • Kode Menjadi Teroganisir: Kode yang terorganisir dengan baik lebih mudah dipahami karena setiap bagian memiliki tujuan yang jelas

2. KISS - Keep It Simple, Stu**d

Prinsip ini memiliki arti bahwa kita harus menulis kode sesederhana mungkin. Penerapan prinsip ini akan membuat kode lebih mudah dipahami terutama ketika kita bekerja sama dalam tim yang terdiri dari banyak orang, di mana orang yang berbeda harus membaca dan memodifikasi kode. Penulisan kode yang bersih dan sederhana juga cenderung memiliki sedikit bug dan lebih mudah diuji. Selain itu, pemeliharaan sistem aplikasi akan lebih mudah untuk diperbaiki dan diperbarui, karena identifikasi masalah menjadi lebih mudah ditemukan. Berikut merupakan contoh penerapan prinsip KISS dalam pemrograman:

function isPalindrome($string) {
    $length = strlen($string);
    $reversedString = '';

    for ($i = $length - 1; $i >= 0; $i--) {
        $reversedString .= $string[$i];
    }

    if ($string === $reversedString) {
        return true;
    } else {
        return false;
    }
}

Kode di atas merupakan contoh ketika kita belum menerapkan prinsip KISS

function isPalindrome($string) {
    return $string === strrev($string);
}

Kode di atas merupakan contoh ketika prinsip KISS sudah diterapkan

Setelah menerapkan prinsip KISS, terlihat lebih simpel bukan? Kode menjadi lebih mudah dibaca dan dipahami.

3. DRY - Don’t Repeat Yourself

DRY atau yang merupakan singkatan dari Don’t Repeat Yourself adalah prinsip fundamental dalam software engineering yang menekankan pentingnya menghindari duplikasi kode. Prinsip ini pertama kali diperkenalkan oleh Andy Hunt dan Dave Thomas dalam buku mereka "The Pragmatic Programmer". Inti dari prinsip DRY adalah bahwa setiap bagian dari pengetahuan (logika bisnis, algoritma, struktur data, dll.) seharusnya hanya diwakili satu kali dalam basis kode. Lebih baik mencari algoritma yang menggunakan loop daripada menduplikasi baris kode. Hal ini karena men-debug satu loop yang menangani 25 pengulangan jauh lebih mudah daripada 25 blok kode yang masing-masing menangani satu pengulangan. Kode yang menerapkan prinsip ini akan lebih mudah dipelihara karena jika ada perubahan dalam logika atau bug yang perlu diperbaiki, kita cukup melakukan perubahan di suatu tempat.

4. YAGNI - You Aren’t Going to Need It

thomas-lefebvre-gp8BLyaTaA0-unsplash.jpg

“You Aren’t Going to Need It” berarti bahwa kita tidak harus mengimplementasikan fungsionalitas tambahan atau fitur baru sampai benar-benar dibutuhkan. Menghindari pengembangan fitur yang tidak dibutuhkan membantu menghemat waktu penyelesaian tugas lebih cepat dan efisien. Dengan menerapkan YAGNI, risiko timbul bug baru akan sangat kecil karena tidak ada kode yang tidak diperlukan yang ditambahkan.

5. Single Responsibility

Menurut prinsip ini, setiap kelas atau modul dalam suatu program hanya boleh melakukan fungsi tertentu. Kelas atau modul harus memiliki satu tanggung jawab utama dan tidak menangani tugas lain di luar tanggung jawab tersebut. Misalnya, sebuah kelas yang bertanggung jawab untuk mengelola data pelanggan tidak boleh mengandung logika untuk mengirim email ke pelanggan. Kelas atau modul yang hanya memiliki satu tanggung jawab cenderung memiliki lebih sedikit ketergantungan dengan bagian lain dari sistem, yang berarti lebih sedikit potensi untuk bug atau masalah ketika ada perubahan atau pembaruan.

6. Refactor

arnold-francisca-f77Bh3inUpE-unsplash.jpg

“Refactor” berarti meninjau ulang kode dan mencari cara untuk mengoptimalkannya, serta membuatnya agar menjadi lebih efisien. Refactoring membantu menghilangkan kode yang tidak dibutuhkan, memperbaiki nama variabel, metode, dan class agar lebih deskriptif. Kode yang telah di-refactor biasanya lebih mudah untuk diuji dan dipelihara. Jika kalian ingin menulis kode yang lebih bersih dan berkualitas, kalian harus mempertimbangkan prinsip ini.

7. Document Your Code

Prinsip ini merupakan salah satu prinsip yang penting untuk diterapkan ketika berkolaborasi atau berkerja dengan orang lain. Prinsip "Document Your Code" adalah panduan penting yang menekankan pentingnya mendokumentasikan setiap aspek kode selama proses development. Dokumentasi kode mencakup penulisan komentar dalam source code, pembuatan dokumen terpisah yang menjelaskan fungsi, struktur, dan penggunaan kode, serta pemeliharaan catatan yang berkaitan dengan perubahan dan pembaruan kode. Dengan menerapkan prinsip ini, software developer dapat memastikan bahwa kode mereka tidak hanya berfungsi dengan baik tetapi juga dapat dipahami, dipelihara, dan dikembangkan lebih lanjut dengan lebih efisien.

<?php

/**
 * Menghitung luas lingkaran.
 *
 * @param float $radius Jari-jari lingkaran
 * @return float Luas lingkaran
 * @throws InvalidArgumentException Jika jari-jari tidak valid
 */
function calculateCircleArea($radius) {
    // Konstanta untuk π
    define('PI', 3.14159);

    // Validasi input
    if ($radius <= 0) {
        throw new InvalidArgumentException('Jari-jari harus positif.');
    }

    // Hitung luas lingkaran
    return PI * pow($radius, 2);
}

// Contoh penggunaan fungsi
$radius = 5;

try {
    // Hitung dan tampilkan luas lingkaran
    $area = calculateCircleArea($radius);
    echo "Luas lingkaran dengan jari-jari $radius adalah $area\\n";
} catch (InvalidArgumentException $e) {
    // Tangani kesalahan input
    echo "Kesalahan: " . $e->getMessage() . "\\n";
}

?>

Kode di atas merupakan contoh kode yang menerapkan prinsip ini dengean menambahkan komentar pada setiap baris kode

8. Composition Over Inheritance

Prinsip ini akan sangat berguna jika kita menggunakan Object Oriented Programming atau yang biasanya disebut OOP. Prinsip ini menganjurkan penggunaan composition daripada inheritance atau pewarisan untuk memperluas fungsionalitas suatu kelas. Kode yang ditulis menggunakan composition akan lebih bersih dan lebih mudah dipelihara serta menyediakan basis kode yang lebih sederhana dan mudah diuji. Prinsip "Composition over Inheritance" mendorong desain yang lebih modular, fleksibel, dan mudah untuk dipelihara dengan cara menggunakan komposisi objek daripada pewarisan. Berikut adalah perbedaan penulisan kode jika menggunakan pewarisan dan komposisi:

  • Inheritance
class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}
  • Composition
class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog {
    private Animal animal = new Animal();
    
    void eat() {
        animal.eat();
    }
    
    void bark() {
        System.out.println("The dog barks.");
    }

Pada contoh komposisi di atas, kelas Dog memiliki (has-a) objek Animal, sehingga dapat menggunakan fungsionalitas eat() dari Animal tanpa mewarisinya. Ini memungkinkan Dog memiliki fleksibilitas untuk mengubah atau menambahkan perilaku lain tanpa terikat pada hierarki pewarisan yang ketat.

Mengapa Harus Menerapkan Prinsip-Prinsip Fundamental dalam Pemrograman?

  • Efisiensi: Penggunaan prinsip-prinsip fundamental dapat meningkatkan efisiensi kinerja kode. Struktur data dan algoritma yang dipilih dengan baik dapat mempercepat eksekusi program dan mengurangi penggunaan resource
  • Pemeliharaan: Kode yang ditulis dengan prinsip-prinsip yang baik lebih mudah untuk diperbaiki dan ditingkatkan
  • Reusabilitas: Prinsip-prinsip seperti DRY (Don't Repeat Yourself) mendorong pembuatan kode yang dapat digunakan kembali sehingga hal ini mengurangi duplikasi kode dan memungkinkan penggunaan kembali komponen yang sudah diuji dan terbukti berfungsi
  • Kolaborasi: Dalam proyek tim, mengikuti standar dan prinsip yang sama memudahkan kolaborasi antar anggota tim. Semua orang dapat bekerja dengan cara yang konsisten dan saling memahami kode satu sama lain

Kesimpulan

Itulah penjelasan mengenai prinsip-prinsip fundamental dalam software engineering yang meliputi SoC (Separation of Concerns) yang membagi program menjadi bagian-bagian yang berbeda dan bekerja secara independen, KISS (Keep It Simple, Stu**d) yang menekankan penulisan kode yang sederhana, DRY (Don’t Repeat Yourself) yang menghindari duplikasi kode, YAGNI (You Aren’t Going to Need It) yang menghindari pengembangan fitur yang tidak dibutuhkan, Single Responsibility yang menekankan setiap kelas atau modul hanya melakukan satu fungsi, Refactor yang mengoptimalkan kode, Document Your Code yang menekankan pentingnya dokumentasi, dan Composition Over Inheritance yang menganjurkan penggunaan komposisi daripada pewarisan. Prinsip-prinsip tersebut perlu untuk dipelajari dan diterapkan agar mempermudah software development.

Semoga artikel ini dapat bermanfaat ya! Dan bagi kalian yang tertarik untuk mempelajari lebih lanjut tentang Software Development, kalian bisa mempelajarinya secara gratis melalui BuildWithAngga loh! Jangan lupa kepoin kelas-kelasnya ya! Sampai jumpa di artikel selanjutnya🙌