J'ai réalisé le problème de la fenêtre temporelle le jour où une tâche est revenue vérifiée, paraissait propre, et a toujours déclenché une fenêtre de validité de 30 secondes dans notre manuel d'exploitation avant que nous laissions le prochain pas se déclencher. Pas parce que le verdict était faux, mais parce que le monde dans lequel il a été vérifié avait déjà changé. Le verdict n'était pas faux, il était juste assez tard pour être dangereux.
Nous avons commencé à suivre un proxy grossier après cela, des vérifications par 100 tâches, et le nombre a explosé pendant les heures de pointe.
La vérification sans horloge n'est qu'une étiquette.
L'instantané source avait tourné. Un bit de politique avait basculé. L'environnement que le vérificateur a vérifié ne correspondait plus à l'environnement dans lequel mon flux de travail s'apprêtait à agir. Le résultat était valide dans un monde passé, et mon prochain pas vivait dans le monde actuel.
C'est ainsi que je finis par lire ROBO, dans la pratique.
Une question, et elle est opérationnelle.
Lorsque ROBO coordonne un travail réel, les fenêtres de fraîcheur deviennent le protocole.
La plupart des systèmes parlent de vérification comme si c'était seulement un oui ou un non. En production, la vérification est aussi un horodatage. Une revendication n'est pas juste vraie ou fausse. Elle est vraie sous un instantané spécifique, un état de politique spécifique, un environnement d'outil spécifique, et un moment spécifique.
Sur ROBO, un reçu est souvent un déclencheur, pas un rapport. Lorsque le protocole ne rend pas ce moment explicite, l'écosystème ajoute des règles d'expiration pour cela.
La stagnation n'est pas un cas particulier. C'est le mode de défaillance par défaut de toute pile d'automatisation qui essaie d'agir sur le monde réel, car le monde change plus vite que le pipeline.
Une surface de travail comme ROBO a une boucle. Une tâche est postée. Un opérateur produit un résultat. Des preuves sont rassemblées. Les revendications sont vérifiées. Un signal d'acceptation est émis. L'exécution en aval se produit.
Maintenant, la seule question qui compte une fois que la boucle fonctionne à grande échelle.
Combien de temps un résultat accepté est-il sûr pour agir.
Lorsque cette réponse est floue, le système forme une habitude.
Attendez, et re-vérifiez.
Une fois que cette habitude apparaît, elle se propage rapidement. Les portefeuilles et les applications ajoutent des délais de protection. Les intégrations ajoutent des voies de rafraîchissement. Les équipes opérationnelles ajoutent des tâches de surveillance qui revalident après succès. Aucune de ces équipes ne pense qu'elles réécrivent quoi que ce soit. Elles pensent qu'elles expédient la fiabilité.
Mais ils définissent le contrat temporel que le réseau n'a pas.
Les artefacts apparaissent dans un ordre prévisible.
Commencez par une petite attente, attendez 2 secondes, puis procédez.
Ajoutez une fenêtre de validité, écartez tout ce qui arrive en dehors de 30 secondes, et re-vérifiez.
Connectez une boucle de re-vérification, rebâtissez les preuves, reconstruisez l'ensemble des revendications, relancez la vérification, et essayez à nouveau.
Dirigez tout ce qui est en dehors de la fenêtre vers une file de réconciliation, où les humains décident si c'est sûr.
À ce moment-là, le réseau est toujours en train de vérifier, mais l'intégration supervise.
La fraîcheur n'est pas qu'une préoccupation de performance. C'est une surface de gouvernance.
Sans règle de fraîcheur au niveau du protocole, les intégrateurs créent les leurs, et ils ne convergent pas.
Une équipe fixe une fenêtre de 10 secondes. Une autre fixe 2 minutes. Une autre considère tout changement de politique comme une invalidation. Une autre ignore les changements de politique et ne rafraîchit que sur dérive d'instantané. Une autre dirige tout ce qui est risqué vers une porte humaine.
Le résultat est la fragmentation.
Pas parce que le protocole s'est scindé, mais parce que le temps l'a fait.
Différentes applications finissent par vivre dans des réalités différentes pendant de petites fenêtres de temps. Pas assez longtemps pour déclencher une panne, assez longtemps pour créer un avantage. Les bots vivent dans ces fenêtres. Les opérateurs apprennent quelles fenêtres sont sûres à exploiter. Les équipes de risque élargissent les tampons parce qu'elles ont été brûlées une fois.
C'est ici que le travail ennuyeux commence à compter.
Une surface de travail sérieuse a besoin d'une notion partagée de fraîcheur. Un reçu a besoin d'une limite de validité explicite, appliquée de la même manière à travers la pile.
L'alternative n'est pas la flexibilité. L'alternative est une logique d'expiration privée partout.
La facture se manifeste sous forme de trafic, de complexité et d'avantage. Plus de lectures, plus de re-vérifications, plus de machines d'état, et le même résultat silencieux, quiconque peut rafraîchir le plus vite agit en premier.
Ainsi, la décision de fraîcheur n'est pas seulement une question de sécurité. C'est une question de quel type de comportement vous vous entraînez sous charge.
Sans discipline de fraîcheur, vous obtenez moins d'échecs explicites, et plus d'ambiguïté silencieuse. Les intégrateurs ajoutent du temps, et l'autonomie se dégrade silencieusement.
Avec une discipline de fraîcheur stricte, vous obtenez plus de rejets visibles, et les équipes se plaignent que le système est sévère. Certaines d'entre elles auront raison. Une expiration stricte réduit ce qui peut réussir, elle force des liaisons et des frontières de phase plus propres, et elle oblige les intégrations lâches à payer d'avance au lieu de laisser fuir le coût plus tard.
Mais cette rigueur achète quelque chose que le marché sous-estime.
Cela empêche la politique temporelle de se transformer en un marché privé.
Un non stable et explicite est préférable à un oui vague qui expire de manière imprévisible.
Un oui vague n'est qu'un non retardé avec un rayon d'explosion supplémentaire.
C'est aussi ici que vous découvrez si un réseau est vraiment coordonné, ou simplement coexistant.
Lorsque le protocole définit la fraîcheur, tout le monde joue le même jeu temporel. Les applications restent plus longtemps à passage unique. Les opérateurs peuvent raisonner sur ce que signifie un reçu. L'automatisation en aval peut se déclencher sans consulter une deuxième source.
Lorsque la fraîcheur est laissée à des règles locales, le système devient un patchwork, et ce patchwork est ce qui transforme l'autonomie en automatisation supervisée.
$ROBO ne devient clair qu'après avoir évalué cette discipline.
Vous devez payer pour des re-vérifications rapides, l'intégralité des reçus et l'application, sinon le coût se relocalise chez des fournisseurs privés.
Si $ROBO n'est pas lié à cette réalité opérationnelle, le coût fuit quand même. Il fuit dans des accords d'infrastructure privés, des fournisseurs de données privilégiés, et des intégrations qui peuvent se permettre des boucles de re-vérification agressives. Le réseau public existe toujours, mais le réseau utilisable appartient à ceux qui peuvent payer pour garder le temps sous contrôle.
La seule façon que je connaisse d'évaluer cela plus tard est simple.
Lorsque ROBO est occupé, les intégrateurs s'appuient soit sur un contrat de fraîcheur partagé, soit ils commencent à écrire des règles d'expiration localement.
Les boucles de re-vérification restent soit rares, soit elles deviennent le deuxième pipeline.
Les tâches de surveillance rétrécissent ou se multiplient.
Les applications convergent soit vers une définition suffisamment finale, soit elles expédient des échelles de minuteurs concurrentes.
Au moment où « voie de rafraîchissement recommandée » apparaît dans un document d'intégration, la fenêtre de temps est déjà le vrai protocole.
Le jour où les équipes cessent d'écrire une logique d'expiration privée est le jour où les fenêtres temporelles cessent d'être un protocole caché.
Jusqu'à ce moment-là, la chaîne ne coordonne pas seulement le travail.
Il coordonne les horloges.
Et si les horloges ne sont pas d'accord, les humains le seront.