Bisa Nyetir Bukan Berarti Harus Jadi Montir: Belajar Abstraction dari Jalan Raya
Fundamentals
Ditulis 12 jam yang lalu Baca ± 8 menit
Bayangin kamu baru aja lulus tes SIM. Setelah beberapa kali belajar nyetir ditemani instruktur (dan beberapa kali hampir nyium trotoar), akhirnya kamu resmi jadi pengemudi. Sekarang kamu udah bisa nyetir sendiri ke kantor, ke supermarket, nongkrong sama teman, bahkan staycation ke luar kota pas long weekend.
Kamu paham cara nyalain mesin, pindah gigi, injak gas pelan-pelan, ngerem
mendadak kalau ada kucing nyebrang, dan tentu saja… belok kanan sambil nyalain
lampu sein biar gak diklaksonin dari belakang.
Semua terasa cukup. Kamu bisa mengendarai mobil. Kamu merasa menguasai
kendali.
Tapi, mari kita berhenti sejenak dan berpikir:
Apakah kamu tahu gimana proses mesin bakar bensin supaya akhirnya roda bisa
berputar?
Apa kamu tahu apa yang terjadi di dalam transmisi otomatis waktu kamu pindah ke
D?
Gimana sistem ABS bekerja saat kamu ngerem di jalanan licin?
Apa yang dilakukan ECU (Electronic Control Unit) setiap detik saat kamu nyetir?
Kemungkinan besar… enggak.
Dan lucunya, kamu tetap bisa nyetir tanpa semua pengetahuan itu.
Kenapa bisa begitu?
Karena sebagai pengemudi, kamu gak dituntut untuk ngerti semua
mekanisme teknis mobil.
Tugas kamu adalah mengendarainya sesuai aturan, memastikan keselamatanmu (dan
penumpangmu), dan sampai tujuan.
Urusan bagaimana mobil bekerja di balik dashboard—itu bukan tanggung
jawab kamu.
Dan inilah momen di mana kita sadar: hidup kadang memang lebih enak kalau gak tahu semuanya. Sama seperti dalam pemrograman, prinsip ini disebut abstraction.
Di Sini Lah Abstraction Berperan
Abstraction dalam OOP adalah prinsip yang menyatakan:
“Tunjukkan ke pengguna apa yang mereka butuhkan, sembunyikan kerumitan yang tidak perlu mereka urus.”
Dan analogi paling dekat yang bisa kita temukan dalam hidup sehari-hari: mobil.
Sebagai pengemudi, kamu tahu:
- Cara nyalain mesin (tekan tombol start atau putar kunci)
- Cara belok kanan atau kiri (putar setir ke arah yang diinginkan)
- Cara ngerem (injak pedal rem)
- Bahkan sekarang, cukup tekan tombol “P” untuk parkir otomatis, dan mobil akan nyari slot sendiri
Tapi kamu gak perlu tahu:
- Apa yang terjadi di dalam ruang bakar waktu kamu tekan pedal gas
- Gimana sistem injeksi bahan bakar mengatur konsumsi bensin biar irit
- Sensor mana yang ngatur traction control saat kamu melintasi jalan licin
- Gimana rasio gigi disesuaikan secara otomatis saat kamu ngebut atau nanjak
Semua itu terjadi di balik layar, atau lebih tepatnya: di balik dashboard.
Dan di dunia pemrograman, hal yang
sama juga berlaku.
Ketika kamu bikin sebuah aplikasi, misalnya aplikasi ride-hailing seperti Gojek
atau Grab, kamu sebagai developer atau user cukup tahu bahwa:
driver.start_engine() driver.turn_left() driver.brake()
Gak perlu tahu:
- Gimana sistem start_engine() mengaktifkan ignition coil
- Apa yang terjadi di sistem elektronik waktu brake() dipanggil
- Gimana data arah dari turn_left() diproses oleh microcontroller
Abstraction membatasi pengetahuan kita pada apa yang penting untuk dilakukan, bukan bagaimana itu dilakukan.
Bayangin kalau abstraction gak ada…
Setiap kali kamu mau start_engine(), kamu harus bikin 10 baris kode tambahan buat simulasi
spark plug, cek tekanan oli, lalu manual nyalain motor starter-nya.
Capek kan?
Dengan abstraction, semua kerumitan itu disembunyikan di dalam class, dan kamu tinggal pakai interface-nya aja. Simple, bersih, dan fokus.
Contoh OOP-nya Gimana?
Sekarang kita coba pindahin analogi
tadi ke dunia pemrograman.
Kita pakai Python, karena syntax-nya bersih dan mudah dipahami bahkan oleh
programmer yang belum ngopi 3 gelas 😄
Kita mulai dengan bikin class abstrak, yang jadi blueprint umum untuk semua kendaraan:
from abc import ABC, abstractmethod classKendaraan(ABC): @abstractmethod defnyalakan(self): pass @abstractmethod defjalan(self): pass
Class Kendaraan ini semacam perjanjian. Dia bilang:
“Kalau kamu mau jadi Kendaraan, kamu wajib bisa dinyalakan dan bisa jalan. Soal caranya gimana? Terserah kamu.”
Nah, sekarang kita bikin class Mobil yang mewarisi Kendaraan dan mengisi sendiri isi metodenya:
classMobil(Kendaraan): defnyalakan(self): print("Mobil dinyalakan.") defjalan(self): print("Mobil berjalan di jalan raya.")
Sekarang, sebagai programmer atau user, kita cukup pakai class-nya seperti ini:
kendaraan = Mobil() kendaraan.nyalakan() kendaraan.jalan()
Dan ini aja udah cukup.
Kita gak perlu tahu apakah Mobil itu:
- Pakai bensin, solar, atau listrik
- Menggunakan starter elektrik atau sistem hybrid
- Punya transmisi manual atau CVT
- Menggunakan ECU buatan Jepang atau Eropa
Yang penting:
Dia bisa dinyalakan, dan bisa jalan.
Abstraction dalam OOP bikin kode
kita terstruktur, fleksibel, dan scalable.
Mau kamu nanti bikin class Motor, Bus, bahkan DroneTerbangOtomatis, selama dia ngikutin blueprint dari Kendaraan, kamu bisa panggil nyalakan() dan jalan() tanpa khawatir cara kerja dalamnya.
Misalnya:
classDrone(Kendaraan): defnyalakan(self): print("Drone siap terbang.") defjalan(self): print("Drone mengudara.")
Tanpa ganti satu baris pun di kode pemanggilnya, kamu bisa:
kendaraan = Drone() kendaraan.nyalakan() kendaraan.jalan()
Dengan abstraction, kita menciptakan kontrak antar class, dan di saat yang sama kita juga menyederhanakan hidup bagi siapa pun yang mau pakai kode kita.
Karena dunia OOP itu udah cukup kompleks, jangan biarkan pengguna tahu dalaman mesinnya. Yang penting: dia bisa nyalain dan jalan.
Kenapa Abstraction Penting?
Tanpa abstraction, hidup (dan ngoding) bisa jauh lebih melelahkan daripada yang seharusnya.
Coba bayangkan, sebelum bisa nyetir:
- Kamu harus belajar jadi montir dulu, lengkap dengan pengetahuan tentang busi, piston, sirkuit kelistrikan, dan rasio gear transmisi.
- Setiap kali mau nyalain mobil, kamu harus buka kap mesin, nyambungin kabel manual, dan pastiin sistem bahan bakar ngalir dengan tekanan yang pas.
- Kamu bahkan mungkin harus mengatur rasio oli dulu sebelum belok, karena sistem kemudi belum otomatis bekerja tanpa setup dari kamu 😅
Terdengar konyol?
Iya, tapi begitulah rasanya kalau kamu bikin program tanpa abstraction.
Setiap class akan kepo dengan urusan
internal class lain.
Driver tahu daleman Car.
Car tahu daleman Engine.
Engine malah tahu isi FuelSystem.
Hasilnya?
Satu perubahan kecil bisa bikin efek
domino.
Ganti satu baris di Engine, tiba-tiba Dashboard, TirePressureMonitor, dan MusicPlayer ikut error.
Kode yang mestinya fleksibel malah
jadi fragile.
Bukannya bikin fitur baru, kamu sibuk jadi “montir” yang tiap hari debugging
kerusakan dari sistem yang saling ketergantungan.
Tanpa abstraction, kodingmu bukan lagi jadi proses kreatif. Dia berubah jadi bengkel permanen.
Abstraction = Kepercayaan + Simplicity
Abstraction bukan cuma soal
nyembunyiin kerumitan.
Dia juga soal membangun kepercayaan antar bagian dalam sistem.
Kamu percaya bahwa waktu kamu injak
pedal gas, mobil akan melaju.
Tanpa perlu kamu mikirin: “Apakah ECU udah kirim sinyal ke injector?” atau
“Apakah throttle body udah buka dengan sudut yang sesuai?”
Kamu percaya sistem akan bekerja
sebagaimana mestinya.
Begitu juga dengan OOP.
Saat kamu manggil kendaraan.nyalakan(), kamu percaya bahwa method itu akan melakukan
tugasnya—entah itu nyalain mesin diesel, aktifkan motor listrik, atau nyulut
roket di belakang.
Dan kamu gak perlu tahu detailnya.
Kepercayaan ini yang bikin kode jadi mudah digunakan, mudah diuji, dan mudah dikembangkan.
Dengan abstraction, kamu bisa:
- Ganti satu class dengan class lain tanpa takut semua sistem ambruk
- Fokus ke apa yang ingin dicapai, bukan gimana mencapainya
- Bikin tim kamu ngoding bareng tanpa saling nyentuh dapur kode masing-masing
Karena abstraction mengajarkan satu filosofi penting dalam OOP:
“Gak semua hal perlu kamu tahu. Tapi hal-hal penting, harus jelas cara pakainya.”
Dan itu berlaku di dunia kode… maupun di dunia nyata.
Penutup: Fokus ke Jalan, Bukan ke Mesin
Abstraction bikin kita bisa fokus ke
"apa yang ingin kita lakukan", bukan ke "bagaimana
cara itu dilakukan."
Dia membebaskan pikiran kita dari detail teknis yang gak relevan dengan tujuan
utama.
Dan itu penting banget.
Bayangin kalau setiap kali kamu mau
belok kiri di persimpangan, kamu harus berhenti, buka dashboard, cek kabel
power steering, dan memastikan tekanan oli hidrolik cukup.
Perjalananmu gak akan pernah lancar. Bahkan kamu bisa lupa mau ke mana.
Sama halnya dalam ngoding.
Abstraction membuat kamu bisa memikirkan fitur, alur logika, dan solusi
untuk pengguna, tanpa terus-menerus diganggu oleh “daleman” class atau
function yang udah kamu percayakan ke sistem.
Abstraction itu seperti punya sopir handal dalam tim—kamu tinggal bilang tujuan, dia yang urus rute dan macetnya.
Ketika kamu bikin sistem reservasi
hotel, kamu gak perlu ribet mikirin algoritma sorting kamar atau gimana
database nge-query harga terendah.
Kamu cukup panggil: cariKamar(tanggal,
lokasi)
Dan voila — hasilnya muncul.
Dengan abstraction, kamu bisa
berpikir lebih strategis.
Bisa menyusun sistem yang scalable.
Bisa kerja bareng tim tanpa saling injek kaki.
Dan yang paling penting: kamu bisa fokus ke hasil akhir, bukan proses
internal yang berliku.
Karena, jujur aja…
Hidup udah cukup kompleks. Kita gak perlu buka kap mesin setiap kali mau jalan.
Kalau kamu udah tahu mau ke mana,
biarkan abstraction jadi jalan tol buat pikiranmu:
cepat, efisien, dan gak ribet.
Dan di dunia OOP, abstraction bukan
cuma teknik—dia adalah filosofi.
Filosofi untuk percaya.
Filosofi untuk menyederhanakan.
Filosofi untuk tetap melaju, tanpa harus tahu setiap baut dan mur di baliknya.
Jadi lain kali kamu coding dan
bingung, coba tanya diri sendiri:
“Ini aku lagi nyetir… atau lagi bongkar mesin?”
Kalau kamu lagi bongkar… mungkin saatnya kasih ruang buat abstraction.
Leave a comment