Primeiros passos

Bem-vindo ao Go: por que a linguagem existe e seu primeiro programa rodando

Intuição

Imagine uma cozinha de restaurante no horário de pico. Não é a cozinha da sua casa: são vinte cozinheiros, centenas de pedidos por hora e gente nova entrando na equipe toda semana. Nesse ambiente, uma receita de doze etapas com utensílios exóticos não é sofisticação — é gargalo. O que funciona é receita curta, ferramenta padronizada e qualquer cozinheiro capaz de ler o prato do colega e continuar de onde ele parou.

Em 2007, o Google era essa cozinha. Milhões de linhas de C++ e Java, compilações que levavam perto de uma hora e engenheiros gastando mais tempo decifrando abstrações uns dos outros do que resolvendo problemas. Rob Pike, Robert Griesemer e Ken Thompson — o mesmo Thompson que criou o Unix — decidiram atacar a causa, não o sintoma. A tese deles era desconfortável na época e continua sendo: uma linguagem melhora quando você remove recursos, não quando adiciona. Go nasceu sem herança de classes, sem exceções, sem sobrecarga de operadores e, na maior parte dos casos, com um único jeito óbvio de fazer cada coisa.

O custo dessa decisão é real: você vai escrever um pouco mais de código explícito do que escreveria em Python ou Ruby. O retorno também é real: qualquer pessoa lê qualquer código Go em segundos, o compilador processa projetos gigantes em segundos, e o binário final é um executável único que roda sem instalar runtime, máquina virtual ou dependência de sistema. Docker, Kubernetes, Terraform e Prometheus — a camada de infraestrutura que sustenta a internet moderna — são escritos em Go. No Brasil, é a linguagem por trás de sistemas de pagamento, bancos digitais e plataformas que processam milhões de requisições por dia.

Para quem chega de outra linguagem, duas diferenças aparecem já na primeira semana. Primeiro, Go é compilado e tipado estaticamente: uma classe inteira de erros que você conheceria em produção às três da manhã morre na compilação, antes de o programa existir. Segundo, Go trata concorrência como recurso central da linguagem, não como biblioteca: criar dezenas de milhares de tarefas simultâneas custa poucos megabytes. Você vai chegar lá no módulo de concorrência; por enquanto, basta saber que essa é a razão de tanta infraestrutura crítica escolher Go.

Este curso segue a mesma filosofia da linguagem: pouca cerimônia, muita prática. Você não vai assistir dez minutos de slides sobre história — vai compilar e rodar Go de verdade nesta página, nos próximos minutos, sem instalar absolutamente nada.

VISUALIZAÇÃOVisualização passo a passo

1 / 4

Código anotado

Este é o menor programa Go útil que existe, e cada linha dele carrega uma decisão de design da linguagem. Vamos montá-lo peça por peça; no final, o conjunto compila e roda exatamente como está.

Todo arquivo Go começa declarando a qual pacote pertence. Pacote é a unidade de organização de código em Go — pense em um diretório de código com um nome. O nome main é especial: ele avisa ao compilador que este pacote vira um executável, e não uma biblioteca para outros programas importarem.

package main

A cláusula import traz pacotes da biblioteca padrão para dentro do arquivo. fmt — de format — cuida de entrada e saída formatada: imprimir no terminal, montar strings com valores, ler dados. Você vai usá-lo em praticamente todas as aulas. Um detalhe que já mostra a personalidade de Go: importar um pacote e não usar é erro de compilação, não aviso. Código morto não entra.

import "fmt"

Funções são declaradas com a palavra func. Esta recebe um parâmetro name do tipo string e devolve uma string — repare que o tipo vem depois do nome, ao contrário de Java ou C. O + concatena strings. O comentário fica em português, como todo comentário deste curso; o identificador fica em inglês, como no mercado.

// greet monta a saudação para o nome recebido.
func greet(name string) string {
	return "Olá, " + name + "! Você está programando em Go."
}

A função main do pacote main é o ponto de entrada: quando o programa roda, a execução começa aqui. fmt.Println imprime uma linha no terminal. Repare no que não está aqui: nenhum public static void, nenhum ponto e vírgula, nenhuma classe envolvendo tudo. Três linhas de cerimônia e o resto é lógica — e essa proporção se mantém em programas de cem mil linhas.

func main() {
	fmt.Println(greet("Gopher"))
	fmt.Println("Compilado e executado no seu navegador.")
}

Quando você clicar em Executar logo abaixo, este programa passa pelo compilador Go real — o mesmo gc que compila o Kubernetes — rodando em WebAssembly dentro do seu navegador. Seu código não sai da sua máquina. Se o programa tiver um erro de sintaxe ou de tipo, o compilador rejeita e explica; leia essas mensagens com atenção desde já, porque elas são parte central de como se trabalha em Go.

Como este curso funciona

Antes do primeiro exercício, vale um minuto para conhecer as ferramentas — elas são as mesmas em todas as 62 aulas desta trilha.

Cada aula tem este mesmo ritmo: uma explicação com analogia real, um programa completo comentado bloco a bloco, um editor livre para você experimentar e de dois a quatro exercícios com testes automáticos. O orçamento é de cerca de uma hora por aula — 15 a 20 minutos de leitura, o resto de prática. A prática não é opcional: é onde a linguagem entra nos dedos.

No editor, você tem quatro botões que importam:

Executar compila e roda o programa, mostrando a saída completa — use para explorar livremente;
Rodar Testes executa sua solução contra uma bateria de casos e mostra, caso a caso, o que era esperado e o que seu código devolveu — igual a um CI de verdade ou a uma entrevista técnica;
gofmt aplica a formatação oficial de Go ao seu código — de graça, em um clique;
Resetar volta ao código inicial se você quiser recomeçar.

Quando travar em um exercício, abra as dicas: a primeira orienta o raciocínio, a segunda aproxima da estrutura da solução. Só depois de tentar, abra a Solução & Explicação — ela não mostra apenas o código, mas o porquê de cada decisão e a armadilha da alternativa que parecia boa. Ler a solução sem ter tentado é jogar fora a parte do aprendizado que fica.

Ao terminar, marque a aula como Concluída no rodapé. Isso alimenta seu progresso na trilha, e o botão de 👍👎 nos diz se a explicação funcionou para você. Seu progresso fica salvo na sua conta: pode fechar o navegador e continuar de outro computador.

Um aviso honesto sobre erros: você vai ver muitos nesta primeira semana, e isso é o plano funcionando. O compilador de Go foi desenhado para dar mensagens curtas e específicas — undefined: greeting significa exatamente que você usou um nome que não existe, provavelmente um erro de digitação. Errar aqui, onde o custo é zero, é o que evita errar em produção.

Experimente

Rode o programa abaixo do jeito que está e confira a saída. Antes de mudar qualquer coisa, preveja: o que acontece se você remover a linha do import "fmt" e executar? Faça o teste e leia a mensagem do compilador com calma — é a sua primeira mensagem de erro em Go, e ela diz exatamente o que está faltando.

package main

import "fmt"

func main() {
	fmt.Println("Olá, Gopher!")
	fmt.Println("Go existe há", 2026-2009, "anos.")
	fmt.Println("Este programa compilou na sua máquina.")
}

Depois experimente: troque a mensagem da primeira linha; adicione uma quarta chamada de fmt.Println com uma conta matemática (fmt.Println(7 * 6)); e apague o ponto e vírgula que você talvez tenha digitado por hábito — em Go, ele não é usado no fim das linhas. Quebrar o programa de propósito e consertar é a forma mais rápida de aprender a ler o compilador.

Exercício 1

Escreva sua primeira função

Complete a função Greeting(name string) string para que ela devolva a mensagem de boas-vindas do curso para o nome recebido.

Entrada: um nome em name, sempre não vazio. Saída: a string exata "Olá, <name>! Boas-vindas ao Go.", com <name> substituído pelo valor recebido.

Exemplos:

Greeting("Maria") → "Olá, Maria! Boas-vindas ao Go.";
Greeting("João") → "Olá, João! Boas-vindas ao Go.".

Os testes comparam a string caractere por caractere: vírgula, exclamação, ponto final e espaços contam. Se um caso falhar, compare o esperado com o recebido no painel — a diferença costuma ser um caractere de pontuação.

Solução & Explicação

A mensagem é uma moldura fixa com o nome no meio, então concatenação direta resolve:

func Greeting(name string) string {
	return "Olá, " + name + "! Boas-vindas ao Go."
}

O + entre strings cria uma nova string com o conteúdo das duas — custo O(n) no tamanho do resultado, o que é irrelevante para uma frase curta. Não há caso de borda aqui porque o contrato garante nome não vazio; quando um contrato garante algo, código defensivo extra é ruído, não segurança.

Uma alternativa que você verá em breve é fmt.Sprintf("Olá, %s! Boas-vindas ao Go.", name) — mesma saída, estilo de template. Para duas ou três partes fixas, o + é mais direto e não paga o custo de interpretar a string de formato. A armadilha clássica do exercício não é técnica, é de atenção: devolver "Ola" sem acento ou esquecer o ponto final. Testes automáticos não fazem “quase certo” — e isso é uma característica, não um defeito: em código de verdade, "não" e "nao" são chaves diferentes de um mapa.

Exercício 2

Monte a linha de progresso do curso

O painel do curso mostra uma linha como "Maria completou 3 de 62 aulas (restam 59).". Implemente ProgressReport(name string, completed int, total int) string para montar exatamente essa frase.

Entrada: o nome em name, o número de aulas concluídas em completed e o total em total, com 0 <= completed <= total. Saída: a string "<name> completou <completed> de <total> aulas (restam <restam>).", onde <restam> é total - completed.

Exemplos:

ProgressReport("Maria", 3, 62) → "Maria completou 3 de 62 aulas (restam 59).";
ProgressReport("Ana", 62, 62) → "Ana completou 62 de 62 aulas (restam 0).".

Aqui há uma novidade em relação ao exercício 1: você precisa colocar números inteiros dentro de uma string. Tente primeiro com + e veja o que o compilador diz — a mensagem vale a leitura. Depois resolva do jeito certo.

Solução & Explicação

Quem tentou "..." + completed + "..." recebeu do compilador algo como invalid operation: mismatched types string and int. Essa recusa é uma decisão central de Go: não existe conversão implícita de tipos. Em JavaScript, "aulas: " + 3 funciona por coerção silenciosa — e a mesma coerção silenciosa produz "3" + 1 === "31". Go prefere que você diga o que quer.

O jeito idiomático de misturar texto e valores é fmt.Sprintf, que devolve a string formatada em vez de imprimi-la:

func ProgressReport(name string, completed int, total int) string {
	remaining := total - completed
	return fmt.Sprintf("%s completou %d de %d aulas (restam %d).", name, completed, total, remaining)
}

%s é o verbo de formatação para strings e %d para inteiros; os argumentos entram na ordem em que os verbos aparecem. Calcular remaining em uma variável própria antes de formatar deixa a linha do Sprintf legível — dá para inserir total - completed direto no argumento, mas nomear o valor documenta a intenção. O custo é O(n) no tamanho da frase; nada relevante aqui.

A alternativa com conversão manual — strconv.Itoa(completed) para cada número e tudo concatenado com + — compila e funciona, mas vira uma expressão longa com seis concatenações onde qualquer espaço esquecido quebra os testes. String de formato existe exatamente para esse caso: a frase inteira fica visível de uma vez, com os buracos marcados. O caso de borda que derruba soluções apressadas é completed == total: a frase precisa dizer (restam 0)., então não invente um texto especial para zero — o contrato pede sempre o mesmo formato.

💡 O Jeito Go

Em Go, formatação de código não é opinião: é decisão da ferramenta gofmt, que acompanha a linguagem desde o início. Indentação com tabs, posição das chaves, alinhamento — tudo padronizado, sem arquivo de configuração, sem variação por time. O Effective Go dedica sua primeira seção, “Formatting”, exatamente a isso, e resume a filosofia: em vez de uma longa lista de regras de estilo para humanos decorarem, a máquina formata e o assunto morre.

Parece autoritário e é — de propósito. O que se elimina não é liberdade útil, é uma categoria inteira de discussão em code review: nunca mais um comentário sobre chave na linha de baixo. Todo código Go profissional que você vai ler — biblioteca padrão, Kubernetes, o código dos seus futuros colegas — tem exatamente a mesma cara, e é por isso que ler Go alheio é tão rápido.

O botão gofmt do editor aplica a ferramenta real ao seu código. Crie o hábito agora, na primeira aula: escreveu, formatou. Nos projetos reais, isso roda automático ao salvar o arquivo ou no CI; aqui, é um clique.

Resumo

Go foi criado no Google em 2007 para atacar problemas de escala de engenharia: builds lentos, código difícil de ler, times grandes. A tese é remover recursos, não acumular.
Go é compilado e tipado estaticamente: erros de tipo e nomes indefinidos morrem na compilação, e não existe conversão implícita entre tipos.
Todo executável tem package main e func main(); import traz pacotes da biblioteca padrão, e importar sem usar é erro de compilação.
fmt.Println imprime valores; fmt.Sprintf formata strings com verbos como %s e %d — seu canivete de I/O nas próximas aulas.
O fluxo do curso é sempre: ler, Executar, experimentar, Rodar Testes nos exercícios, revisar a solução e marcar Concluída.

Na próxima aula, imersao/02-hello-world-e-toolchain, você conhece as ferramentas que fazem Go ser Go fora do navegador: go run, go build, go mod e o papel do gofmt no fluxo profissional.