Guias
Guias passo a passo, com diagramas e código, sobre fundamentos de ciência da computação e design de sistemas. Leia um e pratique o tema com perguntas de verdade.
- Projetar um rate limiter: Onde ele vive, os algoritmos e seus trade-offs, código funcional, Redis em escala e os números.
- Projetar um encurtador de URLs: Códigos curtos, 301 vs 302, colisões, cache, abuso e contagem de cliques sem deixar o redirect lento.
- Estratégias de cache: Onde os caches vivem, cache-aside e os outros padrões, remoção, corridas de invalidação e como sobreviver a stampedes.
- Consistent hashing: Por que hash mod N quebra quando os servidores mudam, como o anel e os nós virtuais resolvem isso, com código e alternativas.
- Como funcionam os índices de banco de dados: B-trees, ordem de índices compostos, índices de cobertura, como ler o EXPLAIN e por que o banco ignora o seu índice.
- Níveis de isolamento de transação: De leituras sujas a write skew, os quatro níveis padrão versus o que o PostgreSQL e o MySQL realmente fazem, e como corrigir cada problema.
- TLS e HTTPS: Como os handshakes do TLS 1.3 e 1.2 funcionam mensagem por mensagem, por que o forward secrecy e os certificados importam, o que a retomada e o 0-RTT custam e os erros que causam quedas.
- O que acontece quando você digita uma URL: DNS, TCP, TLS, HTTP e renderização em ordem, com uma consulta DNS de 29 bytes montada à mão, tempos do curl para cada fase e as formas padrão de cortar cada ida e volta.
- O teorema CAP e os modelos de consistência: O que o CAP realmente diz, um experimento de partição CP versus AP, quóruns (R + W > N), o espectro do linearizável ao eventual e o PACELC.
- Balanceamento de carga: Camada 4 versus camada 7, uma simulação de aleatório, round robin, menos conexões e power of two choices, health checks, draining e sticky sessions.
- Filas de mensagens e garantias de entrega: At-most-once, at-least-once e exactly-once na prática: o transactional outbox, consumidores idempotentes, visibility timeouts e dead-letter queues, executados no PostgreSQL.
- Projetando um news feed: Fan-out na escrita versus na leitura, o problema das celebridades e o híbrido, timelines em Redis com memória medida, paginação por keyset versus OFFSET cronometrada no PostgreSQL, ranqueamento, exclusões e privacidade.
- Projetando um web crawler: A fila de URLs (frontier) com polidez por host (código em quatro linguagens), normalização de URLs, um filtro de Bloom medido, robots.txt, detecção de quase duplicatas, spider traps testadas em um site local e frescor.
- Identificadores persistentes e link rot: Por que uma URL falha como nome, como um DOI é construído e resolvido, como normalizar e verificar identificadores (medido: ISBN-13 e ORCID detectam erros de digitação, DOIs não), por que um 301 quebra atualizações em um navegador real, negociação de conteúdo e regras para projetar seus próprios identificadores.
- Projetando um resolvedor de DOI: Um serviço de redirecionamento de leitura intensiva que precisa sobreviver aos sites para os quais aponta: o caminho de consulta em Python e Go, um cache com TTL testado e uma simulação de taxa de acerto Zipf, por que fazer sharding por prefixo cria shards quentes, escritas versionadas, tombstones, um verificador de links seguro e negociação de conteúdo.
- Projetando um sistema multi-tenant: Tenancy silo, bridge e pool comparados com medições no PostgreSQL: Row-Level Security, chaves estrangeiras compostas, um schema e um role por tenant, o vazamento em conexões de pool, timeouts por tenant, migrações e dumps com 1.000 tenants, resolução de tenant e vizinhos barulhentos.
- Concorrência: condições de corrida, deadlocks e o event loop: Threads, event loops e goroutines comparados; a atualização perdida e o deadlock como animações que você pode percorrer; o que as correções custam, medido em Go e Python; e a única regra de um event loop.
- Projetando uma API REST: Recursos e URLs, métodos e suas garantias, códigos de status e erros, e três riscos testados: um POST repetido que cria dois pedidos, paginação com OFFSET que repete itens e requisições condicionais com ETags.
- Autenticação e sessões: Armazenamento de senhas (custos de hash medidos), sessões e flags de cookie, JWTs, XSS e CSRF, OAuth 2.0 com PKCE e OpenID Connect, códigos de uso único e passkeys, e os erros de autorização por trás da maioria dos vazamentos.
- Transações distribuídas: two-phase commit e sagas: Por que uma operação de negócio em vários bancos de dados é difícil, o two-phase commit (e como ele bloqueia), sagas com compensações e seu isolamento ausente, e passos idempotentes com um outbox, tudo executado no PostgreSQL e em pequenos serviços Python.
- Observabilidade: logs, métricas e traces: O que cada um dos três sinais responde, por que médias escondem requisições lentas e percentis não podem ser tirados em média, cardinalidade de labels, custo de logs, propagação e amostragem de traces e alertas baseados em burn rate de SLO, com um exemplo de dois serviços em Python.
- Replicação, particionamento e sharding: O que cada uma das três ferramentas escala, lag de replicação e read-your-writes, o que um failover assíncrono perde, partition pruning, escolha da shard key, shards quentes e resharding, executados no PostgreSQL e em Python.
- Padrões de resiliência: timeouts, retries e circuit breakers: Como uma dependência lenta se espalha e as ferramentas que a contêm: timeouts e deadlines, retries com backoff, jitter e orçamentos, circuit breakers, bulkheads, backpressure e load shedding, com experimentos medidos e duas animações passo a passo.
- Sistemas operacionais: processos, threads, memória virtual e escalonamento: Processos versus threads, trocas de contexto, escalonamento round-robin, memória virtual, page faults, copy-on-write, substituição de páginas e thrashing, com medições no Linux e duas animações passo a passo.
- DNS, HTTP/2, HTTP/3 e CDNs: Como um nome é resolvido e guardado em cache, o que custa uma conexão nova, como a multiplexação do HTTP/2 e o HTTP/3 sobre QUIC removem o bloqueio de cabeça de fila, e como a taxa de acertos, as chaves de cache e os cabeçalhos de uma CDN decidem o seu valor.
- Busca e indexação de texto completo: O índice invertido, a análise, o ranking BM25, a compressão de listas de postings, segmentos e merges, busca em shards, como manter um índice em sincronia com o banco de dados e quando a busca de texto completo do Postgres basta.
- A hierarquia de memória e o Big-O na prática: Linhas de cache e localidade, por que o mesmo laço O(n) pode ser 18 vezes mais lento, ordem por linhas contra por colunas, layouts de structs, listas ligadas, predição de desvios e quando o fator constante vence o expoente, com experimentos medidos em C.
- Consenso: Raft, eleição de líder e replicação de log: Como um grupo de máquinas concorda sobre um log apesar de quedas: quóruns, os termos do Raft, eleições aleatorizadas, replicação e a regra de commit, partições e o que sobrevive a elas, com uma simulação, injeção de falhas e duas animações passo a passo.
- Motores de armazenamento: B-trees e LSM trees: Como as B-trees atualizam páginas no lugar e as LSM trees acrescentam, descarregam e compactam, com amplificação de escrita, de leitura e de espaço medidas, Bloom filters, estratégias de compactação e quando escolher cada uma.
- Microsserviços, API gateways e service meshes: O que dividir em serviços realmente custa em latência e disponibilidade, como traçar fronteiras, comunicação síncrona contra assíncrona, o API gateway e o BFF, a descoberta de serviços e o service mesh, e a migração strangler fig.
- Segurança de aplicações web: injeção, XSS, CSRF e segredos: Injeção, cross-site scripting, CSRF, controle de acesso quebrado, path traversal, SSRF, desserialização insegura e segredos vazados, cada um mostrado com o código vulnerável, o ataque e a correção, além de cadeia de suprimentos, cabeçalhos e resposta.
- Event sourcing e CQRS: Armazenar fatos em vez de estado: o event store, concorrência otimista, replay e snapshots, read models e projetores, consistência eventual, design de eventos e upcasting, e quando não vale a pena.
- Contêineres e Kubernetes: O que um contêiner realmente é (namespaces, cgroups e camadas de imagem, medidos) e como o Kubernetes mantém o estado desejado: o plano de controle, o agendamento por requests, atualizações graduais e probes, e o autoscaling.
- Internos do Git e pipelines de CI/CD: O Git como um armazenamento de objetos endereçado por conteúdo (hashes, packfiles, bisect, rebase), estratégias de branching, integração e entrega contínuas, e como as implantações canary, blue/green e graduais limitam o dano de uma versão ruim.
- Garbage collection e gerenciamento de memória: Alcançabilidade, contagem de referências contra rastreamento (tracing), coleta geracional, o que a folga do heap e a escolha do coletor custam (medido em Java, Go e Python), vazamentos em linguagens gerenciadas e dimensionamento de um heap em um contêiner.
- Compiladores, interpretadores e runtimes de linguagens: Do texto-fonte ao código em execução: análise léxica, parsing, otimização, máquinas de bytecode e compilação just-in-time, com um tree walker, uma VM de bytecode e código compilado medidos lado a lado.
- Séries temporais e sistemas de muita escrita: Projetando para um fluxo constante de pequenas escritas: batching e COPY, compressão delta-of-delta e XOR, expiração de dados descartando partições, cardinalidade de labels, rollups e por que percentis não podem ser tirados em média.
- Projetando um sistema de chat: Um projeto desenvolvido com números: conexões persistentes, números de sequência por conversa para ordenação, entrega idempotente, fan-out na escrita contra na leitura, presença, sincronização offline e grupos muito grandes.
- Como o Python funciona: Nomes como etiquetas em objetos, mutabilidade e o argumento padrão mutável, o modelo de dados por trás de operadores e laços, geradores (1,4 KB contra 409 MB), closures e ligação tardia, contagem de referências e o coletor de ciclos, __slots__ e custos medidos.
- Desempenho e concorrência em Python: Fazer o profile primeiro, o que o interpretador custa por item, NumPy contra laços, a GIL medida com threads e processos, a sobrecarga de pools de processos, asyncio e chamadas bloqueantes, e como escolher.
- Classes, herança e tipagem em Python: Busca de atributos, a MRO e o super(), properties e descritores, dataclasses e o que custam, classes base abstratas, Protocols e o que as dicas de tipo garantem e não garantem em tempo de execução.
- Decoradores, geradores e async em Python: Decoradores construídos com closures, functools.wraps e lru_cache (e a armadilha dos métodos), pipelines preguiçosos de geradores, corrotinas e o laço de eventos, gather contra await sequencial, cancelamento, TaskGroup e nunca bloquear o laço.
- Erros, recursos e testes em Python: A hierarquia de exceções e try/else/finally, encadeamento com from, EAFP contra LBYL (medido), gerenciadores de contexto e ExitStack, e unittest com mocks: substituir onde o nome é usado, spec, independência dos testes, testes instáveis e o que a cobertura significa.
- Empacotamento, ambientes e imports em Python: Como um import encontra e executa um módulo, sys.path e ofuscação, imports relativos e circulares, o que um ambiente virtual realmente é, pyproject.toml e instalações editáveis, especificadores de versão, arquivos de lock e segurança de dependências.
- Python para dados e web: contêineres, pandas, WSGI e ASGI: Qual contêiner embutido serve ao trabalho e o que ele custa, como o pandas consegue sua velocidade e onde surpreende, e como uma requisição web chega ao seu código por WSGI ou ASGI. Com resultados medidos: buscas em dict, deque contra lista, registros contra colunas, pandas vetorizado contra em laço, e 20 requisições concorrentes em servidores síncronos, com threads e assíncronos.
- React avançado: re-renderizações, memoização, refs, busca de dados e o que o React 19 mudou: Como o React renderiza e re-renderiza, uma escada de triagem que vai de medir, passando por estrutura, cache e o React Compiler, até transições e virtualização, identidade e chaves, Context contra contextos divididos e stores, closures obsoletas, refs, layout e portais, busca de dados (cascatas e respostas fora de ordem explicadas por aritmética que você pode conferir, e como medir o seu app) e tratamento de erros, com o que o React 19.3 mudou.
- Idempotência e efeitos exatamente uma vez: chaves, novas tentativas e deduplicação: Por que um timeout torna as novas tentativas, e portanto as duplicatas, inevitáveis; projetos naturalmente idempotentes; chaves de idempotência e a condição de corrida do conferir-e-agir (465 cobranças extras contra nenhuma); chamadas externas e pontos de recuperação; o outbox e o inbox; e quanto custa guardar as chaves.
- Estimativa de capacidade: carga, armazenamento, largura de banda e memória no guardanapo: As constantes que valem ser memorizadas, o que uma máquina pequena realmente faz (medido), um método de sete passos com a lei de Little, exemplos resolvidos de um encurtador de URLs, compartilhamento de fotos e chat, quanto tempo os dados levam para se mover e os erros que deixam as estimativas erradas por dez.
- Escolhendo um banco de dados: padrões de acesso, trade-offs e custos medidos: Como escolher um banco de dados a partir das perguntas que você fará a ele: as principais famílias (relacional, documentos, chave-valor, colunas largas, grafos, busca, colunar, séries temporais) e seus trade-offs, comparações medidas de documentos contra tabelas, consultas com e sem índice, saltos em grafos, busca de texto completo e layout por linhas contra colunas, um sistema de registro com armazenamentos derivados e uma lista de verificação para discussões de design.
- TCP na prática: conexões, latência, timeouts e o que quebra em produção: O que o TCP promete e o que não promete, quanto custa uma conexão (handshakes, TLS, partida lenta, janelas), a pausa de 40 ms do algoritmo de Nagle com ACKs atrasados, TIME_WAIT e esgotamento de portas, o backlog de accept, conexões semiabertas, keepalive e timeouts, com medições de experimentos em loopback e uma tabela de sintomas para diagnosticar problemas em produção.
- Runtime do Go na prática: goroutines, canais, escalonador, memória e coleta de lixo: Como o runtime do Go se comporta e quanto custa, com medições: memória e custo de início das goroutines, o escalonador G, M e P e a preempção, canais contra mutexes e atômicos, corridas de dados e o modelo de memória, vazamentos de goroutines e cancelamento com context usando um pool de workers, análise de escape e custos de alocação, GOGC e GOMEMLIMIT, e os comportamentos da linguagem que surpreendem.
- Métricas perceptuais aprendidas: LPIPS, perdas perceptuais, transferência de estilo e DeepDream: Por que o PSNR e o SSIM enganam (com números reproduzíveis) e como as características profundas resolvem isso: a distância LPIPS e os julgamentos humanos do BAPPS por trás dela, como usar o LPIPS e a pyiqa e escolher entre métricas, perdas de características (perceptuais), transferência neural de estilo e a matriz de Gram como alinhamento de distribuições, o DeepDream como subida de gradiente sobre a imagem, o compromisso entre percepção e distorção e as armadilhas das métricas aprendidas.
- Qual filtro de imagem devo usar? Um guia de decisão: Parta do que está errado na imagem (ruído, manchas impulsivas, falta de nitidez, luz irregular) e escolha o filtro: caixa, gaussiano, mediana, máscara de nitidez, laplaciano ou gradiente. Como dimensionar o kernel, por que os tamanhos escalam com a resolução, o que a separabilidade economiza, como tratar a borda e os erros comuns.
- Processamento pontual versus de vizinhança: o que cada um pode e não pode fazer: As duas famílias de operações de imagem lado a lado: tabelas de consulta nas operações pontuais, janelas deslizantes nas de vizinhança. O que cada uma pode e não pode fazer, por que uma curva de tons não linear e um filtro não comutam, as operações que vivem nos dois mundos e a ordem padrão de um pipeline: ruído, tom, nitidez.
- Filtragem no espaço e na frequência: uma operação, duas visões: A convolução como multiplicação de espectros e o impulso como constante. A soma de um kernel é seu ganho na frequência zero, kernels passa-alta, rejeita-faixa e passa-faixa construídos de um passa-baixa, por que um gaussiano largo tem espectro estreito, aliasing e filtragem antes de reduzir, e quando calcular no domínio da frequência.
- Receitas de melhoria de imagem: sombreamento, contraste, nitidez e ruído: Cinco receitas com sintoma, etapas, parâmetros e modos de falha: iluminação irregular (dividir por uma estimativa gaussiana), imagens escuras ou de baixo contraste, fotos macias (máscara de nitidez e seus halos), imagens médicas ruidosas (laplaciano mascarado por gradiente suavizado) e manchas em digitalizações (mediana). Dois exemplos de código executáveis.
- Slices, arrays e mapas em Go: cabeçalhos, crescimento, aliasing e retenção de memória: Como os slices realmente funcionam e por que surpreendem: o cabeçalho de três palavras, tamanho e capacidade, como o append cresce (com capacidades medidas), aliasing por arrays compartilhados e argumentos de função, pré-alocação (12 alocações contra 1), retenção de memória por sub-slices e ponteiros removidos, e as regras de mapas e range.
- Context em Go: cancelamento, prazos, valores e causas: Como usar o pacote context corretamente: os quatro métodos, a árvore de contextos derivados, todos os construtores, incluindo WithCancelCause, WithoutCancel e AfterFunc, por que chamar cancel, como respeitar o cancelamento em laços e chamadas bloqueantes, Canceled contra DeadlineExceeded, valores de requisição, servidores HTTP, orçamentos de retentativa e os erros comuns.
- Git: desfazendo erros com reflog, reset, revert, rebase e recuperação: Um guia prático para sair de apuros no Git: as três áreas (árvore de trabalho, índice, repositório), o que cada modo do reset toca, o reflog como ferramenta de recuperação e seus limites, reset contra revert, amend e fixup com autosquash, rebase interativo, cherry-pick, conflitos de merge (zdiff3, rerere), stash, force-with-lease e como descobrir o que mudou.
- Submódulos, subtrees, worktrees, clones parciais e sparse, e LFS no Git: O que cada ferramenta do Git para compartilhar código e lidar com repositórios grandes realmente faz, com saídas reais de comandos: submódulos (gitlinks, .gitmodules, HEAD destacado, update, ordem do push, remoção, armadilhas), subtrees, worktrees, clones rasos e parciais, sparse checkout, Git LFS e um fluxograma de decisão que inclui a opção do gerenciador de pacotes.
- Protocolos: HTTP, SOAP, REST, gRPC, GraphQL, WebSockets e mensageria: Os protocolos que uma pessoa que trabalha de verdade encontra, comparados com as mesmas seis perguntas: HTTP e REST, SOAP e a família WS-*, JSON-RPC e gRPC com protobuf na rede, GraphQL, WebSockets, server-sent events e long polling, webhooks, AMQP, MQTT e STOMP, e SMTP, FTP, SFTP e SSH, com bytes de verdade, uma tabela de vocabulário de erros entre protocolos, portas, versionamento, rastreamento e um fluxo de decisão.
- Como funciona um planejador de consultas: planos, estimativas e por que erram: Ler um plano de execucao e consertar um plano ruim: os caminhos de acesso e os tres algoritmos de juncao entre os quais um planejador escolhe, de onde vem os numeros de custo, como as contagens de linhas sao estimadas e por que a suposicao de independencia e as expressoes escondidas as arruinam, a ordem das juncoes, o que o executor faz com um plano e uma escada de diagnostico - com cada plano e tempo produzidos por uma instancia PostgreSQL 16.
- The JavaScript event loop: tasks, microtasks and why order surprises people: One thread, a call stack, a task queue and a microtask queue: how setTimeout, promises, async/await and queueMicrotask are ordered, why a long synchronous loop freezes a page, and how to yield without breaking things - with every output in this guide produced by running it in Node.
- Closures and `this` in JavaScript: scope, binding rules and the classic traps: How lexical scope and closures keep variables alive, the loop-with-var trap, and the four rules that decide what `this` is (new, explicit, method call, default), why arrow functions ignore them, and how to lose and recover `this` - with every output produced by running the code in Node.
- Prototypes and classes in JavaScript: how objects inherit and what `class` really is: The prototype chain and property lookup, how new, Object.create and class relate, what class fields, private # members and super do, why mutating shared prototype data bites, and when composition beats inheritance - with every output produced by running the code in Node.
- JavaScript modules: ES modules, CommonJS and what bundlers actually do: The difference between import/export (ES modules) and require/module.exports (CommonJS): live bindings against copied values, static against dynamic loading, how Node decides which one a file is, top-level await, dynamic import(), tree shaking, circular imports and what a bundler adds - with outputs produced by running the code in Node 22.
- async/await in C#: what the compiler does, deadlocks and the rules that keep it safe: How an async method becomes a state machine, what Task and ValueTask are, why .Result and .Wait() can deadlock, when ConfigureAwait matters, how to run work concurrently with Task.WhenAll, cancellation with CancellationToken, and the async void trap - with the rules stated plainly and the cases that depend on the runtime flagged.
- LINQ in C#: deferred execution, multiple enumeration and IQueryable: Why a LINQ query runs when you enumerate it and not where you write it, how that causes repeated work and surprising results, the difference between IEnumerable (runs in memory) and IQueryable (translated to SQL), which operators buffer or stream, and the habits that avoid the usual bugs.
- Dependency injection in .NET: lifetimes, captive dependencies and scopes: What the built-in container does, the three lifetimes (transient, scoped, singleton) and when each is right, the captive-dependency bug where a long-lived service holds a short-lived one, how scopes map to requests, injecting factories and IOptions, and how to test with it.
- Entity Framework Core in practice: change tracking, N+1 queries and loading related data: How a DbContext tracks entities and turns changes into SQL on SaveChanges, when to use AsNoTracking, the N+1 problem and the four ways to load related data (Include, split queries, projection, explicit loading), concurrency tokens, migrations and the habits that keep queries predictable.
- Modern C# data modelling: records, immutability and nullable reference types: What a record gives you (value equality, with-expressions, deconstruction), record class against record struct against class, init-only and required members, what nullable reference types really check and what they do not, and how pattern matching ties them together.
- Authentication and sessions: passwords, cookies, tokens and OAuth without the folklore: How to store passwords, what a session is and how session cookies are protected, when a signed token (JWT) is a good idea and when it is not, how OAuth 2.0 and OpenID Connect divide the work between authorization and login, multi-factor authentication and passkeys, and the mistakes that show up in most breach reports.
- Web application attacks and their defences: injection, XSS, CSRF, SSRF and broken access control: How the five most common web vulnerability classes work, with the one defence for each that actually fixes the cause (parameterized queries, contextual output encoding, SameSite and tokens, outbound allowlists, server-side authorization checks), plus the defence-in-depth layers (CSP, headers, least privilege) and a short review checklist.
- Design a notification system: push, email and SMS at scale: A case study in fan-out and reliability: requirements and back-of-envelope numbers, an architecture with a request API, per-channel queues and workers, templates and user preferences, how to get at-least-once delivery without sending twice, retries with backoff, rate limits and priority, and what to measure.
- Design search autocomplete (typeahead): tries, top-k and latency: A case study in serving suggestions within 100 ms: requirements and numbers, a trie with cached top-k results at each node, how the data pipeline builds it from query logs, caching and sharding, handling freshness and trending queries, and the client-side details (debounce, prefix cache) that matter as much as the server.
- Design a file storage and sync service (Dropbox-style): A case study in large files and many devices: splitting files into content-addressed blocks, a metadata service separate from block storage, delta sync and deduplication, change notification to other devices, conflict handling, sharing, and the numbers that show why the block store, not the database, is the big cost.
- Design a payment system: idempotency, ledgers and reconciliation: A case study in correctness over speed: the payment flow with a payment service provider, idempotency keys, a double-entry ledger, state machines for a payment, handling timeouts and unknown outcomes, webhooks, reconciliation against the provider's reports, and why you never store card numbers yourself.
- Design a metrics and monitoring system: time series at scale: A case study in write-heavy time-series data: what is collected and how (push or pull), ingestion through a queue, a time-series store with compression, downsampling and retention, an alert evaluator that avoids flapping, cardinality as the main cost driver, and dashboards that query the store efficiently.
- Design a ticket booking system: seats, holds and contention: A case study in correctness under contention: modelling events, seats and orders, why double-selling is the central risk, temporary holds with expiry, database locking and constraints that make a double sale impossible, handling the flash-crowd moment with a waiting room, payments that fail, and what can be cached safely.