Belajar Software Architecture and Design Patterns - Anti-Patterns & Refactoring Legacy Codebase

#Pendahuluan

Series ini mengajarkan pola yang baik; episode ini mengajarkan mengenali kebalikannya — karena di dunia nyata, tugas paling umum seorang senior engineer bukan membangun dari nol, melainkan menyelamatkan codebase yang sudah berjalan. Membongkar sistem hidup itu seni tersendiri dengan alatnya sendiri.

#Anti-Pattern

#Katalog Lengkap

#Strategi Refactoring

#Strangler Fig

Pola Martin Fowler untuk migrasi bertahap ala pohon beringin: kode baru tumbuh membungkus sistem lama sampai lama mati sendiri.

Langkah demi langkah: rute baru diarahkan ke implementasi baru; fitur dipindah per kapabilitas; sistem lama menyusut hingga bisa dihapus — tanpa big-bang rewrite yang berisiko mati total.

#Seams & Characterization Test

Sebelum menyentuh kode legacy tanpa test, bangun pagarnya:

1. Characterization test (Michael Feathers): test yang MENGGAMBAR perilaku eksisting apa adanya — termasuk bug-nya. Bukan "seharusnya seperti ini", tapi "memang beginilah kini".
2. Seam: titik tempat perilaku bisa ditukar tanpa edit kode (interface injection, fungsi variabel).

1. Tulis characterization test pada unit yang akan disentuh
   (capture output nyata -> jadikan assertion)
2. Jalankan -> hijau = pagar terpasang
3. Refactor KECIL satu langkah -> jalankan pagar -> tetap hijau?
4. Commit. Ulangi. Perubahan besar = banyak langkah kecil hijau.
5. Setelah struktur benar, PERBAIKI assertion yang membekukan bug
   (ubah perilaku secara EKSPLISIT + catat di changelog)

#Real-World Implementasi

Tiga skenario legacy dari outline:

// SEBELUM: OrderController@store 180 baris (validasi+SQL+Midtrans+PDF)
// LANGKAH STRANGLER:
final class PlaceOrderAction {          // logika pindah utuh
    public function __construct(private OrderRepository $orders,
                                private PaymentGateway $payments) {}
    public function execute(CheckoutData $d): Order { /* ... */ }
}
// controller kini 4 baris; SQL masih via Eloquent DI DALAM repo impl.

// SEBELUM: AppModule menyediakan SEMUA provider (users+orders+billing)
// SESUDAH: OrdersModule/UsersModule/BillingModule dengan exports eksplisit
@Module({ imports: [UsersModule], // orders butuh UsersPublicAPI saja
          controllers: [OrdersController],
          providers: [CheckoutService] })
export class OrdersModule {}

// SEBELUM: main.go 600 baris (routing+SQL+logika)
// SESUDAH bertahap:
// 1. characterization test httptest menangkap response endpoint utama
// 2. ekstrak func handleOrder -> handler package
// 3. ekstrak SQL -> repository interface + impl
// 4. main.go tinggal wiring (ep.11)

#Praktik

Target outline: refactor repo legacy mini bertahap dengan characterization test sebagai pagar.

Buat sengaja (atau ambil project lama): aplikasi order dengan
- 1 file/controller raksasa berisi validasi+SQL+diskon+email
- TIDAK ADA test sama sekali
Target akhir: struktur service-repository (ep.10) dengan pagar test.

# Langkah 0: characterization
curl -X POST localhost:8000/orders -H 'Content-Type: application/json' \
  -d @fixtures/order-valid.json > snapshot-before.json
# tulis test yang assert response == snapshot-before.json (perilaku eksisting)
 
# Langkah 1: ekstrak validasi ke DTO/FormRequest -> test hijau? commit
# Langkah 2: ekstrak perhitungan diskon ke PricingService -> hijau? commit
# Langkah 3: ekstrak SQL ke OrderRepository (interface!) -> hijau? commit
# Langkah 4: email -> event listener async -> hijau? commit
# Langkah 5: arch/lint gate agar tidak balik ke kebiasaan lama
 
# Bukti keberhasilan:
git diff main --stat   # banyak file kecil, bukan satu rewrites raksasa
git log --oneline      # riwayat langkah hijau bisa direvert per langkah

#Penutup

Rangkuman episode ini:

• Delapan anti-pattern dengan gejala & obat yang sudah kalian kuasai sepanjang series.
• Strangler fig mengganti sistem hidup bertahap; characterization test + seam membuat refactor legacy aman.
• Praktik membuktikannya: monolit liar menjadi layered dengan lima commit kecil semuanya hijau.

Episode 25 adalah puncak series: Capstone — satu domain order management dibangun bertahap dari layered sampai hexagonal+DDD+CQRS+outbox di ketiga framework, lengkap dengan Docker compose dan perbandingan DX/perf. Sampai jumpa!