Go 1.26 Wawancara Teknis: Green Tea GC, go fix, dan Optimasi Stack

Go 1.26, yang dirilis pada Februari 2026, menghadirkan garbage collector Green Tea sebagai GC default, alat go fix yang dirancang ulang sepenuhnya, serta optimasi signifikan pada alokasi stack. Perubahan-perubahan ini merupakan peningkatan runtime paling substansial dalam beberapa rilis terakhir Go, dan topik-topik tersebut semakin sering muncul dalam sesi wawancara teknis.

Apa Itu Garbage Collector Green Tea di Go 1.26?

Green Tea merupakan garbage collector default baru di Go 1.26, menggantikan strategi pemindaian pada collector concurrent tri-color sebelumnya. Alih-alih melakukan pointer-chasing terhadap objek-objek yang tersebar di heap, Green Tea memindai seluruh halaman memori berukuran 8 KiB secara berurutan. Pola akses memori yang berdekatan (contiguous) ini memungkinkan prefetcher CPU bekerja secara efektif, menghasilkan pengurangan overhead GC antara 10% hingga 40% pada program nyata.

Pada CPU modern seperti Intel Ice Lake atau AMD Zen 4 dan yang lebih baru, GC memanfaatkan instruksi vektor SIMD untuk pemindaian objek berukuran kecil, memberikan peningkatan tambahan sekitar 10%.

Pertanyaan lanjutan yang sering diajukan dalam wawancara adalah bagaimana Green Tea meningkatkan perilaku cache CPU selama proses garbage collection. GC sebelumnya mengikuti pointer antar objek di seluruh heap, yang menyebabkan cache miss secara berulang. Green Tea memproses objek halaman demi halaman dalam blok berurutan berukuran 8 KiB. Prefetcher CPU dapat memprediksi pola akses memori sekuensial tersebut, sehingga cache L1/L2 tetap aktif dan terisi. Peningkatan lokalitas inilah yang menjadi faktor utama di balik pengurangan overhead 10-40%.

// Previous approach: follow pointers across heap
func scanObject(obj *mspan) {
    for _, ptr := range obj.pointers {
        markReachable(ptr) // cache miss likely
    }
}

// Green Tea approach: scan contiguous pages
func scanPage(page *pageBlock) {
    // Sequential 8 KiB scan - CPU prefetcher friendly
    for offset := 0; offset < pageSize; offset += objSize {
        scanSlot(page.base + offset) // cache hit likely
    }
}

Green Tea dapat dinonaktifkan menggunakan GOEXPERIMENT=nogreenteagc saat proses build, namun opsi penonaktifan ini kemungkinan besar akan dihapus pada Go 1.27.

Optimasi Alokasi Stack untuk Slice di Go 1.26

Go 1.26 memperluas alokasi stack ke backing store slice selama proses akumulasi berbasis append. Pada versi sebelumnya, pemanggilan append pertama mengalokasikan slice berukuran 1 di heap, kemudian 2, lalu 4, lalu 8 (penggandaan standar). Go 1.26 mengalokasikan backing store kecil berbasis stack sebelum loop dimulai, sehingga beberapa append pertama menggunakan buffer stack tanpa melibatkan heap sama sekali.

func collectTasks(items []Item) []Task {
    var tasks []Task
    // Before Go 1.26: first append allocates on heap (size 1, 2, 4...)
    // Go 1.26: compiler inserts a stack-backed buffer
    for _, item := range items {
        if item.IsReady() {
            tasks = append(tasks, item.ToTask())
            // First ~4 appends use stack buffer, zero heap allocations
        }
    }
    return tasks
    // If slice escapes, runtime.move2heap() copies once at return
}

Pertanyaan lanjutan yang kerap muncul: apa yang terjadi ketika slice melampaui cakupan fungsi? Bahkan ketika slice harus berpindah ke heap (karena fungsi mengembalikannya), Go 1.26 tetap menggunakan buffer stack selama fase akumulasi. Compiler menyisipkan pemanggilan runtime.move2heap() yang menyalin data akhir ke heap tepat satu kali pada titik pengembalian. Alih-alih melakukan 3 atau lebih alokasi heap awal (ukuran 1, 2, 4...), hasilnya hanyalah tepat 1 alokasi heap di akhir. Pendekatan ini dalam banyak kasus bahkan mengungguli pre-alokasi manual yang dioptimasi, karena penyalinan hanya terjadi jika data sepenuhnya berada di stack hingga titik pengembalian.

Perubahan pada Alat go fix di Go 1.26

Alat go fix telah ditulis ulang secara menyeluruh sebagai wadah bagi modernizers Go. Alat ini menyediakan cara cepat untuk memperbarui basis kode Go ke idiom dan API pustaka standar terbaru. go fix yang baru dibangun di atas framework analisis yang sama dengan go vet, yang berarti analyzer yang menyediakan diagnostik kini juga dapat menyarankan dan menerapkan perbaikan.

Fitur-fitur utama go fix yang baru meliputi puluhan fixer untuk idiom dan API Go modern, inliner tingkat kode sumber yang diaktifkan oleh direktif //go:fix inline, jaminan nol perubahan perilaku (aman untuk kode produksi), serta penghapusan fixer usang dari versi alat sebelumnya.

# Apply all modernizers to the current module
go fix ./...

# The tool automatically updates patterns like:
# - Old-style error wrapping to fmt.Errorf with %w
# - Deprecated API calls to their replacements
# - Legacy patterns to modern Go idioms

Direktif //go:fix inline menandai suatu fungsi atau metode sebagai kandidat untuk inlining tingkat kode sumber oleh go fix. Ketika go fix dijalankan, alat ini mengganti situs pemanggilan fungsi yang diberi anotasi dengan badan fungsinya. Ini berbeda dari inlining compiler: transformasi terjadi pada kode sumber, bukan pada kode mesin yang dihasilkan. Pembuat pustaka memanfaatkan fitur ini untuk mendeprekasi fungsi wrapper dengan cara meng-inline-kan isi fungsi tersebut ke padanan modern di titik pemanggilan.

Peningkatan Performa cgo di Go 1.26

Go 1.26 mengurangi overhead dasar setiap pemanggilan cgo sekitar 30%. Runtime mencapai hal ini dengan menghilangkan state prosesor _Psyscall, sebuah state perantara yang harus dilalui goroutine selama pemanggilan cgo. Penghapusan state transisi ini mengurangi jumlah perpindahan state pada setiap pemanggilan cgo, sehingga secara langsung menurunkan latensi.

Peningkatan ini sangat relevan bagi aplikasi yang melakukan pemanggilan cgo secara intensif, seperti program yang menggunakan pustaka C untuk driver database, pemrosesan gambar, atau operasi kriptografi. Perbaikan ini tidak memerlukan perubahan kode apa pun dari sisi developer.

Perubahan Bahasa di Go 1.26

Go 1.26 memperkenalkan dua perubahan bahasa yang perlu dipahami untuk persiapan wawancara teknis.

1. Fungsi new() yang Ditingkatkan: Fungsi bawaan new kini menerima ekspresi sebagai operand, yang menentukan nilai awal variabel. Sebelumnya, new(T) selalu mengembalikan *T dengan nilai nol.

type Config struct {
    Timeout  *int
    MaxRetry *int
}

// Before Go 1.26: helper function needed
func intPtr(v int) *int { return &v }
func makeConfig() Config {
    return Config{
        Timeout:  intPtr(30),
        MaxRetry: intPtr(3),
    }
}

// Go 1.26: direct initialization
func makeConfig() Config {
    return Config{
        Timeout:  new(30),  // *int pointing to 30
        MaxRetry: new(3),   // *int pointing to 3
    }
}

2. Tipe Generik Self-Referential: Tipe generik kini dapat mereferensikan dirinya sendiri dalam constraint parameter tipe, memungkinkan pola abstraksi lanjutan seperti F-bounded polymorphism.

type Adder[A Adder[A]] interface {
    Add(A) A
}

type Vector2D struct{ X, Y float64 }

func (v Vector2D) Add(other Vector2D) Vector2D {
    return Vector2D{v.X + other.X, v.Y + other.Y}
}

// The constraint ensures the return type matches the receiver type
func Sum[A Adder[A]](items []A) A {
    var result A
    for _, item := range items {
        result = result.Add(item)
    }
    return result
}

Deteksi Kebocoran Goroutine di Go 1.26

Go 1.26 memperkenalkan tipe profil eksperimental goroutineleak di runtime/pprof. Goroutine yang mengalami kebocoran adalah goroutine yang terblokir pada sebuah primitif konkurensi (channel, sync.Mutex, sync.Cond) dan tidak memiliki kemungkinan untuk dibuka blokirnya. Runtime mendeteksi kondisi kebocoran ini menggunakan garbage collector: jika goroutine G terblokir pada primitif P, dan P tidak dapat dijangkau dari goroutine mana pun yang sedang berjalan, maka G tidak akan pernah terbangun.

func processWorkItems(ws []workItem) ([]workResult, error) {
    ch := make(chan result)
    for _, w := range ws {
        go func() {
            res, err := processWorkItem(w)
            ch <- result{res, err} // goroutine blocks here if early return
        }()
    }
    for range len(ws) {
        r := <-ch
        if r.err != nil {
            return nil, r.err // remaining goroutines leak
        }
    }
    return results, nil
}
// Enable detection: GOEXPERIMENT=goroutineleakprofile
// Endpoint: /debug/pprof/goroutineleak

Deteksi ini memanfaatkan analisis keterjangkauan (reachability analysis) GC, sehingga mampu menangkap berbagai kelas kebocoran tanpa memerlukan instrumentasi manual. Fitur ini diperkirakan akan diaktifkan secara default pada Go 1.27.

Peningkatan Keamanan di Go 1.26

Dua peningkatan keamanan yang perlu diperhatikan untuk konteks wawancara teknis:

Randomisasi Alamat Dasar Heap (platform 64-bit): Runtime kini melakukan randomisasi alamat dasar heap saat startup, sehingga mempersulit penyerang dalam memprediksi alamat memori ketika mengeksploitasi kerentanan melalui cgo. Ini merupakan pertahanan tipe ASLR untuk memori heap Go. Fitur ini dapat dinonaktifkan dengan GOEXPERIMENT=norandomizedheapbase64.

Kriptografi Pasca-Kuantum Diaktifkan Secara Default: Koneksi TLS kini menggunakan pertukaran kunci hibrida secara default (SecP256r1MLKEM768, SecP384r1MLKEM1024), menggabungkan kriptografi kurva eliptik klasik dengan ML-KEM (sebelumnya dikenal sebagai CRYSTALS-Kyber) untuk ketahanan terhadap komputasi kuantum. Paket crypto/mlkem juga mengalami peningkatan performa sekitar 18% pada proses enkapsulasi dan dekapsulasi.

Peningkatan Performa Pustaka Standar di Go 1.26

Sejumlah fungsi dalam pustaka standar telah menerima optimasi yang signifikan:

| Fungsi | Peningkatan | Detail | |----------|------------|--------| | fmt.Errorf (tanpa format verbs) | ~92% lebih cepat | Pemanggilan tanpa format kini menyamai performa errors.New | | io.ReadAll | ~2x lebih cepat, 50% lebih hemat memori | Menggunakan pertumbuhan buffer eksponensial alih-alih linear | | crypto/mlkem | ~18% lebih cepat | Enkapsulasi dan dekapsulasi yang dioptimasi | | image/jpeg | Lebih cepat, lebih akurat | Implementasi encoder/decoder baru |

Selain itu, bytes.Buffer mendapatkan metode Peek(), errors mendapatkan fungsi generik AsType(), dan reflect memperkenalkan metode iterator (Type.Fields(), Type.Methods(), Value.Fields()) yang selaras dengan pola range-over-func di Go.

Fungsi Generik errors.AsType untuk Penanganan Error

errors.AsType[T]() merupakan alternatif generik dari errors.As(). Fungsi ini menghilangkan kebutuhan untuk mendeklarasikan variabel target sebelum memanggil As, sehingga mengurangi kode boilerplate secara signifikan.

// Before Go 1.26: two-step process
var pathErr *os.PathError
if errors.As(err, &pathErr) {
    log.Printf("path error on %s: %v", pathErr.Path, pathErr.Err)
}

// Go 1.26: single expression
if pathErr, ok := errors.AsType[*os.PathError](err); ok {
    log.Printf("path error on %s: %v", pathErr.Path, pathErr.Err)
}

Versi generik ini menjamin keamanan tipe pada waktu kompilasi dan menghasilkan kode yang lebih mudah dibaca dalam rangkaian kondisional.

Kesimpulan

• Green Tea GC memindai halaman memori berukuran 8 KiB secara berurutan alih-alih melakukan pointer-chasing, memberikan pengurangan overhead GC sebesar 10-40% tanpa perubahan kode apa pun
• Backing store slice yang dialokasikan di stack menghilangkan 3 atau lebih alokasi heap awal selama loop append, dan hanya menyalin ke heap satu kali di titik escape
• Alat go fix yang diperbarui menerapkan puluhan modernizers berbasis framework analisis go vet, dengan jaminan nol perubahan perilaku
• new() kini menerima ekspresi, menghilangkan kebutuhan fungsi helper untuk pembuatan pointer
• Constraint tipe generik self-referential memungkinkan pola F-bounded polymorphism
• Deteksi kebocoran goroutine (eksperimental) menggunakan analisis keterjangkauan GC untuk mengidentifikasi goroutine yang terblokir secara permanen
• fmt.Errorf tanpa format verbs kini 92% lebih cepat, dan io.ReadAll menggunakan 50% lebih sedikit memori
• Pertukaran kunci hibrida pasca-kuantum diaktifkan secara default pada koneksi TLS

Untuk mempersiapkan diri menghadapi pertanyaan wawancara Go, pemahaman mendalam terhadap perubahan runtime ini sangat penting. Panduan konkurensi Go membahas pola-pola dasar goroutine yang melengkapi fitur deteksi kebocoran yang dibahas dalam artikel ini.