Des articles approfondis sur les technologies qui façonnent l'avenir.

Arithmétique des dates sans bibliothèque, version doomsday

Une vieille prédiction de 1960 cache une leçon pratique : l'arithmétique des dates est facile à démontrer, difficile à bien faire sans bibliothèque.

Étude du milieu du siècle avec tableaux à craie, grilles de calendrier et une calculatrice mécanique
La courbe apocalyptique compte moins que la mécanique du calendrier nécessaire pour nommer le jour de la semaine.

Un vieux titre étrange refait surface : un article de Science de 1960 désignait le vendredi 13 novembre 2026 comme date de l'apocalypse. La prophétie n'est pas ce qui intéresse les développeurs. Ce qui est intéressant, c'est que la date tombe bien un vendredi, et que trouver cette réponse oblige à faire de l'arithmétique des dates : règles des années bissextiles, longueurs des mois, exceptions des années séculaires, années négatives, et la différence discrète entre une formule qui impressionne et du code qui tient en production.

L'article à l'origine du titre vient de Heinz von Foerster et de ses collègues, et il a des airs de provocation. Ils ont étudié la croissance de la population humaine, affirmé qu'elle était pire qu'exponentielle, ajusté une courbe hyperbolique et laissé le dénominateur tendre vers zéro. Le résultat est une singularité avec une date digne de la presse à sensation. Historiens et démographes peuvent débattre de son sérieux : on y lit à moitié un avertissement, à moitié une blague de quelqu'un qui savait exactement à quel point un vendredi 13 sonne dramatique.

Ce qui me revient sans cesse, c'est le savoir-faire caché en dessous. Avant de moquer la prédiction, il faut vérifier le jour de la semaine. Avant de vérifier le jour, il faut décider de quel calendrier on parle : grégorien proleptique ? Dates civiles réelles d'un pays donné ? Numérotation astronomique des années ou convention sans année zéro qu'utilisent les historiens ? La plupart d'entre nous attrapent datetime, java.time ou chrono et passent à autre chose. C'est généralement le bon choix. Mais refaire le calcul sans bibliothèque reste l'un des meilleurs petits entraînements de justesse en programmation, précisément parce que les règles sont finies, anciennes et pleines de pièges.

Une prédiction apocalyptique est un problème de calendrier

Partons de l'affirmation elle-même : le 13 novembre 2026 est un vendredi. On peut le vérifier en quelques secondes dans un REPL. L'intérêt de le faire à la main n'est pas la vitesse. C'est de mettre à nu le modèle. Un calendrier est une machine à états avec des transitions irrégulières : la plupart des mois avancent de trente ou trente et un jours, février change de forme les années bissextiles, les années séculaires ne sont bissextiles que si elles sont divisibles par quatre cents, et l'ensemble du motif se répète sur un cycle de quatre cents ans dans le système grégorien. Une fois ce cycle visible, le calcul du jour de la semaine cesse d'être de la numérologie pour devenir de l'arithmétique modulaire sur un cycle soigneusement conçu.

L'algorithme « doomsday » de Conway offre une méthode mentale mémorable. Chaque siècle possède un jour d'ancrage ; pour les années 2000, c'est le mardi. Pour une année comme 2026, on prend les deux derniers chiffres, vingt-six. On divise par douze pour obtenir deux douzaines d'années, avec un reste de deux, puis on ajoute les années bissextiles contenues dans ce reste, soit zéro. Deux plus deux plus zéro font quatre ; mardi plus quatre tombe sur samedi. C'est le « doomsday » de l'année, le jour de la semaine partagé par des repères faciles comme 4/4, 6/6, 8/8, 10/10, 12/12, le dernier jour de février et le 7 novembre. Si le 7 novembre 2026 est un samedi, le 13 novembre est six jours plus tard : un vendredi. Assez théâtral pour un titre, assez mécanique pour un coin de nappe.

La méthode mentale est élégante parce qu'elle condense le calendrier en quelques repères. Mais cette compression est aussi là où les bugs prospèrent. L'algorithme doomsday suppose la règle grégorienne des années bissextiles, suppose les ancrages de siècle habituels, suppose qu'on ne traverse pas une réforme du calendrier, et suppose qu'on n'a pas discrètement traité janvier et février comme des mois ordinaires. C'est un outil local magnifique. Ce n'est pas une bibliothèque de dates.

Pourquoi le calcul du jour de la semaine casse dans le vrai code

Les bugs de calendrier ne se signalent presque jamais bruyamment. Ils apparaissent sous la forme d'un e-mail de renouvellement envoyé un jour trop tôt après un 29 février, d'une période de facturation qui exclut la date de fin chaque février, d'une tâche hebdomadaire qui dérive après un passage de siècle que personne n'attendait, ou d'un jeu de données d'historien où l'année zéro signifie une chose dans l'ISO 8601 et une autre dans un catalogue de musée. Le fossé entre spécification et implémentation est exactement là où vivent ces défauts, parce que chacun croit la règle évidente jusqu'à ce que deux règles évidentes entrent en collision.

Le cas limite classique est l'année 2000 : divisible par cent, mais toujours bissextile parce que divisible par quatre cents. L'année 1900 ne l'était pas. L'année 2100 ne le sera pas. Beaucoup de vérifications d'année bissextile faites maison se contentent de year % 4 == 0, ce qui est juste pour presque toutes les années qui intéressent une startup, et faux sur un horizon suffisamment long. Les systèmes financiers, les archives et les infrastructures vivent aujourd'hui assez longtemps pour que ces longs horizons ne soient plus théoriques.

  • Compression de la règle bissextile : y % 4 au lieu de la règle grégorienne complète.
  • Pièges de numérotation des mois : janvier vaut un pour les humains, zéro dans beaucoup d'API, et Zeller veut mars en premier.
  • Sémantique des années négatives : année zéro astronomique contre 1 av. J.-C. suivie de 1 ap. J.-C.
  • Indexation des semaines : commençant le dimanche, le lundi ou le samedi selon les formules.
  • Réforme du calendrier : adoption des règles grégoriennes avant la date d'adoption historique d'une région.
  • Division entière : le C tronque vers zéro, alors que les calculs de calendrier veulent souvent une division par défaut (floor).

Remarquez combien de ces erreurs sont des erreurs de représentation plutôt que des erreurs d'arithmétique. C'est la leçon profonde pour la conception des langages et des bibliothèques. Une date n'est pas un entier avec une meilleure image de marque. C'est une valeur dans un système calendaire, avec des règles de validité, une époque, une convention pour les années antérieures à cette époque, et une correspondance avec les jours de la semaine qui dépend de tout cela. De bonnes API rendent les états invalides difficiles à écrire. Les mauvaises vous donnent trois entiers et vous souhaitent bonne chance.

Zeller, doomsday et la forme d'une formule

La congruence de Zeller est la cousine plus ancienne et plus grincheuse de l'astuce de Conway. Pour le calendrier grégorien, on la écrit souvent avec mars comme mois 14, avril comme mois 15, et janvier et février traités comme les mois 13 et 14 de l'année précédente. Avec le jour q, le mois m, l'année du siècle K et le siècle J compté à partir de zéro, une forme courante est h = (q + floor(13(m+1)/5) + K + floor(K/4) + floor(J/4) + 5J) mod 7, où h = 0 signifie samedi. Ça marche. C'est aussi un champ de mines de conventions.

Il existe plusieurs variantes publiées, certaines avec des points zéro de jour de semaine différents, certaines pour le calendrier julien, certaines avec des termes ajoutés au lieu d'être soustraits. Copiez-en une depuis un forum et vous obtiendrez une formule juste pour 1901-2099 et fausse aux bords, ou juste uniquement si votre langage arrondit la division entière comme l'auteur le supposait. C'est pourquoi je n'aime pas présenter Zeller comme du code de production. C'est merveilleux pour comprendre la structure : un terme linéaire pour le jour, une correction de mois qui approxime les longueurs irrégulières, un terme pour l'année, des corrections bissextiles et une correction de siècle. C'est nettement moins merveilleux quand un mainteneur doit rétro-ingénierer la convention que vous avez utilisée.

La méthode de Conway optimise la mémoire humaine. Zeller optimise l'élégance algébrique. Le code de production doit optimiser l'auditabilité. Ce sont des objectifs différents. Au sens de la conception de langages, c'est la différence entre une macro astucieuse et une fonction ennuyeuse dont les invariants figurent dans les noms. Il nous faut davantage de fonctions ennuyeuses avec des invariants dans leurs noms.

Engrenages de calendrier imbriqués avec un engrenage de février changeant à l'intérieur d'anneaux de siècle
Un calendrier est une machine : assez régulier pour être modélisé, assez irrégulier pour punir les raccourcis.

Un noyau grégorien court que vous pouvez auditer

Si j'ai besoin de logique de jour de la semaine dans du code contraint, ma base préférée est la construction days-from-civil de Howard Hinnant. Elle convertit une date grégorienne en un nombre de jours sériel relatif au 1er janvier 1970, puis le jour de la semaine devient de l'arithmétique modulaire à partir d'un jeudi connu. L'implémentation est courte, mais chaque constante a une raison d'être. Elle évite les tables de mois ramifiées en décalant l'année pour que mars devienne le premier mois : le 29 février se retrouve alors à la fin de l'année décalée, où il ne perturbe rien de ce qui le précède.

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;
}

Le nombre magique 153 mérite le respect. Sur les mois décalés de mars à février, les longueurs alternent selon un motif proche de trente et trente et un jours, et (153 * mp + 2) / 5 encode le nombre cumulé de jours avant chaque mois sans table de correspondance. L'expression 146097 est le nombre de jours d'un cycle grégorien de quatre cents ans : 146 000 jours pour quatre siècles, plus quatre-vingt-dix-sept jours bissextiles. Soustraire 719468 recentre le décompte sur l'époque Unix. Rien de mystique là-dedans : c'est la spécification du calendrier distillée en arithmétique.

C'est aussi là que les choix de types comptent. Utilisez des entiers larges signés pour les jours sériels. Soyez explicite sur le grégorien proleptique si c'est ce que vous implémentez. Décidez si les jours hors plage, comme le 31 avril, sont rejetés ou normalisés ; je préfère le rejet pour les dates civiles, car un débordement silencieux masque des bugs en amont. Si vous acceptez des entrées avant notre ère, précisez la numérotation utilisée avant la première soustraction. Cela ressemble à des préoccupations de bibliothèque, mais la même rigueur s'applique dans un firmware ou une procédure stockée où personne ne veut admettre que les dates sont compliquées.

Les fuseaux horaires ne relèvent pas de l'arithmétique calendaire

Un jour de la semaine n'est stable qu'une fois l'échelle de temps et le lieu fixés. Un rendez-vous à 00 h 30 à Tokyo correspond encore à la veille, date civile, à San Francisco. Si votre système stocke des instants, convertissez-les via une base de fuseaux horaires avant de demander le jour de la semaine. Si votre système stocke des dates civiles, ne les convertissez pas à la légère en instants sans rattacher un fuseau. Le mode de défaillance est subtil : deux services peuvent s'accorder sur l'horodatage et être en désaccord sur le jour.

C'est pourquoi je sépare trois notions lors des revues de code. Un instant est un point sur une ligne de temps physique. Une date civile est une étiquette légale ou sociale, comme 2026-11-13. Une heure locale est le couple d'une étiquette civile avec un fuseau et l'historique de ses décalages. Les questions de jour de la semaine concernent surtout les dates civiles. Les questions de planification concernent les instants et les fuseaux. Quand le code mélange les deux, chaque formule propre devient hantée. La conception défensive consiste ici à refuser qu'un horodatage prétende connaître le calendrier de l'utilisateur.

Les secondes intercalaires ajoutent une couche que les gens aiment traîner dans les débats sur les jours de la semaine. Ignorez-les pour le calcul civil du jour. Les jours de la semaine suivent les jours du calendrier, pas un temps atomique lissé. Si vous lissez les secondes intercalaires ou utilisez une horloge monotone pour les durées, très bien, mais que cela ne fuite pas dans la question « est-ce un vendredi ? ». Le vendredi est un fait social.

Des tests qui méritent leur place dans la CI

Le code de dates gagne la confiance grâce à des jeux de données adversariaux, pas à l'intuition. Placez les cas pénibles à côté de la fonction. Testez le 28 février 1900 et le 1er mars 1900 comme jours adjacents sans jour bissextile entre les deux. Testez le 29 février 2000 parce qu'il existe. Testez le 31 décembre 2099 qui bascule en 2100, où une règle ne regardant que les quatre ans se trompe. Testez le 1er janvier 1970 comme jeudi si vous utilisez cette époque. Testez les années négatives si vous prétendez les supporter, et vérifiez que vous rejetez les entrées malformées avant toute arithmétique.

Les tests de propriétés sont utiles si les propriétés sont honnêtes. Ajouter un jour doit faire avancer le jour de la semaine d'un modulo sept, pour toute date valide. Quatre cents années grégoriennes doivent contenir 146 097 jours et revenir au même jour de la semaine. Au sein d'un siècle non bissextile, les repères de type doomsday ne doivent partager un jour de la semaine que si votre implémentation est cohérente. Ne testez pas contre une bibliothèque générée par la même incompréhension que vous cherchez à éviter : fixez les réponses attendues à partir de la norme ou de tables dérivées indépendamment.

Une routine de dates est correcte lorsque ses conventions sont ennuyeuses, explicites et testées aux frontières où le calendrier change d'avis.

Pour la date doomsday elle-même, la réponse attendue est assez simple pour être écrite en dur dans un commentaire : 2026-11-13 donne vendredi selon les règles grégoriennes proleptiques. Ajoutez ensuite le contour : 2026-11-07 est le samedi repère doomsday, 2026-02-28 est un samedi, 2027-02-28 est un dimanche après une année commune, et 2028-02-29 existe parce que 2028 est divisible par quatre et non par cent. Ces petites constellations détectent mieux les erreurs de décalage d'un jour qu'un million de cas aléatoires.

Tuiles de calendrier qui basculent avec des surbrillances rouges sur les cas limites
De bons jeux de tests visent les frontières : jours bissextiles, années séculaires, ancrages d'époque et entrées malformées.

La vieille leçon pour les nouveaux modèles

La courbe apocalyptique de 1960 a échoué en tant que démographie parce que les systèmes humains ne sont pas des points passifs sur une droite ajustée. Les taux de natalité ont changé, les politiques ont changé, l'agriculture a changé, l'urbanisation a changé, et la singularité est restée dans le futur, là où les titres la maintiennent. Cet échec est aussi utile aux programmeurs. Un modèle peut être cohérent en interne, ancré historiquement, et pourtant faux, parce que le système étudié réécrit les règles pendant que vous le mesurez.

L'arithmétique calendaire offre le luxe inverse. Les règles sont lentes, publiques et largement stables, ce qui signifie que la justesse est accessible si l'on respecte la spécification. Cela fait des dates un terrain d'entraînement parfait pour une habitude plus large : nommer le modèle, isoler le cœur des fuseaux horaires et des entrées-sorties, rendre les conventions explicites, et tester les endroits où la continuité se brise. Que vous écriviez du C pour une RTC embarquée, un planificateur de requêtes ou une couche de validation dans un runtime de langage, le gain est le même. La clarté ennuyeuse bat la certitude astucieuse.

Alors oui, le vendredi 13 arrive à l'heure prévue. Pas besoin d'apocalypse. La vraie frayeur, c'est la facilité avec laquelle une équipe peut livrer une logique de jour de la semaine qui fonctionne presque, bâtie sur des congruences à moitié oubliées et sur des hypothèses que personne n'a écrites. Faites la chose simple avec rigueur : implémentez le cycle de quatre cents ans, rejetez les dates impossibles, séparez les instants des étiquettes civiles et laissez aux futurs mainteneurs une trace de constantes qu'ils peuvent vérifier. Doomsday fait un meilleur test unitaire qu'une prévision.