Non mi aspettavo questo, ma la parte di Sign che mi è rimasta impressa non ha nulla a che fare con la creazione o la condivisione di dati, riguarda come i sistemi decidono quali dati hanno anche importanza.
Perché la maggior parte delle applicazioni oggi non si limita a raccogliere dati, li filtra. Decidono ciò che è rilevante, ciò che si qualifica, ciò che dovrebbe essere accettato o ignorato. E di solito, quella logica vive nel profondo dell'app stessa. Nascosta. Codificata. Diversa ovunque.
È lì che le cose iniziano a rompersi.
Ogni app costruisce le proprie regole di filtraggio da zero. Una piattaforma controlla tre condizioni. Un'altra controlla cinque. Una terza controlla le stesse cose ma in un modo leggermente diverso. Anche quando stanno cercando di risolvere lo stesso problema, finiscono con risultati inconsistenti.
Sign si approccia a questo in modo diverso, permettendo agli sviluppatori di definire le regole di validazione direttamente a livello di dati.
Quindi, invece di un'app che decide cosa è valido dopo il fatto, le regole possono essere attaccate alla prova stessa. Le condizioni viaggiano con i dati. E questo cambia il modo in cui i sistemi interagiscono con esso.
Perché ora, quando viene creato un pezzo di dato, porta già la logica che determina se dovrebbe essere accettato.
Questo rimuove uno strato di interpretazione.
Un'app non ha bisogno di indovinare o ricostruire le regole di validazione. Può semplicemente controllare se la prova soddisfa le condizioni definite al momento della creazione. Se lo fa, è valida. Se non lo fa, non lo è.
Semplice. Ma potente.
Quello che ho trovato interessante è come questo riduce il disaccordo tra i sistemi.
In questo momento, se lo stesso utente prova a dimostrare qualcosa su più app, ogni app potrebbe valutarle in modo diverso. Anche piccole differenze nella logica possono portare a risultati diversi.
Qui, la valutazione diventa più coerente.
Perché le condizioni non vengono ridefinite ogni volta. Sono incorporate nella struttura dei dati stessi. Diverse app possono leggere la stessa prova e arrivare alla stessa conclusione senza coordinarsi in anticipo.
Questo non è qualcosa che la maggior parte dei sistemi gestisce bene oggi.
Un altro dettaglio che mi ha colpito è quanto possano essere flessibili queste regole.
Non devono essere statiche. Possono includere soglie, dipendenze o combinazioni di condizioni. Puoi richiedere che più criteri siano soddisfatti prima che qualcosa sia considerato valido, o consentire percorsi alternativi a seconda del contesto.
Quindi, invece di un controllo binario, ottieni qualcosa di più vicino a una validazione programmabile.
E questo apre a casi d'uso più complessi.
Ad esempio, l'idoneità può dipendere da un mix di fattori: identità, comportamento, registri precedenti, senza costringere ogni app a ricostruire quella logica in modo indipendente. La prova stessa definisce cosa significa 'idoneo'.
Questo è un modo diverso di pensare alla validazione.
Si sposta anche la responsabilità.
Invece di spingere tutta la decisione nelle applicazioni, parte di quella responsabilità si sposta nel livello dei dati. Le regole sono definite una volta e poi riutilizzate ovunque i dati vadano.
Questo riduce la duplicazione.
E rende i sistemi più facili da comprendere.
Perché quando guardi una prova, non stai solo vedendo il risultato, stai vedendo i criteri dietro a quel risultato. È trasparente in un modo in cui la maggior parte dei sistemi non lo è.
Ho anche iniziato a pensare a come questo influisce sulla scalabilità.
Man mano che più app e servizi interagiscono, il numero di regole di validazione di solito esplode. Ogni integrazione aggiunge nuove condizioni, nuovi controlli, nuovi casi limite. Diventa più difficile mantenere tutto allineato.
Con questo approccio, quella complessità non cresce così in fretta.
Perché non stai moltiplicando regole tra i sistemi. Le stai riutilizzando.
Una definizione. Molti usi.
E quando qualcosa deve cambiare, aggiorni la regola alla fonte invece di inseguirla su più applicazioni.
Questa è una grande differenza.
Perché la maggior parte dei sistemi oggi non è limitata da quanto dati possono memorizzare. Sono limitati da quanto è difficile mantenere quei dati coerenti attraverso diversi contesti.
Questo sembra un passo verso la risoluzione di questo.
Non semplificando i dati stessi, ma rendendo le regole attorno ad essi più portabili.
E una volta che quelle regole si spostano con i dati, l'intero sistema diventa un po' più prevedibile.
Non perfetto
Ma molto meno frammentata