~/studies/work 2026-11-21

Notas de leitura: Elixir/OTP e workflows duráveis

Notas sobre material público, não sobre meus benchmarks: processos, supervisores e let it crash segundo a documentação do Erlang e do Elixir e a tese de Armstrong, e depois meu próprio mapeamento das mensagens do GenServer para ideias de workflows duráveis, marcado como hipótese.

O que é isto

Notas de leitura sobre documentação pública, consultada em 2026-11-21. Não escrevi nem rodei nenhum Elixir para isto. As fontes:

A segunda metade é meu próprio mapeamento para workflows duráveis, como o que o nagare oferece. Essa parte é analogia, e aviso onde ela começa.

Workers, supervisores e regras de reinício

A página de design principles chama a árvore de supervisão de um modelo de estruturação de processos baseado em workers e supervisores. Os workers fazem o trabalho de fato. Os supervisores monitoram os workers, e um supervisor pode reiniciar um worker se algo der errado.

A página de princípios do supervisor define as estratégias de reinício:

EstratégiaQuando um filho termina
one_for_oneSó esse filho é reiniciado.
one_for_allTodos os filhos restantes são terminados, e depois todos, incluindo o que morreu, são reiniciados.
rest_for_oneOs filhos iniciados depois do que morreu são terminados; o que morreu e esses são reiniciados.
simple_one_for_oneUm one_for_one em que todos os filhos são instâncias do mesmo processo adicionadas dinamicamente.

A intensidade de reinício limita isso: se ocorrerem mais de MaxR reinícios nos últimos MaxT segundos, o supervisor termina todos os seus filhos e depois a si mesmo, com razão shutdown. Os padrões dessa página são intensidade 1 e período 5. A página diz que o mecanismo busca impedir que um processo morra repetidamente pela mesma razão. Os tipos de reinício de um filho são permanent (sempre reiniciado, o padrão), transient (reiniciado só em saída anormal) e temporary (nunca reiniciado).

Let it crash, nas palavras de Armstrong

A seção 4.3 da tese lista os lemas: deixe outro processo fazer a recuperação de erros, se você não consegue fazer o que quer, morra, let it crash, não programe defensivamente. O raciocínio parte do hardware. Para sobreviver à falha de um computador inteiro você precisa de um segundo, então o sistema deve tratar um erro em outro lugar que não onde ele ocorreu. Armstrong faz uma falha de hardware parecer uma de software, uma mensagem de saída do runtime, para haver um único mecanismo uniforme.

A seção 4.4 traça a linha entre exceções e erros. Exceções ocorrem quando o runtime não sabe o que fazer. Erros ocorrem quando o programador não sabe o que fazer. Se o programador previu a condição, como abrir um arquivo que pode não existir, não é um erro e o código a trata. O lema vale para o segundo caso: quando a especificação é silente, não invente comportamento, dê crash e deixe o supervisor decidir.

Nota: a página de getting-started do Elixir que consultei não usa a frase let it crash, e só diz que um supervisor controla se e como os processos devem ser reiniciados. A fonte da frase aqui é a tese.

GenServer: o que é uma mensagem

Um GenServer é descrito como um módulo de comportamento para implementar o servidor de uma relação cliente-servidor: um processo que guarda estado e executa código. Mensagens call esperam resposta e são síncronas, tratadas por handle_call/3. Mensagens cast não, tratadas por handle_cast/2. Todo o resto, incluindo mensagens de send/2, Process.send_after/4 e timeouts, vai para handle_info/2. init/1 constrói o estado inicial e é o único callback obrigatório. Um valor de timeout, padrão infinity, detecta uma pausa nas mensagens e chega como :timeout.

Mais comumente ele é iniciado sob um supervisor. use GenServer gera um child_spec, com :restart padrão em :permanent, e a razão de saída decide se o supervisor o reinicia.

Meu mapeamento para workflows duráveis (hipótese)

Daqui em diante, nada vem das fontes. É como leio os dois modelos lado a lado.

Ideia do OTPContrapartida em workflows duráveis
init/1 constrói o estado a partir de um argumentoIniciar uma execução a partir da sua entrada
handle_call, resposta esperadaUma consulta síncrona ou uma atualização que devolve um resultado
handle_cast, dispara e esqueceUm sinal adicionado à caixa de entrada da execução
handle_info, timers e timeoutsUm timer durável disparando, ou um evento externo
O supervisor reinicia o processoUm worker retomando a execução a partir do seu journal
MaxR em MaxT segundosUm orçamento de tentativas antes de uma execução ser estacionada como falha

A diferença que importa: depois de um reinício do OTP, init/1 roda de novo e o estado antigo em memória se perde, a menos que você mesmo o tenha persistido. Um motor durável faz a escolha oposta. O estado é reconstruído reproduzindo um registro do que já aconteceu, então um reinício continua em vez de recomeçar. A supervisão responde quem reinicia. A durabilidade responde o que ele lembra.

Uma segunda hipótese: let it crash exige que o código sob o supervisor seja seguro para rodar duas vezes. Em um motor durável isso significa que os passos com efeitos colaterais precisam de chaves de idempotência, e por isso um journal e um outbox aparecem juntos. Não construí um sistema OTP para testar essa analogia, então trate-a como uma forma de fazer perguntas ao nagare, não como um resultado.