Je ne m'attendais pas à cela, mais l'un des aspects les plus intéressants de Sign ne concerne pas ce que les données disent, mais comment les données peuvent être regroupées et interprétées à grande échelle sans réécrire la logique à chaque fois.
Parce que la plupart des systèmes ont du mal lorsque vous passez d'enregistrements uniques à des collections d'eux. Une preuve est facile à vérifier. Mais au moment où vous commencez à traiter des centaines ou des milliers, les choses deviennent compliquées. Vous avez besoin de filtres, de règles d'agrégation, de seuils et de logique personnalisée juste pour répondre à des questions simples comme « combien d'utilisateurs sont qualifiés ? » ou « ce groupe répond-il à l'exigence ? »
C’est là que la friction s’accumule.
Sign introduit une manière de traiter des groupes de preuves presque comme des ensembles consultables, plutôt que comme des entrées isolées. Au lieu de gérer chaque enregistrement individuellement, vous pouvez évaluer des schémas sur beaucoup d’entre eux sans reconstruire la logique à chaque fois.
C’est un changement dans la manière dont les données sont utilisées.
Plutôt que de se demander « cet enregistrement est-il valide ? », vous commencez à vous demander « que me dit l’ensemble de ces enregistrements ? ». Et surtout, vous pouvez définir ces conditions une fois, puis les réutiliser partout où c’est nécessaire.
Par exemple, au lieu de vérifier l’éligibilité un utilisateur à la fois, un système peut évaluer un groupe entier sur la base de critères partagés. Il peut déterminer si suffisamment de conditions sont remplies sur l’ensemble d’un jeu de données, et pas seulement dans une preuve unique.
C’est plus proche de la façon dont fonctionnent les vrais systèmes.
Parce que les décisions sont rarement prises sur des points de données isolés. Elles sont prises à partir de tendances, de comptages, de combinaisons et de seuils. Et la plupart des systèmes finissent par reconstruire cette logique séparément pour chaque application.
Ici, cette logique devient réutilisable.
Un autre détail qui m’a marqué, c’est la façon dont cela réduit la duplication à grande échelle.
Dans les configurations classiques, chaque fois que vous voulez analyser un groupe d’enregistrements, vous écrivez de nouvelles requêtes, de nouveaux filtres ou de nouvelles étapes de traitement. Et ils diffèrent souvent légèrement d’un système à l’autre, même quand ils essaient de répondre à la même question.
Cela conduit à des incohérences.
Avec cette approche, la logique de regroupement et d’évaluation des données peut être standardisée. Vous définissez une fois comment un ensemble doit être interprété, puis vous appliquez cette interprétation partout où les données sont utilisées.
Cela réduit les divergences.
Cela rend aussi les résultats plus prévisibles.
Parce qu’au lieu que chaque application calcule les choses à sa façon, elles peuvent s’appuyer sur les mêmes définitions sous-jacentes. Le même jeu de données produit le même résultat, quel que soit l’endroit où il est évalué.
C’est plus difficile à atteindre qu’on ne le pense.
J’ai aussi commencé à réfléchir à la façon dont cela impacte les performances et la complexité.
Quand la logique est dupliquée entre plusieurs systèmes, cela crée un surcoût. Chaque application doit traiter les données de manière indépendante, maintenir ses propres règles et gérer ses propres cas limites. Et tout cela s’additionne très vite.
En rapprochant une partie de cette logique des données elles-mêmes, vous réduisez la quantité de travail que chaque système doit effectuer.
Ils n’ont pas besoin de tout retraiter à partir de zéro. Ils peuvent s’appuyer sur des interprétations partagées.
Et cela simplifie l’architecture.
Au lieu de construire des couches de traitement lourdes dans chaque application, vous vous dirigez vers des systèmes plus légers qui consomment des données déjà structurées, de manière significative.
Ce qui m’intéresse, c’est la façon dont cela change entièrement le rôle des données.
Ce n’est plus seulement quelque chose que vous stockez et que vous récupérez.
Cela devient quelque chose sur quoi on peut raisonner collectivement, sans redéfinir constamment la manière dont ce raisonnement fonctionne.
Et cela ouvre la voie à des cas d’utilisation plus avancés.
Parce qu’une fois que vous pouvez évaluer de façon fiable des groupes de données, vous pouvez commencer à construire des systèmes qui réagissent à des tendances plutôt qu’à des événements individuels. Vous pouvez définir des seuils, suivre l’avancement sur plusieurs enregistrements, ou déclencher des actions lorsque certaines conditions sont remplies sur l’ensemble d’un jeu de données.
C’est un autre niveau d’abstraction.
Et c’est quelque chose que la plupart des systèmes ont du mal à prendre en charge proprement.
Quand je prends du recul, cela ressemble à une amélioration subtile de plus de ce genre.
Ce n’est pas quelque chose qu’on remarque au début.
Mais c’est aussi quelque chose qui devient de plus en plus important à mesure que les systèmes grandissent.
Parce que traiter un seul élément de données, c’est facile.
Gérer de façon cohérente, efficace et sans réécrire la logique à chaque fois des milliers d’éléments : c’est là que la plupart des systèmes commencent à se briser.
Et c’est là que Sign semble adopter une approche différente