Bagian yang Salah Paham dari Tutorial

Setelah bertahun-tahun betah di TypeScript dan React, aku memutuskan serius belajar Go.

Tutorial yang kutemukan semuanya bentuknya sama: tiga bab tentang variabel dan loop, satu bagian soal if, dan — kalau beruntung — satu paragraf soal error handling di halaman paling belakang. Hasilnya: sepuluh menit sudah lancar nulis for loop di Go, tapi begitu ketemu cfg, err := loadConfig(), aku diem menerawang lumayan lama haha.

Di situ akhirnya nyambung: tutorial itu dioptimalkan buat pemula, dan aku bukan pemula — aku cuma pemula di bahasa ini, bukan pemula programming. Yang sebenarnya kubutuhkan adalah peta terjemahan dari mental model yang sudah ada ke sintaks baru. Peta itu tidak dijual di mana-mana.

Jadi ya... bikin sendiri. Dalam bentuk playbook buat AI agent-ku.

Framework 4 Pillar

cross-lang-analogy adalah playbook di repo agent-playbooks-ku (lihat artikel sebelumnya). Playbook ini aktif setiap kali kutanya soal bahasa baru, dan memaksa setiap penjelasan melewati empat pillar:

1. Literal Syntax Reading. Sebelum istilah teknis, kode asing diterjemahkan jadi bahasa manusia biasa, baris per baris. := jadi "deklarasi sekaligus infer tipe" — bukan trivia yang harus dihafal.
2. Padanan di Bahasa yang Dikuasai. Logika yang sama persis, disandingkan berdampingan, di bahasa yang selama ini jadi cara aku mikir.
3. Paradigm Shift & "Kenapa"-nya. Ini yang paling penting. Kenapa bahasa ini tidak pakai cara yang familiar? Nilai desain apa yang mau dijaga?
4. False Friends & Gotchas. Kebiasaan dari stack lama yang di bahasa baru lolos compile — tapi meledaknya di runtime.

Wujud Nyatanya

Nanya "error handling di Go gimana?" dengan playbook ini aktif hasilnya beda dari tutorial. Literal reading dulu: fungsi Go mengembalikan dua nilai, yang kedua adalah error — nil berarti aman. Lalu side-by-side:

// TypeScript: error jalan lewat exception
try {
  const config = loadConfig();
} catch (err) {
  // handle — atau tidak, compiler tidak memaksa
}

// Go: error adalah return value biasa
config, err := loadConfig()
if err != nil {
    return fmt.Errorf("loading config: %w", err)
}

Terus bagian "kenapa": di Go, error adalah value, jadi dia muncul di signature fungsi. Kegagalan adalah bagian dari kontrak tipe, bukan jalur control-flow tersembunyi. Reframing sesederhana ini sudah lebih berguna daripada puluhan halaman "getting started".

Dan terakhir false friend — pillar favoritku. Datang dari TypeScript, aku bisa saja abaikan err dan langsung pakai config. Lolos compile. Tapi config bisa saja nil, dan tidak ada catch yang datang menolong — yang ada cuma runtime panic. Tahu jebakan spesifik ini sebelum nulis Go lebih berharga daripada seratus halaman tutorial.

Satu Anchor, Pelajaran yang Berbeda

Ada satu detail desain yang kusuka: Phase 1 playbook ini adalah anchor discovery — dia bertanya dulu bahasa apa yang paling kamu kuasai sebelum mulai menjelaskan. Soalnya konsep Go yang sama butuh jembatan berbeda buat developer Python (mana duck typing-ku?) versus developer Java (mana class hierarchy-ku?).

Anchor language itu bukan sekadar pengetahuan tambahan — dia sistem koordinatnya. Ganti anchor, semua analoginya ikut berubah.

Lessons Learned

• Belajar bahasa baru itu sebagian besar terjemahan, bukan hafalan — petakan paradigmanya, jangan grind sintaksnya.
• "Kenapa" mengalahkan "cara". Paradigm shift (errors as values, ownership, concurrency CSP) adalah tempat pemahaman sebenarnya tinggal.
• Gotcha itu spesifik per pasangan bahasa. Warning yang dibutuhkan developer TS soal Go berbeda dengan yang dibutuhkan developer Python.
• Formatnya plain markdown, jadi jalan di agent apa pun — Claude Code, Cursor, apa pun yang bisa baca file.

Kalau tahun ini sedang pindah stack, coba ubah kerangka prompt-mu: "jelaskan seperti aku developer TypeScript" itu prompt yang jauh lebih bagus daripada "jelaskan ke aku". Semoga membantu buat yang sedang di fase yang sama. 😄