$FOGO parece que está sendo moldado em torno da ideia de que a velocidade não deve ser uma afirmação cosmética, porque se os blocos são genuinamente rápidos e o tempo de execução pode processar trabalho independente ao mesmo tempo, então a aplicação se torna o verdadeiro gargalo e essa mudança é onde a história do SVM se torna interessante, já que o tempo de execução está basicamente perguntando a cada desenvolvedor a mesma pergunta no momento em que os usuários reais chegam, que é se suas transações são realmente independentes ou se acidentalmente projetaram um bloqueio compartilhado que todos devem tocar.
A execução paralela parece simples quando é explicada como transações rodando juntas, mas o detalhe prático que muda tudo é que ela só funciona quando duas transações não lutam pelo mesmo estado, e no SVM o estado não é um blob invisível que a cadeia interpreta como quiser, o estado é explícito e concreto, e cada transação tem que declarar o que vai ler e o que vai escrever, o que significa que a cadeia pode agendar o trabalho com confiança quando essas declarações não se sobrepõem, e isso também significa que a cadeia não pode salvá-lo do seu próprio layout quando você força tudo a se sobrepor.
Esta é a parte que a maioria dos comentários de nível superficial perde, porque as pessoas falam como se o desempenho vivesse na camada da cadeia, mas no Fogo, no momento em que você começa a modelar uma aplicação, o desempenho se torna algo que você projeta na maneira como as contas e os dados são separados, e é por isso que dois aplicativos na mesma cadeia podem parecer completamente diferentes sob estresse, com um permanecendo suave enquanto o outro fica estranhamente preso, mesmo que ambos estejam no mesmo ambiente de execução rápida.
Eu percebi que quando os construtores vêm de hábitos de execução sequencial, eles carregam um instinto que parece seguro, mas se torna caro no SVM, que é o instinto de manter um objeto de estado central que toda ação atualiza, porque isso torna o raciocínio sobre o sistema parecer limpo, torna a análise fácil e faz o código parecer ter uma única fonte de verdade, mas em uma cadeia SVM esse mesmo design se torna um estrangulamento silencioso, porque cada ação do usuário agora está tentando escrever no mesmo lugar, então mesmo que o tempo de execução esteja pronto para executar em paralelo, seu aplicativo criou uma única faixa pela qual tudo deve entrar.
O que muda no Fogo é que o layout do estado deixa de ser apenas armazenamento e começa a ser política de concorrência, porque cada conta gravável se torna uma espécie de bloqueio, e quando você coloca muito atrás de um bloqueio, você não apenas desacelera um pequeno componente, você colapsa o paralelismo para todo o fluxo, e a cadeia não precisa estar congestionada para você sentir isso, porque o design do seu próprio contrato está gerando a congestão ao forçar usuários não relacionados a colidirem no mesmo conjunto de gravação.
FOGO por um motivo que não tem nada a ver com números de classificação, e tudo a ver com como a cadeia pressiona silenciosamente os construtores a amadurecerem em sua arquitetura, porque quando você constrói em um L1 baseado em SVM, você não está apenas escolhendo um ambiente mais rápido, você está escolhendo um modelo de execução que recompensa um bom design de estado e expõe um mau design de estado sem misericórdia.
O Fogo parece que está sendo moldado em torno da ideia de que a velocidade não deve ser uma alegação cosmética, porque se os blocos são genuinamente rápidos e o tempo de execução pode processar trabalho independente ao mesmo tempo, então a aplicação se torna o verdadeiro estrangulamento, e essa mudança é onde a história do SVM se torna interessante, uma vez que o tempo de execução está basicamente perguntando a cada desenvolvedor a mesma pergunta no momento em que usuários reais chegam, que é se suas transações são realmente independentes ou se eles acidentalmente projetaram um bloqueio compartilhado que todos devem tocar.
A execução paralela parece simples quando é explicada como transações rodando juntas, mas o detalhe prático que muda tudo é que ela só funciona quando duas transações não lutam pelo mesmo estado, e no SVM o estado não é um blob invisível que a cadeia interpreta como quiser, o estado é explícito e concreto, e cada transação tem que declarar o que vai ler e o que vai escrever, o que significa que a cadeia pode agendar o trabalho com confiança quando essas declarações não se sobrepõem, e isso também significa que a cadeia não pode salvá-lo do seu próprio layout quando você força tudo a se sobrepor.
Esta é a parte que a maioria dos comentários de nível superficial perde, porque as pessoas falam como se o desempenho vivesse na camada da cadeia, mas no Fogo, no momento em que você começa a modelar uma aplicação, o desempenho se torna algo que você projeta na maneira como as contas e os dados são separados, e é por isso que dois aplicativos na mesma cadeia podem parecer completamente diferentes sob estresse, com um permanecendo suave enquanto o outro fica estranhamente preso, mesmo que ambos estejam no mesmo ambiente de execução rápida.
Eu percebi que quando os construtores vêm de hábitos de execução sequencial, eles carregam um instinto que parece seguro, mas se torna caro no SVM, que é o instinto de manter um objeto de estado central que toda ação atualiza, porque isso torna o raciocínio sobre o sistema parecer limpo, torna a análise fácil e faz o código parecer ter uma única fonte de verdade, mas em uma cadeia SVM esse mesmo design se torna um estrangulamento silencioso, porque cada ação do usuário agora está tentando escrever no mesmo lugar, então mesmo que o tempo de execução esteja pronto para executar em paralelo, seu aplicativo criou uma única faixa pela qual tudo deve entrar...
O que muda no Fogo Oficial é que o layout do estado deixa de ser apenas armazenamento e começa a ser política de concorrência, porque cada conta gravável se torna uma espécie de bloqueio, e quando você coloca muito atrás de um bloqueio, você não apenas desacelera um pequeno componente, você colapsa o paralelismo para todo o fluxo, e a cadeia não precisa estar congestionada para você sentir isso, porque o design do seu próprio contrato está gerando a congestão ao forçar usuários não relacionados a colidirem no mesmo conjunto de gravação.
A maneira mais útil de pensar sobre isso é tratar cada pedaço de estado gravável como uma decisão sobre quem está autorizado a prosseguir ao mesmo tempo, e o objetivo do design se torna reduzir colisões desnecessárias, o que não significa remover o estado compartilhado completamente, porque algum estado compartilhado é essencial, mas significa ser disciplinado sobre o que deve ser compartilhado e o que foi apenas compartilhado por conveniência, porque a conveniência é onde a execução paralela morre silenciosamente.
No Fogo, os padrões que mantêm as aplicações com sensação de rapidez raramente são complicados, mas são rigorosos, porque exigem que um desenvolvedor separe o estado do usuário agressivamente, isole o estado específico do mercado em vez de empurrar tudo através de um único objeto de protocolo global, e pare de escrever em contas compartilhadas que estão principalmente lá para rastreamento e visibilidade, uma vez que essas métricas derivadas podem existir sem se tornarem parte do caminho crítico de gravação para cada transação.
Quando olho para designs amigáveis ao paralelismo bem-sucedidos, eles tendem a tratar ações do usuário como principalmente locais, onde um usuário toca seu próprio estado e uma fatia estreita de estado compartilhado que é realmente necessária, e a fatia compartilhada é estruturada de uma forma que não força usuários não relacionados a competir, que é por isso que a separação por usuário não é apenas um truque de organização legal, é uma estratégia de throughput, e a separação por mercado não é apenas uma escolha de arquitetura limpa, é a diferença entre um mercado ativo arrastando tudo para baixo e múltiplos mercados fluindo independentemente.
A armadilha oculta é que os desenvolvedores frequentemente escrevem estado compartilhado porque querem uma verdade global instantânea, como totais de taxas globais, contadores de volume globais, rastreadores de atividade globais, placares globais ou métricas globais de protocolos, e o problema não é que essas métricas sejam ruins, o problema é que quando você as atualiza na mesma transação que cada ação do usuário, você injeta uma gravação compartilhada em cada caminho, então cada caminho agora entra em conflito, e de repente você construiu uma aplicação sequencial dentro de um tempo de execução paralelo, e não importa quão rápido o Fogo seja, porque seu próprio design está forçando a cadeia a tratar o trabalho independente como trabalho dependente.
O que a execução paralela muda, de uma maneira muito prática, é que os construtores são pressionados a separar o estado de correção do estado de relatório, e são pressionados a atualizar o estado de relatório em um ritmo diferente, ou a escrevê-lo em segmentos fragmentados, ou a derivá-lo de trilhas de eventos, porque uma vez que você para de forçar cada transação a escrever na mesma conta de relatório, o tempo de execução pode finalmente agendar trabalho paralelo real, e a aplicação começa a parecer que pertence a uma cadeia SVM em vez de apenas rodar em uma.
Isso se torna ainda mais visível em aplicações de estilo de negociação, que é onde a postura do Fogo torna a discussão mais fundamentada, porque a negociação concentra a atividade, e a concentração cria concorrência, e a concorrência é o inimigo da execução paralela, então se um sistema de negociação é projetado em torno de um estado central de livro de ordens que deve ser mutado para cada interação, a cadeia irá serializar essas interações não importa quão rápidas sejam os blocos, e a experiência do usuário irá degradar exatamente quando mais importa, que é por isso que os construtores são forçados a designs mais difíceis, mas melhores, onde os componentes mais quentes são minimizados, onde o estado é particionado, onde os caminhos de liquidação são estreitados, e onde as partes que não precisam ser mutadas em cada ação são removidas do caminho crítico.
A mesma lógica aparece em aplicativos em tempo real que as pessoas assumem que serão fáceis em uma cadeia rápida, como sistemas interativos que atualizam frequentemente, porque a abordagem ingênua é manter um único estado mundial e mutá-lo constantemente, mas no @Fogo Oficial isso se torna um ponto de colisão garantido, uma vez que cada participante está tentando tocar o mesmo objeto gravável, então a melhor abordagem é isolar o estado por participante, localizar zonas compartilhadas em vez de globalizá-las, e tratar agregados globais como algo que é atualizado de maneira mais controlada, porque no momento em que você para de fazer com que cada ação escreva no mesmo objeto compartilhado, o tempo de execução pode começar a executar muitas ações juntas, e é aí que a velocidade percebida se torna real.
No estilo lógico de alta frequência, que é onde as cadeias de baixa latência são frequentemente julgadas severamente, a execução paralela torna falhas de design impossíveis de esconder, porque quando muitos atores submetem ações rapidamente, qualquer estado gravável compartilhado se torna um campo de batalha, e em vez de construir um sistema onde muitos fluxos progridem independentemente, você constrói um sistema onde todos estão correndo pelo mesmo bloqueio, e o resultado não é apenas um aplicativo mais lento, é uma dinâmica de mercado diferente, porque a ordenação se torna dominada pela concorrência em vez de pela estratégia, que é por isso que os melhores designs tendem a isolar gravações, reduzir mutações compartilhadas e tratar os componentes contestados como estreitos e deliberados em vez de amplos e acidentais.
Aplicações pesadas em dados mostram o mesmo padrão de uma maneira mais silenciosa, porque a maioria dos consumidores de dados só precisa ler, e as leituras não são o problema, mas quando os fluxos de consumidores começam a escrever dados compartilhados por conveniência, como carimbar valores em contas globais ou atualizar caches compartilhados, eles envenenam o paralelismo sem ganho real, e a melhor abordagem é permitir que os consumidores leiam dados compartilhados e escrevam apenas suas próprias decisões, porque uma vez que você mantém gravações compartilhadas confinadas a fluxos de atualização dedicados, você protege a concorrência para todos os outros.
A troca que o Fogo implicitamente pede aos desenvolvedores para aceitar é que uma arquitetura amigável ao paralelismo não é gratuita, porque uma vez que você fragmenta o estado e separa as contas, você está gerenciando mais componentes, está raciocinando sobre mais arestas e está construindo sistemas onde a concorrência é real em vez de teórica, o que significa que os testes precisam ser mais rigorosos, os caminhos de atualização precisam ser mais cuidadosos e a observabilidade precisa ser melhor, mas a recompensa é que a aplicação pode escalar da maneira como um tempo de execução SVM foi projetado para suportar, onde ações independentes realmente progridem juntas em vez de esperar atrás de um gargalo global.
O erro que destrói a maior parte da vantagem paralela não é um erro avançado, é um simples, que é criar uma única conta gravável compartilhada que toda transação toca, e em uma cadeia como o Fogo, esse erro é especialmente caro, porque quanto mais rápida a cadeia se torna, mais visível é que seu próprio design é o limitador, e essa visibilidade não é uma falha da cadeia, é a cadeia revelando o que a arquitetura realmente é.