Trilha de Go: o mapa das 65 aulas

Esta é a trilha completa de aulas para quem quer dominar Go. As 65 aulas estão em 9 blocos, na ordem em que cada uma só usa o que as anteriores já ensinaram.

A ordem foi decidida pela dependência entre os assuntos. Os fundamentos vêm primeiro, com conversão de tipos, iota e structs antes de tags. A concorrência vem logo depois, com goroutines antes de WaitGroup, channels e sync. O runtime vem em seguida, porque explica o que a concorrência faz por baixo. A biblioteca padrão, os testes e os dados vêm antes das APIs, e a arquitetura fecha com padrões e observabilidade.

Fundamentos da linguagem

1. Conversão de tipos em Go: estouro, strings, runes e strconv
2. iota em Go: constantes, enums e máscaras de bits
3. Controle de Fluxo Idiomático em Go: Loops, Escopo de Decisão e Type Switches
4. Structs em Go: campos, embedding, ponteiros e padding
5. Tags de struct em Go: reflexão, JSON e validação
6. Anatomia de Slices, Arrays e Maps em Go: Estruturas Internas e Armadilhas
7. Ponteiros, Memória e Escape Analysis em Go
8. Tratamento de Erros Idiomático em Go: Wrapping, Sentinelas e Exceções
9. Módulos, Pacotes e Workspaces em Go: Dependências e Encapsulamento
10. Função new em Go
11. Defer em Go

• Interfaces e composição (aula a escrever, depois de defer e antes de generics)

12. Generics em Go

Concorrência fundamental

13. Goroutines em Go: o que são e por que são baratas
14. WaitGroup em Go: esperando um grupo de goroutines
15. Channels em Go: da analogia ao hchan
16. Select em Go
17. Context em Go
18. Race condition em Go: o que é e como o detector de corrida ajuda
19. O pacote sync em Go: mutex, RWMutex, Once, Map e Pool
20. Deadlock em Go: como acontece, como ler e como prevenir

Runtime e memória

21. Call Stack em Go
22. Heap em Go
23. O scheduler do Go: G, M e P
24. Preempção em Go: como o runtime interrompe goroutines
25. Garbage collector do Go: alcançabilidade, pausas e GOGC
26. Memory leaks em Go: como a memória fica presa

Biblioteca padrão

27. Manipulação de Arquivos e I/O Idiomático em Go
28. Trabalhando com JSON em Go: Da Biblioteca Padrão a Alta Performance
29. Cliente HTTP Profissional em Go: Resiliência, Pooling e Sockets
30. Servidor HTTP Nativo Moderno em Go (1.22+)
31. Gerenciamento de Configuração com Viper

Testes e performance

32. Testes unitários em Go com o pacote testing
33. Table-driven tests e paralelismo em Go
34. Testify: asserções e suítes de testes em Go
35. Mocks e dublês de teste em Go
36. Benchmarking e profiling de testes em Go
37. pprof em Go: perfil de CPU, memória e goroutines
38. Fuzzing nativo em Go: testes guiados por cobertura
39. Testes de integração com Testcontainers em Go

Dados

40. database/sql e connection pooling em Go
41. PostgreSQL com pgx em Go: o driver nativo
42. SQLC: SQL tipado a partir de queries em Go
43. GORM na Prática: Modelagem, CRUD, Associações e Trade-offs
44. SQLX em Go: mapeamento, named queries e transações
45. Database Migrations com Goose: Versionamento, Embed e Zero-Downtime

APIs e mensageria

46. Middlewares em Go: Arquitetura Cebola, Interceptação e Produção
47. Autenticação e JWT em Go: Tokens, Assinatura e RBAC
48. Documentação de APIs com Swagger em Go: OpenAPI, Swag e Automação
49. GraphQL com gqlgen: Abordagem Schema-First, Resolvers e DataLoader
50. Mensageria Prática em Go: RabbitMQ, Apache Kafka e Resiliência
51. Upload de Arquivos para AWS S3 em Go: Streaming, Presigned URLs e Escala
52. SSE e EventSource: como o servidor fala com o navegador sem ser pedido
53. WebSocket em Go: handshake, quadros e broadcast
54. gRPC em Go

Arquitetura e observabilidade

55. Injeção de dependência em Go
56. Design patterns em Go: da teoria clássica à prática idiomática
57. Clean Architecture em Go: Camadas, Inversão de Controle e Pragmatismo
58. Injeção de Dependências com Google Wire: DI em Tempo de Compilação
59. Logging Estruturado com slog: Performance, Contexto e Produção
60. Tracing Distribuído e OpenTelemetry em Go: Spans, Contexto e OTLP
61. Resiliência em Go: Timeouts, Exponential Backoff, Circuit Breaker e Bulkhead

Concorrência aplicada

62. Worker Pools e Rate Limiting em Go: Concorrência Controlada e Vazão
63. Pipeline Pattern e Fan-Out, Fan-In em Go: Concorrência em Estágios
64. Locks Distribuídos com Redis em Go: Exclusão Mútua, Redlock e Lua
65. Graceful Shutdown e Signal Handling em Go: Encerramento Seguro em Produção

Como estudar

Leia as aulas na ordem. Cada uma indica quais aulas anteriores ela pressupõe. Quando uma aula cita um conceito de uma aula posterior, é porque ela só o menciona de passagem.