Saya pernah menulis kode yang rasanya masuk akal saat itu. Logikanya jelas, alurnya rapi, nama variabelnya deskriptif. Tiga bulan kemudian saya buka lagi file yang sama, lalu mikir, “ini tadi mau ngapain sih?” Ya, ternyata saya sendiri juga bisa bingung sama kode buatan sendiri hehe.
Di proyek GPS tracker yang pernah saya tangani, satu function mengurus semuanya: baca database, ubah status dan posisi kendaraan, kirim notifikasi, lalu bikin laporan. Praktis? Awalnya mungkin. Setelah kodenya tumbuh, ya mulai terasa.
Mengenali “Spaghetti Code” #
Spaghetti code bukan istilah teknis formal. Istilah ini menggambarkan kode yang saling terikat dan sulit dipisahkan, seperti mie spaghetti yang sulit diambil sehelai tanpa menarik yang lain.
Kira-kira begini bentuk function-nya (pseudocode):
function handleUpdatePosition(request):
// Langsung query ke database
vehicle = db.query("SELECT * FROM vehicles WHERE id = ?", request.vehicleId)
if not vehicle:
return error("Vehicle not found")
// Business logic campur di sini
if vehicle.status == "inactive":
vehicle.status = "active"
vehicle.lastActivation = now()
// Update posisi
db.query("UPDATE positions SET lat = ?, lng = ?, time = ? WHERE vehicleId = ?",
request.lat, request.lng, now(), request.vehicleId)
// Kirim notifikasi langsung dari sini
if vehicle.hasAlert:
email.send(vehicle.ownerEmail, "Alert: " + vehicle.name)
sms.send(vehicle.ownerPhone, "Alert from " + vehicle.name)
// Generate laporan langsung
report = generateDailyReport(vehicle)
db.query("INSERT INTO reports ...", report)
return success(vehicle)
Bisa dilihat? Satu function nangkap semua, baca database, olah logika bisnis, kirim email, kirim SMS, generate laporan. Saat itu kelihatannya praktis. Tapi coba bayangkan:
- Kalau mau ganti cara kirim notifikasi: harus edit function ini
- Kalau mau test logika bisnis: harus setup database dan email server
- Kalau mau ganti database: harus ubah semua query yang tersebar di mana-mana
- Kalau ada bug di laporan: harus trace lewat function yang sudah panjang ini
┌─────────────────────────────────────────────────┐
│ Spaghetti Flow │
│ │
│ Request ──► [Database + Logic + Email + Report] │
│ │ │
│ ▼ │
│ Semua menyatu. │
│ Ubah satu, risiko semua goyah. │
└─────────────────────────────────────────────────┘
Clean Architecture, Versi Ringkasnya #
Robert C. Martin (Uncle Bob) memopulerkan istilah “Clean Architecture”. Kalau diringkas, idenya begini: logika bisnis jangan bergantung pada detail teknis seperti database, framework, atau API. Biar kedengarannya tidak lebih rumit dari yang perlu.
Logika bisnis biasanya lebih stabil daripada detail teknis. Contohnya aturan menghitung jarak, menentukan kendaraan aktif, dan menetapkan batas kecepatan. Database, framework, dan cara mengirim email adalah detail yang bisa berubah.
Aturan Ketergantungan (Dependency Rule) #
┌──────────────────────────────────────────────────────┐
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ Entity │ │
│ │ Aturan bisnis inti. Paling dalam. │ │
│ │ Tidak tergantung apapun. │ │
│ │ │ │
│ │ ┌──────────────────────────────────────┐ │ │
│ │ │ Use Case │ │ │
│ │ │ Apa yang sistem lakukan. │ │ │
│ │ │ Tergantung ke Entity, bukan ke DB. │ │ │
│ │ │ │ │ │
│ │ │ ┌───────────────────────────────┐ │ │ │
│ │ │ │ Infrastructure │ │ │ │
│ │ │ │ Database, API, Email, SMS. │ │ │ │
│ │ │ │ Detail teknis. Paling luar. │ │ │ │
│ │ │ └───────────────────────────────┘ │ │ │
│ │ └──────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────┘ │
│ │
│ Arah panah: luar ──► dalam │
│ Luar tergantung pada dalam. Dalam TIDAK tergantung │
│ pada luar. │
└──────────────────────────────────────────────────────┘
Panah hanya boleh mengarah ke dalam. Entity tidak tahu tentang database, dan Use Case tidak tahu cara mengirim email. Infrastructure menangani detail teknis.
Kalau kontrak repository tetap sama, mengganti MySQL dengan PostgreSQL tidak mengharuskan perubahan pada Entity atau Use Case. Implementasi di Infrastructure yang berubah.
Tiga Layer yang Penting #
Nah, biasanya pembagian tanggung jawabnya dijelaskan lewat tiga layer ini:
1. Entity, Aturan Bisnis Inti
Ini berisi aturan bisnis inti yang tidak bergantung pada teknologi tertentu. Di proyek GPS tracker, contohnya:
class Vehicle:
id, name, status, currentSpeed, speedLimit
function isSpeeding():
return currentSpeed > speedLimit
function activate():
if status == "inactive":
status = "active"
lastActivation = now()
Di sini tidak ada database query, HTTP request, atau framework. Isinya aturan bisnis: apakah kendaraan speeding dan bagaimana mengaktifkannya.
2. Use Case, Apa yang Sistem Lakukan
Use case mendefinisikan apa yang dilakukan sistem, tanpa peduli bagaimana detailnya.
class UpdatePositionUseCase:
function execute(vehicleId, lat, lng):
// 1. Cari kendaraan
vehicle = vehicleRepository.findById(vehicleId)
if not vehicle:
return error("Vehicle not found")
// 2. Update posisi
vehicle.updatePosition(lat, lng)
// 3. Simpan
vehicleRepository.save(vehicle)
// 4. Kalau speeding, trigger alert
if vehicle.isSpeeding():
alertService.sendSpeedAlert(vehicle)
Use case memanggil vehicleRepository dan alertService, tetapi tidak tahu apakah implementasinya memakai MySQL atau PostgreSQL, atau mengirim alert lewat email atau SMS. Yang diketahuinya hanya “cari kendaraan”, “simpan”, dan “kirim alert”.
Selama kontrak repository tidak berubah, database dapat diganti tanpa mengubah use case.
3. Infrastructure, Detail Teknis
Di sinilah detail implementasi berada: database, API, framework, dan email service.
class MySQLVehicleRepository:
function findById(id):
row = db.query("SELECT * FROM vehicles WHERE id = ?", id)
return Vehicle(id: row.id, name: row.name, ...)
function save(vehicle):
db.query("UPDATE vehicles SET lat = ?, lng = ? WHERE id = ?",
vehicle.lat, vehicle.lng, vehicle.id)
class EmailAlertService:
function sendSpeedAlert(vehicle):
email.send(
to: vehicle.ownerEmail,
subject: "Speed Alert: " + vehicle.name,
body: vehicle.name + " is going " + vehicle.currentSpeed
)
Ini bagian yang boleh berubah. Kalau mau ganti MySQL ke PostgreSQL, ubah di sini. Kalau mau ganti email ke WhatsApp, ubah di sini. Entity dan Use Case tidak tersentuh.
Coba Terapkan ke Contoh GPS Tracker #
Berikut versi “clean” dari kode spaghetti di awal:
Before: Spaghetti #
Satu function menangani semuanya: membaca database, menjalankan logika, mengirim notifikasi, dan membuat laporan.
After: Clean #
// === Entity: Vehicle ===
// (aturan bisnis murni, tidak tergantung apapun)
class Vehicle:
function updatePosition(lat, lng):
this.lat = lat
this.lng = lng
this.lastUpdate = now()
function isSpeeding():
return this.currentSpeed > this.speedLimit
// === Use Case: UpdatePosition ===
// (apa yang dilakukan, tanpa peduli bagaimana)
class UpdatePositionUseCase:
function execute(vehicleId, lat, lng):
vehicle = repository.findById(vehicleId)
if not vehicle:
return error("Not found")
vehicle.updatePosition(lat, lng)
repository.save(vehicle)
if vehicle.isSpeeding():
alertService.sendSpeedAlert(vehicle)
return success(vehicle)
// === Infrastructure ===
// (detail teknis, boleh berubah kapanpun)
class MySQLVehicleRepository:
function findById(id):
return db.query("SELECT ...")
function save(vehicle):
db.query("UPDATE ...")
class EmailAlertService:
function sendSpeedAlert(vehicle):
email.send(...)
Apa yang Berubah? #
| Aspek | Spaghetti | Clean |
|---|---|---|
| Test logika bisnis | Perlu setup DB + email | Cuma test Vehicle class |
| Ganti database | Ubah semua query di mana-mana | Ubah cuma repository |
| Ganti cara alert | Cari di seluruh codebase | Ubah cuma AlertService |
| Onboarding developer baru | Baca satu function panjang | Baca per layer, mulai dari Entity |
| Efek samping perubahan | Domino effect | Terisolasi per layer |
Setiap layer bisa diuji sendiri: Vehicle tanpa database, UpdatePositionUseCase dengan mock repository, dan MySQLVehicleRepository secara terpisah.
Kalau Proyeknya Kecil Gimana? #
Mungkin kamu sedang berpikir, “Ini kan buat proyek gede. Skripsi saya cuma aplikasi kecil.” Bisa jadi. Untuk aplikasi kecil, Clean Architecture memang gampang jadi overkill. Tapi memisahkan logika bisnis dari urusan teknis tetap ada gunanya, apalagi kalau nanti kodenya perlu dites atau detail implementasinya berubah.
Saat menjelaskan rancangan skripsi, dosen mungkin bertanya “kenapa kamu design sistem seperti ini?” Jawaban “karena logika bisnis saya tidak tergantung pada database” lebih jelas daripada “karena tutorial yang saya ikuti seperti itu”.
Kapan Tidak Perlu Repot-repot #
Clean Architecture bukan silver bullet. Ada saatnya tidak perlu:
- Prototype: kalau kamu cuma mau proof of concept, tulis saja cepat. Jangan overthink.
- Script kecil: kalau cuma 50 baris untuk scrape data, tidak perlu layer-layeran.
- Belajar dasar dulu: kalau belum nyaman dengan OOP atau design pattern, pelajari itu dulu. Clean Architecture butuh fondasi tersebut.
Jadi, pakai kalau kompleksitas proyeknya memang sudah minta begitu. Jangan cuma karena namanya kedengaran keren, nanti keburu sibuk bikin layer sebelum masalahnya ada hehe.
Yang Saya Catat #
Spaghetti code bisa kejadian #
Spaghetti code bisa muncul ketika kode terus tumbuh tanpa pembagian tanggung jawab yang jelas. Tidak perlu langsung panik atau menghakimi kode lama. Mulai saja dengan mencari bagian mana yang saling menempel.
Bedakan “apa” dan “bagaimana” #
Logika bisnis menjawab apa yang sistem lakukan. Database, API, dan framework adalah cara teknis untuk menjalankannya. Buat saya, pemisahan itu inti idenya.
Kalau susah dites, cek lagi pembagiannya #
Kesulitan menulis unit test bisa jadi tanda pembagian tanggung jawabnya perlu dilihat lagi. Di contoh ini, Entity dan Use Case bisa dites tanpa menghubungi database atau layanan email.
Ini alat, bukan aturan wajib #
Clean Architecture itu tool, bukan agama (saya ulang biar tidak ada yang bikin layer demi layer). Pahami idenya, lalu pakai kalau memang cocok dengan proyeknya.
Nah, Terus Gimana? #
Jadi, yang penting bukan banyaknya layer atau pattern yang fancy. Tujuannya supaya tanggung jawab tidak campur aduk, dan supaya beberapa bulan lagi kita masih bisa paham kode sendiri. Saya sendiri pernah gagal di bagian terakhir itu hehe.
Kalau penasaran seperti apa penerapannya di proyek nyata, termasuk migrasi PHP ke Go dengan 370+ endpoint, saya pernah menulis catatan terpisah.
Kalau ingin membahas penerapannya atau mencari bantuan, hubungi saya atau lihat layanan yang saya tawarkan.
Tag: catatan · arsitektur