Nu m-am așteptat la asta, dar partea din Sign care a rămas cu mine nu are nimic de-a face cu crearea sau partajarea datelor, ci se referă la modul în care sistemele decid ce date contează.
Pentru că cele mai multe aplicații de astăzi nu doar colectează date, ci le filtrează. Ele decid ce este relevant, ce se califică, ce ar trebui acceptat sau ignorat. Și de obicei, această logică trăiește adânc în interiorul aplicației în sine. Ascuns. Hardcoded. Diferit peste tot.
Acolo lucrurile încep să se destrame.
Fiecare aplicație își construiește propriile reguli de filtrare de la zero. O platformă verifică trei condiții. Alta verifică cinci. O a treia verifică aceleași lucruri, dar într-un mod ușor diferit. Chiar și atunci când încearcă să rezolve aceeași problemă, ajung la rezultate inconsistent.
Sign abordează asta diferit, lăsând dezvoltatorii să definească regulile de validare direct la nivel de date.
Așa că, în loc ca o aplicație să decidă ce este valid după fapt, regulile pot fi atașate dovezii în sine. Condițiile călătoresc cu datele. Și asta schimbă cum interacționează sistemele cu ea.
Pentru că acum, când o bucată de date este creată, ea poartă deja logica care determină dacă ar trebui să fie acceptată.
Asta elimină un strat de interpretare.
O aplicație nu trebuie să ghicească sau să reconstruiască regulile de validare. Poate pur și simplu să verifice dacă dovada îndeplinește condițiile definite la crearea ei. Dacă da, e validă. Dacă nu, nu e.
Simplu. Dar puternic.
Ce am găsit interesant este cum asta reduce neînțelegerile între sisteme.
Acum, dacă același utilizator încearcă să dovedească ceva în mai multe aplicații, fiecare aplicație ar putea să le evalueze diferit. Chiar și mici diferențe în logică pot duce la rezultate diferite.
Aici, evaluarea devine mai consistentă.
Pentru că condițiile nu sunt redefinite de fiecare dată. Ele sunt încorporate în structura datelor în sine. Aplicații diferite pot citi aceeași dovadă și ajunge la aceeași concluzie fără a coordona înainte.
Asta nu e ceva ce majoritatea sistemelor gestionează bine astăzi.
Un alt detaliu care m-a impresionat este cât de flexibile pot fi aceste reguli.
Nu trebuie să fie statice. Pot include praguri, dependențe sau combinații de condiții. Poți cere îndeplinirea mai multor criterii înainte ca ceva să fie considerat valid, sau permite căi alternative în funcție de context.
Așa că, în loc de o verificare binară, obții ceva mai aproape de validarea programabilă.
Și asta deschide cazuri de utilizare mai complexe.
De exemplu, eligibilitatea poate depinde de un amestec de factori: identitate, comportament, înregistrări anterioare, fără a forța fiecare aplicație să reconstruiască acea logică independent. Dovada în sine definește ce înseamnă "eligibil".
Asta e o modalitate diferită de a gândi despre validare.
De asemenea, schimbă responsabilitatea.
În loc să împingi toată luarea deciziilor în aplicații, o parte din acea responsabilitate se mută la nivelul datelor. Regulile sunt definite o dată și apoi reutilizate oriunde merge datele.
Asta reduce duplicarea.
Și face sistemele mai ușor de înțeles.
Pentru că atunci când te uiți la o dovadă, nu vezi doar rezultatul, vezi criteriile din spatele acelui rezultat. E transparent într-un mod în care majoritatea sistemelor nu sunt.
De asemenea, am început să mă gândesc la cum afectează asta scalarea.
Pe măsură ce mai multe aplicații și servicii interacționează, numărul regulilor de validare explodează de obicei. Fiecare integrare adaugă noi condiții, noi verificări, noi cazuri marginale. Devine mai greu să menții totul aliniat.
Cu această abordare, complexitatea nu crește atât de repede.
Pentru că nu multiplici regulile între sisteme. Le reutilizezi.
O definiție. Multe utilizări.
Și când ceva trebuie să se schimbe, actualizezi regula la sursă în loc să o urmărești prin mai multe aplicații.
Asta e o diferență mare.
Pentru că majoritatea sistemelor de astăzi nu sunt limitate de cât de multe date pot stoca. Ele sunt limitate de cât de greu este să mențină acele date consistente în diferite contexte.
Asta se simte ca un pas spre rezolvarea asta.
Nu prin simplificarea datelor în sine, ci prin facilitarea regulilor din jurul lor.
Și odată ce acele reguli se mută cu datele, întregul sistem devine puțin mai previzibil.
Nu e perfect.
Dar mult mai puțin fragmentat.