Go 1.26 na rozmowie rekrutacyjnej: Green Tea GC, go fix i optymalizacje stosu

Go 1.26, wydane w lutym 2026 roku, wprowadza trzy fundamentalne zmiany w srodowisku uruchomieniowym: garbage collector Green Tea jako domyslny mechanizm odsmiecania pamieci, gruntownie przebudowane narzedzie go fix oraz optymalizacje alokacji slice'ow na stosie. Kazda z tych zmian bezposrednio wplywa na wydajnosc produkcyjnych aplikacji, a znajomosc ich dzialania staje sie coraz czestszym wymogiem podczas rozmow kwalifikacyjnych na stanowiska zwiazane z Go. Niniejszy artykul omawia najwazniejsze aspekty Go 1.26 w formacie pytan rekrutacyjnych, z konkretnymi przykladami kodu i wyjasnieniami mechanizmow wewnetrznych.

Czym jest garbage collector Green Tea w Go 1.26?

Oczekiwana odpowiedz: Green Tea to nowy domyslny garbage collector w Go 1.26, zastepujacy dotychczasowa strategie skanowania stosowana przez wspolbiezny kolektor trojkolorowy. Zamiast sledzic pojedyncze obiekty rozproszone po stercie (tzw. pointer-chasing), Green Tea skanuje cale 8 KiB strony pamieci sekwencyjnie. Taki wzorzec dostepu do ciaglych blokow pamieci umozliwia efektywne dzialanie mechanizmu prefetchingu procesora, co przekalda sie na redukcje narzutu GC o 10-40% w rzeczywistych aplikacjach.

Na nowoczesnych procesorach (Intel Ice Lake, AMD Zen 4 i nowsze) garbage collector dodatkowo wykorzystuje instrukcje wektorowe SIMD do skanowania malych obiektow, co daje okolo 10% dodatkowej poprawy wydajnosci.

Pytanie uzupelniajace: W jaki sposob Green Tea poprawia zachowanie pamieci podrecznej procesora podczas odsmiecania?

Poprzedni GC podazal za wskaznikami miedzy obiektami rozrzuconymi po calej stercie, co powodowalo czeste chybienia w pamieci podrecznej (cache misses). Green Tea przetwarza obiekty strona po stronie w ciaglych blokach 8 KiB. Prefetcher procesora potrafi przewidziec sekwencyjny wzorzec dostepu do pamieci, utrzymujac pamiec podreczna L1/L2 w stanie aktywnym. To wlasnie poprawa lokalnosci dostepu stanowi glowny czynnik odpowiedzialny za redukcje narzutu o 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 mozna wylaczyc flaga GOEXPERIMENT=nogreenteagc podczas kompilacji, jednak ta opcja zostanie usunieta w Go 1.27.

Jak Go 1.26 optymalizuje alokacje slice'ow na stosie?

Oczekiwana odpowiedz: Go 1.26 rozszerza mozliwosc alokacji na stosie o bufory zapasowe slice'ow podczas operacji akumulacji z uzyciem append. We wczesniejszych wersjach pierwsze wywolanie append alokwalo slice o dlugosci 1 na stercie, nastepnie 2, potem 4, potem 8 (standardowe podwajanie). Go 1.26 tworzy maly bufor na stosie przed wejsciem do petli, dzieki czemu kilka pierwszych operacji append korzysta z bufora stosowego bez angarzowania sterty.

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
}

Pytanie uzupelniajace: Co dzieje sie, gdy slice opuszcza zakres funkcji?

Nawet gdy slice musi trafic na sterte (poniewaz funkcja zwraca go na zewnatrz), Go 1.26 nadal wykorzystuje bufor stosowy podczas fazy akumulacji. Kompilator wstawia wywolanie runtime.move2heap(), ktore kopiuje ostateczne dane na sterte dokladnie raz w punkcie zwracania wartosci. Zamiast 3 lub wiecej startowych alokacji na stercie (rozmiary 1, 2, 4...), wynik to dokladnie 1 alokacja na stercie na koncu.

Co zmienilo sie w narzedziu go fix w Go 1.26?

Oczekiwana odpowiedz: Narzedzie go fix zostalo calkowicie przepisane i pelni teraz role centralnego repozytorium modernizatorow kodu Go. Zapewnia jednoprzyciskowy sposob aktualizacji baz kodu do najnowszych idiomow i API biblioteki standardowej. Nowe go fix oparte jest na tym samym frameworku analizy co go vet, co oznacza, ze te same analizatory, ktore wyswietlaja diagnostyke, moga rowniez sugerowac i automatycznie wprowadzac poprawki.

Glowne cechy nowego narzedzia go fix:

• Dziesiaki modernizatorow dla wspolczesnych idiomow i API Go
• Inliner na poziomie kodu zrodlowego aktywowany dyrektywa //go:fix inline
• Gwarancja braku zmian w zachowaniu programu (bezpieczne dla kodu produkcyjnego)
• Usuniecie przestarzalych modernizatorow z poprzedniej wersji narzedzia

# 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

Pytanie uzupelniajace: Jak dziala dyrektywa //go:fix inline?

Dyrektywa //go:fix inline oznacza funkcje lub metode jako kandydata do inliningu na poziomie kodu zrodlowego przez go fix. Podczas uruchomienia narzedzia wywolania oznaczonej funkcji sa zastepowane jej trescia bezposrednio w miejscu uzycia. Rozni sie to od inliningu kompilatora: transformacja odbywa sie na kodzie zrodlowym, nie na wygenerowanym kodzie maszynowym.

Poprawa wydajnosci cgo w Go 1.26

Oczekiwana odpowiedz: Go 1.26 redukuje bazowy narzut kazdego wywolania cgo o okolo 30%. Srodowisko uruchomieniowe osiagnelo to poprzez eliminacje stanu procesora _Psyscall -- posredniego stanu, przez ktory goroutine przechodzily podczas wywolan cgo. Usuniecie tego stanu przejsciowego zmniejsza liczbe zmian stanu przypadajacych na jedno wywolanie cgo, co bezposrednio redukuje opoznienia.

Jakie zmiany jezykowe wprowadza Go 1.26?

Oczekiwana odpowiedz: Go 1.26 wprowadza dwie zmiany na poziomie jezyka:

1. Rozszerzona funkcja new(): Wbudowana funkcja new akceptuje teraz wyrazenie jako operand, okreslajace wartosc poczatkowa zmiennej. Dotychczas new(T) zawsze zwracalo wskaznik do wartosci zerowej typu *T.

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. Samoodwolujace sie typy generyczne: Typy generyczne moga teraz odwolywac sie do samych siebie w ograniczeniach parametrow typow, co umozliwia zaawansowane wzorce abstrakcji typow, takie jak polimorfizm ograniczony (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
}

Wykrywanie wyciekow goroutine w Go 1.26

Oczekiwana odpowiedz: Go 1.26 wprowadza eksperymentalny typ profilu goroutineleak w pakiecie runtime/pprof. Wyciek goroutine definiowany jest jako goroutine zablokowana na prymitywie wspolbieznosci (kanal, sync.Mutex, sync.Cond), ktora nie ma mozliwosci odblokowania. Srodowisko uruchomieniowe wykrywa takie wycieki za pomoca garbage collectora: jesli goroutine G jest zablokowana na prymitywie P, a P jest nieosiagalny z zadnej uruchamialnej goroutine, wowczas G nigdy sie nie obudzi.

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

Ulepszenia bezpieczenstwa w Go 1.26

Oczekiwana odpowiedz: Go 1.26 wprowadza dwa istotne ulepszenia w zakresie bezpieczenstwa:

Randomizacja adresu bazowego sterty (platformy 64-bitowe): Srodowisko uruchomieniowe losowo wybiera adres bazowy sterty przy starcie programu, co utrudnia atakujacym przewidywanie adresow pamieci podczas prob wykorzystania podatnosci przez cgo. Mechanizm ten stanowi odpowiednik ASLR dla pamieci sterty w Go.

Kryptografia postkwantowa wlaczona domyslnie: Polaczenia TLS korzystaja teraz domyslnie z hybrydowej wymiany kluczy (SecP256r1MLKEM768, SecP384r1MLKEM1024), laczacej klasyczna kryptografie krzywych eliptycznych z ML-KEM (dawniej CRYSTALS-Kyber) w celu zapewnienia odpornosci na ataki z uzyciem komputerow kwantowych.

Poprawa wydajnosci biblioteki standardowej w Go 1.26

Oczekiwana odpowiedz:

| Funkcja | Poprawa | Szczegoly | |----------|------------|--------| | fmt.Errorf (bez czasownikow formatowania) | ~92% szybciej | Wywolania bez formatowania osiagaja wydajnosc errors.New | | io.ReadAll | ~2x szybciej, 50% mniej pamieci | Bufor rosnie wykladniczo zamiast liniowo | | crypto/mlkem | ~18% szybciej | Zoptymalizowane operacje enkapsulacji i dekapsulacji | | image/jpeg | Szybciej, dokladniej | Nowa implementacja kodera/dekodera |

Dodatkowo bytes.Buffer zyskal metode Peek(), pakiet errors wzbogacil sie o generyczna funkcje AsType(), a pakiet reflect otrzymal metody iteratorowe zgodne ze wzorcem range-over-func.

Jak nowa funkcja errors.AsType upraszcza obsluge bledow?

Oczekiwana odpowiedz: errors.AsType[T]() to generyczna alternatywa dla errors.As(). Eliminuje koniecznosc deklarowania zmiennej docelowej przed wywolaniem As, redukujac ilosc kodu szablonowego.

// 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)
}

Podsumowanie

• Green Tea GC skanuje 8 KiB strony pamieci zamiast sledzic wskazniki miedzy obiektami, osiagajac redukcje narzutu GC o 10-40% bez zmian w kodzie aplikacji
• Alokacja buforow slice'ow na stosie eliminuje 3 lub wiecej startowych alokacji na stercie podczas petli z append, kopiujac dane na sterte tylko raz w punkcie ucieczki
• Przebudowane narzedzie go fix stosuje dziesiatki modernizatorow opartych na frameworku analizy go vet z gwarancja braku zmian w zachowaniu programu
• Funkcja new() akceptuje teraz wyrazenia, eliminujac potrzebe pisania funkcji pomocniczych do tworzenia wskaznikow
• Samoodwolujace sie ograniczenia typow generycznych umozliwiaja wzorce polimorfizmu ograniczonego (F-bounded polymorphism)
• Eksperymentalne wykrywanie wyciekow goroutine wykorzystuje osiagalnosc GC do identyfikacji trwale zablokowanych goroutine
• fmt.Errorf bez czasownikow formatowania jest teraz o 92% szybsze, a io.ReadAll zuzywa 50% mniej pamieci
• Hybrydowa wymiana kluczy postkwantowa jest wlaczona domyslnie w polaczeniach TLS

Przygotowanie do pytan rekrutacyjnych z Go wymaga zrozumienia tych zmian w srodowisku uruchomieniowym. Przewodnik po wspolbieznosci w Go omawia podstawowe wzorce goroutine, ktore stanowia uzupelnienie mechanizmu wykrywania wyciekow opisanego w niniejszym artykule.