DEV Community: Arif Bugaresa

Single Responsibility Principle (SRP)

Arif Bugaresa — Tue, 22 Sep 2026 07:29:14 +0000

Single Responsibility Principle (SRP) merupakan prinsip SOLID yang menyatakan bahwa sebuah kelas harus hanya memiliki satu tanggung jawab yang spesifik. Jika sebuah kelas memiliki lebih dari satu tanggung jawab dapat memengaruhi tanggung jawab yang lainnya maka dapat meningkatkan risiko bug.

Analoginya untuk studi kasus mengelola sebuah resto akan ada banyak pekerjaan yang harus dilakukan seperti memasak makanan, melayani pengunjung yang datang dan membersihkan meja tamu. jika hanya ada satu petugas yang bertanggung jawab atas seluruh tugas, kemungkinan besar akan kewalahan dalam mengelola resto tersebut. jika tiba tiba ada masalah di dapur maka pengunjung akan menunggu lebih lama untuk mendapatkan pelayanan. disisi lain jika banyak pengunjung yang datang di waktu yang bersamaan maka petugas tersebut mungkin tidak sempat untuk membersihkan ruangan. itu lah mengapa di restoran yang baik, seharusnya memiliki beberapa petugas seperti koki yang fokus untuk memasak hidangan, pelayan yang hanya fokus melayani pengunjung yang datang dan cleaning service yang bertugas untuk membersihkan seluruh ruangan.

Dalam konteks SRP, setiap kelas harus fokus pada tanggung jawab yang spesifik. Jika ada masalah di sebagian kode, seharusnya tidak akan memengaruhi kode yang lain. dengan menerapkan SRP ini maka code akan lebih mudah dikelola dan dipelihara.

mari kita lihat contoh kode tanpa menerapkan single responsibility principle berikut.

type UserManager struct {
}

func (um *UserManager) CreateUser() {
    fmt.Println("create user")
}

func (um *UserManager) SendEmail() {
    fmt.Println("send email")
}

Understanding SOLID Principles

Arif Bugaresa — Tue, 22 Sep 2026 07:06:31 +0000

SOLID principles sejatinya hanyalah aturan yang dirancang untuk membantu programmer menulis kode yang terstruktur dan mudah dipelihara. Secara garis besar konsep SOLID ini meliputi Single Responsibility, Open/Close, Liskov Subtitution, Interface Segregation, Dependency Inversion. artikel ini diharapkan dapat memberikan pemahaman penerapan SOLID di bahasa go dan sebagai reminder pribadi saat merasa bahwa kode yang saya tulis terasa tidak rapi dan sulit dipahami.

Konsep ini seringkali dijadikan fondasi dalam membangun sebuah sistem perangkat lunak modern dan konsep ini seringkali hadir sebagai guideline dalam menulis kode yang rapih karena prinsip ini seharusnya dapat membuat code yang kita tulis lebih mudah dipahami oleh orang lain, mudah diperbaiki dan juga mudah dikembangkan di masa mendatang.

kenapa kita perlu setidaknya mengetahui SOLID principle ini? menulis kode biasanya hanya sekedar membuat kode yang berfungsi sesuai kebutuhan saja, tetapi seiring berjalannya waktu kadang kita akan menyadari bahwa kode yang berfungsi saja tidak cukup. kode yang tidak terstruktur dengan baik akan menjadi mimpi buruk saat harus diperbaiki atau di optimize.

Berikut beberapa alasan mengapa kadang solid principle ini perlu untuk di ikuti:

kode yang terstruktur dengan baik tidak hanya lebih mudah untuk dimengerti, tetapi juga memudahkan tim lain yang mungkin harus bekerja dengan kode yang orang lain tulis.
mendesain kode yang fleksibel dan mudah diperluas membuat perubahan dapat dilakukan tanpa mempengaruhi bagian kode yang lain
membagi kode ke dalam tanggung jawab yang terpisah memudahkan dalam memperbaiki bug dengan lebih cepat dan efisien.
kode yang modular dan bersih memudahkan dalam memahami bagian-bagian progam dengan mudah.
membantu dalam pembuatan code skala besar yang scalable seiring bertambahnya fitur fitur lain nya.

Single Reponsibility Principle (SRP)
Single Responsibility Principle merupakan prinsip yang menyatakan bahwa sebuah kelas harus hanya memiliki satu tanggung jawab yang spesifik

Open/Closed Principle (OCP)
Open Closed Principle merupakan prinsip yang menyatakan bahwa sebuah entitas perangkat lunak terbuka untuk ekstensi atau menambahkan fitur baru tanpa mengubah code yang sudah ada

Liskov Subtitution Principle (LSP)
Liskov Substitution Principle merupakan prinsip yang menyatakan bahwa kelas turunan harus dapat menggantikan kelas dasarnya tanpa mengubah sifatnya

Interface Segregation Principle (ISP)
Interface Segregation Principle merupakan prinsip yang menyatakan bahwa sebuah klien tidak seharusnya dipaksa untuk bergantung pada metode-metode yang tidak digunakannya atau interface yang terlalu besar harus dipisah menjadi beberapa interface yang lebih spesifik sesuai dengan kebutuhan

Dependency Inversion Principle (DIP)
Dependency Inversion Principle merupakan prinsip yang menyatakan bahwa modul tingkat tinggi tidak boleh bergantung pada modul tingkat
rendah. Keduanya harus bergantung pada abstraksi

References:
https://emmanueladeyemi180.medium.com/a-structured-guide-to-the-solid-principles-of-object-oriented-programming-oop-903c311489d1

Test Post Part 1

Arif Bugaresa — Tue, 22 Sep 2026 07:01:49 +0000

test

Test Post

Arif Bugaresa — Tue, 22 Sep 2026 07:01:22 +0000

Linked Url

Post not found or has been removed.