O Que É a Linguagem de Programação Go? Um Guia Simples da Linguagem da Nuvem

Quando você assiste a um vídeo, pede uma corrida ou abre um site, há uma boa chance de que parte do software que responde nos bastidores esteja escrita em Go. Você provavelmente nunca o viu, mas ele move discretamente uma grande parte da internet moderna: as ferramentas que empacotam apps, gerenciam servidores na nuvem e atendem milhões de pedidos por segundo.

O Go foi criado no Google para ser simples como o Python, mas rápido como o C, e para ser muito bom em fazer muitas coisas ao mesmo tempo. Este artigo explica, em linguagem simples, o que é o Go, por que ele foi criado, o que o torna especial e onde ele é usado.

Por que o Google criou uma nova linguagem

Em 2007, o Google tinha programas enormes escritos principalmente em C++, Java e Python, rodando em milhares de computadores. Cada linguagem tinha um problema:

• O C++ gerava programas rápidos, mas era complicado, e compilar um programa grande em C++ podia levar muitos minutos. Um dos criadores do Go, Rob Pike, já contou que a ideia do Go tomou forma enquanto ele esperava um programa enorme em C++ compilar.
• O Python era agradável de escrever, mas lento demais para alguns dos sistemas mais movimentados do Google.
• E os computadores ganhavam cada vez mais núcleos de processador, mas nenhuma dessas linguagens facilitava usar todos eles ao mesmo tempo.

Então três engenheiros do Google, Robert Griesemer, Rob Pike e Ken Thompson, decidiram projetar algo melhor. Ken Thompson já era uma lenda: ele ajudou a criar o sistema operacional Unix e a linguagem B, a antepassada direta do C (veja O Que É a Linguagem de Programação C?).

O Go foi apresentado ao mundo como software livre e de código aberto em 2009, e o Go 1.0 chegou em 2012.

Pequeno de propósito

A maioria das linguagens cresce ganhando recursos. Os criadores do Go fizeram o contrário: mantiveram a linguagem pequena, para que seja rápida de aprender e todo programa Go pareça familiar. O Go tem só 25 palavras-chave (palavras reservadas especiais como if, for e func), menos que a maioria das linguagens populares.

Veja o clássico primeiro programa:

1package main
2
3import "fmt"
4
5func main() {
6	fmt.Println("Olá, mundo!")
7}

O package main diz que este é um programa que pode ser executado, o import "fmt" traz a caixa de ferramentas de formatação, e o func main() é onde o programa começa. Ele mostra Olá, mundo!.

O Go não tem classes como o Java ou o C#. Em vez disso, você descreve os dados com uma struct (um pacote de valores com nome) e prende ações a ela:

1type Carro struct {
2	Cor        string
3	Velocidade int
4}
5
6func (carro *Carro) Acelerar() {
7	carro.Velocidade += 10
8}
9
10func main() {
11	meuCarro := Carro{Cor: "vermelho"}
12	meuCarro.Acelerar()
13	meuCarro.Acelerar()
14	fmt.Printf("O meu carro %s anda a %d km/h\n", meuCarro.Cor, meuCarro.Velocidade)
15}

Isso mostra O meu carro vermelho anda a 20 km/h. O sinal := cria uma variável e deixa o Go descobrir o tipo dela sozinho, então você tem a segurança dos tipos sem precisar escrevê-los em todo lugar.

O Go até encerra as discussões sobre estilo: ele vem com uma ferramenta chamada gofmt que formata o seu código automaticamente do único jeito oficial. Espaços, quebras de linha e alinhamento nunca estão em debate, e todo código Go fica parecido.

O superpoder: goroutines

O recurso mais famoso do Go é a facilidade de fazer muitas coisas ao mesmo tempo. Imagine preparar o café da manhã. Você poderia passar o café, esperar três minutos e só então começar a torrada. Ou poderia começar os dois e deixar que trabalhem lado a lado.

No Go, você começa uma tarefa "por fora" escrevendo a palavra go na frente dela. Isso cria uma goroutine, uma tarefa leve que roda junto com o resto do programa:

1func fazerCafe(pronto chan string) {
2	time.Sleep(3 * time.Second)
3	pronto <- "O café está pronto"
4}
5
6func fazerTorrada(pronto chan string) {
7	time.Sleep(2 * time.Second)
8	pronto <- "A torrada está pronta"
9}
10
11func main() {
12	inicio := time.Now()
13	pronto := make(chan string)
14
15	go fazerCafe(pronto)
16	go fazerTorrada(pronto)
17
18	fmt.Println(<-pronto)
19	fmt.Println(<-pronto)
20	fmt.Printf("Café da manhã pronto em %.0f segundos\n", time.Since(inicio).Seconds())
21}

Quando rodamos, ele mostrou:

A torrada está pronta
O café está pronto
Café da manhã pronto em 3 segundos

Três segundos em vez de cinco, porque as duas tarefas rodaram ao mesmo tempo. A torrada terminou primeiro, então a mensagem dela chegou primeiro.

A outra ideia nova aqui é o canal (chan), um cano que as goroutines usam para passar mensagens umas para as outras. Cada tarefa deixa uma mensagem no canal pronto quando termina, e o <-pronto espera até uma mensagem sair. Um ditado popular do Go resume a ideia: "Não se comunique compartilhando memória; compartilhe memória se comunicando." Em vez de várias tarefas brigarem pelos mesmos dados, elas passam os resultados umas para as outras, como cozinheiros passando pratos pela janela da cozinha.

As goroutines também são baratas. Cada uma começa com só alguns kilobytes de memória, e o Go as distribui pelos núcleos do computador por você. No nosso notebook, um programa de teste iniciou 100.000 goroutines de uma vez em cerca de meio segundo. É por isso que um único servidor em Go consegue atender uma quantidade enorme de visitantes ao mesmo tempo, dando a cada um a sua própria goroutine.

Usando todos os núcleos

As goroutines não servem só para esperar coisas lentas. Elas também podem dividir um trabalho pesado. Contamos os números primos abaixo de 2 milhões num programa Go, dividindo o trabalho entre cada vez mais goroutines:

Com 16 goroutines, a mesma tarefa terminou quase 7 vezes mais rápido, e o programa quase não mudou: algumas goroutines pegando blocos de números de um canal. O ganho se estabiliza no fim, em parte porque os núcleos de um notebook dividem calor e energia, e alguns deles são núcleos menores e mais lentos, feitos para poupar bateria.

O Go é rápido?

Sim. O Go é uma linguagem compilada: antes de rodar, o seu código é traduzido para a linguagem de máquina do próprio computador, como o C. Cronometramos a mesma tarefa simples, contar os números primos abaixo de 2 milhões com um só trabalhador, em cinco linguagens:

O Go terminou em 0,39 segundo, praticamente empatado com o C e o JavaScript neste pequeno teste, e cerca de 45 vezes mais rápido que o Python puro. Para ser justo com todas as linguagens, a versão em Go usou os mesmos números de 32 bits das versões em C e Java. Com os números de 64 bits, maiores, que o Go usa por padrão, levou 0,56 segundo, porque dividir números maiores é um pouco mais lento para o processador.

O Go também é famoso pela compilação rápida. Mesmo programas grandes em Go costumam compilar em segundos, o que era um dos objetivos originais. (Veja O Que É a Linguagem de Programação Python? para entender por que o Python puro é tão mais lento, e como ele contorna isso.)

Um arquivo que roda em qualquer lugar

Outro motivo de as pessoas adorarem o Go é a facilidade de compartilhar um programa pronto:

• Um arquivo: o go build junta o seu programa e tudo o que ele precisa num único arquivo. O nosso "Olá, mundo!" virou um hello.exe de 2 MB que roda em qualquer computador Windows, sem instalar nada.
• Qualquer computador: do mesmo notebook Windows, mudar duas configurações gerou versões para Linux e para Mac. Criar um programa para outro sistema se chama compilação cruzada, e o Go torna isso muito fácil.

Isso faz muita diferença em servidores: em vez de instalar uma linguagem, bibliotecas e versões compatíveis em cada máquina, você copia um arquivo e roda.

Onde o Go é usado

• O Docker empacota apps em contêineres, pacotes organizados que rodam do mesmo jeito em qualquer computador. Ele é escrito em Go.
• O Kubernetes, criado no Google, roda e coordena quantidades enormes de contêineres em centros de dados. Também é Go.
• O Terraform permite que engenheiros descrevam num arquivo de texto os servidores na nuvem que querem, e os cria automaticamente.
• Empresas como Cloudflare, Uber, Twitch e o próprio Google usam Go em serviços de bastidores muito movimentados.
• O Ollama, um app popular para rodar modelos de linguagem de IA no seu próprio computador, é escrito em Go.
• Ferramentas de terminal práticas, como o gh do GitHub e o criador de sites Hugo, são programas Go distribuídos como um único arquivo.

Como tanto software de nuvem é escrito nele, o Go costuma ser chamado de "a linguagem da nuvem".

As desvantagens

O Go não usa "exceções" para avisar de problemas. Em vez disso, as funções devolvem um erro que você confere na hora. Aqui, tentamos transformar o texto "quarenta" num número:

1idade, err := strconv.Atoi("quarenta")
2if err != nil {
3	fmt.Println("Isso não é um número:", err)
4	return
5}

Isso mostra Isso não é um número: strconv.Atoi: parsing "quarenta": invalid syntax ("análise de "quarenta": sintaxe inválida"). E isso nos leva aos pontos fracos do Go:

• Tratamento de erros repetitivo. Conferir erros assim é claro e explícito, mas o if err != nil aparece tanto que virou piada entre programadores Go.
• Simples pode significar limitado. O Go deixa de fora, de propósito, recursos que outras linguagens têm. Só em 2022 ele ganhou genéricos (um jeito de escrever um código que funciona com vários tipos), um dos recursos mais pedidos.
• Não foi feito para tudo. O Go raramente é usado em apps de celular, programas de desktop com janelas e botões, jogos ou pesquisa em IA, áreas onde outras linguagens têm ferramentas melhores.
• Não é o mais rápido de todos. O coletor de lixo e as verificações de segurança do Go custam um pouco de velocidade, então para os trabalhos mais exigentes, como motores de jogos ou sistemas operacionais, normalmente se escolhe C, C++ ou Rust.

Uma breve história

Um marco curioso: em 2015, o compilador do Go, o programa que transforma código Go em código de máquina, foi ele mesmo reescrito em Go. Quando uma linguagem consegue construir a si mesma, os programadores dizem que ela é auto-hospedada (self-hosting).

Vale a pena aprender Go?

• Ótimos motivos: você quer construir servidores web, serviços de bastidores, ferramentas de nuvem ou programas de terminal, ou quer trabalhar com Docker e Kubernetes. O Go também é uma ótima segunda linguagem: pequeno o bastante para aprender em poucas semanas, com regras claras.
• Bom saber: o Go é gratuito e roda no Windows, no Mac e no Linux. O site oficial, go.dev, tem um playground on-line onde você pode escrever e rodar código Go no navegador, além de um tour interativo e gratuito pela linguagem.

Um pequeno glossário

• Go (Golang): uma linguagem de programação criada no Google e anunciada em 2009.
• Linguagem compilada: uma linguagem cujo código é traduzido para código de máquina antes de rodar.
• Struct: um pacote de valores com nome, como a cor e a velocidade de um carro.
• gofmt: a ferramenta que formata o código Go do único jeito oficial.
• Goroutine: uma tarefa leve que roda junto com o resto do programa, iniciada com a palavra go.
• Canal (channel): um cano que as goroutines usam para mandar mensagens umas para as outras.
• Concorrência: cuidar de muitas tarefas ao mesmo tempo.
• Núcleo: uma das unidades de processamento dentro do processador. Os processadores modernos têm vários.
• Coletor de lixo: a parte do Go que libera a memória que o programa não usa mais.
• Compilação cruzada: criar um programa num tipo de computador para outro tipo.
• Contêiner: um pacote organizado com um app e tudo o que ele precisa, rodado por ferramentas como o Docker.
• Genéricos: um jeito de escrever um código uma vez que funciona com vários tipos de valores.

Conclusão

O Go nasceu da frustração com compilações lentas e código complicado no Google, e respondeu com uma linguagem pequena e legível, que compila em segundos e roda quase tão rápido quanto o C. O truque característico dele, as goroutines, deixa fazer muitas coisas ao mesmo tempo tão simples quanto digitar go, e os programas de um arquivo só são uma alegria de levar para os servidores.

Ele não tenta ser tudo, e as verificações de erro podem parecer repetitivas. Mas se você usou um site ou app moderno hoje, há uma boa chance de que algum pequeno programa em Go estivesse em algum lugar ajudando, fazendo muitas coisas ao mesmo tempo.