Belajar Hal Baru Pas Udah Senior: Kenapa Gue Sering Merasa Bodoh Lagi

Gue udah 8 tahun nge-code. Udah jago React, Node, Postgres, Docker, AWS. Tiap project baru, gue tau gimana caranya. Begitu liat codebase, struktur udah kebayang. Shortcut IDE udah muscle memory. Debugging produksi udah routine. Gue ngerasa "gue udah senior, gue udah jago."

Terus 2 bulan lalu gue mau belajar Rust. Gue pikir "gue udah jago 5 bahasa, ini cuma bahasa ke-6. Probably 2 minggu kelar."

2 minggu kemudian, gue masih struggle dengan ownership dan borrowing. Gue butuh 3 jam buat nulis code yang di Python cuma 10 menit. Gue ngerasa bodoh. Bukan "lambat" - bodoh. Code yang gue tulis gak compile, gue gak ngerti kenapa. Error message Rust ngejelaskan sesuatu yang gue gak ngerti konsepnya. Gue yang biasanya baca dokumentasi 5 menit langsung paham, sekarang baca 30 menit masih bingung.

Itu momen gue sadar: belajar hal baru pas udah senior itu experience yang beda. Bukan cuma "belajar lagi." Ada psikologis yang gak siap. Ada ego yang harus dijegal. Ada ekspektasi yang musti di-reset. Artikel ini bukan tentang "cara belajar Rust." Ini tentang kenapa belajar hal baru pas udah jago itu justru lebih susah dari pas pertama kali belajar coding.

---

Masalahnya Bukan Bahasa Baru. Masalahnya Ego.

Pas gue pertama belajar Python (2017), gue gak punya ekspektasi. Gue pemula. Lambat = normal. Gak ngerti = normal. Tiap hari belajar hal baru = harapan.

Pas gue belajar Rust 2 bulan lalu, gue udah punya ekspektasi "gue senior." Ekspektasi ini yang bikin susah, bukan Rust-nya. Tiap kali gue gak ngerti sesuatu, otak gue bilang: "harusnya gue udah ngerti ini. Gue udah 8 tahun nge-code. Kenapa gue bingung?"

Perbandingan yang bikin paham:

| Aspek | Belajar pertama (2017, Python) | Belajar keenam (2025, Rust) |
|---|---|---|
| Ekspektasi | Pemula, wajar lambat | Senior, harusnya cepet |
| Ego | Gak ada stake | Tinggi, "gue udah jago" |
| Validasi eksternal | Belum ada | Udah ada (gaji, title, respect) |
| Frustrasi | "Belum ngerti" | "Harusnya gue ngerti" |
| Mindset | "Belajar" | "Sekedar nambah skill" |
| Waktu belajar | 1-2 jam/hari, cukup | 1-2 jam/hari, gak cukup (butuh unlearn) |

Filosofi yang gue temuin: belajar hal baru pas senior itu 2x lebih susah, bukan karena materinya 2x lebih susah, tapi karena lo musti ngelakuin 2 hal sekaligus: belajar hal baru + unlearn pola lama.

---

"Unlearning" Itu yang Paling Sakit

Contoh konkret dari Rust. Di Python/JS, ini valid:

Python - gampang, familiar
items = [1, 2, 3]
first = items[0]
items.append(4)
print(first) # 1, no problem

Di Rust, versi yang "kayak gitu" gak compile:

// Rust - error: borrow after move
let items = vec![1, 2, 3];
let first = items[0]; // borrow
items.push(4); // mutable borrow - error!
println!("{}", first);

Error: "cannot borrow items as mutable because it is also borrowed as shared." Buat yang belum pernah dengar "borrow checker," itu terdengar kayak alien language.

Di Python, otak gue udah jadi: "variable = reference, semua boleh, garbage collector yang urus." Di Rust, otak gue musti belajar: "variable punya owner, kalau di-borrow immutable, gak boleh dimutate."

Unlearning = nge-override reflex yang udah otomatis. Bukan nambah pengetahuan baru. Membongkar yang lama. Itu yang berat.

Kayak pemain gitar akustik belajar gitar elektrik. Tuning beda, technic beda, tapi yang sama: jari-jari udah terbiasa posisi tertentu. Mau belajar chord baru susah, tapi lebih susah: nge-ubah cara jari yang udah reflex.

Pas senior belajar hal baru, 70% effort buat "belajar yang baru." 30% effort buat "unlearn yang lama." Yang 30% itu yang bikin frustrasi. Otak lo udah otomatis pake pola lama. Tiap kali lo sadar lo pake pola lama, musti actively stop, inget pola baru, eksekusi. Tiap kali lupa, balik ke pola lama. Tiap kali balik, frustrasi naik.

---

Dunning-Kruger dan Senior Dev

Dunning-Kruger effect: orang yang baru belajar sesuatu overestimate kemampuan mereka. Grafik klasik: mulai dari "Mount Stupid" (sangat yakin padahal baru sedikit), turun ke "Valley of Despair" (sadar banyak yang gak tau), naik pelan ke "Slope of Enlightenment," akhirnya "Plateau of Sustainability."

Yang gue pelajarin: senior dev yang belajar hal baru mulai dari puncak plateau (di skill lama). Terus pindah ke topik baru, langsung jatuh ke Valley of Despair. Itu drop yang paling curam. Dari "gue jago" ke "gue gak ngerti apa-apa" dalam 1 minggu.

Sensasi drop itu yang gak siap. Bukan "gue belum belajar." Sensasi: "gue pikir gue pinter, ternyata gue bodoh." Ego yang kena.

Pas junior belajar, mereka naik dari 0. Tiap kemajuan = naik. Sense of progress. Pas senior belajar, mereka turun dari 100 ke 0 dulu, baru naik pelan. Sense of regression sebelum sense of progress.

Filosofi yang gue pegang sekarang: kalau lo senior dan belajar hal baru, lo musti accept bahwa lo akan ngerasa bodoh. Bukan "terlihat bodoh" - benar-benar bodoh di topik itu. Ego gak boleh ikut campur. Lo memang pemula di topik baru, walau senior di topik lama.

---

Mindset yang Bener (Yang Gue Susah Banget Pegang)

1. "Beginner's mind" bukan sekadar slogan.

Konsep Zen: shoshin, "beginner's mind." Baca tentang cara belajar senior. Intinya: kalau lo datang dengan kepala "gue udah ngerti," lo gak akan belajar. Lo harus datang dengan kepala "gue gak tau apa-apa."

Implementasinya susah. Tiap gue baca dokumentasi Rust, otak gue bilang "ah ini kayak di C, gue udah ngerti pointer." Terus gue skip baca, langsung coding. Error. Ternyata Rust reference beda konsep dengan C pointer. Gue harus balik baca, kali ini dengan ego diturunin.

// Gue pikir &mut itu kayak pointer di C
fn modify(val: &mut i32) {
*val += 1;
}

// Tapi Rust punya aturan: 1 mutable borrow OR many immutable borrows
// Gak boleh keduanya bersamaan
let mut x = 5;
let r1 = &x; // ok, immutable borrow
let r2 = &x; // ok, multiple immutable borrows allowed
let r3 = &mut x; // ERROR: cannot borrow as mutable, already borrowed as shared

Gue butuh 1 minggu buat paham kenapa Rust strict kayak gitu. Bukan karena Rust rumit, tapi karena gue musti unlearn Python/JS mindset di mana "semua reference, bebas dipake siapa aja."

2. Compare, but don't dismiss.

Salah satu cara paling cepet belajar: bandingin sama yang udah lo tau. "Di Python list.append(x). Di Rust vec.push(x). Sama tapi beda nama." Itu membantu.

Tapi bahaya kalau compare bikin dismissive. "Ah, Rust ribet, Python cuma 1 baris." Lo belajar bukan buat nge-bandingin mana yang "lebih baik." Lo belajar buat ngerti kenapa Rust didesign kayak gitu. Setiap bahasa punya philosophy.

Rust philosophy: "memory safety without garbage collector." Itu kenapa borrow checker strict. Bukan karena pembuatnya susahin lo, tapi karena safety itu tujuan utamanya. Kalau lo dismiss "Ribet, gue tetep Python," lo gak akan paham kenapa Rust menang di use case tertentu (system programming, embedded, performance-critical).

3. Pilih project kecil, bukan tutorial.

Gue pernah coba belajar Rust lewat tutorial. 1 minggu baca "The Rust Programming Language" book. Paham konsep, tapi gak bisa nulis. Pas coba nulis, blank.

Switch strategi: bikin project kecil. HTTP server pake axum, endpoint /health yang balikin JSON. 50 baris code. Dalam 50 baris itu, gue kena semua konsep: ownership, borrowing, Result type, async, error handling. Tiap error = belajar.

// 50 baris pertama gue di Rust
use axum::{Json, routing::get, Router};
use serde::Serialize;
use std::net::SocketAddr;

#[derive(Serialize)]
struct Health {
status: String,
uptime: u64,
}

async fn health() -> Json {
Json(Health {
status: "ok".to_string(),
uptime: 0,
})
}

#[tokio::main]
async fn main() {
let app = Router::new().route("/health", get(health));
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
println!("Listening on {}", addr);
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}

50 baris. 2 hari nulis (di Python 5 menit). Tapi 2 hari itu gue belajar lebih banyak dari 1 minggu baca buku. Karena belajar = active struggle, bukan passive consumption.

---

Yang Gue Pelajarin Dari Sisi Lebih Dalam

Belajar bukan akumulasi. Belajar adalah transformasi.

Gue pikir belajar = nambah pengetahuan ke kepala. Salah. Belajar = nge-ubah struktur kognitif lo. Otak lo harus rewiring untuk paham konsep baru. Itu yang berat.

Bayangin gue punya "rak buku" di otak: React, Node, Postgres, Python, Docker. Tiap rak punya struktur sendiri. Rust dateng, gue bikin rak baru. Tapi rak Rust gak bisa kosong - gue musti isi pake konsep yang gak ada di rak lain (ownership, lifetime, zero-cost abstraction). Tiap gue mau naruh konsep Rust, gue musti check rak lain: "apakah ini sama kayak di Python? Tidak. Apakah sama kayak di C? Sedikit. Bikin rak baru."

Proses itu = transformasi. Bukan nambah rak kosong, tapi modifikasi seluruh struktur. Itu kenapa capek. Bukan karena materi banyak, tapi karena otak lo actively restructuring.

Sense of progress hilang, muncul lagi.

Pas belajar Python dulu, tiap hari ada sense of progress. Hari 1: print hello world. Hari 2: if-else. Hari 3: function. Tiap hari jelas naik.

Pas belajar Rust sekarang, 2 minggu pertama gue ngerasa stagnan. Tiap hari baca dokumentasi, tiap hari gak ngerti. Hari 15 baru "klik" - semua yang gue baca 2 minggu jadi masuk akal. Sense of progress gak linear, tapi step function. Stuck lama, tiba-tiba naik. Frustrasi sebelum klik.

Filosofi yang gue pegang sekarang: belajar hal baru = investasi yang return-nya delay. Lo invest waktu 2 minggu, gak dapet apa-apa. Terus di minggu ke-3, semuanya klik. Sense of progress baru muncul setelah lo invest cukup. Pas senior, lo udah terbiasa "invest 1 jam, dapet hasil 1 jam." Belajar hal baru: invest 10 jam, dapet 0. Minggu depan invest 10 jam lagi, dapet 0. Baru 5 minggu kemudian, dapet 100. Tidak linear. Itu yang musti disiapkan secara mental.

---

Tanda-Tanda Lo Berjuang dengan Senior Learning Plateau

• Lo nulis code, gak jalan, langsung ngerasa "gue jelek" bukan "gue belum belajar"
• Lo bandingin diri sama junior yang udah jago bahasa itu, ngerasa insecure
• Lo baca dokumentasi, gak paham, frustasi - padahal dulu lo paham doc apapun dalam 10 menit
• Lo mulai mikir "mungkin gue emang gak cocok bahasa ini" padahal masalahnya cuma 2 minggu belum cukup
• Lo skip fundamental, langsung coding - pas error, gak ngerti kenapa karena fundamental gak solid

Setiap tanda di atas = ego yang lagi struggle. Bukan skill yang kurang. Mindset yang musti di-adjust.

---

Penutup yang Jujur

Belajar hal baru pas udah senior itu experience yang gak gue siapin. Gue pikir "gue senior, pasti gampang." Enggak. Justru lebih susah, karena ego, karena ekspektasi, karena harus unlearn.

Filosofi yang gue bawa sekarang: kalau lo senior dan belajar hal baru, lo musti matiin ego lo dulu. Lo emang pemula di topik baru, walau senior di topik lama. Accept that. Gak malu nanya. Gak malu lambat. Gak malu error message gak ngerti.

Rust 2 bulan kemudian: gue masih struggle, tapi gue udah bisa nulis HTTP server, CLI tool, dan kecil-keilan script. Masih lambat dibanding Python, tapi tiap baris code yang gue tulis di Rust, gue ngerti kenapa gue tulis gitu. Itu yang beda dari Python - gue nulis Python karena familiar, gue nulis Rust karena paham.

Gue gak akan bilang "Rust lebih baik dari Python." Gue bilang: belajar Rust nge-ubah cara gue mikir tentang memory dan ownership, dan cara berpikir itu balik mempengaruhi cara gue nulis Python. Belajar hal baru gak cuma nambah skill, tapi nge-ubah cara lo liat hal yang udah lo tau.

Kalau lo senior yang lagi struggle belajar hal baru: lo gak sendirian. Itu normal. Ego lo yang gak normal - terlalu tinggi. Turunin. Lo pemula di topik baru. Mulai dari situ.