Go: história, compilador e diferencial 2026

# toolchain oficial (gc), escrito em Go desde 1.5
main.go
  |-- parse       --> AST
  |-- typecheck   --> typed AST
  |-- SSA         --> SSA IR (desde Go 1.7)
  |-- opt + gen   --> assembly especifico da arch (amd64, arm64, ...)
  |-- link        --> binario estatico com runtime embutido

# build e instantaneo mesmo em projetos grandes
go build -o app ./cmd/app           # ~segundos
GOOS=linux GOARCH=arm64 go build    # cross-compile trivial
CGO_ENABLED=0 go build              # binario totalmente static (sem libc)

# runtime embutido no binario (~2MB overhead):
#   - scheduler M:N (goroutines multiplexadas em OS threads)
#   - GC concurrent tri-color mark-and-sweep (pause < 1ms tipico)
#   - allocator com size classes (similar a tcmalloc)
#   - netpoller (epoll Linux, kqueue BSD, IOCP Windows)

// Go 1.0 (2012): a base. Garantia de compatibilidade backward.

// Go 1.5 (2015): toolchain 100% em Go (self-hosted)
// Go 1.7 (2016): SSA backend, perf real

// Go 1.11 (2018): Go modules (go.mod, go.sum) — fim do GOPATH
module github.com/user/app
go 1.22
require github.com/go-chi/chi/v5 v5.1.0

// Go 1.13 (2019): errors.Is, errors.As, errors.Unwrap
if errors.Is(err, sql.ErrNoRows) { ... }

// Go 1.18 (2022): generics — maior adicao desde 1.0
func Map[T, U any](s []T, f func(T) U) []U {
    r := make([]U, len(s))
    for i, v := range s { r[i] = f(v) }
    return r
}

// Go 1.21 (2023): slices e maps packages, PGO estavel,
//                 min/max/clear builtins
n := max(a, b, c)

// Go 1.22 (2024): loop variable scoping fix (semantica nova)
// cada iteracao tem sua propria copia de i, v — bug classico de closures some
for _, v := range itens {
    go func() { processar(v) }()  // agora captura o v correto
}

// Go 1.23 (2024): range over function (iteradores custom)
for v := range meuIterador { ... }

// Go 1.24 (2025): melhorias de perf e tooling

// 1. Goroutines + channels (CSP de Tony Hoare aplicado)
// goroutines tem stack inicial de 2KB (cresce dinamicamente)
// scheduler multiplexa em OS threads (modelo M:N)
func worker(jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2
    }
}
// milhares de goroutines sem esforco, sintaxe sincrona simples

// 2. Context para cancellation (canonical)
func Fetch(ctx context.Context, url string) error {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    _, err := http.DefaultClient.Do(req)
    return err
}

// 3. Interfaces implicitas + composition
// aceita interfaces, retorna structs; nada a declarar, a struct implementa
// se tiver os metodos certos (duck typing estrutural verificado em compile-time)
type Reader interface { Read(p []byte) (n int, err error) }

// 4. Build speed + static binary + cross-compile
// "go build" gera single binary self-contained. Deploy = scp.