Belajar Software Architecture and Design Patterns - Pengenalan Arsitektur Software & Design Patterns

#Pendahuluan

Sebelum menyentuh satu pattern pun, kalian butuh peta besar: apa bedanya arsitektur, design pattern, dan prinsip? Banyak developer menghabiskan bertahun-tahun menggunakan ketiga istilah ini bergantian — padahal mereka beroperasi di level abstraksi yang berbeda dan menjawab masalah yang berbeda.

Episode ini membangun kosakata dan cara pandang yang akan dipakai konsisten selama 27 episode ke depan.

#Konsep

#Architecture vs Design Pattern

Arsitektur adalah struktur makro sistem: bagaimana komponen-komponen besar dibagi, siapa boleh bicara dengan siapa, dan di mana batas-batasnya. Contoh: "sistem kita layered, modul orders tidak boleh query tabel billing langsung."

Design pattern adalah solusi mikro untuk masalah yang berulang: bagaimana mengorganisir class/fungsi dalam skala lokal. Contoh: "pembuatan koneksi DB pakai Factory Method; akses data pakai Repository."

Analogi bangunan: arsitektur = denah & struktur gedung; design pattern = cara merakit jendela/pintu standar; prinsip = building code.

#Coupling & Cohesion Menentukan Umur Kode

Dua metrik kualitas yang muncul terus-menerus:

• Coupling (kopling) — seberapa banyak satu module harus tahu tentang internal module lain. Coupling tinggi = mengubah A memecah B.
• Cohesion (kohesi) — seberapa relevan isi sebuah module satu sama lain. Cohesion rendah = "modul util" tempat sampah semua orang.

Kode awet = low coupling + high cohesion. Hampir semua pattern dan arsitektur di series ini pada dasarnya adalah alat mencapai dua hal itu.

#Technical Debt

Istilah Ward Cunningham untuk biaya akumulasi shortcut: kode cepat-jadi hari ini = bunga yang dibayar setiap kali fitur baru disentuh. Tanda debt menumpuk:

1. Estimasi fitur "kecil" selalu meledak (sentuh satu, rusak lima)
2. Takut refactor karena tidak ada test yang bisa dipercaya
3. File/class dengan ratusan baris dan banyak if-branch domain
4. Logika bisnis tersebar di controller, view, dan job tanpa rumah tetap

Kenapa arsitektur menentukan umur kode? Karena debt tumbuh di sambungan antar komponen. Arsitektur yang baik membuat perubahan lokal tetap lokal.

#Klasifikasi

#Tiga Lapis Kosakata Series Ini

Perhatikan hubungan sebab-akibat: prinsip (SOLID) melahirkan motif; pattern (GoF) adalah resep konkret; arsitektur mengatur bagaimana resep-resep itu hidup bersama dalam sistem besar. Episode 3–4 membahas SOLID, 5–7 katalog GoF, lalu 8–14 fondasi layering sebelum naik ke arsitektur advanced.

#Praktik

Target outline: bedah satu codebase nyata — identifikasi coupling buruk & titik refactor.

Ambil project CRUD lab dari episode 0 (atau codebase kerja kalian), lalu jalankan audit berikut:

// orders.service.ts - 340 baris, gejala coupling buruk:
@Injectable()
export class OrdersService {
  constructor(
    private http: HttpService,
    private mailer: MailerService,
    private prisma: PrismaService, // query SQL mentah di service
  ) {}
 
  async create(dto: CreateOrderDto) {
    // validasi bisnis + hitung total + panggil payment API
    // + tulis DB + kirim email + update statistik - SEMUA DI SINI
  }
}
// Temuan: 6 tanggung jawab (SRP langgar), detail infrastruktur
// (http/mailer/sql) bocor ke logika bisnis (DIP langgar).

# Audit ep01 - [nama project]
| Lokasi                  | Gejala                    | Titik Refactor            |
|-------------------------|---------------------------|---------------------------|
| orders.service.create() | 6 tanggung jawab          | pecah service + repository|
| OrderController         | validasi + logika bisnis  | pindah validasi ke DTO    |
| utils/helpers.ts        | kohesi rendah, grab-bag   | pecah per domain          |
# Simpan file ini - episode 13-15 akan memakainya sebagai baseline.

Latihannya sederhana namun membentuk mata arsitek: temukan minimal tiga lokasi dengan coupling buruk, tulis kenapa ia buruk, dan tebak pattern/layer mana yang akan memperbaikinya. Jawaban resminya akan kalian dapatkan sepanjang series.

#Penutup

Rangkuman episode ini:

• Arsitektur = struktur makro; design pattern = solusi mikro; prinsip = kompas nilainya.
• Low coupling + high cohesion adalah tujuan universal; technical debt tumbuh di sambungan antar komponen.
• Audit codebase melatih mata: gejala favorit adalah god-class, fat controller, dan folder grab-bag.

Episode 2 menggali fondasi OOP yang menjadi bahasa semua pattern: empat pilar OOP di tiga bahasa, dan kenapa pattern modern memilih komposisi daripada inheritance. Sampai jumpa!