A história da linguagem Go

Go nasceu num quadro branco do Google, em 21 de setembro de 2007, porque C++ demorava demais para compilar. Em novembro de 2025 a linguagem fez 16 anos de código aberto. Em setembro de 2026 a série estável é a 1.27.1. Docker, Kubernetes, Terraform, o go que você instala no Linux — tudo isso desce dessa reunião de três pessoas.

Por que uma linguagem nova

Google no fim dos anos 2000: servidores em C++ e Java, builds de três quartos de hora, concorrência na unha, dependências que não fechavam. Rob Pike descreveu o recado em Go at Google: Language Design in the Service of Software Engineering: não era moda linguística, era engenharia de software em escala. Compilar rápido, tipar estático, falar com a rede sem um framework de threads, e um binário só.

O FAQ oficial fecha a origem: Robert Griesemer, Rob Pike e Ken Thompson começaram a rabiscar metas no quadro no dia 21 de setembro de 2007. Em poucos dias virava plano. Em janeiro de 2008 Ken já tinha um compilador que emitia C. Em maio, Ian Lance Taylor, por conta própria, começava um frontend GCC. Russ Cox entrou no fim de 2008 e tirou o protótipo do laboratório.

Unix, Plan 9, CSP

Os três currículos explicam o gosto da língua. Ken Thompson co-criou o Unix e a linguagem B. Pike veio do Plan 9 e do Inferno, co-inventou UTF-8 com Thompson, e passou décadas em linguagens concorrentes — Newsqueak, Alef, Limbo — todas na linha do CSP de Tony Hoare (1978). Griesemer veio de compilador: HotSpot da Java, V8. Go herda o minimalismo Unix, os canais do CSP e a teimosia de um runtime que compila em segundos.

O nome surgiu no e-mail de Pike em 25 de setembro de 2007: “go”. Curto, verbo, domínio fácil. “Golang” é o apelido de busca — o golang.org existia porque go.org não estava livre. O site canônico hoje é go.dev.

A ideia central: goroutines e canais

Antes de seguir a cronologia, vale ver o que a linguagem faz de diferente — porque não é a sintaxe, é o modelo de concorrência.

Uma goroutine não é uma thread do sistema. É uma função que o runtime do Go agenda sobre um punhado de threads reais, com pilha inicial de poucos kilobytes que cresce sob demanda. Por isso você lança dez mil delas sem pensar duas vezes — o que com pthread seria irresponsável:

go processar(pedido)   // é isso. Não há pool, não há executor, não há Future.

A comunicação entre elas é o outro lado do desenho, e vem direto do CSP de Tony Hoare: em vez de compartilhar memória e proteger com mutex, você passa o dado por um canal. O lema da comunidade resume: “não se comunique compartilhando memória; compartilhe memória comunicando”.

resultados := make(chan string)

for _, host := range hosts {
    go func(h string) {
        resultados <- checar(h)      // envia pelo canal
    }(host)
}

for range hosts {
    fmt.Println(<-resultados)        // recebe, bloqueando até chegar
}

E o select é o epoll da linguagem: espera em vários canais ao mesmo tempo, incluindo um de timeout.

select {
case r := <-resultados:
    fmt.Println(r)
case <-time.After(2 * time.Second):
    fmt.Println("estourou o tempo")
}

É esse conjunto — goroutine barata, canal, select, e um binário estático sem VM — que explica por que praticamente toda ferramenta de infraestrutura da última década escolheu Go. Não é a linguagem mais expressiva; é a que um time inteiro lê igual na segunda-feira.

10 de novembro de 2009

Go virou projeto público nesse dia. O mascote — o gopher azul de olhos enormes — veio com o lançamento. Renée French, que já tinha desenhado o coelho do Plan 9 (e é casada com Pike), adaptou um gopher de uma camiseta da WFMU. Chamou-se Gordon um tempo; desde 2010 é só “the Go gopher”. As GopherCon do mundo inteiro saíram daí.

Ainda não era Go 1. Havia dois compiladores: o gc (a linha Plan 9, 6g/8g) e o gccgo do Taylor. A biblioteca padrão copiava o gosto do Plan 9 — o pacote fmt inclusive o nome.

Go 1.0 e a promessa

28 de março de 2012: Go 1.0. O contrato que segurou a adoção: programa escrito para Go 1 continua compilando em qualquer 1.x. Não haverá Go 2 que quebre o mundo. Empresas apostaram. O ritmo virou semestral (fevereiro e agosto, com atraso de dias, não de anos).

Marcos que importam no Linux:

• 1.5 (agosto de 2015): o compilador passa a ser escrito em Go (self-hosting); GC concorrente.
• 1.11 (agosto de 2018): módulos, ainda experimentais. Adeus GOPATH como prisão.
• 1.13 (2019): módulos oficiais; errors.Is / %w.
• 1.16 (2021): //go:embed, módulos default.
• 1.18 (15 de março de 2022): generics — type parameters. O pedido mais antigo da FAQ.
• 1.21 (2023): GOTOOLCHAIN baixa sozinho a versão que o go.mod pede; min/max; pacotes slices e maps.
• 1.22 (2024): loop var por iteração (fim do clássico bug do for); roteamento melhor no net/http.
• 1.25 (agosto de 2025): o coletor Green Tea aparece como experimento (10–40% menos custo de coleta em muitos serviços).
• 1.26 (10 de fevereiro de 2026): o Green Tea vira o coletor padrão; modernizers no go fix.
• 1.27 (agosto de 2026; 1.27.1 em 28 de agosto): métodos genéricos — proposta do Griesemer aprovada em março de 2026 —, o novo motor de JSON (encoding/json/v2) e criptografia pós-quântica na biblioteca padrão. Some também a opção de desligar o Green Tea.

A infra da internet

Docker (2013) é Go. Kubernetes também. Terraform, Prometheus, o cliente do Git, metade das CLIs de nuvem. Um binário estático, sem VM, sem node_modules de 400 MB — isso vendeu a língua para quem opera Linux. No ranking TIOBE de 2026 o Go oscila perto da 12ª casa; no GitHub e nos repositórios de infra, o peso é outro.

A concorrência é o cartão: go func(), canais, select. Não é Erlang, não é Java com thread pool. É CSP que cabe num syslog.

O que Go recusou

Sem herança de tipos, sem exceção no estilo throw, sem macros, sem overload de método. Generics chegaram tarde e estreitos. Métodos genéricos só em 2026. A FAQ ainda diz: se você sente falta de X, talvez Y já cubra. Pike, em 2023 (What We Got Right, What We Got Wrong), admite o que pesou: o gopher acertou; o GOPATH demorou a morrer; a comunicação do “porquê” chegou em 2013, quatro anos depois do lançamento.

As queixas que sobraram, e que valem para quem vai decidir a stack:

• if err != nil em toda linha. A ausência de exceção deixa o erro explícito — e deixa também um terço do arquivo repetindo a mesma verificação. É o debate mais antigo da comunidade, e nenhuma proposta de açúcar sintático passou até hoje.
• nil continua existindo. Ponteiro nulo, mapa nulo, interface nula que não é nula: o Go não seguiu o caminho do Option que o Rust tomou, e o panic por desreferência segue sendo o bug mais comum em produção.
• Coletor de lixo é coletor de lixo. O Green Tea reduziu bastante o custo, mas quem precisa de latência previsível no percentil 99,9 ainda esbarra nele — e é exatamente aí que o Rust entra na conversa.
• A governança é do Google. Aberta, com propostas públicas e revisão à vista, mas a palavra final é da equipe da empresa. É diferente da fundação independente que o Rust e o Kubernetes montaram.

Nada disso é acidente. O Go foi desenhado para times grandes escreverem serviço de rede com pouca cerimônia, não para ser a linguagem mais poderosa da sala. As recusas são o produto.

No Linux, hoje

A série estável em setembro de 2026 é a 1.27.1, de 28 de agosto. O caminho recomendado é o tarball do go.dev, porque o pacote da distro costuma ficar uma ou duas versões atrás:

# descobre a versão atual sem abrir o navegador
VER=$(curl -fsSL 'https://go.dev/VERSION?m=text' | head -n1)
echo "$VER"

# instala no lugar canônico
curl -fLO "https://go.dev/dl/${VER}.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "${VER}.linux-amd64.tar.gz"

# PATH permanente
echo 'export PATH=$PATH:/usr/local/go/bin' | sudo tee /etc/profile.d/go.sh
source /etc/profile.d/go.sh
go version

Para manter várias versões lado a lado — útil quando um projeto ainda está preso numa antiga — o próprio Go resolve, sem gerenciador externo:

go install golang.org/dl/go1.26@latest
go1.26 download
go1.26 version

Desde a 1.21, aliás, o GOTOOLCHAIN faz isso sozinho: se o go.mod pede uma versão que você não tem, a toolchain certa é baixada na hora do build.

O howto completo está em Instalando Golang no Linux; o irmão de 2017, com o 1.8.3, ficou em Instalando Golang 1.8.3 no Linux.

Linha do tempo

• 21 de setembro de 2007 — Griesemer, Pike e Thompson rabiscam as metas no quadro branco do Google.
• 25 de setembro de 2007 — no e-mail de Pike, a linguagem ganha nome: go.
• Janeiro de 2008 — Ken Thompson tem um compilador que emite C.
• Maio de 2008 — Ian Lance Taylor começa, por conta própria, o frontend do GCC.
• Fim de 2008 — Russ Cox entra e tira o protótipo do laboratório.
• 10 de novembro de 2009 — o projeto é aberto; o gopher de Renée French vem junto.
• 28 de março de 2012 — Go 1.0 e a promessa de compatibilidade que segurou a adoção.
• 2013 — o Docker nasce em Go e leva a linguagem para a infraestrutura.
• 2014 — o Kubernetes também; o cargo do Go, o go get, ainda dependia do GOPATH.
• Agosto de 2015 — a 1.5 se auto-hospeda (compilador escrito em Go) e ganha GC concorrente.
• Agosto de 2018 — a 1.11 traz módulos, ainda experimentais; o GOPATH começa a morrer.
• 2019 — a 1.13 torna os módulos oficiais.
• 2021 — a 1.16 traz //go:embed e módulos por padrão.
• 15 de março de 2022 — a 1.18 finalmente entrega generics.
• 2023 — a 1.21 traz GOTOOLCHAIN, min/max, slices e maps.
• 2024 — a 1.22 conserta o bug clássico da variável de laço.
• Agosto de 2025 — a 1.25 traz o coletor Green Tea como experimento.
• 10 de fevereiro de 2026 — a 1.26 torna o Green Tea padrão.
• Agosto de 2026 — a 1.27 entrega métodos genéricos, JSON v2 e criptografia pós-quântica.

O que ficou

Três pessoas, um quadro, uma língua que recusou peso e ganhou a nuvem. Dezesseis anos depois do open source, o contrato da 1.x ainda vale e o gopher ainda é azul. A aposta oposta, da mesma década, está em A história da linguagem Rust; o mapa completo, em As 7 principais linguagens. E o que o Go construiu está em A história do Docker e A história do Kubernetes. Fontes: FAQ, Go’s Sweet 16, Pike, dez anos, wiki e notas de release em go.dev/doc/devel/release.

Gopher baseado no mascote oficial de Renee French, licença CC BY 3.0.