- Apa itu Arsitektur Software?
- Prinsip Clean Code
- Struktur Arsitektur Berlapis
- Pola Arsitektur: Monolith hingga Microservices
- Design Pattern
- Desain Sistem & Arsitektur yang Skalabel
- Praktik Terbaik Rekayasa Perangkat Lunak
- Siapa itu Software Architect?
- Bagaimana Sebuah Sistem Dirancang?
- Perjalanan Rekayasa Perangkat Lunak (1968βSekarang)
- Referensi Klasik yang Masih Relevan
1. APA ITU ARSITEKTUR SOFTWARE?
- Arsitektur software adalah struktur besar sebuah sistem: bagian apa saja yang ada, apa tugas masing-masing, dan bagaimana bagian-bagian itu saling berkomunikasi.
- Martin Fowler menyederhanakannya sebagai "keputusan penting yang sulit diubah di kemudian hari", misalnya pilihan monolith atau microservices, jenis database, dan cara antar layanan berkomunikasi.
- Arsitektur yang baik membuat software mudah dipahami, mudah diubah, mudah diuji, dan sanggup melayani pengguna yang terus bertambah.
- Arsitektur yang buruk membuat setiap perubahan kecil terasa berisiko, bug terus muncul, dan tim semakin lambat bekerja.
- Pembahasan arsitektur software memiliki dua tingkat utama:
- Tingkat Besar (Macro) β desain sistem, pola arsitektur, microservices, dan skalabilitas
- Tingkat Kecil (Micro) β clean code, prinsip SOLID, dan design pattern di dalam kode
2. PRINSIP CLEAN CODE
- Clean code adalah kode yang mudah dibaca, dipahami, dan diubah oleh orang lain, termasuk oleh dirimu sendiri enam bulan kemudian.
- Istilah ini dipopulerkan oleh Robert C. Martin (Uncle Bob) melalui buku Clean Code (2008), tetapi banyak prinsipnya sudah dikenal sejak 1970-an.
- Kode jauh lebih sering dibaca daripada ditulis, sehingga kejelasan lebih penting daripada kode yang terlihat "pintar".
- Prinsip yang paling penting dipahami adalah:
- Aturan Dasar Clean Code
- SOLID
- DRY, KISS, dan YAGNI
ATURAN DASAR - PRINSIP CLEAN CODE
- Nama yang jelas: variabel, fungsi, dan class harus menjelaskan maksudnya, misalnya
totalHarga, bukanxataudata2. - Fungsi kecil dan fokus: satu fungsi mengerjakan satu hal saja.
- Hindari duplikasi: logika yang sama cukup ditulis di satu tempat.
- Komentar menjelaskan "mengapa", bukan "apa". Jika kode butuh banyak komentar untuk dipahami, biasanya kodenya yang perlu diperbaiki.
- Boy Scout Rule: tinggalkan kode sedikit lebih bersih daripada saat kamu menemukannya.
Kode:
// Kurang jelas
function hitung(a, b, c) {
return a * b - (a * b * c / 100);
}
// Lebih bersih: nama menjelaskan maksud
function hitungTotalSetelahDiskon(harga, jumlah, persenDiskon) {
const subtotal = harga * jumlah;
const potongan = subtotal * persenDiskon / 100;
return subtotal - potongan;
}
SOLID - PRINSIP CLEAN CODE (LANJUTAN)
- Dirangkum oleh Robert C. Martin sekitar tahun 2000, sedangkan singkatan SOLID diberikan oleh Michael Feathers.
- S β Single Responsibility: satu class hanya punya satu alasan untuk berubah.
- O β Open/Closed: kode terbuka untuk ditambah, tetapi tertutup untuk diubah. Fitur baru ditambahkan tanpa membongkar kode lama.
- L β Liskov Substitution (Barbara Liskov, 1987): class turunan harus bisa menggantikan class induknya tanpa merusak program.
- I β Interface Segregation: lebih baik banyak interface kecil yang spesifik daripada satu interface besar.
- D β Dependency Inversion: kode bergantung pada abstraksi (interface), bukan pada implementasi langsung seperti database tertentu.
DRY, KISS, YAGNI - PRINSIP CLEAN CODE (LANJUTAN)
- DRY (Don't Repeat Yourself): dari buku The Pragmatic Programmer (1999). Setiap pengetahuan cukup punya satu sumber di dalam sistem.
- KISS (Keep It Simple, Stupid): prinsip teknik dari tahun 1960-an. Solusi sederhana lebih mudah dirawat daripada solusi rumit.
- YAGNI (You Aren't Gonna Need It): dari Extreme Programming (akhir 1990-an). Jangan membuat fitur "untuk jaga-jaga" yang belum dibutuhkan.
- Donald Knuth (1974) mengingatkan: "Premature optimization is the root of all evil". Buat kode yang benar dan jelas dulu, optimasi bagian yang terbukti lambat.
3. STRUKTUR ARSITEKTUR BERLAPIS
Kode:
ββ Presentation (UI / Controller / API) ββββββββββββββββ
β menerima input dan menampilkan output
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β memanggil
βΌ
ββ Application (Use Case / Service) ββββββββββββββββββββ
β alur proses: "buat pesanan", "batalkan pesanan"
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β memakai
βΌ
ββ Domain (Entity & Aturan Bisnis) βββββββββββββββββββββ
β inti sistem: Pesanan, Produk, aturan diskon
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β² mengimplementasikan interface milik domain
β
ββ Infrastructure (Database / API Luar / File) βββββββββ
β MySQL, Redis, payment gateway, layanan email
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
Aturan dependensi: lapisan luar bergantung ke dalam.
Domain tidak boleh bergantung pada framework atau database.
Pola berlapis ini memiliki beberapa variasi yang masih dipakai hingga sekarang: MVC (Trygve Reenskaug, 1979), Hexagonal Architecture (Alistair ****burn, 2005), Onion Architecture (Jeffrey Palermo, 2008), dan Clean Architecture (Robert C. Martin, 2012). Intinya sama: aturan bisnis dipisahkan dari detail teknis, sehingga database atau framework bisa diganti tanpa menulis ulang inti sistem.
4. POLA ARSITEKTUR: MONOLITH HINGGA MICROSERVICES
- Pola arsitektur menentukan bagaimana sistem dipecah dan di-deploy.
- Tidak ada pola yang paling benar untuk semua kasus. Pilihan tergantung ukuran tim, kompleksitas bisnis, dan kebutuhan skala.
- Pola arsitektur yang umum digunakan adalah:
- Monolith & Modular Monolith
- Microservices
- Event-Driven Architecture
MONOLITH & MODULAR MONOLITH - POLA ARSITEKTUR
- Monolith adalah satu aplikasi utuh yang di-deploy sekaligus, dengan satu codebase dan biasanya satu database.
- Kelebihannya sederhana dibuat, mudah diuji, dan mudah di-deploy. Sangat cocok untuk project baru dan tim kecil.
- Kekurangannya, jika tidak dijaga, monolith bisa berubah menjadi "Big Ball of Mud" (istilah Foote & Yoder, 1997): semua bagian saling terkait dan sulit diubah.
- Modular Monolith adalah jalan tengah: tetap satu aplikasi, tetapi dibagi ke modul-modul dengan batas yang tegas (misalnya modul Pesanan, Pembayaran, Pengiriman). Shopify adalah contoh perusahaan besar yang memakai pendekatan ini.
MICROSERVICES - POLA ARSITEKTUR (LANJUTAN)
- Istilah microservices dipopulerkan oleh James Lewis dan Martin Fowler pada tahun 2014, setelah perusahaan seperti Amazon dan Netflix memecah sistem besarnya menjadi banyak layanan kecil.
- Setiap layanan berdiri sendiri, memiliki database sendiri, dan berkomunikasi lewat API (REST/gRPC) atau pesan (message queue).
- Kelebihannya, setiap tim bisa mengembangkan, men-deploy, dan menambah kapasitas layanannya sendiri secara mandiri.
- Kekurangannya, sistem menjadi terdistribusi: butuh monitoring, penanganan kegagalan jaringan, dan infrastruktur yang jauh lebih rumit.
- Kesalahan umum adalah "distributed monolith": layanan sudah dipisah, tetapi masih saling bergantung dan harus di-deploy bersamaan.
- Pelajaran penting: pada tahun 2023, tim Amazon Prime Video memindahkan salah satu layanan monitoring dari microservices kembali ke monolith dan memangkas biaya infrastrukturnya hingga 90%. Microservices adalah alat, bukan tujuan.
- Conway's Law (Melvin Conway, 1968): struktur sistem cenderung mengikuti struktur komunikasi tim yang membuatnya. Karena itu, microservices biasanya cocok untuk organisasi dengan banyak tim.
EVENT-DRIVEN ARCHITECTURE - POLA ARSITEKTUR (LANJUTAN)
- Layanan tidak saling memanggil secara langsung, tetapi mengirim event (kejadian), misalnya "PesananDibuat".
- Layanan lain yang berkepentingan (stok, email, notifikasi) mendengarkan event tersebut dan bereaksi sendiri-sendiri.
- Memakai message broker seperti RabbitMQ (2007) atau Apache Kafka (dirilis open source oleh LinkedIn pada 2011).
- Membuat layanan tidak saling terikat (loosely coupled), tetapi alur proses menjadi lebih sulit dilacak.
| Aspek | Monolith | Modular Monolith | Microservices |
|---|---|---|---|
| Deploy | Satu kesatuan | Satu kesatuan | Per layanan |
| Kompleksitas awal | Rendah | Sedang | Tinggi |
| Skala per bagian | Tidak bisa | Terbatas | Bisa |
| Cocok untuk | Project baru, tim kecil | Produk berkembang, tim menengah | Organisasi besar, banyak tim |
5. DESIGN PATTERN
- Design pattern adalah solusi umum yang sudah teruji untuk masalah desain yang sering muncul dalam pemrograman.
- Dipopulerkan oleh buku Design Patterns (1994) karya Gamma, Helm, Johnson, dan Vlissides, yang dikenal sebagai Gang of Four (GoF). Buku ini memuat 23 pattern.
- Pattern bukan kode jadi untuk di-copy, melainkan "resep" yang disesuaikan dengan kebutuhan.
- Design pattern dibagi menjadi tiga kelompok:
- Creational β cara membuat objek
- Structural β cara menyusun objek
- Behavioral β cara objek berinteraksi
CREATIONAL PATTERN - DESIGN PATTERN
- Factory: membuat objek tanpa harus tahu class persisnya, misalnya membuat objek notifikasi email atau SMS sesuai pengaturan.
- Builder: menyusun objek yang rumit secara bertahap, misalnya membangun query atau laporan.
- Singleton: memastikan hanya ada satu objek, misalnya konfigurasi aplikasi. Gunakan dengan hati-hati karena membuat kode sulit diuji.
STRUCTURAL PATTERN - DESIGN PATTERN (LANJUTAN)
- Adapter: menjembatani dua interface yang berbeda, misalnya menyamakan cara memanggil beberapa payment gateway.
- Facade: menyediakan satu pintu sederhana untuk sistem yang rumit.
- Decorator: menambah kemampuan objek tanpa mengubah class aslinya, misalnya menambahkan logging atau caching.
BEHAVIORAL PATTERN - DESIGN PATTERN (LANJUTAN)
- Strategy: menukar algoritma dengan mudah, misalnya metode pembayaran atau cara menghitung ongkir.
- Observer: satu objek memberi tahu banyak objek lain saat terjadi perubahan. Ini adalah dasar sistem event dan notifikasi.
- Command: membungkus sebuah aksi menjadi objek, sehingga bisa diantrekan, dicatat, atau dibatalkan (undo).
Contoh Strategy Pattern (TypeScript). Metode pembayaran baru bisa ditambahkan tanpa mengubah fungsi checkout, sesuai prinsip Open/Closed:
Kode:
interface MetodePembayaran {
bayar(jumlah: number): void;
}
class BayarEwallet implements MetodePembayaran {
bayar(jumlah: number) { /* proses e-wallet */ }
}
class BayarTransferBank implements MetodePembayaran {
bayar(jumlah: number) { /* proses transfer bank */ }
}
function checkout(total: number, metode: MetodePembayaran) {
metode.bayar(total);
}
6. DESAIN SISTEM & ARSITEKTUR YANG SKALABEL
- Desain sistem (system design) adalah proses merancang komponen besar sebuah sistem agar memenuhi kebutuhan fungsional (fitur) dan non-fungsional (kecepatan, ketersediaan, keamanan).
- Arsitektur yang skalabel tetap stabil walaupun pengguna naik dari ratusan menjadi jutaan.
- Komponen yang umum dipakai adalah:
- Skalabilitas Horizontal & Stateless
- Ketahanan (Resilience)
- Observability
Kode:
[ Pengguna ]
β
βΌ
[ CDN ] β file statis: gambar, CSS, JS
β
βΌ
[ Load Balancer ] β membagi request ke banyak server
β
βββ [ Server App 1 ]
βββ [ Server App 2 ] (stateless, mudah ditambah)
βββ [ Server App N ]
β
βββ [ Cache: Redis ] β data yang sering dibaca
βββ [ Database Primary ] β menulis data
β βββ [ Replica ] β membaca data
βββ [ Message Queue ] β antrean tugas berat
βββ [ Worker ] β email, laporan, video
SKALABILITAS HORIZONTAL & STATELESS - DESAIN SISTEM
- Vertical scaling menambah CPU/RAM pada satu server. Mudah, tetapi ada batasnya.
- Horizontal scaling menambah jumlah server di belakang load balancer. Inilah cara sistem besar melayani jutaan pengguna.
- Syaratnya, server harus stateless: tidak menyimpan data sesi di memorinya sendiri. Data sesi disimpan di Redis atau database agar request bisa dilayani server mana pun.
- Tugas berat (email, laporan PDF, video) dimasukkan ke message queue dan diproses worker di belakang layar, sehingga pengguna tetap mendapat respons cepat.
- Panduan The Twelve-Factor App (Heroku, 2011) merangkum aturan membangun aplikasi yang siap di-scale di cloud, dan masih dijadikan acuan sampai sekarang.
KETAHANAN (RESILIENCE) - DESAIN SISTEM (LANJUTAN)
- Pada sistem terdistribusi, kegagalan pasti terjadi. Yang penting adalah sistem tetap berjalan walaupun sebagian komponennya bermasalah.
- Timeout: jangan menunggu layanan lain tanpa batas waktu.
- Retry dengan backoff: ulangi request yang gagal dengan jeda yang makin panjang.
- Circuit Breaker (dipopulerkan Michael Nygard dalam buku Release It!, 2007): hentikan sementara panggilan ke layanan yang sedang rusak agar kegagalan tidak menjalar.
- Idempotency: request yang terkirim dua kali (misalnya pembayaran) tidak boleh diproses dua kali.
OBSERVABILITY - DESAIN SISTEM (LANJUTAN)
- Observability adalah kemampuan untuk mengetahui apa yang terjadi di dalam sistem dari luar.
- Tiga pilar utamanya: Logs (catatan kejadian), Metrics (angka seperti jumlah request dan waktu respons), dan Traces (jejak satu request melewati banyak layanan).
- OpenTelemetry (2019) kini menjadi standar terbuka untuk mengumpulkan ketiganya.
7. PRAKTIK TERBAIK REKAYASA PERANGKAT LUNAK
- Version control dengan Git (Linus Torvalds, 2005): setiap perubahan tercatat, bisa ditelusuri, dan bisa dibatalkan.
- Code review: setiap perubahan diperiksa rekan setim sebelum digabungkan, untuk menangkap bug dan berbagi pengetahuan.
- Automated testing: ikuti Test Pyramid (Mike Cohn, 2009), yaitu banyak unit test, cukup integration test, dan sedikit end-to-end test. Test-Driven Development (Kent Beck, awal 2000-an) menulis test sebelum kodenya.
- Refactoring (Martin Fowler, 1999): memperbaiki struktur kode tanpa mengubah perilakunya, dilakukan sedikit demi sedikit secara rutin.
- CI/CD: setiap perubahan otomatis di-build, diuji, dan siap di-deploy. Dipopulerkan oleh buku Continuous Delivery (2010).
- Semantic Versioning: format versi MAJOR.MINOR.PATCH, misalnya 2.4.1, agar pengguna tahu apakah sebuah update aman.
- Architecture Decision Record (ADR) (Michael Nygard, 2011): catatan singkat tentang keputusan arsitektur dan alasannya, agar tim berikutnya paham konteksnya.
- Ukur performa tim dengan empat metrik DORA dari buku Accelerate (2018): frekuensi deploy, lead time perubahan, tingkat kegagalan perubahan, dan waktu pemulihan.
8. SIAPA ITU SOFTWARE ARCHITECT?
Seorang software architect adalah engineer berpengalaman yang bertanggung jawab atas keputusan struktur besar sebuah sistem dan memastikan keputusan itu sesuai dengan kebutuhan bisnis.
Software architect biasanya melakukan hal-hal berikut:
- Menerjemahkan kebutuhan bisnis menjadi rancangan teknis.
- Memilih pola arsitektur, teknologi, dan cara komunikasi antar komponen.
- Menimbang trade-off, misalnya kecepatan pengembangan dibanding fleksibilitas jangka panjang.
- Menetapkan standar kode, review, dan dokumentasi untuk tim.
- Mendokumentasikan keputusan dalam bentuk diagram dan ADR.
- Membimbing engineer lain dan tetap ikut menulis kode agar memahami kondisi nyata di lapangan.
9. BAGAIMANA SEBUAH SISTEM DIRANCANG?
Contoh: merancang sistem pemesanan tiket konser.
- Pahami kebutuhan: fitur apa saja (cari konser, pilih kursi, bayar) dan kebutuhan non-fungsional (kursi tidak boleh terjual dua kali, sistem tahan lonjakan saat penjualan dibuka).
- Perkirakan skala: berapa pengguna bersamaan, berapa transaksi per detik, berapa besar datanya.
- Buat desain tingkat tinggi: gambar komponen utama seperti aplikasi, API, database, cache, dan antrean.
- Detailkan bagian kritis: misalnya memakai transaksi database dan penguncian kursi sementara agar tidak terjadi pemesanan ganda.
- Identifikasi titik lemah: apa yang terjadi jika database mati atau layanan pembayaran lambat?
- Catat keputusan dan trade-off dalam ADR, lalu mulai dari versi paling sederhana dan kembangkan bertahap sesuai kebutuhan nyata.
10. PERJALANAN REKAYASA PERANGKAT LUNAK (1968βSEKARANG)
Banyak gagasan lama masih menjadi dasar praktik modern:
- 1968β1979: Lahirnya Disiplin Software Engineering β Konferensi NATO mempopulerkan istilah "software engineering" (1968), Dijkstra menulis "Go To Statement Considered Harmful" (1968), Conway's Law (1968), David Parnas memperkenalkan modularitas dan information hiding (1972), Fred Brooks menulis The Mythical Man-Month (1975), dan MVC lahir (1979).
- 1980β1999: Objek, Pattern & Refactoring β Prinsip Liskov (1987), buku Design Patterns GoF (1994), istilah Big Ball of Mud (1997), serta buku Refactoring dan The Pragmatic Programmer (1999).
- 2000β2009: Agile & Desain yang Bersih β Prinsip SOLID dirangkum (2000), Agile Manifesto (2001), Domain-Driven Design oleh Eric Evans (2003), Hexagonal Architecture (2005), Git (2005), Clean Code (2008), dan gerakan DevOps (2009).
- 2010β2015: Cloud & Microservices β Continuous Delivery (2010), Twelve-Factor App (2011), Clean Architecture (2012), Docker (2013), artikel Microservices (2014), dan Kubernetes 1.0 (2015).
- 2016β2020: Keandalan & Data β Buku Site Reliability Engineering dari Google (2016), Designing Data-Intensive Applications (2017), Accelerate dan metrik DORA (2018), serta OpenTelemetry (2019).
- 2021βSekarang: Penyederhanaan & AI β Banyak tim kembali ke modular monolith setelah merasakan rumitnya microservices, platform engineering berkembang, dan asisten AI ikut menulis kode. Karena kode makin cepat dihasilkan, kemampuan menilai desain dan melakukan review justru makin penting.
Ringkasnya, alat dan teknologinya terus berganti, tetapi prinsip intinya bertahan puluhan tahun: modularitas, kesederhanaan, pemisahan tanggung jawab, dan kode yang mudah dibaca.
SOFTWARE ENGINEER vs. SOFTWARE ARCHITECT
Software Engineer
- Fokus pada implementasi fitur dan kualitas kode.
- Menerapkan clean code, design pattern, dan automated testing di dalam struktur yang sudah dirancang.
- Tools: IDE, Git, framework, tool testing.
Software Architect
- Fokus pada struktur besar, batas antar modul, dan arah teknis jangka panjang.
- Menimbang trade-off antara biaya, kecepatan, dan skalabilitas.
- Tools: diagram arsitektur (C4 Model, UML), ADR, dan dokumen desain.
MENGAPA ARSITEKTUR & CLEAN CODE PENTING?
Software Selalu Berubah
Kebutuhan bisnis berubah terus. Software yang dirancang dengan baik bisa diubah dengan cepat dan aman, sedangkan software yang berantakan makin lama makin mahal untuk diubah.
Ilmu yang Awet
Framework bisa berganti setiap beberapa tahun, tetapi prinsip seperti modularitas, SOLID, dan design pattern tetap relevan sejak puluhan tahun lalu.
It Pays Very Well
Engineer yang memahami arsitektur dan desain sistem biasanya dipercaya memegang posisi senior, tech lead, hingga architect dengan penghasilan yang lebih tinggi.
Itβs Important to Do It Well
Keputusan arsitektur yang salah sangat mahal untuk diperbaiki. Utang teknis (technical debt) yang dibiarkan bisa membuat sebuah produk berhenti berkembang.
ANALOGI ARSITEKTUR SOFTWARE
Arsitektur software lebih mudah dipahami dengan analogi merancang sebuah kota.
1. Tata Ruang Kota β Arsitektur Sistem
Kota dibagi menjadi kawasan perumahan, industri, dan perkantoran dengan batas yang jelas. Seperti itulah modul dan layanan dalam sistem: setiap bagian punya tanggung jawab sendiri.
2. Jalan & Aturan Lalu Lintas β API dan Kontrak
Antar kawasan terhubung lewat jalan dengan aturan yang disepakati. Dalam software, antar modul berkomunikasi lewat API dan interface yang jelas, bukan saling masuk ke "rumah" tetangganya.
3. Standar Bangunan β Clean Code & Design Pattern
Setiap bangunan mengikuti standar konstruksi yang teruji agar aman dan mudah direnovasi. Clean code dan design pattern adalah standar bangunan di dalam kode.
4. Antisipasi Pertumbuhan β Skalabilitas
Kota yang baik menyiapkan jalur untuk pertumbuhan penduduk, tetapi tidak membangun jalan tol sepuluh jalur untuk desa kecil. Sistem pun dikembangkan sesuai kebutuhan nyata, bukan berlebihan sejak awal.
5. Kesimpulan
Software yang baik terdiri dari:
- Arsitektur: pembagian tanggung jawab yang jelas
- API dan Interface: komunikasi yang tertib
- Clean Code dan Design Pattern: kualitas di setiap baris kode
- Skalabilitas: siap tumbuh tanpa berlebihan
Tata ruang jelas, jalan tertib, bangunan standar, dan pertumbuhan yang realistis menghasilkan software yang profesional.
ANTI-PATTERN YANG HARUS DIHINDARI
Selain mengenal praktik yang baik, penting juga mengenali kesalahan yang sering terjadi:
- Spaghetti Code: alur kode melompat-lompat tanpa struktur sehingga sulit diikuti.
- God Object: satu class yang mengerjakan terlalu banyak hal dan diketahui oleh seluruh sistem.
- Over-Engineering: memakai microservices, Kubernetes, dan banyak pattern untuk aplikasi yang sebenarnya sederhana.
- Copy-Paste Programming: menduplikasi kode, sehingga satu bug harus diperbaiki di banyak tempat.
- Ditambah tiga yang sudah dibahas sebelumnya: Big Ball of Mud, Distributed Monolith, dan Premature Optimization.
REFERENSI KLASIK YANG MASIH RELEVAN
Berikut buku yang menjadi fondasi arsitektur software dan masih dibaca hingga sekarang:
1. The Mythical Man-Month (1975) β Fred Brooks
Brooks's Law: menambah orang ke project yang terlambat justru membuatnya makin terlambat.
2. Design Patterns (1994) β Gang of Four
23 design pattern klasik yang menjadi bahasa bersama developer di seluruh dunia.
3. Refactoring (1999, edisi kedua 2018) β Martin Fowler
Teknik memperbaiki struktur kode secara aman. Edisi kedua memakai contoh JavaScript.
4. The Pragmatic Programmer (1999, edisi 20 tahun 2019) β Andrew Hunt & David Thomas
Sumber prinsip DRY dan banyak kebiasaan baik developer, dari pemula hingga senior.
5. Domain-Driven Design (2003) β Eric Evans
Memodelkan software mengikuti bahasa bisnis, dasar menentukan batas layanan microservices.
6. Clean Code (2008) & Clean Architecture (2017) β Robert C. Martin
Kode yang mudah dibaca dan arsitektur berlapis, bacaan pertama tentang kualitas kode.
7. Designing Data-Intensive Applications (2017) β Martin Kleppmann
Database, replikasi, dan sistem terdistribusi, referensi utama desain sistem skalabel.
Kesimpulan Singkat
Urutan belajar yang disarankan:
- Kuasai clean code dan prinsip SOLID
- Pelajari design pattern yang paling sering dipakai
- Pahami arsitektur berlapis dan modular monolith
- Lanjutkan ke desain sistem, skalabilitas, dan microservices
- Terapkan praktik terbaik: Git, code review, automated testing, dan CI/CD
Terakhir diedit: