KISS #

Dalam dunia software engineering, kompleksitas adalah musuh yang sering tidak disadari. Banyak bug, keterlambatan delivery, dan sistem yang sulit dirawat bukan karena kurangnya teknologi canggih, tetapi karena desain yang terlalu rumit. Salah satu prinsip fundamental untuk melawan hal ini adalah KISS.

KISS adalah singkatan dari Keep It Simple, Stupid (kadang juga ditulis Keep It Simple and Straightforward). Intinya sederhana: buat solusi sesederhana mungkin, tapi tidak lebih sederhana dari yang dibutuhkan.

Artikel ini akan membahas prinsip KISS secara mendalam: latar belakang, tujuan, manfaat, jebakan umum, serta contoh konkret penerapannya menggunakan Golang.

Apa Itu Prinsip KISS? #

Prinsip KISS mendorong engineer untuk:

Menghindari kompleksitas yang tidak perlu
Memilih solusi paling sederhana yang bisa bekerja dengan baik
Membuat kode mudah dibaca, dipahami, diuji, dan dirawat

Kesederhanaan di sini bukan berarti ceroboh atau naif, tetapi:

Struktur jelas
Alur logika mudah diikuti
Tidak over-engineering

“Complexity is easy to add, but hard to remove.”

Tujuan dan Nilai Penting Prinsip KISS #

Maintainability #

Kode sederhana lebih mudah:

Dibaca oleh engineer lain
Dipelihara setelah berbulan-bulan atau bertahun-tahun

Reliability #

Semakin kompleks kode, semakin besar:

Permukaan bug
Edge case tersembunyi

Development Speed #

Kode sederhana:

Lebih cepat ditulis
Lebih cepat di-debug
Lebih cepat di-refactor

Testability #

Implementasi yang sederhana:

Mudah di-unit-test
Tidak butuh mocking berlebihan

KISS vs Over-Engineering #

Over-engineering biasanya muncul dalam bentuk:

Abstraction berlapis-lapis tanpa kebutuhan nyata
Pattern yang dipaksakan
Config dan generic system untuk masalah sederhana

Tanda-tanda over-engineering:

Lebih banyak kode untuk mendukung framework internal dibanding logic bisnis
Perlu waktu lama hanya untuk memahami alur sederhana

KISS tidak anti-arsitektur atau pattern, tetapi:

Gunakan hanya ketika ada masalah nyata yang perlu diselesaikan.

KISS dalam Konteks Golang #

Golang secara filosofis sangat dekat dengan prinsip KISS:

Syntax sederhana
Tidak ada inheritance kompleks
Interface kecil dan eksplisit
Error handling eksplisit

Go mendorong engineer untuk:

Menulis kode jelas dibanding kode “pintar”
Memilih kejelasan daripada keindahan abstraksi

Contoh 1: Fungsi Terlalu Kompleks vs Sederhana #

❌ Terlalu Kompleks #

func IsAdult(user map[string]interface{}) bool {
    if age, ok := user["age"]; ok {
        if ageInt, ok := age.(int); ok {
            if ageInt >= 18 {
                return true
            } else {
                return false
            }
        }
    }
    return false
}

Masalah:

Struktur data tidak jelas
Banyak nested condition
Sulit diuji

✅ Versi KISS #

type User struct {
    Age int
}

func IsAdult(user User) bool {
    return user.Age >= 18
}

Lebih:

Jelas
Aman
Mudah diuji

Contoh 2: Abstraction Berlebihan #

❌ Over-Abstraction #

type PaymentProcessor interface {
    Process(amount int) error
}

type PaymentService struct {
    processor PaymentProcessor
}

func (s PaymentService) Pay(amount int) error {
    return s.processor.Process(amount)
}

Jika hanya ada satu implementasi dan tidak ada rencana ekspansi, ini belum perlu.

✅ KISS #

func ProcessPayment(amount int) error {
    // logic pembayaran
    return nil
}

Tambahkan interface hanya ketika kebutuhan nyata muncul.

Contoh 3: Error Handling yang Jelas #

❌ Terlalu “Pintar” #

func ReadConfig() error {
    return wrap(load(validate(parse())))
}

Sulit di-debug dan dipahami.

✅ KISS ala Go #

func ReadConfig() error {
    data, err := load()
    if err != nil {
        return err
    }

    cfg, err := parse(data)
    if err != nil {
        return err
    }

    return validate(cfg)
}

Lebih panjang, tapi:

Mudah dibaca
Mudah di-debug

KISS pada Desain API #

❌ Endpoint Terlalu Generic #

POST /api/action
{
  "type": "create_user",
  "payload": { ... }
}

✅ KISS #

POST /api/users

API yang eksplisit:

Mudah dipahami
Mudah didokumentasikan

KISS dan Modularisasi #

KISS bukan berarti satu file besar.

Prinsip yang benar:

Fungsi kecil
Tanggung jawab tunggal
Struktur folder jelas

Contoh struktur sederhana:

service/
  user_service.go
  user_repository.go
  user_handler.go

Jebakan Umum saat Menerapkan KISS #

Terlalu sederhana sampai tidak fleksibel
Mengorbankan readability demi baris kode lebih sedikit
Menunda abstraction yang sebenarnya sudah dibutuhkan

KISS bukan dogma, tapi guideline.

Kapan Tidak Menggunakan KISS Secara Ketat? #

Sistem framework atau library publik
Core platform dengan banyak consumer
Domain kompleks (misalnya rule engine, workflow engine)

Namun bahkan di kasus ini:

Mulailah dari sederhana, evolusikan secara bertahap.

Ringkasan #

KISS = Keep It Simple, Stupid
Kesederhanaan mengurangi bug dan biaya maintenance
Golang secara natural mendukung prinsip KISS
Hindari over-engineering dan abstraction prematur
Kode yang jelas > kode yang pintar

Simple is not easy, but it is worth it.

Penutup #

Prinsip KISS adalah fondasi penting bagi engineer profesional. Dengan menerapkannya secara konsisten, kita tidak hanya menulis kode yang bekerja hari ini, tetapi juga kode yang masih bisa dipahami dan dirawat bertahun-tahun ke depan.