$FOGO sembra che venga modellato attorno all'idea che la velocità non dovrebbe essere una dichiarazione cosmetica, perché se i blocchi sono veramente veloci e il runtime può elaborare lavori indipendenti contemporaneamente, allora l'applicazione diventa il vero collo di bottiglia e quel cambiamento è dove la storia dell'SVM diventa interessante, poiché il runtime sta fondamentalmente ponendo a ogni sviluppatore la stessa domanda nel momento in cui arrivano gli utenti reali, cioè se le loro transazioni sono effettivamente indipendenti o se accidentalmente hanno progettato un unico blocco condiviso che tutti devono toccare.
L'esecuzione parallela sembra semplice quando viene spiegata come transazioni che si svolgono insieme, ma il dettaglio pratico che cambia tutto è che funziona solo quando due transazioni non combattono per lo stesso stato, e su SVM lo stato non è una massa invisibile che la catena interpreta come vuole, lo stato è esplicito e concreto, e ogni transazione deve dichiarare cosa leggerà e cosa scriverà, il che significa che la catena può pianificare il lavoro con fiducia quando quelle dichiarazioni non si sovrappongono, e significa anche che la catena non può salvarti dal tuo stesso layout quando costringi tutto a sovrapporsi.
Questa è la parte che la maggior parte dei commenti superficiali ignora, perché la gente parla come se le prestazioni vivessero a livello di catena, ma su Fogo nel momento in cui inizi a modellare un'applicazione, le prestazioni diventano qualcosa che progetti nel modo in cui gli account e i dati sono separati, e questa è la ragione per cui due app sulla stessa catena possono sembrare completamente diverse sotto stress, con una che rimane fluida mentre l'altra diventa stranamente bloccata, anche se entrambe si trovano sullo stesso ambiente di esecuzione veloce.
Ho notato che quando i costruttori provengono da abitudini di esecuzione sequenziale, portano un istinto che sembra sicuro ma diventa costoso su SVM, che è l'istinto di mantenere un oggetto di stato centrale che ogni azione aggiorna, perché rende il ragionamento sul sistema pulito, rende l'analisi facile e rende il codice come se avesse una singola fonte di verità, ma su una catena SVM quel stesso design diventa un silenzioso limitatore, perché ogni azione dell'utente sta ora cercando di scrivere nello stesso posto, quindi anche se il runtime è pronto per eseguire in parallelo, la tua applicazione ha creato una singola corsia in cui tutto deve entrare.
Cosa cambia su Fogo è che il layout dello stato smette di essere solo uno storage e inizia a essere una politica di concorrenza, perché ogni account scrivibile diventa una sorta di blocco, e quando metti troppo dietro un blocco non rallenti solo un piccolo componente, collassi il parallelismo per l'intero flusso, e la catena non ha bisogno di essere congestionata affinché tu lo senta, perché il design del tuo contratto sta generando la congestione costringendo utenti non correlati a collidere sullo stesso set di scritture.
FOGO per un motivo che non ha nulla a che fare con i numeri della classifica, e tutto a che fare con come la catena esercita silenziosamente pressione sui costruttori per crescere nella loro architettura, perché quando costruisci su un L1 basato su SVM non stai solo scegliendo un ambiente più veloce, stai scegliendo un modello di esecuzione che ricompensa un buon design dello stato ed espone un cattivo design dello stato senza pietà.
Fogo sembra che venga modellato attorno all'idea che la velocità non dovrebbe essere un'affermazione cosmetica, perché se i blocchi sono genuinamente veloci e il runtime può elaborare lavoro indipendente allo stesso tempo, allora l'applicazione diventa il vero collo di bottiglia, e quel cambiamento è dove la storia SVM diventa interessante, poiché il runtime sta fondamentalmente chiedendo a ogni sviluppatore la stessa domanda nel momento in cui arrivano utenti reali, che è se le loro transazioni siano realmente indipendenti o se accidentalmente abbiano progettato un blocco condiviso che tutti devono toccare.
L'esecuzione parallela sembra semplice quando viene spiegata come transazioni che si svolgono insieme, ma il dettaglio pratico che cambia tutto è che funziona solo quando due transazioni non combattono per lo stesso stato, e su SVM lo stato non è una massa invisibile che la catena interpreta come vuole, lo stato è esplicito e concreto, e ogni transazione deve dichiarare cosa leggerà e cosa scriverà, il che significa che la catena può pianificare il lavoro con fiducia quando quelle dichiarazioni non si sovrappongono, e significa anche che la catena non può salvarti dal tuo stesso layout quando costringi tutto a sovrapporsi.
Questa è la parte che la maggior parte dei commenti superficiali ignora, perché la gente parla come se le prestazioni vivessero a livello di catena, ma su Fogo nel momento in cui inizi a modellare un'applicazione, le prestazioni diventano qualcosa che progetti nel modo in cui gli account e i dati sono separati, e questa è la ragione per cui due app sulla stessa catena possono sembrare completamente diverse sotto stress, con una che rimane fluida mentre l'altra diventa stranamente bloccata, anche se entrambe si trovano sullo stesso ambiente di esecuzione veloce.
Ho notato che quando i costruttori provengono da abitudini di esecuzione sequenziale, portano un istinto che sembra sicuro ma diventa costoso su SVM, che è l'istinto di mantenere un oggetto di stato centrale che ogni azione aggiorna, perché rende il ragionamento sul sistema pulito, rende l'analisi facile e rende il codice come se avesse una singola fonte di verità, ma su una catena SVM quel stesso design diventa un silenzioso limitatore, perché ogni azione dell'utente sta ora cercando di scrivere nello stesso posto, quindi anche se il runtime è pronto per eseguire in parallelo, la tua applicazione ha creato una singola corsia in cui tutto deve entrare...
Cosa cambia su Fogo Official è che il layout dello stato smette di essere solo storage e inizia a essere una politica di concorrenza, perché ogni account scrivibile diventa una sorta di blocco, e quando metti troppo dietro un blocco non rallenti solo un piccolo componente, collassi il parallelismo per l'intero flusso, e la catena non ha bisogno di essere congestionata affinché tu lo senta, perché il design del tuo contratto sta generando la congestione costringendo utenti non correlati a collidere sullo stesso set di scritture.
Il modo più utile di pensarci è trattare ogni pezzo di stato scrivibile come una decisione su chi è autorizzato a procedere allo stesso tempo, e l'obiettivo di design diventa ridurre le collisioni non necessarie, il che non significa rimuovere completamente lo stato condiviso, perché alcuni stati condivisi sono essenziali, ma significa essere disciplinati su cosa deve essere condiviso e cosa è stato condiviso solo per comodità, perché la comodità è dove l'esecuzione parallela muore silenziosamente.
Su Fogo, i modelli che mantengono le applicazioni che sembrano veloci sono raramente complicati, ma sono rigorosi, perché richiedono a uno sviluppatore di separare aggressivamente lo stato utente, di isolare lo stato specifico del mercato invece di spingere tutto attraverso un solo oggetto di protocollo globale, e di smettere di scrivere a conti condivisi che sono per lo più lì per il tracciamento e la visibilità, poiché quelle metriche derivate possono esistere senza diventare parte del percorso di scrittura critico per ogni transazione.
Quando guardo a design paralleli di successo, tendono a trattare le azioni degli utenti come per lo più locali, dove un utente tocca il proprio stato e una ristretta fetta di stato condiviso che è veramente necessaria, e la fetta condivisa è strutturata in modo da non costringere utenti non correlati a contendersi, ed è per questo che la separazione per utente non è solo un trucco di organizzazione ordinata, è una strategia di throughput, e la separazione per mercato non è solo una scelta di architettura pulita, è la differenza tra un mercato attivo che trascina tutto giù e più mercati che fluiscono indipendentemente..
La trappola nascosta è che gli sviluppatori spesso scrivono stato condiviso perché vogliono una verità globale istantanea, come totali delle commissioni globali, contatori di volume globali, tracker di attività globali, classifiche globali o metriche globali del protocollo, e il problema non è che quelle metriche siano cattive, il problema è che quando le aggiorni nella stessa transazione di ogni azione utente, inietti una scrittura condivisa in ogni percorso, quindi ogni percorso ora confligge, e all'improvviso hai costruito un'applicazione sequenziale all'interno di un runtime parallelo, e non importa quanto sia veloce Fogo, perché il tuo stesso design sta costringendo la catena a trattare il lavoro indipendente come lavoro dipendente.
Cosa cambia nell'esecuzione parallela, in un senso molto pratico, è che i costruttori sono spinti a separare lo stato di correttezza dallo stato di reporting, e sono spinti ad aggiornare lo stato di reporting su una cadenza diversa, o a scriverlo in segmenti sharded, o a derivarlo da trail di eventi, perché una volta che smetti di costringere ogni transazione a scrivere lo stesso account di reporting, il runtime può finalmente pianificare un lavoro parallelo reale, e l'applicazione inizia a sembrare che appartenga a una catena SVM invece di semplicemente funzionare su una.
Questo diventa ancora più visibile nelle applicazioni in stile trading, dove la postura di Fogo rende la discussione concreta, perché il trading concentra l'attività, e la concentrazione crea contesa, e la contesa è il nemico dell'esecuzione parallela, quindi se un sistema di trading è progettato attorno a uno stato di orderbook centrale che deve essere mutato per ogni interazione, la catena serializzerà quelle interazioni non importa quanto siano veloci i blocchi, e l'esperienza dell'utente degraderà esattamente quando conta di più, ed è per questo che i costruttori sono costretti a progetti più difficili ma migliori, dove i componenti più caldi sono ridotti al minimo, dove lo stato è partizionato, dove i percorsi di regolamento sono ristretti e dove le parti che non devono essere mutate per ogni azione sono rimosse dal percorso critico.
La stessa logica appare in applicazioni in tempo reale che la gente assume saranno facili su una catena veloce, come sistemi interattivi che si aggiornano frequentemente, perché l'approccio ingenuo è mantenere un singolo stato del mondo e mutarlo costantemente, ma su @Fogo Official ciò diventa un punto di collisione garantito, poiché ogni partecipante sta cercando di toccare lo stesso oggetto scrivibile, quindi l'approccio migliore è isolare lo stato per partecipante, localizzare le zone condivise invece di globalizzarle e trattare gli aggregati globali come qualcosa che viene aggiornato in modo più controllato, perché nel momento in cui smetti di far scrivere ogni azione allo stesso oggetto condiviso, il runtime può iniziare a eseguire molte azioni insieme, e lì la velocità percepita diventa reale.
Nello stile di logica ad alta frequenza, che è dove le catene a bassa latenza sono spesso giudicate severamente, l'esecuzione parallela rende impossibili da nascondere i difetti di design, perché quando molti attori inviano azioni rapidamente, qualsiasi stato scrivibile condiviso diventa un campo di battaglia, e invece di costruire un sistema in cui molti flussi progrediscono indipendentemente, si costruisce un sistema in cui tutti corrono per lo stesso blocco, e il risultato non è solo un'app più lenta, è una dinamica di mercato diversa, perché l'ordinamento diventa dominato dalla contesa piuttosto che dalla strategia, ed è per questo che i migliori design tendono a isolare le scritture, ridurre la mutazione condivisa e trattare i componenti contestati come ristretti e deliberati piuttosto che ampi e accidentali.
Le applicazioni a elevato contenuto di dati mostrano lo stesso schema in modo più silenzioso, perché la maggior parte dei consumatori di dati ha solo bisogno di leggere, e le letture non sono il problema, ma quando i flussi dei consumatori iniziano a scrivere dati condivisi per comodità, come timbrare valori in account globali o aggiornare cache condivise, avvelenano il parallelismo senza un vero guadagno, e l'approccio migliore è lasciare che i consumatori leggano dati condivisi e scrivano solo le proprie decisioni, perché una volta che mantieni le scritture condivise confinate a flussi di aggiornamento dedicati, proteggi la concorrenza per tutti gli altri.
Il compromesso che Fogo chiede implicitamente agli sviluppatori di accettare è che l'architettura amichevole per il parallelo non è gratuita, perché una volta che shard lo stato e separi gli account, stai gestendo più componenti, stai ragionando su più bordi e stai costruendo sistemi in cui la concorrenza è reale piuttosto che teorica, il che significa che il testing deve essere più rigoroso, i percorsi di aggiornamento devono essere più cauti e l'osservabilità deve essere migliore, ma la ricompensa è che l'applicazione può scalare nel modo in cui un runtime SVM è progettato per supportare, dove azioni indipendenti procedono davvero insieme invece di aspettare dietro un collo di bottiglia globale.
L'errore che distrugge la maggior parte del vantaggio parallelo non è un errore avanzato, è un errore semplice, che è creare un singolo account scrivibile condiviso che ogni transazione tocca, e su una catena come Fogo quell'errore è particolarmente costoso, perché più la catena diventa veloce, più è visibile che il tuo stesso design è il limitatore, e quella visibilità non è un fallimento della catena, è la catena che rivela cos'è veramente l'architettura.
\u003cm-61/\u003e \u003ct-63/\u003e\u003cc-64/\u003e