Tutorial Coding: Keluar dari Plateau of False Competence di Python

Tutorial Coding: Keluar dari Plateau of False Competence di Python

Ada satu fase berbahaya dalam karier hampir setiap developer. Fase ini nggak kelihatan, nggak ada error message, dan nggak bikin aplikasi langsung crash. Tapi efek jangka panjangnya brutal. Namanya: Plateau of False Competence.

Biasanya muncul sekitar tahun kedua ngoding. Di fase ini, kamu sudah hafal sintaks. Sudah bisa bikin API pakai Flask atau FastAPI. Sudah deploy ke AWS atau VPS. Loop for sudah otomatis ngetik sendiri di otak. Kamu merasa “udah jago”.

Masalahnya: merasa jago ≠ benar-benar paham.

Banyak developer (termasuk saya) terjebak bertahun-tahun di sini. Kodenya jalan. Fitur terkirim. Tapi begitu ketemu bug aneh, race condition, atau memory leak yang nggak masuk akal semuanya ambruk. Bukan karena Python jelek, tapi karena fondasinya bolong.

Tutorial ini bukan tentang “cara bikin app”, tapi tentang cara memahami Python sebagai bahasa, bukan sekadar alat. Kita mulai dari jebakan paling klasik yang jadi pembuka mata banyak orang.

1. Jebakan Mematikan: Mutable Default Argument

Kalau kamu cuma ingat satu hal dari artikel ini, ingat bagian ini. Ini bukan teori. Ini bug nyata yang pernah bikin data bocor antar user di sistem produksi.

Perhatikan kode berikut:

def add_buyer(buyer, buyers=[]):
    buyers.append(buyer)
    return buyers


print(add_buyer("Alice"))  # ['Alice']
print(add_buyer("Bob"))    # ['Alice', 'Bob']  # LOH?

Secara logika manusia normal, harusnya pemanggilan kedua cuma berisi ['Bob']. Tapi Python bilang lain. Dan ini bukan bug Python. Ini desain.

Baca Juga

• Belajar Fungsi Tanpa Parameter Python
• Python Kryword Arguments

 

Di Mana Kesalahannya?

Di Python, default argument dievaluasi satu kali, saat fungsi didefinisikan—bukan setiap kali fungsi dipanggil.

Artinya:

• buyers=[]dibuat sekali
• List itu disimpan di memori
• Setiap pemanggilan fungsi pakai list yang sama

Jadi kamu bukan bikin list baru. Kamu mendaur ulang list lama.

Kalau kamu terbiasa dengan C++ atau Java, ini terasa “aneh”. Tapi Python bukan C++ dengan sintaks lucu. Python punya model objek sendiri.

Solusi yang Benar: Sentinel Value (None)

Pola yang benar adalah selalu pakai None untuk default mutable.

def add_buyer(buyer, buyers=None):
    if buyers is None:
        buyers = []
    buyers.append(buyer)
    return buyers

Sekarang setiap pemanggilan fungsi dapat list baru. Aman. Predictable. Nggak bocor ke mana-mana.

Ini bukan cuma soal list. Berlaku juga untuk:

• dictionary
• set
• object custom

Kalau default-nya mutable, jangan pernah langsung ditulis di parameter.

Kenapa Ini Bisa Terjadi ? Memori, Objek, dan Referensi

Masalah ini muncul karena banyak developer menganggap variabel itu seperti “wadah”. Padahal di Python, variabel itu label ke objek.

a = []
b = a
b.append(1)
print(a)  # [1]

a dan b bukan dua list. Mereka menunjuk ke objek yang sama di memori.

Begitu kamu paham ini, banyak “keanehan Python” tiba-tiba masuk akal:

• Kenapa list bisa berubah tanpa kamu sadari
• Kenapa default argument bisa bocor
• Kenapa copy kadang nggak benar-benar copy

 

2. Shallow Copy vs Deep Copy (Musuh Dalam Selimut)

Banyak bug muncul dari asumsi bahwa copy() itu aman.

original = [[1, 2], [3, 4]]
copied = original.copy()


copied[0].append(99)
print(original)  # [[1, 2, 99], [3, 4]]

Kenapa original ikut berubah?

Karena copy() itu shallow copy. Yang disalin cuma referensi level pertama. Objek di dalamnya masih sama.

Kalau kamu butuh benar-benar terpisah:

import copy
deep_copied = copy.deepcopy(original)

Ini penting banget di:

• konfigurasi aplikasi
• template data
• state management

 

3. Immutability: Kenapa Tuple Lebih Aman dari List

List bisa berubah. Tuple tidak.

config = ("localhost", 5432)

Kenapa ini penting?

Karena object immutable:

• aman dipakai sebagai key dictionary
• lebih aman di multi-threading
• kecil kemungkinan berubah tanpa sengaja

Makanya string itu immutable. Kalau string mutable, Python bakal jadi mimpi buruk.

 

4. Function Is an Object (Bukan Sekadar Blok Kode)

Di Python, fungsi itu objek kelas satu.

def greet(name):
    return f"Halo {name}"


say_hello = greet
print(say_hello("Froz"))

Ini bukan trik. Ini fondasi:

• decorator
• callback
• higher-order function

Kalau kamu pakai framework tapi nggak paham ini, kamu cuma “pemakai”, bukan “penguasa”.

 

5. Late Binding di Loop (Bug yang Bikin Garuk Kepala)

Contoh klasik:

funcs = []
for i in range(3):
    funcs.append(lambda: i)


print([f() for f in funcs])  # [2, 2, 2]

Kenapa bukan [0, 1, 2]?

Karena i dievaluasi saat fungsi dipanggil, bukan saat dibuat.

Solusinya:

funcs.append(lambda i=i: i)

Ini kelihatan sepele, tapi sering muncul di:

• async code
• event handler
• closure kompleks

 

6. is vs ==: Kembar Tapi Tak Sama

a = [1, 2, 3]
b = [1, 2, 3]


a == b  # True
a is b  # False

• ==→ nilai sama
• is→ objek yang sama

Kesalahan pakai is bisa bikin bug logika yang tidak konsisten dan susah direproduksi.

 

7. Truthy dan Falsy: Python Lebih Fleksibel dari yang Kamu Kira

if []:
    print("Ini jalan?")  # Tidak

Di Python:

• list kosong → False
• string kosong → False
• 0 → False
• None → False

Ini powerful, tapi juga berbahaya kalau kamu nggak sadar apa yang sedang dicek.

 

8. Exception Bukan Musuh, Tapi Kontrak

Banyak developer takut try-except.

Padahal:

try:
    value = int(user_input)
except ValueError:
    value = 0

Ini bukan tanda gagal. Ini tanda kamu mengantisipasi realita.

Code tanpa exception handling itu optimis berlebihan.

 

9. Python Bukan Interpreted Sederhana

Python:

• compile ke bytecode
• disimpan di .pyc
• dijalankan oleh virtual machine

Kenapa ini penting? Karena ini menjelaskan:

• kenapa import cepat setelah pertama kali
• kenapa scope dan lifetime objek bekerja seperti itu

 

10. “Works” Is Not the Goal

Kode yang “jalan” itu baru syarat minimum, bukan garis finish. Aplikasi bisa hidup hari ini, tapi pertanyaannya: apakah masih bisa dipahami besok, minggu depan, atau enam bulan lagi saat bug muncul jam 2 pagi? Kode yang baik itu predictable—perilakunya konsisten dan bisa ditebak. Ia juga maintainable, artinya mudah dirawat, diperbaiki, dan dikembangkan tanpa rasa takut merusak bagian lain. Kalau setiap perubahan kecil bikin deg-degan, itu tanda kodenya memang “jalan”, tapi belum sehat.

Titik baliknya ada pada pemahaman. Saat kamu bisa menjelaskan kenapa sebuah fungsi ditulis seperti itu, kenapa struktur datanya dipilih, dan apa konsekuensinya di memori atau performa, di situlah kamu naik level. Kamu tidak lagi sekadar membuat Python menuruti perintah, tapi benar-benar mengendalikan bahasanya. Ketika kode bisa kamu jelaskan dengan tenang ke orang lain—atau ke diri sendiri di masa depan—itulah momen resmi keluar dari Plateau of False Competence.

 

Penutup: Turun Dulu untuk Naik Lebih Tinggi

Hampir semua developer hebat pernah sadar satu hal pahit: “Selama ini gue cuma kelihatan jago.” Dan itu bukan kegagalan. Itu titik balik.

Balik lagi ke dasar bukan berarti mundur. Justru itu cara satu-satunya buat naik level. Python itu bahasa yang ramah, tapi jangan salah—di balik kesederhanaannya, ada konsep serius yang menentukan apakah kamu cuma tukang ketik kode, atau engineer sungguhan.

Kalau kamu merasa “kok banyak yang baru gue sadari”, itu pertanda bagus. Artinya kamu sudah mulai benar-benar belajar.

Published on March 03, 2026
Last updated on June 03, 2026