
Instalação do Go, Docker e das dependências do projeto nas principais distribuições Linux, com os ajustes específicos que cada uma exige.
Instalação do Go, Docker Desktop e WSL2, e configuração do terminal para rodar o projeto no Windows sem atrito nas aulas seguintes.
Como funcionam generics em Go de verdade. Você vai ver os três generics reais do projeto (fsm.Machine[T], memcache.Cache[V], batch.Batcher[In, Out]), entender constraints como comparable e ~, e como o compilador usa GCShape stenciling, não monomorfização como C++ nem type erasure como Java.
Interfaces em Go não se declaram, se satisfazem. Você vai ver a diferença entre method set de valor e de ponteiro com um erro de compilação real, o padrão de asserção estática usado no projeto, e a armadilha clássica de uma interface segurando um ponteiro nil por dentro.
Concorrência aplicada, não só teoria de canal. Você vai desmontar o dynamic batcher do pipeline de fraude linha por linha, ver select com e sem default, e entender os erros mais comuns que causam goroutine leak e panic de canal fechado.
Como o projeto protege estado compartilhado sem travar tudo. RWMutex com sharding pra reduzir contenção, WaitGroup garantindo shutdown limpo, e duas aplicações bem diferentes de sync.Once no mesmo código-base.
Como um prazo de 100ms viaja do gateway até o serviço de fraude e volta. Você vai ver WithTimeout em produção, por que defer cancel() nunca pode faltar, e por que este projeto nunca usa context.Value.
Go não tem exceção, erro é valor. Você vai ver sentinel errors reais, a diferença entre errors.Is e ==, wrapping com %w através de múltiplas camadas, e como um erro de domínio vira um código HTTP na outra ponta do sistema.
Antes de qualquer linha de código, o porquê. Você vai passar pelos 11 Architecture Decision Records reais do projeto, cada um com contexto, decisão e o preço que ela cobra, o mesmo processo que times de engenharia sênior usam pra não repetir os mesmos debates duas vezes.
Por que os quatro serviços vivem no mesmo repositório, com deploys totalmente independentes. Você vai ver a estrutura real de pastas, as regras de importação que o próprio compilador Go reforça, e como um único go.mod versiona tudo junto.
Como um arquivo .proto vira o contrato oficial entre os serviços. Você vai ver os arquivos reais ledger.proto e fraud.proto, o que o protoc gera automaticamente em Go, por que a tag numérica do campo é o contrato de verdade (não o nome), e por que todo enum começa em UNSPECIFIED.
Antes da primeira aula de código, criamos um único arquivo, AGENTS.md, na raiz do projeto. Ele documenta as convenções que valem para todo o curso: quando comentar código (só quando o "porquê" não é óbvio), como tratar erros (sentinelas com errors.Is), quando usar generics, e como a Clean Architecture se organiza em cada serviço (domain/usecase/infra/adapter).
A partir desta aula, qualquer agente de IA que você usar para gerar código (Junie, ou outro) carrega essas regras automaticamente, sem você precisar repeti-las em cada prompt. É uma configuração que você faz uma única vez e que economiza tempo em todas as aulas seguintes do curso.
Antes de escrever qualquer código, você entende por que o pipeline de fraude deste projeto é modelado como uma máquina de estados finita explícita, em vez de uma sequência de ifs aninhados.
Você vai ver a anatomia da struct Machine[T], como ela é construída por method chaining, o loop de Run passo a passo, e o papel do FallbackTo quando um estágio falha. A aula fecha ligando tudo ao ADR 0005, o registro real da decisão por trás desse design.
Primeira aula de código do módulo: você cria pkg/fsm/fsm.go do zero, começando pelos tipos fundamentais que sustentam o pacote inteiro.
Você continua fsm.go construindo a struct Machine e os construtores que permitem montá-la com opções configuráveis. A aula explica o raciocínio por trás de cada campo e fecha com a documentação de cada função, deixando claro o contrato público do pacote antes de implementar seu comportamento.
Aqui entra o coração da API pública do pacote: os métodos Handle e Terminal, que registram handlers e estados finais, e o FallbackTo, que você escreve inteiro do zero. É a peça que te obriga a entender de verdade como o mecanismo de fallback se encaixa no resto da máquina.
Esta aula fecha fsm.go com o método Run, o loop que efetivamente executa a máquina de estados. Você escreve à mão a decisão entre abortar a execução ou usar o fallback configurado, a decisão de design mais importante do pacote inteiro
Você começa fsm_test.go, testando o caminho feliz da máquina de estados: uma sequência de transições que roda sem erro, do início ao fim esperado. A aula fecha escrevendo as asserções que provam exatamente o que precisa ser validado para confirmar que a máquina funcionou.
Você testa o que acontece quando um handler falha e a máquina precisa decidir entre abortar ou usar o FallbackTo. A asserção do trace[1].Err é a prova, em código de teste, da decisão de design implementada nas aulas anteriores.
Você entende por que este projeto não usa Redis para o cache de velocity e o cache semântico: uma chamada de rede custa ~0,5ms contra ~50ns de acesso em memória, e o orçamento total do caminho de fraude é de apenas 100ms. A aula também explica o gargalo real de um mutex único sob centenas de goroutines concorrentes, e como dividir o cache em 16 shards independentes reduz a chance de colisão para 1 em 16.
Você cria pkg/memcache/memcache.go do zero, começando pelos tipos fundamentais de um cache genérico em memória, shardado, com suporte a TTL. Essa base sustenta todo o restante do pacote construído nas próximas quatro aulas.
Você implementa o construtor New e a função shardFor, responsável por decidir em qual dos 16 shards uma chave específica vive. Essa é a peça que transforma a teoria em código: é shardFor que garante que operações em chaves diferentes quase nunca competem pelo mesmo lock.
Você começa a suíte de testes do pacote, cobrindo o comportamento básico de Set/Get e o caso mais importante de todos: um item expirado realmente deixa de ser retornado. A aula também explica uma decisão de design real: por que este pacote não usa um relógio falso (fake clock) nos testes de expiração.
Você escreve um teste que dispara múltiplas goroutines incrementando a mesma chave ao mesmo tempo, e confirma que o valor final bate exatamente com o esperado, a prova de que Increment não perde nenhum incremento sob concorrência real, não hipotética.
Você fecha memcache.go com Len (contagem total de itens across todos os shards), Close (onde sync.Once garante que o encerramento aconteça uma única vez mesmo sob chamadas concorrentes) e o janitor, a única goroutine de fundo do pacote, responsável por limpar periodicamente itens expirados de cada shard.
Última aula do módulo: você testa acesso concorrente distribuído entre chaves diferentes, cobrindo shards diferentes ao mesmo tempo, um cenário distinto do teste da aula 30, que concentrava tudo numa única chave. Fecha a suíte confirmando que Len reflete corretamente o estado do cache mesmo depois de toda essa concorrência.
Você entende por que chamadas concorrentes ao modelo de scoring de fraude (TreeModel.Score) não podem ir uma a uma direto ao modelo, o dynamic batcher agrupa várias chamadas simultâneas em um único lote, disparado por dois gatilhos: tamanho máximo atingido ou uma janela de tempo, o que vier primeiro. A aula também adianta o detalhe mais sutil do pacote inteiro: o bug clássico do timer.Reset que gera um "tick fantasma" se não for tratado com cuidado.
Você cria pkg/batch/batch.go do zero, começando pelos tipos genéricos que sustentam um dynamic batcher reutilizável, Batcher[In, Out], capaz de agrupar qualquer tipo de entrada e devolver qualquer tipo de saída, não só scores de fraude.
Você implementa Close, o encerramento gracioso do batcher, e dispatch, a função responsável por decidir exatamente o que cada chamador recebe de volta depois que um lote é processado. dispatch é o ponto mais fácil de introduzir um bug silencioso no pacote inteiro.
Você fecha a lógica central com loop, a goroutine de fundo que efetivamente decide quando disparar um lote. Esta é a aula mais importante do módulo: você escreve do zero a parte mais sutil do pacote inteiro, como resetar o timer corretamente sem deixar escapar um tick fantasma, a causa raiz de um bug de concorrência clássico em Go.
Você começa a suíte de testes cobrindo os dois gatilhos de flush explicados na teoria: um lote que fecha porque atingiu o tamanho máximo, e outro que fecha porque a janela de tempo expirou primeiro. Os dois testes provam, com concorrência real, que os dois caminhos de disparo funcionam de forma independente.
Implementar o domínio de fraude em Go: extração de features, regras determinísticas rápidas e um modelo de árvore de decisão avaliado nativamente, sem sidecar Python, com validação agressiva e sigmoid sem depender do pacote math.
Você cria internal/fraud/domain/features.go do zero, começando pelo struct Attempt, que representa uma tentativa de pagamento. A parte mais importante desta aula é a distinção entre os dados que chegam prontos na entrada e os dados que só existem depois de o pipeline enriquecer a tentativa .
Você implementa FeatureVector, a função que transforma uma tentativa de pagamento num vetor numérico pronto para o modelo de scoring. Essa função é o contrato entre o código Go e o modelo treinado: qualquer mudança na ordem ou no significado de uma posição do vetor quebra esse contrato silenciosamente, por isso ela merece atenção total.
Você fecha features.go com o tipo Verdict e a função VerdictFromScore, que traduz um score contínuo (um número entre 0 e 1) numa decisão discreta: aprovado, negado ou revisão manual. Essa é a ponte entre "o modelo calculou um número" e "o sistema toma uma ação".
Você cria internal/fraud/domain/rules.go, começando pelos tipos de resultado, os limites de valor e velocity, e a blocklist de cartões conhecidos. Essas são as regras determinísticas que rodam antes de qualquer modelo de machine learning — rápidas, previsíveis, e responsáveis por resolver os casos óbvios sem gastar o orçamento de latência do modelo.
Você começa internal/fraud/domain/tree.go, o arquivo que implementa uma árvore de decisão avaliada nativamente em Go, sem depender de um sidecar Python. Você define os tipos Tree e Node, e escreve TreeModel, o tipo que amarra toda a estrutura da árvore.
Você implementa ParseTreeModel, responsável por carregar e validar um modelo de árvore de decisão a partir de dados serializados. O laço de validação de cada nó é a parte mais importante desta aula: é ele que decide se um deploy com modelo quebrado falha rápido e visível, ou se vira um score errado silencioso em produção.
Você implementa Score, o ponto de entrada público que avalia uma árvore de decisão contra um conjunto de features, e eval, o laço que efetivamente percorre a árvore nó a nó sem nenhuma alocação de memória, uma decisão de performance importante para um caminho que roda em todo scoring de pagamento.
Última aula do módulo: você fecha tree.go implementando sigmoid de forma numericamente estável, e expNeg, uma série de Taylor escrita à mão que calcula exponencial sem depender do pacote math da biblioteca padrão. Você entende por que essa escolha foi feita e como uma implementação própria pode ser mais previsível em contextos de baixa latência.
Você cria internal/fraud/usecase/pipeline.go, começando pelos seis estados da máquina que representam cada estágio do processo de scoring de fraude. Você também escreve as três interfaces que o pipeline depende, sem conhecer nenhuma implementação concreta de infraestrutura.
Você define Decision, o tipo de saída pública que representa o resultado final de uma tentativa de pagamento, e depois implementa scoringData e Pipeline, os dois tipos internos que carregam o estado de uma execução enquanto ela passa pelos estágios da máquina.
Você implementa NewPipeline, a função construtora que monta o pipeline completo. As duas partes centrais desta aula são o closure do batcher, que agrupa chamadas de scoring concorrentes usando o pacote construído no módulo anterior, e o wiring da máquina de estados, conectando cada estado ao seu handler correspondente.
Você implementa Close, responsável pela limpeza de recursos quando o pipeline é encerrado, e Score, o método público que recebe uma tentativa de pagamento e a executa por toda a máquina de estados até chegar a uma decisão final.
Você implementa o handler enrich, responsável por adicionar informações que os estágios seguintes precisam. A parte de geo é a mais importante desta aula, incluindo o tratamento de falha best effort, garantindo que uma falha ao buscar localização não impeça o restante do processamento de continuar.
Você implementa fastRules, o prefiltro determinístico que resolve casos óbvios rapidamente, e mlScore, o handler mais crítico do pipeline inteiro. mlScore inclui o caminho de degradação, o comportamento que garante que uma falha no modelo de machine learning não impeça uma decisão de ser tomada.
Você fecha pipeline.go implementando finalize, a rede de segurança final que garante uma decisão consistente ao encerrar o processamento, e tiebreak, o handler que resolve scores ambíguos usando similaridade semântica contra decisões anteriores.
Você começa a suíte de testes do pipeline, criando o fake staticGeo para simular respostas de localização de forma controlada, e o helper newPipeline, responsável por montar um pipeline real, com peças reais de infraestrutura, pronto para ser usado em todos os testes seguintes.
Você adiciona as dependências de gRPC e protobuf ao projeto usando go get, nunca digitando a versão manualmente no arquivo. A aula reforça uma prática importante: o gerenciamento de dependências passa sempre pelas ferramentas do próprio Go, e você confere o resultado direto no go.mod depois de cada comando.
Você cria proto/fraud/v1/fraud.proto, o contrato da API do serviço de fraude. Você escreve o comentário do serviço e o campo degraded da resposta, uma decisão de design que comunica quando o score foi calculado sob uma condição degradada, algo importante o suficiente para não pular.
Você começa proto/ledger/v1/ledger.proto, definindo o serviço e o primeiro RPC, Authorize. Você escreve os outros quatro RPCs do serviço e o enum PaymentStatus, já que essa é a definição do desenho completo da API do ledger, não uma repetição mecânica do primeiro RPC.
Você fecha ledger.proto com as mensagens de histórico, revisão e pagamentos recentes. Você escreve os três campos de Review que guardam a decisão humana e o campo followed_recommendation, o ponto exato onde a regra de negócio da revisão manual fica registrada no contrato.
Última aula do módulo: você adiciona um novo target ao Makefile que embrulha o comando protoc, seguindo o mesmo padrão de comentário usado pelos outros targets do projeto. Você roda a geração de código pela primeira vez e faz um tour pelo código Go gerado a partir dos arquivos .proto escritos nas aulas anteriores.
Todo curso de Go ensina sintaxe. Poucos ensinam o que fazer com ela quando o sistema precisa rodar em produção, sob carga real.
Neste curso, você não vai construir mais um CRUD de exemplo. Vai construir um processador de pagamentos completo, com quatro microsserviços independentes, gateway, ledger, fraud e investigator, comunicando entre si via gRPC, publicando eventos no Kafka através do padrão outbox, e persistindo tudo em Postgres com transações de dupla entrada contábil, o mesmo modelo usado por sistemas financeiros reais.
O diferencial está no serviço de fraude. Em vez de chamar uma API externa de terceiros, você vai implementar um motor de decisão nativo em Go, uma árvore de decisão que roda em nanossegundos, uma máquina de estados com fallback determinístico para nunca travar uma autorização, e um agente de investigação com IA que usa o Model Context Protocol, implementado do zero, sem esconder a mecânica atrás de um SDK.
Cada decisão de arquitetura é justificada com um ADR (Architecture Decision Record) real, o mesmo processo usado por times de engenharia sênior para documentar por que uma escolha técnica foi feita, e não outra. Você vai entender o porquê por trás de cada linha, não só copiar código.
O curso cobre Go do nível avançado, generics, concorrência com goroutines e channels, sync primitives, context, tratamento idiomático de erros, além de Clean Architecture, Protocol Buffers, observabilidade com Prometheus e Grafana, testes automatizados, e deploy real em Kubernetes na Google Cloud.
Ao final, você terá construído, sozinho, um sistema distribuído completo, do primeiro go.mod até o kubectl apply em produção, entendendo cada peça que compõe um backend financeiro moderno.