Escrevendo Código Go Testável Sem Mockar Tudo
Implementações reais ao invés de mocks, test fixtures que funcionam, e design patterns que tornam código testável sem gerar arquivos mock para cada interface.
Posts
Profiling de Alocações de Memória em um Serviço Go de Alta Vazão
Como reduzimos pausas de GC de 50ms para 2ms encontrando alocações escondidas. Técnicas práticas de pprof, escape analysis e as otimizações que realmente importam.
Worker Pools e Concorrência Limitada em Go
Padrões práticos para controlar concorrência: worker pools, errgroup, semáforos, fan-out/fan-in e backpressure. Como processar trabalho concorrentemente sem sobrecarregar seu sistema.
Graceful Shutdown em Go É Mais Difícil Do Que Você Pensa
Lidando com requisições em andamento, consumidores Kafka, conexões de banco de dados e sinais de terminação do Kubernetes corretamente. Os detalhes que os tutoriais pulam.
Estratégias de Error Handling Além de if err != nil
Erros estruturados, wrapping de erros feito corretamente, sentinel errors vs verificação de comportamento, e padrões que tornam debug de produção realmente possível.
Injeção de Dependência em Go Sem Frameworks
DI manual, functional options, geração de código com Wire, e por que Go não precisa de containers estilo Spring. Padrões práticos para construir aplicações testáveis e manuteníveis.
Por Que Nosso Microserviço Precisou de um Circuit Breaker (E Como Construímos)
Cascatas de latência reais que encontramos, como derrubaram nosso sistema, e a implementação de circuit breaker que nos salvou.
Quando Ir para Sistemas Distribuídos
Um guia para decidir quando migrar de um monolito para arquitetura distribuída, e como fazer isso corretamente.
Padrões de Propagação de Context em Grandes Codebases Go
Quando passar context, quando não passar, e os erros comuns que levam a goroutines vazadas, cancelamentos perdidos e pesadelos de debug.
Estruturando um Monolito Go Para Que Possa Virar Microserviços Depois
Fronteiras de módulos práticas, organização de pacotes, e os padrões que tornam decomposição futura possível sem reescrever tudo.
Clean Architecture em Go
Implementando Clean Architecture em aplicações Go para código mais testável, manutenível e escalável.
Construindo APIs REST com Go
Um guia prático para construir APIs RESTful robustas usando Go e a biblioteca padrão.
Entendendo Interfaces em Go
Um mergulho profundo em interfaces Go, duck typing e como usar interfaces para escrever código flexível e testável.
Começando com Go
Um guia para iniciantes sobre a linguagem de programação Go e seu ecossistema.
Projetando Fronteiras de Serviço e Contratos de API
Onde você desenha fronteiras de serviço — e como trata os contratos entre elas — decide se um sistema é genuinamente desacoplado ou um monolito distribuído vestido de microsserviço. Sobre posse de dados, acoplamento, e evoluir contratos sem quebrar consumidores.
ClojureScript para Desenvolvedores React
Se você já conhece React, a maior parte do ClojureScript está mais perto do que você imagina. Reagent é React com dados imutáveis e hiccup no lugar de JSX — eis o mapa mental, a história de interop, e por que re-render por igualdade de referência é o ganho silencioso.
Redux e re-frame: Duas Abordagens para Estado no Front-End
Redux (React/JS) e re-frame (ClojureScript) partem da mesma ideia — um estado imutável da app, updates puros, views derivadas — e divergem de formas instrutivas. O que cada um acerta, e o que os effects e interceptors do re-frame adicionam.
GraphQL em Go: Matando o N+1 e Encolhendo Payloads
Os dois problemas que todo servidor GraphQL enfrenta quando clientes reais chegam: a explosão de queries N+1 vinda de resolvers aninhados, e o custo ilimitado de query. Como consertar ambos em Go com dataloaders e limites de complexidade.
Escolhendo Entre REST, gRPC e GraphQL
Três formas de expor uma API, três apostas diferentes. Uma comparação prática de REST, gRPC e GraphQL em contratos, transporte, adequação ao cliente, evolução e cache — com as condições concretas sob as quais cada um é a escolha certa.
Datomic para Domínios com Muitos Dados: O Banco de Dados como um Valor
O que o Datomic dá a um domínio com muitos dados que um banco tradicional não dá: o datom atômico, schema como dados, valores imutáveis do banco que você consulta como funções puras, viagem no tempo e auditoria de graça — e um olhar honesto sobre onde ele machuca.
Estratégias de Cache com Redis Que Realmente Fizeram Diferença
Cache-aside vs write-through, TTLs com jitter, e o cache stampede que derruba seu banco na pior hora possível — com Go e Redis, e um olhar honesto sobre o problema de invalidação do qual ninguém escapa.
Performance em Clojure com Muitos Dados: Transducers, Transients e core.async
Deixando Clojure rápido em datasets grandes: por que pipelines de lazy-seq alocam, como transducers e transients cortam isso para perto de zero, matando reflection em loops quentes, e usando pipelines de core.async para fan-out I/O-bound com backpressure.
Desenvolvimento Guiado pelo REPL: Como Eu Realmente Escrevo Clojure
Desenvolvimento guiado pelo REPL não é 'um console melhor' — é editar um programa vivo. Como eu construo funções incrementalmente contra dados reais de dentro do meu editor, usando rich comments e tap>, e onde o fluxo morde.
O Padrão BFF em Clojure: Contratos Tipados para um Frontend com Muitos Dados
Construindo um backend-for-frontend em Clojure com Ring, Reitit e malli: roteamento orientado a dados, contratos HTTP tipados sem um sistema de tipos estático, fan-out paralelo para serviços downstream e degradação graciosa quando um deles está lento.
Indexação no PostgreSQL para Serviços de Alto Volume
Um guia prático de indexação no Postgres sob carga: como índices B-tree de fato são usados, por que a ordem das colunas num índice composto importa, índices covering e parciais, lendo o EXPLAIN, e o custo de escrita que torna 'só adiciona um índice' o padrão errado.