Neste artigo
- O que torna Go diferente
- Seu primeiro programa em Go
- Variáveis, funções e a tipagem explícita
- Goroutines: a concorrência que mudou o jogo
- Para quem é Go na carreira
- Canais: como as goroutines conversam
- Os três erros de quem vem de linguagem dinâmica
- A ferramenta que acompanha a linguagem
- Go é difícil para iniciantes?
- Go serve para frontend?
- Quando usar Go em vez de Node ou Python?
- O que são goroutines em uma frase?
Go é a linguagem que a Google criou para ser simples e rápida em sistemas de rede e infraestrutura. É ela que move o Kubernetes, o Docker e uma geração de APIs de alta vazão. Se você quer backend performático ou trabalhar com infraestrutura, Go é a resposta mais direta que existe hoje.
Go é uma linguagem compilada, de sintaxe enxuta e concorrência embutida via goroutines. Comece pelo pacote, a função main e a sintaxe mínima, e depois entenda a goroutine, que é o superpoder da linguagem. A visão completa está no guia completo de Go.
O que torna Go diferente
Go foi desenhado para resolver os problemas que linguagens antigas arrastavam: compilação lenta, complexidade assíncrona e ferramenta dispersa. Ele compila para binário único, tem o garbage collector embutido e a concorrência como recurso de primeira classe. A sintaxe é propositalmente pequena, para que o código pareça igual em qualquer projeto.
💡 Dica: a frase que define Go é "menos é mais". Não tem herança de classes nem exceção; a linguagem troca recursos por clareza. É uma escolha de design que faz código de time grande ficar legível.
Seu primeiro programa em Go
Todo programa Go pertence a um pacote e começa na função main. O exemplo imprime uma linha usando o pacote padrão fmt.
package main
import "fmt"
func main() {
fmt.Println("Olá, mundo!")
}
O package main marca o executável, o import traz o fmt e o func main() é a entrada. A estrutura é mínima de propósito: não há classe, não há namespace, apenas pacote e função. Quem vem de outra linguagem estranha a ausência de cerimônia.
Variáveis, funções e a tipagem explícita
Go é tipado de forma estática, mas com inferência: o compilador descobre o tipo quando você usa o operador curto :=. Funções podem devolver vários valores, um recurso usado para o retorno de erro junto do resultado, o padrão Go de tratar falha.
func dobrar(n int) int {
return n * 2
}
func dividir(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("divisão por zero")
}
return a / b, nil
}
O par "valor, erro" é a filosofia do Go: erro não é exceção, é valor de retorno que você verifica. Dá mais trabalho que lançar exceção, mas torna o caminho de falha explícito e difícil de esquecer, o que em sistema de produção é uma vantagem.
Goroutines: a concorrência que mudou o jogo
Concorrência é fazer várias tarefas avançarem ao mesmo tempo, e Go resolve isso com goroutine, um fio leve que você lança com a palavra go. Milhares de goroutines rodam sobre poucos processadores, e o canal coordena a troca de dados entre elas.
go func() {
fmt.Println("executando em paralelo")
}()
Esse é o recurso que colocou Go no centro da infraestrutura: servidores que atendem milhares de conexões simultâneas sem afogar. Não é o primeiro conceito a aprender, mas é o que justifica escolher Go em vez de outra linguagem para backend de vazão.
Para quem é Go na carreira
Go é forte em três frentes: backend de rede, ferramenta de linha de comando e infraestrutura de nuvem. A demanda cresce junto com o uso em DevOps e microsserviços, e a curva curta é um atrativo para quem vem de outra linguagem. Para entender onde ele se encaixa entre os runtimes, o comparativo de runtimes ajuda a decidir.
Canais: como as goroutines conversam
Goroutines trabalham em paralelo, e os canais são o jeito que elas trocam dado com segurança, sem condition de corrida. Você cria um canal com make(chan tipo), uma goroutine envia e outra recebe. É essa coordenação que torna o paralelo em Go tão direto quanto o restante da linguagem.
numero := make(chan int)
go func() {
numero <- 42 // envia
}()
valor := <-numero // recebe
fmt.Println(valor)
O símbolo <- indica a direção do dado, e o canal sincroniza as duas pontas. É a ferramenta que transforma o "rodar em paralelo" em "trabalhar em paralelo trocando resultado", e é onde a concorrência de Go se torna produtiva em vez de ser demonstração. Quando esse binário for para produção, o caminho continua no guia de Docker para quem nunca usou.
Os três erros de quem vem de linguagem dinâmica
O primeiro erro é tratar o zero-value como valor inválido: em Go, toda variável nasce com um valor definido, e quem programa como se viesse nil em tudo escreve checagem desnecessária e mascaramento de estado. O segundo é ignorar o error como cidadão de primeira classe: guardar exceção para depois não existe, e quem encapsula o erro em log silencioso perde a rastreabilidade que sustenta produção. O terceiro é abrir goroutine sem controle de término: cada uma que vaza segura memória e, em volume, derruba o processo.
Esses três aparecem na primeira semana de quem migra. A correção não é decorar regra, é rodar o vet e os testes com race detector em todo commit, porque a ferramenta pega exatamente a classe de erro que a linguagem não esconde. Quando o binário estiver estável, a entrega em container segue o guia de Docker para quem nunca usou, que cobre a parte que a linguagem propositalmente não cobre.
A ferramenta que acompanha a linguagem
Go vem com a oficina completa embutida em um único comando. O go mod init cria o módulo com o arquivo go.mod, que declara dependências e versões sem arquivo de configuração extra. O go build compila, o go test roda os testes que ficam no mesmo pacote, o gofmt padroniza o formato e o go vet aponta suspeitas comuns. Compilar, testar e formatar nunca exigiram instalar nada além da linguagem.
Esse detalhe explica parte da adoção em times grandes: quando o formato é decidido pela ferramenta, a discussão de estilo desaparece do code review, e qualquer pessoa compila o projeto com o mesmo comando. Se a dúvida é entre Go e a outra linguagem de sistemas da moda, o comparativo de Rust e Go para alto desempenho pesa os compromissos de cada uma com curva de aprendizado e segurança de memória.
Perguntas frequentes
Go é difícil para iniciantes?
A sintaxe é deliberadamente simples, então o começo é rápido. O que pede prática é pensar em concorrência, que é o diferencial. A curva é menor que a de linguagens com muito conceito de orientação a objetos.
Go serve para frontend?
Não diretamente. Go brilha no backend, na ferramenta de linha de comando e na infraestrutura. Para interface, o JavaScript continua o domínio.
Quando usar Go em vez de Node ou Python?
Go quando a prioridade é performance, concorrência e binário único; Node quando o time já domina JavaScript; Python quando o foco é dados e protótipo. A escolha segue o problema, não a moda.
O que são goroutines em uma frase?
São fios leves que rodam tarefas em paralelo dentro do mesmo processo, lançados com a palavra reservada go e coordenados por canais.