Belajar Menata Kode dengan Refactoring: Improving the Design of Existing Code

Pernahkah kamu merasa cemas saat harus menyentuh sebuah file kode yang sudah lama berjalan? Kamu takut jika mengubah satu baris perintah saja, bagian lain dari program tiba-tiba rusak atau error. Rasa takut ini biasanya muncul karena struktur kode yang berantakan, sulit dipahami, dan tidak rapi.

Dalam buku Refactoring: Improving the Design of Existing Code karya Martin Fowler, keresahan ini dibahas secara mendalam. Buku ini memberikan panduan praktis tentang bagaimana kamu bisa menata ulang struktur internal kode tanpa mengubah perilaku luarnya sama sekali. Dengan teknik yang benar, kamu bisa mengubah kode yang "beruntung bisa jalan" menjadi perangkat lunak yang bersih, mudah dirawat, dan siap untuk dikembangkan lebih lanjut.

Mengenal Konsep Refactoring dalam Pemrograman

Refactoring bukan sekadar urusan estetika agar kode terlihat cantik. Secara definisi, refactoring adalah proses teratur untuk memperbaiki struktur internal kode tanpa mengubah perilaku luarnya. Tujuannya adalah membuat perangkat lunak lebih mudah dipahami dan lebih mudah untuk dirawat dalam jangka panjang.

Banyak proyek pengembangan perangkat lunak tersendat bukan karena performa komputer yang lambat, melainkan karena programmer kesulitan membaca kode buatan orang lain atau bahkan kode buatan mereka sendiri di masa lalu. Kode yang berantakan akan menghambat proses penambahan fitur baru karena setiap perubahan kecil berisiko merusak sistem secara keseluruhan.

Martin Fowler memberikan contoh nyata melalui program penyewaan video yang sederhana. Secara fungsi, program tersebut berjalan lancar untuk mencatat penyewaan dan mencetak tagihan. Namun, rancangan kodenya sangat buruk karena logika perhitungan biaya, poin pelanggan, hingga pencetakan teks semuanya menumpuk dalam satu fungsi yang sangat panjang.

Masalah besar muncul saat pemilik toko ingin mengubah format tagihan dari teks biasa menjadi halaman web. Jika kamu langsung menyalin logika perhitungan yang berantakan itu ke fungsi baru, kamu hanya akan menciptakan masalah baru. Setiap kali ada perubahan aturan tarif, kamu terpaksa mengubah dua tempat sekaligus, yang tentu saja sangat tidak efisien.

Disiplin Dua Topi dan Pentingnya Pengujian Otomatis

Salah satu kesalahan umum yang sering dilakukan pengembang adalah mencoba melakukan dua hal berbeda dalam satu waktu. Untuk menghindari hal ini, Fowler memperkenalkan konsep dua topi (two hats) yang diadaptasi dari pemikiran Kent Beck.

• Topi Pertama (Menambah Fitur): Fokusmu hanya pada menambah kemampuan baru ke dalam sistem. Di tahap ini, kamu hanya peduli agar fitur tersebut bekerja dan lolos pengujian.
• Topi Kedua (Refactoring): Fokusmu berubah total menjadi menyusun ulang struktur kode tanpa mengubah hasil kerjanya sedikit pun.

Jangan pernah mencoba memakai kedua topi ini sekaligus. Jika kamu sedang merapikan nama variabel lalu tiba-tiba tergoda untuk menambahkan logika validasi baru, berhentilah. Jika program tiba-tiba error, kamu akan bingung apakah masalahnya berasal dari kesalahan saat merapikan atau dari logika fitur baru yang kamu masukkan.

Agar proses berganti topi ini aman, kamu wajib memiliki pengujian otomatis sebagai jaring pengaman. Refactoring yang benar memiliki ritme kerja yang disiplin: lakukan tes, buat perubahan kecil, lalu jalankan tes lagi. Pola ini harus terus berulang.

Dengan adanya kumpulan pengujian atau test suite yang lengkap, kamu bisa bekerja dengan lebih tenang. Setiap kali kamu memindahkan satu potongan rumus ke metode baru, kamu langsung menjalankan tes. Jika lampu pengujian tetap hijau, kamu aman untuk melangkah ke baris berikutnya. Jika mendadak gagal, kamu cukup membatalkan satu langkah kecil terakhir yang baru saja kamu lakukan.

Mendeteksi dan Mengatasi Bau Kode

Dalam dunia pemrograman, ada istilah yang disebut code smells atau bau kode. Ini bukan berarti programmu mati atau error, melainkan tanda-tanda di permukaan bahwa struktur program sedang bermasalah dan butuh perbaikan. Mengenali bau ini membantu kamu tahu kapan harus mulai bergerak.

Beberapa contoh bau kode yang sering ditemui antara lain:

• Duplikasi Kode: Logika yang sama disalin ke dua tempat berbeda. Ini berbahaya karena jika aturan berubah, kamu harus memperbarui keduanya.
• Metode Panjang (Long Method): Baris perintah yang terlalu banyak dalam satu kelompok membuat alur kerja sulit dipahami.
• Kecemburuan Fitur (Feature Envy): Sebuah fungsi tampak lebih sering memakai data milik objek lain daripada datanya sendiri.
• Obsesi Primitif (Primitive Obsession): Terus menggunakan teks atau angka biasa untuk konsep yang seharusnya memiliki objek mandiri, seperti mata uang.

Agar tidak terjebak dalam proses pembersihan yang tanpa ujung, kamu bisa menggunakan Aturan Tiga (Rule of Three). Saat kamu membuat sesuatu untuk pertama kalinya, selesaikan saja. Saat kedua kalinya, kamu mungkin merasa sedikit terganggu, tapi teruskan saja. Namun, ketika kamu menulis logika yang sama untuk ketiga kalinya, saat itulah kamu harus berhenti dan mulai merapikannya.

Salah satu teknik dasar untuk mengatasi masalah ini adalah Extract Method. Teknik ini bekerja dengan mengambil bagian perhitungan atau logika yang rumit dari fungsi utama, lalu mengubahnya menjadi fungsi tersendiri dengan nama yang jelas. Dengan begitu, kode yang tadinya menumpuk kini terbagi menjadi bagian-bagian yang mandiri.

Menata Ulang Struktur Data dan Logika

Setelah mengenali masalahnya, kamu bisa mulai menata ulang tanggung jawab di dalam kode. Dalam pemrograman berorientasi objek, data dan fungsi yang mengolah data tersebut seharusnya berada di tempat yang sama. Jika sebuah fungsi terlalu sibuk mengambil data milik objek lain, gunakan teknik Move Method untuk memindahkan fungsi tersebut ke kelas yang memiliki data paling banyak.

Selain itu, hindari membuat kelas yang "terlalu gemuk". Kelas yang terlalu gemuk adalah kelas yang mengurus terlalu banyak hal, mulai dari profil pengguna hingga format nomor telepon. Kamu bisa menggunakan teknik Extract Class untuk memisahkan tanggung jawab tersebut ke dalam kelas-kelas baru yang lebih ramping dan modular.

Untuk bagian logika, kamu juga bisa melakukan perapian pada percabangan yang rumit. Jika kamu menemui percabangan bersarang yang menjorok terlalu dalam, gunakan Guard Clauses. Dengan Guard Clauses, jika ada kondisi khusus atau data tidak valid, kamu langsung mengeluarkan fungsi di baris atas. Ini membuat alur utama program tetap berjalan lurus dan mudah dibaca.

Terakhir, lindungilah datamu dengan teknik enkapsulasi. Jangan biarkan variabel diakses secara terbuka dari mana saja karena sangat mudah diubah tanpa pengawasan. Dengan membungkus variabel di balik fungsi pengambil dan penyimpan, kodemu akan menjadi lebih aman dan terprediksi.

Mengelola Utang Teknis secara Bertahap

Setiap kali kamu memilih untuk menulis solusi cepat yang berantakan demi mengejar tenggat waktu, kamu sebenarnya sedang menciptakan utang teknis (technical debt). Seperti utang uang, utang teknis ini harus dibayar di kemudian hari beserta "bunganya" berupa kesulitan pengembangan di masa depan.

Cara terbaik untuk melunasi utang ini bukanlah dengan menghentikan seluruh proyek selama berbulan-bulan untuk menulis ulang semuanya. Pendekatan perbaikan besar-besaran secara mendadak justru berisiko tinggi memunculkan kesalahan baru. Fowler menyarankan strategi untuk mengikis masalah sedikit demi sedikit dari pinggirannya.

Ketika kamu perlu menyentuh sebuah modul yang rumit untuk menambah fitur, perbaikilah satu bagian kecil di sekitarnya terlebih dahulu. Dengan menjaga ritme kerja yang disiplin dan melakukan perubahan kecil yang terukur, kamu bisa menjaga sistem tetap stabil sambil terus meningkatkan kualitas perangkat lunak secara bertahap.

Mulai Merawat Kode Anda Sekarang

Keahlian merapikan kode bukanlah bakat bawaan, melainkan keterampilan praktis yang bisa dipelajari siapa pun melalui latihan yang berulang. Semakin sering kamu berlatih, kepekaanmu dalam melihat kelemahan struktur program akan semakin tajam.

Kamu tidak perlu langsung menjadi ahli untuk mulai memberikan perubahan nyata. Kuncinya adalah kedisiplinan dalam memegang prinsip dasar: sadari topi mana yang sedang kamu pakai, gunakan pengujian otomatis, dan lakukan perubahan dalam skala kecil.

Cobalah satu langkah kecil hari ini. Buka proyek kerjamu, pilih satu fungsi yang paling panjang atau paling sulit dipahami, pastikan fungsi itu sudah memiliki pengujian otomatis, lalu pecah satu bagian kecilnya menjadi fungsi terpisah yang memiliki nama jelas. Dengan satu tindakan terukur, kamu sudah mulai membangun kebiasaan merawat perangkat lunak yang sehat.

Dapatkan panduan lengkap dan teknik mendalam lainnya dengan membaca ringkasan buku Refactoring: Improving the Design of Existing Code di BacaApps.

Baca ringkasan lengkapnya di BacaApps: Refactoring: Improving the Design of Existing Code karya Martin Fowler