Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Aritmética de Datas do Juízo Final Sem Bibliotecas

Uma manchete de juízo final de 1960 esconde uma lição prática: aritmética de datas é fácil de demonstrar e difícil de acertar sem bibliotecas.

Estúdio de meados do século com quadro-negro com curvas, grades de calendário e uma calculadora mecânica
A curva do juízo final importa menos do que a maquinaria de calendário necessária para nomear o dia da semana.

Uma manchete antiga e estranha voltou a circular: um item de 1960 da Science apontava para sexta-feira, 13 de novembro de 2026, e chamava a data de juízo final. A profecia não é a parte interessante para quem programa no dia a dia. O interessante é que a data realmente cai numa sexta-feira, e chegar a essa resposta obriga você a encarar aritmética de datas: regras de anos bissextos, tamanhos de meses, exceções de século, anos negativos e a diferença discreta entre uma fórmula que impressiona as pessoas e um código que sobrevive em produção.

O artigo por trás da manchete veio de Heinz von Foerster e colegas, e tem cara de provocação. Eles observaram o crescimento da população humana, argumentaram que ele era pior que exponencial, ajustaram uma curva hiperbólica e deixaram o denominador tender a zero. O resultado foi uma singularidade com data de manchete sensacionalista. Historiadores e demógrafos podem discutir o quão sério aquilo era; soa metade como alerta e metade como piada contada por alguém que sabia exatamente o quanto uma sexta-feira 13 soaria dramática.

O que não paro de pensar é no capricho escondido por baixo. Antes de zombar da previsão, verifique o dia da semana. Antes de verificar o dia da semana, decida qual calendário você quer. Gregoriano prolético? Datas civis reais de um país específico? Numeração astronômica de anos ou a convenção sem ano zero que historiadores usam? A maioria de nós recorre a datetime, java.time ou chrono e segue em frente. Normalmente é a decisão certa. Mas fazer isso sem bibliotecas continua sendo um dos melhores pequenos exercícios de correção da programação, justamente porque as regras são finitas, antigas e cheias de armadilhas.

Uma manchete de juízo final é um problema de calendário

Comece pela afirmação em si: 13 de novembro de 2026 é uma sexta-feira. Você confere isso em um REPL em segundos. O objetivo de fazer à mão não é velocidade. É expor o modelo. Um calendário é uma máquina de estados com transições irregulares: a maioria dos meses avança trinta ou trinta e um dias, fevereiro muda de tamanho em anos bissextos, anos de século se recusam a ser bissextos a menos que sejam divisíveis por quatrocentos, e todo o padrão se repete em ciclos de quatrocentos anos no sistema gregoriano. Depois que você enxerga esse ciclo, o cálculo do dia da semana deixa de ser numerologia e vira aritmética modular sobre um ciclo cuidadosamente projetado.

O método do juízo final de Conway oferece um algoritmo mental memorável. Em cada século há um dia da semana âncora; para os anos 2000 é terça-feira. Para um ano como 2026, pegue os dois últimos dígitos, vinte e seis. Divida por doze para obter duas dúzias de anos, resto dois, e some os anos bissextos dentro desse resto, zero. Dois mais dois mais zero dá quatro; terça-feira mais quatro cai em sábado. Esse é o “juízo final” do ano, o dia da semana compartilhado por marcos fáceis como 4/4, 6/6, 8/8, 10/10, 12/12, o último dia de fevereiro e 7 de novembro. Se 7 de novembro de 2026 é sábado, 13 de novembro são seis dias depois: sexta-feira. Teatral o bastante para uma manchete, mecânico o bastante para um guardanapo.

O método mental é elegante porque comprime o calendário em alguns marcos. Mas compressão também é onde bugs se reproduzem. O algoritmo do juízo final assume a regra gregoriana de anos bissextos, assume as âncoras de século mais comuns, assume que você não está atravessando uma reforma de calendário e assume que você não tratou janeiro e fevereiro silenciosamente como meses comuns. É uma ferramenta local linda. Não é uma biblioteca de datas.

Por que o cálculo do dia da semana quebra em código real

Bugs de calendário raramente anunciam sua chegada com estardalhaço. Eles aparecem como um e-mail de renovação enviado um dia antes depois de um dia bissexto, um período de fatura que exclui o último dia todo fevereiro, um job semanal que vai derivando depois de uma virada de século que ninguém espera ver, ou um conjunto de dados de historiadores em que o ano zero significa uma coisa na ISO 8601 e outra num catálogo de museu. A distância entre especificação e implementação é exatamente onde esses defeitos vivem, porque todo mundo acha que a regra é óbvia até que duas regras óbvias colidam.

O caso de fronteira clássico é o ano 2000: divisível por cem, mas ainda bissexto por ser divisível por quatrocentos. O ano 1900 não foi. O ano 2100 não será. Muitas verificações de bissexto feitas à mão lembram de year % 4 == 0 e param aí, o que está certo para quase todos os anos com que uma startup se preocupa e errado num horizonte suficientemente longo. Sistemas financeiros, arquivos e infraestrutura agora vivem tempo suficiente para que horizontes longos não sejam mais teóricos.

  • Compressão da regra de bissexto: y % 4 em vez da regra gregoriana completa.
  • Armadilhas na numeração dos meses: janeiro humano é um, muitas APIs usam zero, Zeller quer março primeiro.
  • Semântica de anos negativos: ano zero astronômico versus 1 a.C. seguido de 1 d.C. histórico.
  • Indexação de semanas: começando no domingo, na segunda ou no sábado, em fórmulas diferentes.
  • Reforma de calendário: adotar regras gregorianas antes de uma região historicamente tê-las adotado.
  • Divisão inteira: C trunca em direção ao zero, enquanto cálculos de calendário costumam querer divisão por piso.

Repare em quantos desses são erros de representação e não erros aritméticos. Essa é a lição profunda para o design de linguagens e bibliotecas. Uma data não é um inteiro com uma embalagem melhor. É um valor em um sistema calendário, com regras de validade, uma época de referência, uma convenção para anos anteriores a essa época e um mapeamento para dias da semana que depende de tudo isso. APIs boas tornam estados inválidos desconfortáveis de construir. APIs ruins entregam três inteiros e desejam boa sorte.

Zeller, juízo final e a forma de uma fórmula

A congruência de Zeller é a prima mais antiga e rabugenta do truque de Conway. Para o calendário gregoriano, ela costuma ser escrita com março como mês 14, abril como 15, e janeiro e fevereiro tratados como meses 13 e 14 do ano anterior. Com dia q, mês m, ano do século K e século baseado em zero J, uma forma comum é h = (q + floor(13(m+1)/5) + K + floor(K/4) + floor(J/4) + 5J) mod 7, em que h = 0 significa sábado. Funciona. Também é um campo minado de convenções.

Existem várias variantes publicadas, algumas com pontos zero diferentes para os dias da semana, algumas para calendários julianos, algumas com termos somados em vez de subtraídos. Copie uma de um fórum e você pode acabar com uma fórmula certa para 1901-2099 e errada nas bordas, ou certa apenas se sua linguagem arredondar a divisão inteira para baixo do jeito que o autor supôs. Por isso não gosto de apresentar Zeller como código de produção. Ele é maravilhoso para entender a estrutura: um termo linear de dias, uma correção de mês que aproxima tamanhos irregulares, um termo de ano, correções de bissexto e uma correção de século. É bem menos maravilhoso quando um mantenedor precisa fazer engenharia reversa para descobrir qual convenção você usou.

O método de Conway otimiza para a memória humana. Zeller otimiza para a elegância algébrica. Código de produção deve otimizar para auditabilidade. São objetivos diferentes. No sentido de design de linguagens, é a diferença entre uma macro esperta e uma função chata com invariantes nos nomes. Precisamos de mais funções chatas com invariantes nos nomes.

Engrenagens de calendário entrelaçadas com uma engrenagem de fevereiro que muda dentro de anéis de século
Um calendário é uma máquina: regular o bastante para modelar, irregular o bastante para punir atalhos.

Um núcleo gregoriano pequeno que você pode auditar

Se preciso de lógica de dia da semana em código restrito, minha base favorita é a construção days-from-civil de Howard Hinnant. Ela converte uma data gregoriana em uma contagem serial de dias em relação a 1970-01-01; o dia da semana vem então da aritmética modular a partir de uma quinta-feira conhecida. A implementação é curta, mas cada constante tem um motivo. Ela evita tabelas de meses cheias de ramificações ao deslocar o ano para que março seja o primeiro mês; assim, o dia bissexto fica no fim do ano deslocado, onde não perturba nada que vem antes.

typedef long long i64;
/* Gregorian proleptic calendar; March is treated as the first month. */
static i64 days_from_civil(i64 y, int m, int d) {
y -= m <= 2;
i64 era = (y >= 0 ? y : y - 399) / 400;      /* floor-ish 400-year era */
int yoe = (int)(y - era * 400);              /* year of era, 0..399 */
int mp = m + (m > 2 ? -3 : 9);               /* Mar=0 ... Feb=11 */
int doy = (153 * mp + 2) / 5 + d - 1;        /* day of shifted year */
int doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
return era * 146097 + doe - 719468;          /* 1970-01-01 == 0 */
}
/* Returns 0=Sunday, 1=Monday, ... 6=Saturday. */
static int weekday_gregorian(i64 y, int m, int d) {
i64 z = days_from_civil(y, m, d);
int r = (int)((z + 4) % 7);                  /* 1970-01-01 was Thursday */
if (r < 0) r += 7;
return r;
}

O número mágico 153 merece respeito. Ao longo dos meses deslocados de março a fevereiro, os tamanhos alternam num padrão próximo de trinta e trinta e um dias, e (153 * mp + 2) / 5 codifica os dias acumulados antes de cada mês sem tabela de consulta. A expressão 146097 é o número de dias de um ciclo gregoriano de quatrocentos anos: 146.000 dias dos quatro séculos, mais noventa e sete dias bissextos. Subtrair 719468 recentraliza a contagem na época Unix. Nada disso é místico; é a especificação do calendário destilada em aritmética.

É aqui que as escolhas de tipo importam. Use inteiros largos com sinal para dias seriais. Seja explícito sobre gregoriano prolético se for isso que você implementa. Decida se dias fora do intervalo, como 31 de abril, são rejeitados ou normalizados; eu prefiro rejeitar datas civis porque a normalização silenciosa esconde bugs upstream. Se você aceita entradas a.C., diga qual numeração usa antes da primeira subtração. Isso soa como preocupação de biblioteca, mas a mesma disciplina vale dentro de um blob de firmware ou de uma stored procedure, onde ninguém quer admitir que datas são complicadas.

Fusos horários não são aritmética de calendário

Um dia da semana só é estável depois que você fixa a escala de tempo e a localização. Uma reunião às 00:30 em Tóquio ainda é o dia civil anterior em San Francisco. Se seu sistema armazena instantes, converta por meio de um banco de dados de fusos horários antes de perguntar o dia da semana. Se seu sistema armazena datas civis, não as converta casualmente em instantes sem anexar um fuso. O modo de falha é sutil: dois serviços podem concordar sobre o timestamp e discordar sobre o dia.

Por isso eu separo três ideias nas revisões de código. Um instante é um ponto em uma linha do tempo física. Uma data civil é um rótulo legal ou social como 2026-11-13. Um horário local é o par formado por um rótulo civil, um fuso e seu histórico de deslocamentos. Perguntas sobre dia da semana pertencem principalmente a datas civis. Perguntas de agendamento pertencem a instantes mais fusos. Quando o código mistura essas coisas, cada fórmula limpa fica assombrada. Engenharia defensiva aqui significa não deixar um timestamp fingir que conhece o calendário do usuário.

Segundos intercalares são outra camada que as pessoas adoram puxar para debates sobre dia da semana. Ignore-os para o cálculo civil. Dias da semana seguem dias do calendário, não o tempo atômico suavizado. Se você suaviza segundos intercalares ou usa um relógio monotônico para duração, tudo bem, mas não deixe isso vazar para a pergunta “isto é sexta-feira?”. Sexta-feira é um fato social.

Testes que merecem um lugar no CI

Código de datas ganha confiança com fixtures adversariais, não com achismos. Coloque os casos complicados ao lado da função. Teste 1900-02-28 e 1900-03-01 como dias adjacentes sem dia bissexto entre eles. Teste 2000-02-29 porque ele existe. Teste 2099-12-31 virando 2100, onde uma regra só de quatro anos dá errado. Teste 1970-01-01 como quinta-feira se você usar essa época. Teste anos negativos se disser que os suporta, e teste que você rejeita entradas malformadas antes da aritmética.

Testes de propriedade são úteis se as propriedades forem honestas. Adicionar um dia deve avançar o dia da semana em um, módulo sete, para qualquer data válida. Quatrocentos anos gregorianos devem conter 146.097 dias e voltar ao mesmo dia da semana. Dentro de um século não bissexto, marcos no estilo juízo final devem compartilhar um dia da semana apenas se sua implementação for consistente. Não teste contra uma biblioteca gerada pelo mesmo equívoco que você tenta evitar; fixe respostas esperadas a partir do padrão ou de tabelas derivadas de forma independente.

Uma rotina de datas está correta quando suas convenções são chatas, explícitas e testadas nas fronteiras onde o calendário muda de ideia.

Para a própria data do juízo final, a resposta esperada é simples o bastante para ser fixada num comentário: 2026-11-13 resulta em sexta-feira sob as regras gregorianas proléticas. Depois, teste o caminho ao redor: 2026-11-07 é o sábado do marco do juízo final, 2026-02-28 é sábado, 2027-02-28 é domingo após um ano comum, e 2028-02-29 existe porque 2028 é divisível por quatro e não por cem. Essas pequenas constelações pegam erros de off-by-one melhor do que um milhão de casos aleatórios.

Peças de calendário virando de estado com destaques vermelhos nos casos de fronteira
Bons fixtures miram nas fronteiras: dias bissextos, anos de século, âncoras de época e entradas malformadas.

A velha lição para novos modelos

A curva do juízo final de 1960 fracassou como demografia porque sistemas humanos não são pontos passivos numa reta ajustada. Taxas de natalidade mudaram, políticas mudaram, a agricultura mudou, a urbanização mudou, e a singularidade ficou no futuro, onde as manchetes a mantêm. Esse fracasso também é útil para programadores. Um modelo pode ser internamente consistente, historicamente fundamentado e ainda assim estar errado porque o sistema estudado edita as regras enquanto você mede.

A aritmética de calendário é o luxo oposto. As regras são lentas, públicas e em grande parte estáveis, o que significa que a correção é alcançável se respeitarmos a especificação. Isso torna datas um campo de treino perfeito para um hábito mais amplo: nomeie o modelo, isole o núcleo de fusos horários e IO, torne as convenções explícitas e teste os pontos onde a continuidade se quebra. Esteja você escrevendo C para um RTC embarcado, um planejador de consultas ou uma camada de validação em um runtime de linguagem, o ganho é o mesmo. Clareza entediante vence certeza engenhosa.

Então sim, a sexta-feira 13 está chegando no horário. Nenhum apocalipse necessário. O susto real é como uma equipe pode lançar lógica de dia da semana que quase funciona, construída a partir de congruências meio lembradas e de suposições que ninguém escreveu. Faça a coisa simples com rigor: implemente o ciclo de quatrocentos anos, rejeite datas impossíveis, mantenha instantes separados de rótulos civis e deixe para os futuros mantenedores um rastro de constantes que eles possam verificar. O juízo final faz um teste unitário melhor do que uma previsão.