SO, rede, Git: o que está acontecendo embaixo do código.
Oito ideias que estão por trás de todo sistema real. Sem elas, "concorrência" e "containers" viram receitas de bolo. Com elas, você consegue depurar quando algo der errado.
Espaços de endereçamento, escalonamento, file descriptors, sinais. A unidade fundamental que tudo o que vem depois pressupõe.
Onde os dados vivem, quem os mata, e por que aliasing em Go, GC em C# e contagem de referências em Python produzem comportamentos sutis diferentes.
O que acontece embaixo de um read(). epoll, kqueue, IOCP — o motor que torna possível um servidor lidar com milhões de conexões.
Você não precisa virar especialista em RFC. Mas precisa entender o suficiente para depurar quando latência aparecer, certificado expirar e DNS falhar.
ss, lsof, strace, htop, tcpdump, journald. As ferramentas que distinguem quem investiga de quem chuta.
Container não é "VM leve". É um processo Linux com isolamento controlado. Saber a diferença muda como você desenha imagens, debugga ambientes e racionaliza recursos.
Rebase interativo, bisect, reflog, trunk-based. Commits atômicos com mensagens claras são forma de design — não cosmética.
Como times maduros operam: branches curtos, PRs pequenos, review como prática de design, mensagens de commit que viram changelog automaticamente.
Você não vai escrever código de kernel — mas vai escrever código que roda em um. Quando algo falhar em produção (e vai), os fundamentos dessa camada serão a diferença entre depurar em minutos ou ficar perdida em horas.
As perguntas que separam quem entende a máquina de quem só consome a abstração.
Threads ou async/await — quando usar cada?
Para I/O-bound (banco, rede, arquivos), async/await é quase sempre superior: mesmo número de threads atende mais conexões. Para CPU-bound (cálculos pesados, compressão, criptografia), threads ou processos reais vencem — async não paraleliza CPU. A heurística: se 90% do tempo é esperar I/O, async; se 90% é computação, paralelismo de fato.
Container ou VM — onde está a fronteira?
Containers compartilham o kernel do host; VMs têm kernel próprio. Containers são leves (centenas em uma máquina) e startam em milissegundos; VMs são caras e startam em segundos. Mas: containers não isolam contra exploits de kernel — ambiente multi-tenant inseguro precisa de VMs ou microVMs (Firecracker). Para a maioria dos casos corporativos, containers ganham; para isolamento forte, VMs continuam relevantes.
HTTP/2 ou HTTP/3 em produção?
HTTP/2 está universalmente suportado e cobre a maioria dos ganhos (multiplexing, header compression). HTTP/3, baseado em QUIC sobre UDP, ganha em redes ruins (mobile, alta latência) por eliminar head-of-line blocking. Para APIs internas, HTTP/2 é o padrão sólido. Para clientes móveis ou globais, HTTP/3 vira diferencial. Browsers já fazem fallback, então habilitá-lo no edge é seguro.
Trunk-based ou Git Flow?
Trunk-based vence em times maduros com CI/CD funcional, deploys frequentes e feature flags. Git Flow (com branches develop, release, hotfix) faz sentido em ciclos de release longos, software com versionamento explícito (libs públicas, software embarcado). A maioria dos times de produto modernos opera em trunk-based — branches curtos (horas a dias), merge rápido, deploy contínuo.
Implementar um shell minimalista força você a tocar diretamente em syscalls, processos, file descriptors, sinais — exatamente o que este módulo cobre.
Um shell minimalista que executa comandos, suporta pipelines (ls | grep | wc),
redirecionamento (>, <), execução em background (&),
e trata sinais corretamente (SIGINT, SIGTERM, SIGCHLD).
fork + exec para executar — entender por que separadopipe() + dup2()&) + wait não bloqueanteSIGINT (Ctrl+C cancela comando atual, não o shell)cd, exit, jobsShell funcional nas três linguagens, README documentando syscalls usadas, e um ADR comparando a "distância" de cada linguagem das syscalls do SO. Em Python e Go, a stdlib expõe quase tudo direto. Em .NET, P/Invoke é a ponte — e isso ensina muito sobre quanto a runtime esconde.
Perguntas reais sobre fundamentos de sistema. Quem responde com confiança aqui passa em entrevistas para qualquer posição backend sênior.
O que acontece quando você digita curl https://google.com e aperta Enter? Descreva da resolução DNS até a renderização.
Diferença entre processo e thread? Quando preferir cada um? E o que mudou com o GIL no Python 3.13+?
O que SIGTERM faz, e por que isso importa em containers Kubernetes? O que acontece se o app não reagir a ele?
Como você investiga um app que está "travando" sem retornar resposta? Liste cinco ferramentas Linux que usaria, na ordem.
Diferença entre git merge e git rebase? Quando cada um cabe? E o que faz git bisect?