Trilha de Go

Do básico da linguagem à concorrência em produção: 37 aulas em 7 fases, da memória aos sistemas distribuídos.

1. 1
   LidaPonteiros, Memória e Escape Analysis em Go

   Como o compilador do Go decide entre stack e heap, o que dispara o escape analysis e por que retornar ponteiros pode pesar no GC.
2. 2
   LidaAnatomia de Slices, Arrays e Maps em Go: Estruturas Internas e Armadilhas

   Por dentro de arrays, slices e maps em Go: o slice header (ptr, len e cap), como o append realoca memória e por que maps não são thread-safe.
3. 3
   LidaTratamento de Erros Idiomático em Go: Wrapping, Sentinelas e Exceções

   Como tratar erros como valores em Go: encadear causas com %w, inspecionar com errors.Is e errors.As e quando evitar panic.
4. 4
   LidaMódulos, Pacotes e Workspaces em Go: Dependências e Encapsulamento

   Como organizar pacotes em Go com internal e pkg, controlar visibilidade pelas maiúsculas e gerenciar vários módulos com go.work.
5. 5
   LidaControle de Fluxo Idiomático em Go: Loops, Escopo de Decisão e Type Switches

   Os laços for e range modernos (escopo por iteração do Go 1.22+), a inicialização curta em if e switch e os type switches.
6. 6
   LidaManipulação de Arquivos e I/O Idiomático em Go

   Como io.Reader e io.Writer permitem ler e transmitir arquivos grandes com memória constante, com filepath.WalkDir e streams.
7. 7
   LidaTrabalhando com JSON em Go: Da Biblioteca Padrão a Alta Performance

   Quando usar Marshal e Unmarshal na memória e quando usar Decoder e Encoder em streams, com foco em performance no encoding/json.
8. 8
   LidaCliente HTTP Profissional em Go: Resiliência, Pooling e Sockets

   Como configurar o http.Client com timeouts, reaproveitar conexões com http.Transport e drenar respostas para não vazar recursos.
9. 9
   LidaServidor HTTP Nativo Moderno em Go (1.22+)

   Como criar APIs REST completas só com a biblioteca padrão, usando o roteador http.ServeMux do Go 1.22+ com verbos e parâmetros.
10. 10
    LidaGerenciamento de Configuração com Viper

    Como unir arquivos YAML, variáveis de ambiente e flags em uma configuração única, seguindo o princípio de configurar pelo ambiente.
11. 11
    LidaTestes unitários em Go com o pacote testing

    Como escrever testes com o pacote testing do Go: convenções de arquivos, caixa-preta e caixa-branca, e a diferença entre Errorf e Fatalf.
12. 12
    LidaTable-driven tests e paralelismo em Go

    Como estruturar cenários de teste em tabelas com subtestes paralelos e por que a captura de variáveis no loop exigia cuidado antes do Go 1.22.
13. 13
    LidaTestify: asserções e suítes de testes em Go

    Como usar as asserções do Testify, a diferença entre assert e require e como organizar suítes de testes mais legíveis em Go.
14. 14
    LidaMocks e dublês de teste em Go

    Como criar fakes, stubs e spies manualmente e usar o testify/mock para isolar regras de negócio de dependências lentas ou externas.
15. 15
    LidaBenchmarking e profiling de testes em Go

    Como escrever benchmarks confiáveis com testing.B, ler métricas de alocação e evitar que o compilador elimine o código medido.
16. 16
    LidaFuzzing nativo em Go: testes guiados por cobertura

    O que é fuzzing guiado por cobertura, como escrever funções FuzzXxx e como o Go transforma uma falha em um caso de teste reproduzível.
17. 17
    LidaTestes de integração com Testcontainers em Go

    Como subir PostgreSQL, Redis ou Kafka reais em contêineres Docker durante os testes, de forma programática, isolada e descartável.
18. 18
    Lidadatabase/sql e connection pooling em Go

    Como o pool de conexões do database/sql funciona por dentro, quais os quatro parâmetros de capacidade e como controlar transações.
19. 19
    LidaPostgreSQL com pgx em Go: o driver nativo

    Como usar o driver pgx v5 no modo nativo do PostgreSQL, com prepared statements automáticos, pipelines e alta vazão em aplicações Go.
20. 20
    LidaSQLC: SQL tipado a partir de queries em Go

    Como o SQLC gera código Go fortemente tipado a partir de queries SQL puras, com a interface Querier e sem reflexão em tempo de execução.
21. 21
    LidaGORM na Prática: Modelagem, CRUD, Associações e Trade-offs

    Como modelar, fazer CRUD e associações com o GORM, quando vale usar um ORM em Go e como evitar armadilhas como N+1 e queries lentas.
22. 22
    LidaDatabase Migrations com Goose: Versionamento, Embed e Zero-Downtime

    Como versionar o esquema do banco com Goose, embutir migrações no binário e aplicar mudanças sem downtime com o padrão expand e contract.
23. 23
    LidaMiddlewares em Go: Arquitetura Cebola, Interceptação e Produção

    Como construir middlewares em Go que envolvem http.Handler, com a arquitetura de cebola, interceptação de requisições e cuidados de produção.
24. 24
    LidaAutenticação e JWT em Go: Tokens, Assinatura e RBAC

    Como emitir e validar JWT com assinatura, aplicar RBAC nas rotas e tratar expiração e revogação em uma API Go stateless.
25. 25
    LidaDocumentação de APIs com Swagger em Go: OpenAPI, Swag e Automação

    Como gerar a documentação OpenAPI de uma API Go a partir de anotações no código com Swag, evitando documentação desatualizada.
26. 26
    LidaGraphQL com gqlgen: Abordagem Schema-First, Resolvers e DataLoader

    Como construir uma API GraphQL com gqlgen na abordagem schema-first, com resolvers e DataLoader para evitar o problema N+1.
27. 27
    LidaMensageria Prática em Go: RabbitMQ, Apache Kafka e Resiliência

    Como integrar serviços com RabbitMQ e Kafka em Go, com resiliência, desacoplamento temporal e tratamento de mensagens falhas.
28. 28
    LidaUpload de Arquivos para AWS S3 em Go: Streaming, Presigned URLs e Escala

    Como enviar arquivos grandes para o AWS S3 em Go com streaming, presigned URLs e controle de memória, do primeiro upload à escala de produção.
29. 29
    LidaClean Architecture em Go: Camadas, Inversão de Controle e Pragmatismo

    Como separar regras de negócio de detalhes externos em Go com camadas, inversão de controle e o pragmatismo necessário para não exagerar.
30. 30
    LidaInjeção de Dependências com Google Wire: DI em Tempo de Compilação

    Como montar o grafo de dependências de um projeto Go em tempo de compilação com Google Wire, sem container de IoC em tempo de execução.
31. 31
    LidaLogging Estruturado com slog: Performance, Contexto e Produção

    Como fazer logs estruturados com o pacote slog da biblioteca padrão, com níveis, campos de contexto e saída pronta para produção.
32. 32
    LidaTracing Distribuído e OpenTelemetry em Go: Spans, Contexto e OTLP

    Como instrumentar microsserviços Go com tracing distribuído, spans, propagação de contexto e exportação via OTLP com OpenTelemetry.
33. 33
    LidaResiliência em Go: Timeouts, Exponential Backoff, Circuit Breaker e Bulkhead

    Como proteger chamadas a serviços lentos com timeouts, retry com exponential backoff, circuit breaker e bulkhead, em Go e em produção.
34. 34
    LidaWorker Pools e Rate Limiting em Go: Concorrência Controlada e Vazão

    Como controlar a concorrência com worker pools e rate limiting em Go, evitando criar uma goroutine por tarefa sem limite.
35. 35
    LidaPipeline Pattern e Fan-Out, Fan-In em Go: Concorrência em Estágios

    Como encadear estágios concorrentes com channels em um pipeline, com fan-out para paralelizar e fan-in para juntar os resultados.
36. 36
    LidaLocks Distribuídos com Redis em Go: Exclusão Mútua, Redlock e Lua

    Como implementar exclusão mútua entre processos com locks distribuídos no Redis, incluindo o Redlock e scripts Lua para atomicidade.
37. 37
    LidaGraceful Shutdown e Signal Handling em Go: Encerramento Seguro em Produção

    Como encerrar um serviço Go com segurança em produção: tratar sinais do sistema, drenar requisições e fechar workers e conexões.