Bisa Nyetir Bukan Berarti Harus Jadi Montir: Belajar Abstraction dari Jalan Raya

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.