Clean Code

Prinsip-Prinsip Clean Code Uncle Bob & Software Engineering Principles

Daftar Isi

  1. Prinsip Dasar Clean Code

  2. Prinsip Naming

  3. Prinsip Functions

  4. Prinsip Comments

  5. Prinsip Formatting

  6. Prinsip Objects and Data Structures

  7. Prinsip Error Handling

  8. Prinsip Classes

  9. Prinsip Testing

  10. Prinsip Systems

  11. Prinsip Concurrency

  12. General Programming Principles

  13. SOLID Principles

  14. Other Clean Code Heuristics

Prinsip Dasar Clean Code

Prinsip dasar Clean Code menekankan pada filosofi fundamental yang menjadi pondasi untuk menulis kode yang berkualitas. Ini bukan hanya aturan teknis, tapi mindset yang membantu programmer membuat kode yang mudah dipahami, dipelihara, dan dikembangkan oleh orang lain (atau diri sendiri di masa depan). Uncle Bob menekankan bahwa kode yang baik seperti cerita yang mengalir, bukan teka-teki yang membingungkan.

1. The Boy Scout Rule

Aturan ini diambil dari prinsip pramuka: "Selalu tinggalkan tempat perkemahan lebih bersih daripada saat kamu temukan." Dalam konteks kode, setiap kali kamu menyentuh atau memodifikasi bagian kode (misalnya untuk fix bug atau tambah fitur), luangkan waktu sedikit untuk memperbaiki atau membersihkan kode di sekitarnya. Ini bisa berupa refactoring kecil seperti mengganti nama variabel, menghapus duplikasi, atau menambahkan komentar yang jelas. Manfaatnya adalah kode secara bertahap menjadi lebih baik tanpa memerlukan refactoring besar-besaran yang berisiko.

Contoh Kode (Java):

// Kode awal (sebelum disentuh)
public class UserService {
    int u; // user count

    public void addUser(String name) {
        // tambah user
        u++;
        // simpan ke db
    }
}

// Setelah apply Boy Scout Rule (saat fix bug lain, kita clean up)
public class UserService {
    private int userCount = 0; // Renamed for clarity, made private

    public void addUser(String name) {
        userCount++; // Simplified comment removal since code is self-explanatory
        saveToDatabase(name); // Extracted to separate method for better structure
    }

    private void saveToDatabase(String name) {
        // Database saving logic here
    }
}

Dalam contoh ini, saat menyentuh metode addUser, kita membersihkan nama variabel dan memisahkan logika database.

2. Readability First

Kode dibaca jauh lebih sering (sekitar 10 kali lipat) daripada ditulis. Oleh karena itu, prioritaskan kemudahan membaca daripada menunjukkan kecerdasan atau trik pintar. Kode yang "cerdas" tapi sulit dibaca akan menyulitkan maintenance. Gunakan struktur yang sederhana, nama yang deskriptif, dan hindari shortcut yang tidak perlu.

Contoh Kode (Java):

// Buruk: Sulit dibaca meski "cerdas"
int r = (a+b)*(a-b); // Rumus perbedaan kuadrat

// Baik: Mudah dibaca
int differenceOfSquares = (firstNumber + secondNumber) * (firstNumber - secondNumber);

3. Express Intent

Kode harus secara langsung menyatakan maksud atau intent programmer tanpa memerlukan dokumentasi ekstensif. Ini berarti kode itu sendiri harus seperti bahasa Inggris yang jelas, sehingga pembaca bisa memahami apa yang terjadi tanpa menebak-nebak.

Contoh Kode (Java):

// Buruk: Intent tidak jelas
if (list.size() % 2 == 1) {
    // lakukan sesuatu
}

// Baik: Express intent clearly
if (hasOddNumberOfElements(list)) {
    processOddCase();
}

Prinsip Naming

Naming adalah salah satu aspek terpenting dalam Clean Code karena nama yang baik membuat kode lebih mudah dipahami tanpa komentar tambahan. Uncle Bob bilang, "Names are everywhere in software," jadi pilih nama yang mengungkapkan intent, konteks, dan tujuan.

1. Use Intention-Revealing Names

Nama harus menjawab tiga pertanyaan: mengapa variabel/fungsi ini ada, apa yang dilakukannya, dan bagaimana digunakan. Hindari nama singkat yang ambigu.

Contoh Kode (Java):

// Buruk
int d; // elapsed time in days

// Baik  
int elapsedTimeInDays;
int daysSinceCreation;
int daysSinceModification;

2. Avoid Mental Mapping

Hindari nama yang memaksa pembaca untuk "menerjemahkan" mental, seperti menggunakan indeks atau singkatan yang tidak standar.

Contoh Kode (Java):

// Buruk
for (int i = 0; i < theList.length; i++) {
    if (theList[i] == 4) {
        list1.add(theList[i]);
    }
}

// Baik
for (Cell cell : gameBoard) {
    if (cell.isFlagged()) {
        flaggedCells.add(cell);
    }
}

3. Class Names

Class names harus berupa noun (kata benda) atau noun phrase, mencerminkan entitas yang direpresentasikan. Hindari kata-kata generik seperti Manager atau Data karena kurang deskriptif.

Contoh Kode (Java):

// Buruk
class Manager { } // Apa yang dimanage?

// Baik
class Customer { }
class WikiPage { }
class Account { }

4. Method Names

Method names harus verb (kata kerja) atau verb phrase, mencerminkan aksi. Untuk accessor/mutator, gunakan prefix seperti get/set/is.

Contoh Kode (Java):

// Buruk
void payment() { } // Apa yang dilakukan?

// Baik
void postPayment() { }
void deletePage() { }
void save() { }
boolean isPosted() { }

5. Pick One Word per Concept

Gunakan kata yang konsisten untuk konsep yang sama di seluruh codebase. Jangan gunakan sinonim yang bisa membingungkan.

Contoh Kode (Java):

// Buruk: Mix fetch, get, retrieve
User fetchUser();
User getProfile();
User retrieveAccount();

// Baik: Konsisten dengan "get"
User getUser();
User getProfile();
User getAccount();

Prinsip Functions

Fungsi adalah building block utama kode. Prinsip ini fokus pada membuat fungsi sederhana, fokus, dan mudah dipahami.

1. Small!

Fungsi harus sangat kecil, idealnya kurang dari 20 baris. Blok dalam if/else/while sebaiknya satu baris saja, biasanya panggilan fungsi lain.

Contoh Kode (Java):

// Buruk: Terlalu panjang
public void process() {
    // 50+ baris kode di sini
}

// Baik: Kecil dan terpecah
public void process() {
    validateInput();
    computeResult();
    saveOutput();
}

2. Do One Thing

Fungsi harus fokus pada satu tugas saja. Jika bisa dipecah menjadi beberapa fungsi, berarti terlalu banyak tanggung jawab.

Contoh Kode (Java):

// Buruk: Melakukan banyak hal
public void loginUser(String username, String password) {
    // Validate credentials
    // Log attempt
    // Update session
    // Redirect
}

// Baik: Satu hal saja
public void validateCredentials(String username, String password) { /* ... */ }
public void logLoginAttempt() { /* ... */ }

3. One Level of Abstraction per Function

Jaga agar semua pernyataan dalam fungsi berada di level abstraksi yang sama (tinggi atau rendah, jangan campur).

Contoh Kode (Java):

// Buruk: Campur high dan low level
public String renderPage() {
    String html = "<html>";
    html += getHeader(); // High level
    html += "<body>";    // Low level string concat
    // ...
    return html;
}

// Baik: Satu level
public String renderPage() {
    return buildHtml(
        getHeader(),
        getBody(),
        getFooter()
    );
}

4. Reading Code from Top to Bottom: The Stepdown Rule

Kode harus dibaca seperti narasi dari atas ke bawah, dengan fungsi selanjutnya di level abstraksi lebih rendah.

Contoh Kode (Java):

// Contoh struktur
public void mainProcess() {
    prepareData();
    processData();
    outputResults();
}

private void prepareData() { /* detail */ }

5. Switch Statements

Switch sulit dibuat kecil dan sering melanggar SRP. Gunakan polymorphism untuk menggantinya.

Contoh Kode (Java):

// Buruk
switch (type) {
    case "employee": /* ... */ break;
    case "manager": /* ... */ break;
}

// Baik: Polymorphism
abstract class Worker {
    abstract void calculatePay();
}
class Employee extends Worker { /* impl */ }
class Manager extends Worker { /* impl */ }

6. Function Arguments

Kurangi jumlah argumen. 0-2 ideal, lebih dari 3 hindari.

Contoh Kode (Java):

// Buruk: Terlalu banyak arg
void createUser(String name, int age, String email, String address, boolean active);

// Baik: Gunakan object
void createUser(UserData data);

7. Common Monadic Forms

Bentuk fungsi dengan 1 argumen: tanya, transform, atau event.

Contoh Kode (Java):

boolean fileExists(String path); // Question
InputStream fileOpen(String path); // Transform
void passwordAttemptFailedNtimes(int attempts); // Event

8. Flag Arguments

Hindari boolean arg karena menandakan fungsi melakukan lebih dari satu hal.

Contoh Kode (Java):

// Buruk
void render(boolean isSuite);

// Baik
void renderForSuite();
void renderForSingleTest();

9. Have No Side Effects

Fungsi jangan punya efek samping yang tidak terduga.

Contoh Kode (Java):

// Buruk: Side effect
String checkPassword(String userName, String password) {
    initializeSession(); // Side effect!
    return "OK";
}

// Baik
String checkPassword(String userName, String password) {
    // Hanya check
}

10. Command Query Separation

Fungsi either command (ubah state) atau query (return value), bukan keduanya.

Contoh Kode (Java):

// Buruk
int getAndIncrementCounter() { return counter++; }

// Baik
int getCounter() { return counter; }
void incrementCounter() { counter++; }

11. Prefer Exceptions to Returning Error Codes

Exception lebih baik karena memisahkan error handling dari logic utama.

Contoh Kode (Java):

// Buruk
int ERROR = -1;
int withdraw(int amount) {
    if (balance < amount) return ERROR;
    // ...
}

// Baik
void withdraw(int amount) {
    if (balance < amount) throw new InsufficientFundsException();
    // ...
}

Prinsip Comments

Komentar sebaiknya jarang, karena kode yang baik seharusnya self-explanatory. Komentar buruk bisa menyesatkan.

1. Comments Do Not Make Up for Bad Code

Jangan gunakan komentar untuk menutupi kode buruk; refactor saja.

Contoh Kode (Java):

// Buruk: Komentar nutupi kode jelek
// Ini untuk hitung total (kode rumit)

// Baik: Refactor tanpa komentar
int calculateTotalPrice(List<Item> items) { /* kode jelas */ }

2. Explain Yourself in Code

Gunakan kode untuk menjelaskan, bukan komentar.

Contoh Kode (Java):

// Buruk
// Check to see if the employee is eligible for full benefits
if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))

// Baik  
if (employee.isEligibleForFullBenefits())

3. Good Comments

Gunakan untuk legal, informative, intent, clarification, warning, TODO, amplification.

Contoh Kode (Java):

// Legal: Copyright (c) 2025, xAI

// Informative: Returns time in milliseconds
long getElapsedTime() { /* ... */ }

// TODO: Refactor this when API v2 is ready

4. Bad Comments

Hindari mumbling, redundant, misleading, mandated, journal, noise, dll.

Contoh Kode (Java):

// Buruk: Redundant
int x = 5; // Set x to 5

// Baik: Hapus komentar, kode sudah jelas
int x = 5;

Prinsip Formatting

Formatting memengaruhi readability. Kode yang diformat baik seperti dokumen profesional.

1. The Purpose of Formatting

Formatting untuk komunikasi. Kode yang rapi memudahkan kolaborasi.

2. Vertical Formatting

File 200-500 baris optimal. Gunakan blank lines untuk pisah konsep, jaga related code dekat.

Contoh Kode (Java):

// Contoh vertical openness
public class Example {

    // Concept 1
    void method1() { }

    // Concept 2
    void method2() { }
}

3. Horizontal Formatting

Line max 80-120 char. Gunakan whitespace untuk clarity.

Contoh Kode (Java):

// Buruk: No whitespace
int result=a+b*c;

// Baik
int result = a + (b * c);

4. Team Rules

Setuju pada satu style (e.g., Google Java Style) dan ikuti.

Prinsip Objects and Data Structures

Fokus pada bagaimana menyembunyikan detail implementasi.

1. Data Abstraction

Abstraksi harus menyembunyikan implementasi.

Contoh Kode (Java):

// Buruk: Expose detail
class Point {
    public double x;
    public double y;
}

// Baik: Abstract
class Point {
    private double x, y;
    public double getDistance(Point other) { /* ... */ }
}

2. Data/Object Anti-Symmetry

Objects hide data, expose behavior. Data structures expose data, no behavior.

Contoh Kode (Java):

// Data Structure
class PointData {
    double x, y; // Exposed
}

// Object
class PointObject {
    private double x, y;
    void move(double dx, double dy) { /* ... */ }
}

3. The Law of Demeter

Jangan "bicara dengan stranger" – hanya interaksi dengan objek terkait langsung.

Contoh Kode (Java):

// Buruk
final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();

// Baik
final String outputDir = ctxt.getScratchDirectoryPath();

4. Data Transfer Objects

Untuk transfer data, seperti dari DB.

Contoh Kode (Java):

class UserDTO {
    public String name;
    public String email;
}

Prinsip Error Handling

Error handling harus clean dan tidak mengganggu logic utama.

1. Use Exceptions Rather Than Return Codes

Exception pisah happy path.

Contoh Kode (Java):

// Buruk
if (deletePage(page) == E_OK) { /* ... */ }

// Baik
try {
    deletePage(page);
} catch (Exception e) { /* handle */ }

2. Write Your Try-Catch-Finally Statement First

Mulai dengan try-catch untuk define contract.

Contoh Kode (Java):

public void delete(Page page) {
    try {
        deletePageAndAllReferences(page);
    } catch (Exception e) {
        logError(e);
    }
}

3. Use Unchecked Exceptions

Unchecked tidak force handling, lebih fleksibel.

4. Provide Context with Exceptions

Message exception harus detail.

Contoh Kode (Java):

throw new InvalidInputException("Invalid age: " + age + " for user: " + name);

5. Define Exception Classes in Terms of Caller's Needs

Group exception berdasarkan bagaimana ditangani.

Contoh Kode (Java):

class ACMEPort {
    public void open() throws DeviceResponseException { /* ... */ }
}

6. Define the Normal Flow

Gunakan pattern untuk handle special case tanpa if banyak.

Contoh Kode (Java):

// Special Case
class NullLogger implements Logger {
    public void log(String msg) { /* do nothing */ }
}

7. Don't Return Null

Return empty collection atau throw.

Contoh Kode (Java):

// Buruk
List<User> getUsers() { return null; }

// Baik
List<User> getUsers() { return new ArrayList<>(); }

8. Don't Pass Null

Hindari pass null; gunakan optional atau check.

Contoh Kode (Java):

// Buruk
public void register(User user) {
    if (user == null) { /* handle */ }
}

// Baik: Asumsi tidak null, atau gunakan Optional

Prinsip Classes

Class harus kecil dan fokus.

1. Class Organization

Ikuti konvensi: constants, variables, public methods, private.

Contoh Kode (Java):

public class Example {
    public static final int CONSTANT = 1;
    private static int staticVar;
    private int instanceVar;
    
    public void publicMethod() { }
    private void privateUtility() { }
}

2. Encapsulation

Keep private, tapi jangan overdo.

3. Classes Should Be Small

Ukur dengan responsibilities, bukan lines.

4. The Single Responsibility Principle (SRP)

Satu alasan untuk berubah.

Contoh Kode (Java):

// Buruk
class Modem {
    void dial(); // Connection
    void send(); // Data
}

// Baik
class Connection { void dial(); }
class DataChannel { void send(); }

5. Cohesion

Methods manipulate same variables.

6. Maintaining Cohesion Results in Many Small Classes

Split jika cohesion rendah.

7. Organizing for Change

Design untuk mudah diubah.

Prinsip Testing

Testing adalah kunci untuk confidence dalam refactoring.

1. The Three Laws of TDD

  1. Tulis failing test dulu.

  2. Tulis test minimal.

  3. Tulis kode minimal untuk pass.

Contoh Kode (Java dengan JUnit):

// Test dulu
@Test
void testAdd() {
    assertEquals(4, calculator.add(2, 2));
}

// Lalu implement
int add(int a, int b) { return a + b; }

2. Keeping Tests Clean

Test harus readable seperti production code.

3. What Makes a Clean Test

Gunakan BUILD-OPERATE-CHECK.

Contoh Kode (Java):

@Test
void test() {
    // Build
    User user = new User("test");
    
    // Operate
    user.activate();
    
    // Check
    assertTrue(user.isActive());
}

4. One Assert per Test

Fokus satu assert.

5. Single Concept per Test

Test satu ide.

6. F.I.R.S.T.

Fast, Independent, Repeatable, Self-Validating, Timely.

Prinsip Systems

Fokus pada arsitektur sistem besar.

1. Separate Constructing a System from Using It

Pisah inisialisasi dari runtime.

Contoh Kode (Java):

// Construction
Application app = new ApplicationBuilder().build();

// Use
app.run();

2. Dependency Injection

Gunakan DI untuk decoupling.

Contoh Kode (Java dengan Spring-like):

class Service {
    private Repository repo;
    
    public Service(Repository repo) { this.repo = repo; } // Injected
}

3. Scaling Up

Grow incrementally.

4. Cross-Cutting Concerns

Gunakan AOP untuk concerns seperti logging.

Prinsip Concurrency

Concurrency sulit; lindungi data.

1. Why Concurrency?

Decouple timing, improve performance.

2. Concurrency Defense Principles

SRP untuk concurrency, limit shared data, use copies, independent threads.

Contoh Kode (Java):

// Gunakan synchronized untuk limit access
synchronized void updateSharedData() { /* ... */ }

3. Know Your Library

Gunakan ConcurrentHashMap, dll.

4. Know Your Execution Models

Understand producer-consumer, dll.

Contoh Kode (Java):

// Producer-Consumer
BlockingQueue queue = new LinkedBlockingQueue();

void produce() { queue.put(item); }
void consume() { item = queue.take(); }

General Programming Principles

Prinsip umum di luar Clean Code spesifik.

1. DRY (Don't Repeat Yourself)

Hindari duplikasi knowledge.

Contoh Kode (Java):

// Buruk - Duplication
public void printUserInfo(User user) {
    System.out.println("Name: " + user.getName());
    System.out.println("Age: " + user.getAge());  
    System.out.println("Email: " + user.getEmail());
}

public String formatUserInfo(User user) {
    return "Name: " + user.getName() + ", Age: " + user.getAge() + ", Email: " + user.getEmail();
}

// Baik - DRY Applied
public String formatUserInfo(User user) {
    return String.format("Name: %s, Age: %d, Email: %s", 
           user.getName(), user.getAge(), user.getEmail());
}

public void printUserInfo(User user) {
    System.out.println(formatUserInfo(user));
}

2. KISS (Keep It Simple, Stupid)

Jaga simplicity.

Contoh Kode (Java):

// Buruk - Over-complicated
public boolean isUserValid(User user) {
    if (user != null) {
        if (user.getName() != null) {
            if (user.getName().length() > 0) {
                if (user.getEmail() != null) {
                    if (user.getEmail().contains("@")) {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

// Baik - Simple and Clear
public boolean isUserValid(User user) {
    return user != null 
        && user.getName() != null 
        && !user.getName().isEmpty()
        && user.getEmail() != null 
        && user.getEmail().contains("@");
}

3. YAGNI (You Aren't Gonna Need It)

Jangan tambah fitur premature.

Contoh Kode (Java):

// Buruk - Premature Implementation
public class User {
    private String name;
    private String email;
    private String address;        // Might need later?
    private List<String> hobbies;  // Might need later?
    private LocalDate birthDate;   // Might need later?
    private String phoneNumber;    // Might need later?
    
    // All getters/setters even if not used
}

// Baik - Implement Only What's Needed Now
public class User {
    private String name;
    private String email;
    
    // Add other fields when actually needed
}

4. SINE (Simple Is Not Easy)

Simple butuh effort.

5. SLAP (Single Level of Abstraction Principle)

Satu level abstraksi.

Contoh Kode (Java):

// Buruk - Mixed abstraction levels
public void processUser(String userData) {
    // High level
    User user = parseUser(userData);
    
    // Low level  
    if (user.getName().length() > 0 && user.getEmail().contains("@")) {
        // Medium level
        validateUser(user);
        saveToDatabase(user);
    }
}

// Baik - Same abstraction level
public void processUser(String userData) {
    User user = parseUser(userData);
    if (isValidUser(user)) {
        saveUser(user);
    }
}

6. CQS (Command Query Separation)

Pisah command dan query.

Contoh Kode (Java):

// Buruk - Command and Query mixed
public int pop() {
    if (isEmpty()) {
        throw new EmptyStackException();
    }
    return items[--size]; // Both modifies and returns
}

// Baik - Separated
public int peek() {      // Query only
    if (isEmpty()) {
        throw new EmptyStackException();
    }
    return items[size - 1];
}

public void pop() {      // Command only  
    if (isEmpty()) {
        throw new EmptyStackException();
    }
    size--;
}

7. Tell, Don't Ask

Tell object apa yang dilakukan.

Contoh Kode (Java):

// Buruk - Ask for data
if (user.getAge() > 18) {
    user.setCanVote(true);
}

// Baik - Tell what to do
user.checkVotingEligibility();

8. Fail Fast

Fail segera jika error.

Contoh Kode (Java):

public void process(String input) {
    if (input == null) throw new IllegalArgumentException("Input null"); // Fail fast
    // Lanjut
}

9. Composition Over Inheritance

Favor composition.

Contoh Kode (Java):

// Inheritance buruk jika misuse
class Car extends Engine { } // Salah

// Composition baik
class Car {
    private Engine engine;
}

10. Program to Interfaces, Not Implementations

Depend on interface.

Contoh Kode (Java):

// Buruk
ArrayList<User> users = new ArrayList<>();

// Baik
List<User> users = new ArrayList<>();

SOLID Principles

SOLID adalah akronim untuk 5 prinsip OOP oleh Uncle Bob.

1. Single Responsibility Principle (SRP)

Satu tanggung jawab.

Contoh Kode (Java):

// Buruk - Multiple responsibilities
public class User {
    private String name;
    private String email;
    
    public void save() {
        // Database logic
    }
    
    public void sendEmail() {
        // Email logic  
    }
    
    public String toJSON() {
        // Serialization logic
    }
}

// Baik - Single responsibility
public class User {
    private String name;
    private String email;
    // Only user data logic
}

public class UserRepository {
    public void save(User user) {
        // Database logic only
    }
}

public class EmailService {
    public void sendEmail(User user) {
        // Email logic only
    }
}

2. Open/Closed Principle (OCP)

Open for extension, closed for modification.

Contoh Kode (Java):

// Buruk: Modify class untuk extend
class Shape {
    void drawCircle() { }
    void drawSquare() { } // Tambah baru = modify
}

// Baik: Extend tanpa modify
abstract class Shape {
    abstract void draw();
}
class Circle extends Shape { void draw() { /* ... */ } }

3. Liskov Substitution Principle (LSP)

Subclass bisa ganti superclass tanpa break.

Contoh Kode (Java):

// Buruk: Break LSP
class Bird { void fly() { } }
class Penguin extends Bird { void fly() { throw Exception(); } } // Break

// Baik: Separate
interface Flyable { void fly(); }
class Sparrow implements Flyable { /* ... */ }
class Penguin { /* no fly */ }

4. Interface Segregation Principle (ISP)

Interface kecil, client jangan force implement unused.

Contoh Kode (Java):

// Buruk: Fat interface
interface Worker {
    void work();
    void eat();
}

// Baik: Segregated
interface Workable { void work(); }
interface Eatable { void eat(); }

5. Dependency Inversion Principle (DIP)

Depend on abstraction.

Contoh Kode (Java):

// Buruk: High depend low
class Lamp { /* ... */ }
class Switch {
    private Lamp lamp; // Concrete
}

// Baik
interface Switchable { void turnOn(); }
class Lamp implements Switchable { /* ... */ }
class Switch {
    private Switchable device; // Abstraction
}

Other Clean Code Heuristics

Heuristics tambahan untuk smell code.

1. Environment

Build dan test one step.

2. Functions

Hindari too many args, flags, dead functions.

3. General

Hindari duplication, wrong abstraction, dead code, inconsistency, dll.

Contoh Kode (Java untuk Duplication):

// Buruk: Duplication
int area1 = length * width;
int area2 = length * width;

// Baik
int calculateArea(int l, int w) { return l * w; }

4. Java

Gunakan wildcard import sparingly, enums over constants.

5. Names

Descriptive, appropriate level, no encodings.

6. Tests

Sufficient, cover boundaries, fast.

Simple Design Rules (Kent Beck's 4 Rules)

  1. Runs all tests.

  2. No duplication.

  3. Expresses intent.

  4. Minimizes classes/methods.

Prinsip Tambahan dari Software Engineering

1. WET (Write Everything Twice)

Duplicate 2x OK sebelum abstract, tapi jangan abuse.

2. AHA (Avoid Hasty Abstractions)

Duplication better than wrong abstraction.

3. GRASP Principles

Assign responsibilities properly: Controller, Creator, Expert, dll.

Contoh untuk Expert: Assign tugas ke class yang punya info paling banyak.

4. Hollywood Principle

High-level calls low-level.

5. Principle of Least Surprise

Code behave as expected.

6. Robustness Principle (Postel's Law)

Conservative send, liberal accept.

Implementasi Best Practices

1. Refactoring Safely

Test first, small changes.

2. Code Review Guidelines

Check readability, principles.

3. Continuous Improvement

Boy Scout, regular refactor, education.

4. When to Break Rules

Untuk performance atau legacy, tapi track debt.

Kesimpulan

Clean Code tentang professionalism. Code is communication, consistency key, simplicity wins, test everything, refactor continuously.

"Indeed, the ratio of time spent reading versus writing is well over 10 to 1..." - Uncle Bob

Perfect code tak ada, tapi strive for clean membuat better systems.

PreviousIntroduction to Change Data Capture (CDC) and DebeziumNext12 Factor App

Last updated