Introdução ao Go: história, filosofia e os criadores da linguagem

Talvez você se pergunte: por que mais uma linguagem de programação? No final dos anos 2000, os engenheiros do Google enfrentavam um problema concreto. Os sistemas da empresa cresciam em escala e complexidade a uma velocidade que as ferramentas disponíveis não acompanhavam com conforto. C++ oferecia desempenho, mas seus tempos de compilação eram dolorosamente lentos e sua complexidade sintática exigia esforço considerável da equipe. Java resolvia parte da produtividade, mas carregava o peso de uma máquina virtual e de um ecossistema verboso. Python era ágil para escrever, porém insuficiente para sistemas de alto desempenho e concorrência massiva.

Foi nesse cenário que três engenheiros experientes decidiram projetar algo novo do zero — não por vaidade intelectual, mas por necessidade prática.

Os criadores

Robert Griesemer é engenheiro de compiladores com décadas de experiência. Trabalhou no V8, o motor JavaScript do Chrome, e na máquina virtual HotSpot do Java. Sua contribuição para Go está profundamente ligada ao design do compilador e ao sistema de tipos da linguagem.

Rob Pike é um veterano da computação. Trabalhou nos laboratórios Bell, onde participou do desenvolvimento do sistema operacional Plan 9 e da codificação UTF-8, ao lado de Ken Thompson. É também co-autor do livro clássico The Unix Programming Environment. Em Go, Pike influenciou fortemente a filosofia de simplicidade e a abordagem à concorrência.

Ken Thompson dispensa apresentações no mundo da computação. Criador do Unix, co-inventor da linguagem B (predecessora do C) e co-desenvolvedor do UTF-8, Thompson trouxe para o Go décadas de sabedoria sobre o que faz um sistema ser duradouro e eficiente. Sua participação no projeto foi fundamental nas fases iniciais de design.

Os três iniciaram as discussões sobre a linguagem em setembro de 2007, enquanto aguardavam a compilação de um sistema em C++ que levava cerca de 45 minutos. A lenda conta que foi justamente nessa espera improdutiva que a conversa sobre "como uma linguagem ideal seria" se tornou um projeto concreto.

A linha do tempo

• Setembro de 2007 — Griesemer, Pike e Thompson iniciam o design da linguagem internamente no Google.
• Novembro de 2009 — Go é anunciada publicamente como um projeto open source. A data, 10/11/2009, é considerada o nascimento oficial da linguagem.
• Março de 2012 — Lançamento do Go 1.0, com a promessa de estabilidade de API que persiste até hoje. Programas escritos para Go 1.0 compilam e funcionam corretamente nas versões mais recentes.
• Agosto de 2015 — O Go 1.5 passa a ter o compilador escrito no próprio Go e troca o garbage collector por um coletor concorrente, que trabalha junto com o programa em vez de pará-lo inteiro. As pausas caem para poucos milissegundos; com o Go 1.8, em 2017, ficam abaixo de um milissegundo na maior parte dos casos.
• Março de 2022 — O Go 1.18 traz Generics, a adição mais significativa à linguagem em anos, respondendo a uma das demandas mais antigas da comunidade.
• 2023 e 2024 — O Go 1.21 traz o slog, de logging estruturado; o 1.22 dá a cada volta do for a sua própria variável; o 1.23 permite percorrer com range uma função iteradora. As duas últimas só valem para módulos cujo go.mod declara a versão correspondente — com go 1.22 no arquivo, o range sobre função é recusado com requires go1.23 or later. Há anos o ritmo é de uma versão nova a cada seis meses, em fevereiro e em agosto.

A filosofia da linguagem

Go foi desenhada com um conjunto de princípios muito deliberados, e entendê-los é tão importante quanto aprender a sintaxe.

Simplicidade acima de tudo. A linguagem tem poucas palavras-chave — apenas 25. Não existe sobrecarga de operadores, não existe herança de classes, não existe manipulação de exceções com try/catch. Cada decisão de design foi guiada pela pergunta: isso é realmente necessário?

Compilação rápida. Um dos objetivos originais era que grandes bases de código compilassem em segundos, não minutos. Isso impacta diretamente a produtividade no dia a dia.

Concorrência como cidadã de primeira classe. Go foi projetada para o mundo multicore. Goroutines e channels são parte da linguagem, não bibliotecas externas. Rodar milhares de tarefas concorrentes é natural em Go.

Um único jeito de formatar o código. A ferramenta gofmt formata qualquer código Go de forma padronizada. Não existem guerras de tabs versus espaços em times que usam Go — o formatador decide, e todos aceitam.

Erros são valores. Go não usa exceções. Funções retornam o resultado e um valor de erro. Para usar o resultado, o programador precisa receber também o erro e decidir, de forma visível no código, o que fazer com ele — embora nada impeça de descartá-lo, e é para isso que linters como o errcheck existem. Isso parece verboso no início, mas produz código mais previsível e auditável.

Um primeiro programa

O melhor jeito de sentir uma linguagem é lê-la. Abaixo está o programa mais clássico possível, com alguns elementos extras para ilustrar a estrutura.

package main

import "fmt"

func main() {
    fmt.Println("Olá, mundo. Bem-vindo ao Go.")
}

Algumas observações importantes sobre esse código mínimo:

• Todo programa executável em Go pertence ao pacote main.
• A função main é o ponto de entrada — sem ela, o compilador recusa o programa.
• import "fmt" traz o pacote de formatação da biblioteca padrão. Diferente de outras linguagens, Go não permite importações que não sejam usadas: isso causa erro de compilação.
• Não há ponto e vírgula ao final das linhas — o compilador os insere automaticamente.

Go na prática: onde a linguagem é usada

Conhecer os casos de uso reais ajuda a compreender para onde os estudos devem apontar.

Infraestrutura e DevOps. Docker, Kubernetes, Terraform, Prometheus e o próprio CLI do GitHub foram escritos em Go. A linguagem tornou-se o padrão de fato para ferramentas de infraestrutura cloud.

Backends de alta performance. Empresas como Uber, Twitch, Cloudflare, Dropbox e o próprio Google usam Go em serviços que precisam responder a milhões de requisições com baixa latência.

Ferramentas de linha de comando. A capacidade de compilar um binário único — estático de fato quando compilado com CGO_ENABLED=0 — torna Go ideal para CLIs distribuídas.

APIs e microserviços. Frameworks como Gin, Echo e Fiber tornaram Go uma escolha popular para times que constroem APIs RESTful performáticas.

Go versus outras linguagens: uma perspectiva honesta

Go não é a linguagem certa para tudo, e seus criadores nunca afirmaram o contrário.

Para sistemas de tempo real extremo, onde cada microssegundo importa, C e Rust ainda levam vantagem pela ausência de garbage collector. Para análise de dados e machine learning, Python domina pelo ecossistema. Para aplicações corporativas com regras de negócio complexas, Java e Kotlin têm ecossistemas mais maduros.

O ponto forte de Go está na interseção entre produtividade de desenvolvimento e performance em produção. Equipes que usam Go reportam com frequência que conseguem escrever código correto e eficiente mais rápido do que em linguagens de sistemas tradicionais, sem abrir mão de desempenho comparável.

Go nasceu de incômodos concretos — um build de 45 minutos, concorrência difícil de acertar, código que só o próprio autor entendia —, e quase toda regra da linguagem responde a um deles: o gofmt sem opções, o import que não pode sobrar, o erro que volta como valor. Quando alguma dessas regras parecer rígida demais nas próximas semanas, vale procurar o incômodo por trás dela antes de tentar contorná-la; em geral ele custou caro a alguém, em escala.

Fontes e leituras recomendadas

• Site oficial do Go — Documentação, tour interativo e playground online. https://go.dev

• A Tour of Go — Tutorial oficial interativo, disponível em português. https://go.dev/tour/

• Effective Go — Guia oficial de boas práticas escrito pela equipe do Go. https://go.dev/doc/effective_go

• Entrevista com Rob Pike sobre o design do Go — Conversa profunda sobre as motivações por trás da linguagem. https://www.informit.com/articles/article.aspx?p=1623555

• The Go Programming Language (livro) — Alan Donovan e Brian Kernighan. O livro de referência mais respeitado da comunidade. https://www.gopl.io/

• Go by Example — Exemplos práticos anotados para cada recurso da linguagem. https://gobyexample.com

• Repositório oficial no GitHub — Código-fonte da linguagem, issues e evolução da especificação. https://github.com/golang/go

Exercícios

Exercício 1

Numa conversa sobre qual linguagem usar num serviço sensível a latência, alguém descarta Go de saída: "tem garbage collector, então o programa congela de tempos em tempos". O argumento valia para o Go de 2012? E para o de hoje?

Exercício 2

O artigo conta que Go nasceu durante a espera por um build de C++ de 45 minutos. Um colega pergunta o que, no desenho da linguagem, faz o compilador do Go ser rápido. Cite duas regras que um programador sente no dia a dia e que existem, em boa parte, por causa disso.

Exercício 3

Para mostrar como Go é pequena, um colega lista as 25 palavras-chave num slide e inclui int, string, true, nil, len e append. O que está errado na lista, e que consequência prática, pouco conhecida, isso tem?

Exercício 4

Um time vindo do Java lê que "erros são valores" e conclui que, em Go, é impossível esquecer de tratar um erro. Numa revisão, você encontra a linha strconv.Atoi(entrada) sozinha, sem nada à esquerda. Ela compila? E se a linha fosse n := strconv.Atoi(entrada)?

Exercício 5

Uma equipe desenvolve em Linux uma ferramenta de linha de comando que precisa ser distribuída para colegas em Windows e em Macs com processador Apple. Ela vai precisar de três máquinas de build? O que muda se a ferramenta usar uma biblioteca em C via cgo?