~/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.
- elixir
- otp
- supervision
- durable-execution
- reading-notes
- ~/project/versatile-sh
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:
- GenServer docs: https://elixir.hexdocs.pm/GenServer.html
- OTP design principles: https://www.erlang.org/doc/system/design_principles.html
- Supervisor behaviour principles: https://www.erlang.org/doc/system/sup_princ.html
- Joe Armstrong, Making reliable distributed systems in the presence of software errors (2003): https://erlang.org/download/armstrong_thesis_2003.pdf
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égia | Quando um filho termina |
|---|---|
| one_for_one | Só esse filho é reiniciado. |
| one_for_all | Todos os filhos restantes são terminados, e depois todos, incluindo o que morreu, são reiniciados. |
| rest_for_one | Os filhos iniciados depois do que morreu são terminados; o que morreu e esses são reiniciados. |
| simple_one_for_one | Um 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 OTP | Contrapartida em workflows duráveis |
|---|---|
| init/1 constrói o estado a partir de um argumento | Iniciar uma execução a partir da sua entrada |
| handle_call, resposta esperada | Uma consulta síncrona ou uma atualização que devolve um resultado |
| handle_cast, dispara e esquece | Um sinal adicionado à caixa de entrada da execução |
| handle_info, timers e timeouts | Um timer durável disparando, ou um evento externo |
| O supervisor reinicia o processo | Um worker retomando a execução a partir do seu journal |
| MaxR em MaxT segundos | Um 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.