Clean Code: Kebiasaan Coding agar Program Mudah Dipahami

Saat belajar coding, banyak pemula lebih fokus membuat program berjalan tanpa error. Padahal, program yang bisa berjalan belum tentu memiliki kode yang mudah dipahami.

Bayangkan sebuah program memiliki ratusan atau bahkan ribuan baris kode. Jika penulisannya berantakan, nama variabel tidak jelas, dan terlalu banyak kode yang berulang, programmer akan kesulitan ketika ingin memperbaiki atau mengembangkan program tersebut.

Di sinilah konsep Clean Code menjadi penting. Clean Code membantu programmer menulis kode yang lebih rapi, jelas, mudah dipahami, dan mudah dipelihara.

Apa Itu Clean Code?

Clean Code adalah prinsip dan kebiasaan dalam menulis kode agar struktur program mudah dibaca, dipahami, diuji, dan dikembangkan.

Clean Code bukan berarti kode harus dibuat sesingkat mungkin. Kode yang pendek belum tentu mudah dipahami.

Contohnya:

x = 10000
y = 3
z = x * y
print(z)

Kode tersebut memang sederhana, tetapi kita tidak langsung mengetahui apa arti x, y, dan z.

Kode yang lebih jelas:

harga_produk = 10000
jumlah_produk = 3
total_harga = harga_produk * jumlah_produk

print(total_harga)

Kode kedua memiliki lebih banyak karakter, tetapi maksudnya jauh lebih mudah dipahami.

Mengapa Clean Code Penting?

Clean Code memberikan banyak manfaat, terutama ketika proyek mulai berkembang.

Beberapa manfaatnya adalah:

• Kode lebih mudah dibaca.
• Proses debugging menjadi lebih mudah.
• Perubahan kode lebih aman.
• Mengurangi kode yang berulang.
• Mempermudah kerja dalam tim.
• Memudahkan programmer lain memahami proyek.
• Program lebih mudah dikembangkan.

Clean Code juga sangat berguna ketika programmer kembali mengerjakan proyek lama setelah beberapa minggu atau bulan.

1. Gunakan Nama Variabel yang Jelas

Nama variabel merupakan salah satu bagian terpenting dalam Clean Code.

Hindari nama yang terlalu singkat dan tidak memberikan informasi.

Contoh kurang baik:

a = 50000
b = 2
c = a * b

Lebih baik:

harga = 50000
jumlah = 2
total = harga * jumlah

Jika program lebih kompleks, gunakan nama yang lebih spesifik:

harga_produk = 50000
jumlah_produk = 2
total_harga = harga_produk * jumlah_produk

Dengan begitu, programmer tidak perlu menebak arti setiap variabel.

2. Buat Function dengan Tugas yang Jelas

Function sebaiknya memiliki satu tanggung jawab utama.

Contoh function yang terlalu banyak melakukan pekerjaan:

def proses():
    # menghitung harga
    # menyimpan database
    # mengirim email
    # membuat laporan
    # mencetak data
    pass

Akan lebih baik jika tugasnya dipisahkan:

def hitung_total(harga, jumlah):
    return harga * jumlah


def simpan_data(data):
    pass


def kirim_email(email):
    pass

Dengan cara tersebut, setiap function lebih mudah dipahami dan diuji.

3. Hindari Kode yang Berulang

Kode yang sama ditulis berkali-kali dapat membuat program sulit dirawat.

Contohnya:

print("Selamat datang, Rina")
print("Selamat datang, Budi")
print("Selamat datang, Andi")

Jika pola tersebut digunakan berkali-kali, lebih baik menggunakan function:

def sapa(nama):
    print(f"Selamat datang, {nama}")


sapa("Rina")
sapa("Budi")
sapa("Andi")

Jika pesan tersebut nantinya berubah, programmer cukup mengubahnya pada satu tempat.

4. Jangan Membuat Function Terlalu Panjang

Function yang terlalu panjang biasanya menjadi sulit dibaca.

Misalnya satu function memiliki:

Input pengguna
↓
Validasi data
↓
Perhitungan
↓
Database
↓
Pengiriman email
↓
Pembuatan laporan
↓
Output

Lebih baik beberapa proses tersebut dipisahkan menjadi function yang lebih kecil.

Contohnya:

def validasi_data():
    pass


def hitung_data():
    pass


def simpan_database():
    pass


def buat_laporan():
    pass

Pembagian seperti ini membuat struktur program lebih terorganisir.

5. Gunakan Komentar Secukupnya

Komentar dapat membantu menjelaskan kode, tetapi jangan menggunakan komentar untuk menjelaskan sesuatu yang sebenarnya sudah jelas dari kode.

Contoh yang tidak terlalu berguna:

# Menambahkan 1 ke angka
angka += 1

Kode tersebut sudah cukup jelas.

Komentar lebih berguna ketika menjelaskan alasan di balik suatu keputusan:

# Gunakan batas 3 percobaan untuk mencegah brute force login
if jumlah_percobaan >= 3:
    blokir_akun()

Jadi, komentar sebaiknya memberikan informasi yang memang tidak langsung terlihat dari kode.

6. Gunakan Format Kode yang Konsisten

Kode akan lebih mudah dibaca jika memiliki format yang konsisten.

Contohnya:

def hitung_total(harga, jumlah):
    total = harga * jumlah
    return total

Gunakan indentasi, spasi, dan penamaan yang konsisten di seluruh proyek.

Jangan sampai satu bagian menggunakan:

totalHarga

sementara bagian lainnya menggunakan:

total_harga

Pilih satu gaya dan gunakan secara konsisten.

7. Hindari Angka atau Nilai yang Tidak Jelas

Nilai yang langsung ditulis di dalam kode tanpa penjelasan sering disebut magic number.

Contohnya:

if umur >= 17:
    print("Dewasa")

Dalam program sederhana mungkin tidak menjadi masalah. Namun, dalam proyek besar lebih baik menggunakan konstanta:

BATAS_UMUR = 17

if umur >= BATAS_UMUR:
    print("Dewasa")

Dengan begitu, maksud angka tersebut menjadi lebih jelas.

8. Gunakan Struktur Kondisi yang Mudah Dipahami

Kondisi yang terlalu kompleks dapat membuat kode sulit dibaca.

Contoh:

if umur >= 17 and memiliki_ktp and status == "aktif":
    print("Boleh melakukan pendaftaran")

Jika kondisinya semakin panjang, pertimbangkan untuk memisahkan logika:

data_valid = umur >= 17
dokumen_valid = memiliki_ktp
akun_aktif = status == "aktif"

if data_valid and dokumen_valid and akun_aktif:
    print("Boleh melakukan pendaftaran")

Kode menjadi lebih mudah diperiksa.

9. Hapus Kode yang Tidak Digunakan

Kode yang sudah tidak digunakan sebaiknya dihapus.

Contohnya:

nama = "Rina"
umur = 17
alamat = "Lampung"

print(nama)

Jika umur dan alamat memang tidak digunakan, keberadaannya hanya membuat kode lebih ramai.

Hindari juga meninggalkan banyak kode yang dikomentari:

# print("Data lama")
# proses_lama()
# fungsi_lama()

Jika kode tersebut sudah tidak diperlukan dan sudah tersimpan dalam version control, biasanya lebih baik dihapus.

10. Gunakan Error Handling yang Tepat

Program yang baik tidak hanya memikirkan kondisi normal, tetapi juga kemungkinan terjadi kesalahan.

Contohnya:

try:
    angka = int(input("Masukkan angka: "))
    print(angka)
except ValueError:
    print("Input harus berupa angka.")

Dengan error handling, program dapat memberikan respons yang lebih baik ketika pengguna memberikan input yang salah.

11. Jangan Terlalu Mengandalkan Kode yang Rumit

Kode yang terlihat canggih belum tentu merupakan kode yang baik.

Contohnya, daripada membuat satu baris kode yang sangat kompleks, terkadang lebih baik memecahnya menjadi beberapa langkah:

harga_diskon = harga * 0.9
total_harga = harga_diskon * jumlah

dibandingkan membuat satu ekspresi panjang yang sulit dibaca.

Keterbacaan sering kali lebih penting daripada membuat kode terlihat pintar.

12. Gunakan Prinsip DRY

DRY merupakan singkatan dari Don’t Repeat Yourself.

Prinsip ini mengajarkan programmer untuk menghindari pengulangan logika yang sama.

Contoh:

def hitung_luas_persegi(sisi):
    return sisi * sisi

Function tersebut dapat digunakan berkali-kali:

print(hitung_luas_persegi(5))
print(hitung_luas_persegi(10))
print(hitung_luas_persegi(20))

Daripada menulis rumus yang sama berulang kali.

13. Pisahkan Tanggung Jawab Program

Program yang besar sebaiknya tidak menempatkan semua kode dalam satu file atau satu function.

Misalnya aplikasi web dapat dipisahkan menjadi:

project/
├── controllers/
├── models/
├── views/
├── assets/
├── config/
└── routes/

Struktur tersebut membantu programmer menemukan bagian tertentu dengan lebih cepat.

14. Lakukan Refactoring

Refactoring adalah proses memperbaiki struktur kode tanpa mengubah fungsi utama program.

Misalnya:

x = 10000
y = 5
z = x * y

Dapat diperbaiki menjadi:

harga = 10000
jumlah = 5
total_harga = harga * jumlah

Hasil program tetap sama, tetapi kode menjadi lebih mudah dipahami.

Refactoring dapat dilakukan secara berkala ketika proyek berkembang.

15. Clean Code Bukan Berarti Kode Tanpa Error

Ini merupakan hal penting.

Clean Code tidak menjamin program bebas dari bug.

Program tetap bisa mengalami:

• Syntax Error
• Logic Error
• Runtime Error
• Database Error
• Network Error

Clean Code membantu membuat struktur kode lebih mudah dipahami sehingga proses menemukan dan memperbaiki masalah menjadi lebih mudah.

Contoh Kode Sebelum dan Sesudah Clean Code

Sebelum

a = 10000
b = 3

if b > 0:
    c = a * b
    print("Total:", c)

Kode tersebut sebenarnya dapat berjalan. Namun, nama variabelnya kurang deskriptif.

Setelah

harga_produk = 10000
jumlah_produk = 3

if jumlah_produk > 0:
    total_harga = harga_produk * jumlah_produk
    print("Total:", total_harga)

Versi kedua lebih mudah dipahami karena setiap nama variabel menjelaskan tujuannya.

Kebiasaan Clean Code untuk Pemula

Jika baru belajar programming, tidak perlu langsung menerapkan semua prinsip secara sempurna.

Mulailah dengan kebiasaan sederhana:

1. Gunakan nama variabel yang jelas.
2. Buat function dengan tugas spesifik.
3. Hindari kode berulang.
4. Gunakan indentasi dengan konsisten.
5. Berikan komentar ketika memang diperlukan.
6. Hapus kode yang tidak digunakan.
7. Validasi input pengguna.
8. Biasakan melakukan refactoring.
9. Baca kembali kode setelah selesai membuat fitur.
10. Tulis kode yang dapat dipahami programmer lain.

Kesimpulan

Clean Code merupakan kebiasaan penting yang perlu dimiliki programmer. Tujuannya bukan sekadar membuat kode terlihat rapi, tetapi membuat program lebih mudah dibaca, dipahami, diperbaiki, dan dikembangkan.

Mulailah dari hal sederhana seperti menggunakan nama variabel yang jelas, menghindari kode berulang, membuat function yang terarah, menggunakan format konsisten, serta melakukan refactoring.

Semakin terbiasa menulis Clean Code sejak awal belajar coding, semakin mudah pula mengelola proyek ketika program yang dibuat menjadi semakin besar dan kompleks.