Meetup #06 - Yul & Solidity compiler - Matheus Aguiar (Solidity core team)

Transcript

boa beleza então Mateus obrigado por ter topado aqui a nossa iniciativa eh que é um público bem nichado né a intenção aqui da r55 é ser uma organização Independente de empresa Para justamente ter esse viés de independência de conteúdo tentar trazer os conteúdos mais relevantes técnicos da comunidade web 3 mais focada no etério mas não não limitante né eh e e pô e juntar a comunidade Dev né que além disso acho que aqui no Brasil a comunidade às vezes está meio dispersa é um evento que acontece no ano então tem

esses momentos mais mensais aí pra gente conversar e discutir o que que tá rolando de tecnologia eh mais focada no público intermediário para avançado né a gente acha que tem algumas iniciativas que tá focando legal no público eh iniciante mas a intenção aqui é meio que ser o próximo nível então Obrigadão por ter topado eh a gente se conheceu lá no no etério rio do ano passado e super legal ter um brasileiro aí representando no time que que é uma um dos pilares né para mim vocês eu enxergo Sabe aquele meme que é tipo ah internet inteira e aí é um software open source do do para mim é isso aqui o solidity a gente nem imagina a importância para toda a

comunidade web 3 né tá permeando Sei lá eu acho que o market share solidity vers outras linguagens aí deve ser 90% ou mais né Eh então obrigado por ter topado o palco é seu e apesar de seros sermos poucos hoje aí dos gados pingados o conteúdo vai ficar gravado e a gente espera atingir muito mais devis aí no futuro tranquilo tranquilo Obrigado aí Robson eh então boa noite aí todo mundo tá aí agora aqui online com a gente saudações aí para quem vai assistir depois eh agradeço aí Hã A o convite você é sempre bom acho que

sempre bom tá aí compartilhando conhecimento né eh você pediu para falar um pouquinho né da minha trajetória então né Eh antes de est trabalhando aí com com solite eu fui professor né durante um tempo e então assim é para para mim é é bastante gratificante poder e vir aqui passar né passar asas conhecimentos e explicar um pouquinho mais para vocês e então já falando um pouquinho da minha trajetória né Eu sou formado em ciência computação e pela Universidade Federal de Uberlândia de um mestrado emal também e a minha meu caminho assim né na na área de web 3

começou de uma forma tanto corrupta ou às vezes como eu costumo falar eu caí de para-quedas eh né atrás das das né das Linhas Inimigas né ou lá no centro eh desse dessa área aí da web3 porque como eu falei eh depois de fazer meu mestrado eu trabalhei e eh um pouco e depois eh atuei por 8 anos como professor né então era professor da da rede Federal do Instituto Federal do trin Mineiro Professor 8 anos e decidi né procurar voltar assim pra indústria trabalhar na indústria

e enfim né acho que foi uma questão assim de de né de time ali né Na hora apareceu uma vaga compador de Solid e e eu Ach eu achei muito interessante né porque além de ser um compilador Open Source eh como você falou é é é uma ferramenta aí que que ela é fundamental ela é é muito importante pro funcionamento da etério como um todo então né foi aí nesse momento então que eu entrei na área de web 3 e aí eu vim por né acho que é uma forma até assim é bastante acho que eh não convencional aí

essa trajetória até porque para tá atuando lá no solite a gente escreve contarem ser mais mais então não né não era necessário né não era uma coisa que estava sendo buscada no perfil alguém que tivesse na área de cripto na área do blockchain né mas apesar disso o que eu percebi né Então aí trazendo essa visão minha de fora né at uma visão com alguém que eu tô com professor eh o que eu percebi é que eh é uma área que tem uma demanda muito grande e que eh tem muita coisa para ser feita né e tem tem eh o que eu vejo é que ainda assim tem tem muito espaço né para crescer né Então até comentei com alguns amigos que

eh né desse ano anterior aí né foram afetados pelo pelos layoffs né até comentei com eles né Aprende aprende solite né vai para web3 porque é uma área que eh tem muito potencial tem muita coisa acontecendo e tem uma demanda muito grande de talentos né então eh eu acho que que é a minha trajetória então foi foi por esse por esse lado né Então teve tinha uma demanda no computador de solite por desenvolvedor ser mais mais né E como eu falei questão de time na hora eu tava exatamente procurando um trabalho na indústria e foi uma coisa que eh foi uma oportunidade que se alinhou muito com eh O que eu o que eu tava buscando né ou o

que eu que eu vivia ali como professor né então professor da rede pública eh quando apareceu para minha oportunidade de trabalhar no projeto source né para mim foi mais ou menos como eh enfim né para mim eu tava eu tô continuando né Essa questão de tá trabalhando R público né e acho que isso é isso é bastante gratificante por si só eh então isso aí é um né Masi um review aí da minha minha trajetória E então tem TRS anos quase que eu tô trabalhando aí no com computador de solite né Eu entrei em Maio de 2021 e né Aprendi muita coisa e da web3 desde então depois sobre o computador Solid sobre a linguagem mas

até como eu comentei com você né robon quando você me chamou para dar a palestra e você pediu para vez eu trazer algum tema do solite em si né algum padrão alguma coisa eu falei né Eu acho que ainda assim né E esse não é o meu foco né E no momento eu ainda acho que eu não sou a pessoa mais adequada né como eu falei acho que é uma área que tem muita coisa que ser explorada e né e uma carência muito grande de talento Então acho que eu preparei aqui uma apresentação pra gente ter alguns pontos para seguir então eu vou eh compartilhar minha tela e vou e vou alternando aí entre a minha apresentação e alguns de código né algumas configurações né que eu vou que eu vou apresentar aí e

explicar para vocês e aí pessoal durante a minha apresentação eh podem fazer perguntas aí no chat né acho que é oportuno a gente para e discute elas acho que vai acrescentando aí então deixa eu compartilhar aqui [Música] eh eh tá aparecendo aí para todo mundo legal então Ô legal então Eh vou então nessa nessa

talk quezinha aí a gente vai falar um pouco sobre n o solite mais do compilador solite né Eh o iu e apresentar para vocês um pouquinho né sobre otimizações esses detalhes né que às vezes a gente fica só no o tem mais go through lá né só liga o otimizador eh e às vezes não sabe ou tem um certo receit se aprofundar em detalhes que existem né então H vou falar aqui só né isso aqui só pra gente delinear aqui o tops Basic que a gente vai organizar né mas como eu falei a gente vai alternando aí entre código e e slides né então Eh como eh enfim né esse conteúdo aí vai ficar público

eh então para para ser mais acessível possível né começar falando um pouquinho aí né Do de compiladores em geral né então o compilador ele tá dividido aí né em um front end e um backend né Só que no caso aqui o frontend eh é a parte que vai vamos dizer assim vai analisar o código que você escreveu por exemplo o código solit né o computador solite vai analisar ele e vai falar se aquele código se você escreveu o código eh correto né se se a sintaxe tá correta se vocês não esqueceram um ponto e vírgul né se se o eh não tem uma variável lá que não tá declarada esse tipo de coisa

Ah esse é o frontend então por exemplo ah pessoal comentou aí né do Viper né Tem outra linguagem também eh o Fi não sei se vocês ouviram falar eh o o fi ele usa ele é ele é uma é uma linguagem e atualmente eles têm basicamente o pront front Change Pronto né então o frontend deles gera aí uma um código intermediário né que que tá mostrando aí na figura eh que no caso é o iu que a gente vai comentar né E aí depois eles usam o backend do Solid né que é a parte que vai pegar esse essa essa representação intermediária e realmente transformar

ela no código final que a gente quer né no caso né do da eum aí no da IVM né no P code ah então né os computadores em gerais eles têm essas duas etapas certo pode pode falar Eh Rob eu sei não sei se você tá acompanhando o chat Às vezes quem tá apresentando não não não consegue ver é não apareceu para mim deixa eu ver aqui [Música] eh o RF tem algo a ver com isso também ou Nada a ver aí o Roof é o rof é outra

eh o ruof não ele não gera iu né aí o ruof Ele é bem próximo do do da da da evm né do bite cod certo então Eh se a gente pensar em níveis de abstração né eu trazer assim vamos trazer para pras linguagens aí eh né mais tradicionais se a gente pensar aí que tem o o assembly né o assemble é bem próximo do do código de máquina mesmo que é executado né do zer E1 vamos dizer assim o ruf é mais ou menos isso né Ele é meio como se fosse quase que um bite code ali mesmo da IVM e E aí o solit vifi são linguagens que são mais um como Java né o py são

linguagens mais alto nível de abstração eh e aí nesse contexto que a gente vai est comentando do iu né o iu ele tá bem bem aqui no meio mesmo né Ele é uma linguagem ele é uma ele é uma linguagem que ela funciona como uma representação intermediária né então aí eu diria que o RF ele tá vamos dizer assim no nível de abstração né ele tá abaixo do do iu né porque ele tá mais próximo ali do VM by code né Legal eu acho que eu consigo ver aqui não tá aparecendo o chat mas aparece uma sinalização zinha aqui agora eu vou prestar atenção Robson Mas qualquer coisa você pode me dar um toque aí também eh Beleza então isso é só para situar né

galera e assim às vezes também né pessoal uma coisa que eu percebi foi que às vezes a gente utiliza frameworks ID né ids e e às vezes a gente até esquece né eu acaba não né não sabendo que né na verdade existe compilador né existe um um software né um aplicativo que faz isso né que pega o seu código solite e transforma naquilo né e não é o o hard Hat né não é o foundry eh não é o remix né E eles são né vamos dizer assim ferramentas que usam o solidity né para produzir isso certo ah né Então aí só esse esse dar esse preâmbulo aí né de

maneira que nosso a nossa T fica o mais acessível possível para todos então é nesse contexto aí que a gente vai tá né que eu vou est comentando falando do do solite né do compador e da linguagem né e do iu do processo de compilação né então Eh aqui tem essa outra figura que ela tá um pouco mais eh detalhada né mas só pra gente ter noção né do que eu tava comentando lá né então o frontend né ele faz essa análise léxica né então El ele e Verê se tudo que você escreveu existe né então quando você escreve if né Ele sabe que o if existe né se você escrever lá né uma um keyword que não existe né ele vai perceber isso nessa fase né do front Change né né Aí tem a análise de sintaxe análise semântica eh Então tudo

isso aqui vamos dizer assim vai validar o código que você escreveu E aí só depois que o backend vai pegar o resultado do frontend e vai produzir um eh realmente ali o seu process o seu eh programa aqui né alvo target program que é o no caso nosso aí é o evm by cod tá então isso só pra gente ter um eh vamos diz assim um overview a uma visão bem topd o que que acontece quando a gente fala do solite da compilação do processo de compilação Ah E aí antes de falar um pouquinho antes um pouquinho de falar sobre do do solite do do iu em si né queria comentar aí sobre o os pipelines né até porque eh a gente tá eh

preparando aí uma mudança né Eh Entre esses pipelines né que é o pipeline Legacy e e o pipeline vamos dier assim o o via ir né ou que usa o iu né que usa essa essa representação intermediária então Eh o pipeline Legacy né é o que é a configuração Def padrão hoje do compilador então se você não né não não fizer nada não escolher nada em relação ao outro pipeline que é o vi ir né que usa o iu Esse é a opção padrão que tá habilitada né E aí o pipeline Legacy basicamente o que que ele faz né ele transforma o código solidity numa representação intermediário que é é é o aast né que a gente fala que é uma

árvore tá uma estrutura de dados uma árvore essa ABS syntax TRE Ah E aí diretamente dessa representação dessa árvore ele já cria o evm by code né então quando você liga uma otimização eh no pipeline Legacy né são otimizações que vão ser feitas eh sobre o bite code que foi gerado tá não é É sobre o Solid né o controlador ele não otimiza o seu código Solid né ele otimiza o resultado né que foi gerado ele otimiza dá uma pós processada né vamos dizer assim otimizando ele e aí gera um bite code mais enxuto né um tamanho menor e com um custo mais barato

né E aí depois a gente vai ver vou comentar né os detalhes eh dependendo da situação você às vezes vai querer eh priorizar um tamanho menor né ah porque aí é uma uma questão onde você perde e ganha né quanto menor o tamanho eh você vai ter um custo maior né e para as vezes minimizar o custo né ou para minimizar o custo você tem que eh aumentar o tamanho um pouco então tem um tradeoff ali né Tem esse perde e ganha aí Eh mas isso tem um parâmetro na otimização que a gente consegue controlar também né geralmente é quando a gente vai fazer o Deploy né do contrato ele vai rodar só uma vez né então a gente eh não vai não vai se preocupar P aí muito com eh o custo dele

né mas com tamanho eh então falando aí do pipeline do esse novo né novo pipeline vamos dizer assim né mas ele já existe né o pipeline vai eh via ir né via ir aí né esse ir de eh intermediary representation né representação intermediária Então essa representação intermediária é o iu né que essa a linguagem que a gente vai falar daqui a pouquinho tá hã e A grande questão do U né ele ele não foi introduzido para ser outra linguagem pra gente criar Smart contracts né ele foi introduzido mais para ser realmente uma linguagem eh intermediária de apresentação para ajudar na otimização e para ajudar em

resolver problemas né como o stack to Deep error né que é um erro muito comum no pipeline Legacy tá eh que é um erro que acontece que é uma limitação eh da IVM tá da da da da da etherum virtual Machine não é uma limitação do solite não é uma limitação do controlador solite tá eh é uma limitação da daí assim né uma limitação do compilador Solid no sentido de que eh o código gerado dele né às vezes Eh cai nessa situação da evm né em que ela limita o tamanho da stack da pilha eh você só consegue acessar né as 16 eh variáveis que estão no toto da pil né

então sem tentar entrar muito em detalhes técnicos né existe essa limitação na evm eh e por vezes o pipeline Legacy gera código que causa esse erro do specto Deep né ã E aí é um erro que né acho que é um erro dos dos dos mais odiados aí no do solite né nas pesquisas que a gente faz eh sempre aparece aí né pessoal Reclamando dele eh E então esse pipeline aí o via eh ir né vai a Art que já existe ele elimina praticamente todos osos casos né Tem sobram algum né alguns corner cas ali eh que ainda incorrem nesse problema mas aí tem coisas que a

gente pode fazer a nível de solite ou mesmo a nível de u eh para melhorar isso né então esse pipeline né El ele é diferente do Legacy exatamente né no sentido de que o código solite primeiro ele é transformado num código iu né esse cod u pode sofrer então aí eh melhorias otimizações E aí depois ah a gente gera o bte Code a partir do u e a gente pode de novo aplicar otimizações eh nesse bite code né então a gente tem duas etapas de otimização tá E aí a vantagem é a gente pode testar aqui né tar alguns exemplos que aí a gente consegue

ah né um código bem mais otimizado né porque no nível do iu a gente consegue fazer coisas que a gente não consegue fazer no nível do bode tá e né E isso aí fica bem visível pra gente e acho PR comunidade como too aí solução dos né E aí né esse código depois do i já é otimizado e é gerado Bod el sofre uma segunda etapa de otimização que melhora mais ainda tá Ah então esse aí são os doos dois pipelines que existem hoje tá então se você não tá configurando nada de disso

tá no seu projeto eh ele tá compilando nesse Legacy Ok se você eh e eu vou mostrar aqui posso mostrar aqui se você configurar o vi aí você vai est entrando nesses pipeline aqui Opa perdão então Eh pra gente eh ativar então a compilação aí né através do iu pelo vi a gente pode ativar essas opções aqui ó né Tem tem essas opções na linha de comando tá na linha de comando quanto através do eh das configurações do do Jon de input tá aí dependendo aí do de como você usa

o compilador né geralmente acho que quando quando a gente usa comame work hard Hat founder e etc a gente tem um arquivo de configuração né um json E aí você pode eh ativar isso tá eu vou mostrar aqui na documentação eh e vou mostrar um exemplo Zinho aqui do um arquivo como que a gente faz isso E aí como eu falei então o u o foco dele é em ser uma eh uma representação intermediária né a gente vai utilizar ele mais para fazer debugs né vez de um tresto específico você precisa aplicar uma otimização manual tá então são situações bem eh específicas Opa deixa eu então passar voltar aqui agora e mostrar para vocês

um pouquinho dos de código aqui e da gente vendo essas eh vendo essas otimizações vou colocar outra tela aqui Eu acho que eu vou ter que colocar o meu minha tela inteira para ficar poder trocando mais fácil

eh então aqui ó pessoal deixa eu mostrar aqui para vocês H aqui a aqui um exemplo tá do que que a gente pode escrever né com iu então só para vocês terem noção né como eu disse é uma linguagem que ela tá ali né em questão de níveis de abstração ela tá entre o solidity e entre vamos dizer assim o bite code né então basicamente o iu você coloca todo o código dentro de um bloco principal aqui né e você pode fazer várias coisas você pode ter funções você pode declarar variáveis você pode eh acessar diretamente instruções

eh como funções né então aqui por exemplo né ó tô pedindo para carregar posição zero né dá um memory load aí um M load né na posição zero né atribuindo aqui numa variável que eu declarei let x ah né não tem tipo né todos os tipos aqui são eh são são Slots né da IVM 256 eh bytes E aí a gente tem né construções como if for tá LS entãoa é uma linguagem eh que ela é mais baixo nível né ela tá bem mais próxima ali do B code mas ela não tá tão baixo pres exo quanto o quanto o ruf né

ã Então esse aqui é o tipo de coisa que a gente consegue fazer a gente consegue também declarar funções tá pode declarar funções tá elas TM tipo de retorno elas TM eh Elas têm parâmetros Mas como eu falei o objetivo do U né não é a gente escrevendo Smart contracts nele tá o que a gente vai fazer se a gente precisar fazer alguma coisa nele é inspecionar o que tá acontecendo com o código né então aqui agora eu vou eu tô utilizando usando aqui a linha de comando tá pessoal porque basicamente é assim que eu uso o

compilador né assim que eu sinto mais confortável com ele tá mas basicamente o que eu tô fazendo é o que que eu vou est fazendo é o que você faz quando você usa aí o seu Framework a sua ide você manda compilar né eu vou usar aqui só a linha de comando eh porque eu já tô mais acostumado n então quando esse latest aqui é a última versão eh do nosso controlador Ah então por exemplo eu criei aqui um arquivo de Test tá Solid né Não sei se eu preciso aumentar aí o código tá muito pequeno ou tá legal Dá para ver mas acho que se der uma um zoom um pouquinho deixa eu dar um

zoom comand mais é control mais o comand de é Ah é verdade legal valeu a dica aí até esquecido disso aí eu tenho aqui esse código tá simplesinho aqui só pra gente eh ver o que que é que a gente consegue ver esses elementos que eu falei lá né então eu falei que tem uma árvore né ali no meio falei que tem um iu código yuk que é gerado né e ah a gente vai conseguir ver também a diferença do código né do bte Code que é gerado com sem otimizações né enfim vamos colocar um pouquinho a mão na massa aqui então vou pegar esse teste pon sol aqui e vou compilar ele tá

Então primeiramente que eu vou compilar ele e vou pedir Olha só vou só mostrar essa aast que eu comentei lá deixa jogar ela para um arquivo de texto aqui tá pra gente conseguir ver que eu tô [Música] falando es que seja mais uma opção aqui legal tá todas as opções pessoal

são opções do compilador que eh Vocês conseguem configurar tá aqui eu tô colocando direto na na linha de comando ã mas por exemplo se você der um você eh olhar na documentação né tal o próprio help aqui do do compador Mostra todas asas opções para nós então aqui voltando né naquela árvore que eu comentei tá Ah então aquele código né que a gente tá tem aqui ó ele foi transformado numa árvore né então não sei se todo mundo eh familiarizado com uma árvore né mas basicamente o que a gente vai ter né É

no caso lá né Tem um contrato né então tem um contrato C aqui ó e aí dentro dele eu tenho aquela função f e eu tenho o o x né então a árvore é essa estrutura aqui ó né acho que todo mundo às vezes já viu alguma coisa desse tipo né então ele vai tendo eh ele vai eh criando tá o compilador solite ele cria essa representação então lá tem uma coisa acontecendo assim né de né Depois eu vou voltar lá né mas tem um X isso aqui é um mais tá pessoal aí feio aí pode falar essa aí é

a abstract syntax 3 certo essa é a abstract syntax 3 tá que ele gerou para nós aqui ó tá nesse nesse arquiv eh se a gente olhar aqui ó tem todos aqueles Nós tá que eu desenhei aqui né esses nós aqui né o c aí dentro do contrato C eu tenho a variável x né a função f certo dentro de F eu tenho Ah uma atribuição né que tem de um lado x e de outro lado uma adição né E essa adição tem um x e um y Então tudo isso ele transforma numa estrutura que tem mais ou menos esse formato aqui que eu desenhei certo e isso aqui tá descrito né de forma textual aqui nesse Jon Então

se a gente olhar aqui tem aqui eh aqui ó né o contrato C né então o contrato C né o esse nó ele tem um tipo né que é a definição de um contrato e aí a gente tem várias outras informações que tão aqui né como por exemplo eh essas informações aqui elas são eh importantes paraas ids por exemplo né então lá na sua ide quando ela eh acessa lá o a função quando você clica na função ela tia lá na definição né todas essas informações ela busca aqui dessa as né Então essa essa ess ela a né ela não é só uma representação intermediária né ela também ela vai persistir inclusive lá no no pipeline vaiar porque ela carrega eh informações

eh de forma estruturada né Eh eh para próxima etapa que é a c Generation né então geralmente todo trabalha com uma estrutura desse tipo tá com uma árvore assim então aqui a gente pode vai poder inspecionar ela ã mais a tipo de curiosidade assim tá pessoal isso aqui como eu falei mais utilizado por debuggers verificadores às vezes pode fazer algum tipo de verificação formal utilizando isso também né mas aí a gente pode então visualizar e esse tipo de coisa tá com compilador só para começar a mostrar algum opções que a gente tem que às vezes são

desconhecidas ou inexploradas então Eh continuando aqui né Vamos falar vamos ver aqui um pouquinho mais sobre os pipelines né que eu comentei eh acho que eu vou vou aumentar aqui também um pouquinho o meu meu terminal Ach control mais funciona também funciona também ainda não tá funcionando control shift mais talvez testar esse

aqui é não mas acho que agora tá legal né ã então outra coisa aqui que dá para fazer também né É vamos vamos testar aqui os os pipelines as otimizações Ah então por exemplo quando a gente eh só pega o o pipeline eh o Legacy né que eu chamei que a gente chama lá de Legacy a gente consegue já ver uma diferença nas otimizações então eu vou mandar compilar eh o nosso teste PS e agora vamos ver o o bite code dele né que ele vai gerar ã esse aqui é o é o binário mesmo né vamos ver aqui o assembly né então

esse vamos dar uma olhada lá no vs code esse aqui ó né é o resultado ó né o assemble né O que vai ser executado lá na IVM eh de verdade né então H isso aqui é o Né praticamente o código de máquina né que a IGM executa certo então às vezes o pessoal também gosta de dar uma inspecionada aqui para ver o que tá acontecendo ver Às vezes se dá para eh às vezes algum problema de eh stack Deep Às vezes a gente tem que dar uma inspecionada aqui e ver o que tá

acontecendo aí que é um nível muito baixo né Eh de abstração né pessoal aqui é um nível muito baixo Mas é isso aqui efetivamente que é é o resultado aí do compilador solite tá então se a gente prestar atenção aqui né perceber aqui esse código aqui ele é bem longo né para aquela para para esse código aqui que é relativamente simples né Tem uma atribuição e uma eh soma acontecendo é uma função e uma variável aqui no Storage E aí ele gera né bastante código tá tem aqui 298 linhas de código aí né Do do do

do do assemble gerado Vamos colocar aqui então o optimize n só PR a gente ter uma noção o que que acontece com esse eh esse arquivo né com esse o código que vai ser gerado agora com as otimizações Então já diminuiu bastante né ã mas a gente vê que ele cria né Essas várias tags aqui ó tá vendo essas várias tags aqui para quem conhece assembly sabe né que é é um bloco que é como se fosse uma função Zinha né Um bloco que vai ser referenciado em algum lugar você vai ter um Jump né falando para vir aqui para essa tag né e muitas vezes né

Engraçado que essas tags são Jumps para outras tags né então mesmo às vezes com eh as otimizações ligadas a gente tem eh como eu falei né o p que ele ainda pode ser eh melhorado ainda então a gente pode Esse é o pipeline Legacy né então a gente pode ativar agora o outro pipeline n como eu comentei utilizando a opção E aí ele vai utilizar agora o outro pipeline que primeiro compila né através a partir do código gera o

código pois gera o código Solid né Inclusive a gente pode até pedir primeiro tá pro compilador mostrar aqui para nós e a representação intermediária tá o código iu que ele tá gerando né E aí no caso aqui eu não preciso nem colocar porque como eu tô pedindo a representação intermediária que é o iu ele vai obviamente compilar aí para essa representação ação Tá então vamos dar uma olhadinha aqui como é que fica esse U que ele gerou tá Então olha só a partir né agora

no no pipeline do Viar a partir do código solidity ele gerou esse código iu né então todo c u Ele tá contido em um ou em um objeto principal né E pode ter outros sub objetos então aqui a gente tem eh né Se a gente for fazer um contraste com o bite code o né na forma do assembly lá que a gente viu Eh aqui agora a gente tem eh um nível de abstração maior né mais alto então a gente tem funções eh atribuições a as instruções da IVM elas são eh referenciadas aqui como né funções que

recebem parâmetros então é mais fácil até até mesmo pra gente inspecionar Esse código né ã então o objetivo do iu é é é realmente esse né é ser realmente uma uma representação intermediária que facilita a otimização pelo computador mas facilita também né a intervenção humana eh aqui eh fazer uma otimização manual ou também principalmente fazer uma auditoria certo pessoal então aqui a gente vamos dar uma olhada aqui tá tem muita coisa acontecendo aqui também né para aquele eh código simples Tá mas

a gente vai perceber que o compilador ele gera várias funções né Eh engraçadas né assim vamos dizer né Por exemplo essa função aqui né shift left zer né é uma função que pega um valor transforma ele eh fazendo um shift eh do zero né tantas vezes esse valor n Então faz enfim né o código né com as otimizações a gente vê que esse tipo de coisa que some né ou esse tipo de coisa aqui eh por exemplo vira só isso né ã vira só essa operação direto tá sem ter uma função Ah uma atribuição para um novo valor e etc

e tal né e outras coisas aí vamos dizer assim mais complexas acontecendo no meio do caminho então Eh colocar aqui jogar um parâmetro né o optimiz aqui porque aí ele vai mudar aqui pra gente então vou pedir aqui agora né Essa representação intermediária mais otimizada tá então esse aqui é outro parâmetro que o compador também aceita né PR gente V aquele código iu lá eh otimizado né E aí o có deu para ver que ele é menor e ele tem bem menos funções tá né Apesar de que a função que

eu falei que ia desaparecer eh não desapareceu né mas é com certeza né É algumas outras funções aqui alum eh outras coisas aí ele eh consegue colapsar consegue remover eh e tudo isso pode ser eh a gente pode ajustar né tudo isso pessoal que aí eh é a próxima parte que eu queria trazer aqui também pra gente pode falar Robson tem alguma pergunta no chat Essas funções ir aparece todosos contratos eh independentemente de serem usadas Não elas vão ser

Eh vamos dizer assim específicas né ou dependentes do do contrato que contrato solite que foi é passado compilador tá geralmente tem coisas né que são vamos dizer assim que sempre aparecem né então por exemplo essa primeira parte toda vez que a gente olha Às vezes a a primeira parte de um contrato né Deploy dele sempre tem esse TR de código aqui ó n sempre tem esse MS Store aqui aqui então às vezes tem coisas que vamos dizer assim tem alguns né que ele gera né Essas funções no final das quas elas são todas helpers né que ele vai

gerando que elas vamos dizer assim são universalmente utilizadas né lá aquele MS Store que eu comentei lá né sempre aparece né Se você pegar qualquer contrato compilar você sempre vai ver que tem esse MS Store aqui tá eh então assim tem algumas coisas que às vezes você vai ver que elas estão sempre aparecendo Tá mas é porque elas são utilizadas beleza Então essa aqui é a etapa intermediária né pessoal aí como eu comentei essa parte aqui do iu é mais quando a gente tem algum eh algum motivo muito específico mesmo de inspecionar de fazer alguma intervenção manual aqui alguma otimização aqui ou de fazer até mesmo

auditoria né mas é só pra gente poder ver que realmente eh no nesse pipeline né então ele vai passar primeiramente aí por o pelo iu e depois ele vai gerar ã o byte code né então a gente tem aqui né esse esse primeiro bite code aqui que foi gerado pelo nosso pipeline Legacy otimizado né eh e aí eu vou gerar aqui então um outro né bite code ali ou ou na verdade ali eu tava mostrando a assembly né

E aí eu vou chamar ele de colocar aqui e a gente pode dar uma olhada nele também Então olha só né aí olhando aqui assim dá pra gente ter uma noção então do vamos dizer assim do do ganho né do que o pipeline vai ardar pra gente então no

final né a gente teve aqui o assembly da IVM gerado pelo pipeline do Viar com né 60 linhas de código aqui vamos falar né e do pipeline Legacy né os dois com otimizações as otimizações padrões Ele é cinco vezes maior né ele tem aqui 200 né 300 300 linhas de código certo ã Então esse esse é o poder né do do pipeline do vi e é por isso que e o plano é que ele se torne aí e no futuro aí breve o vamos dizer assim a opção

né a desvantagem eh que é importante comentar é importante est ciente é que a compilação ela ela vai demorar mais né o pipeline vaiar ele demora consideravelmente eh mais do que o pipeline legas dependendo do projeto às vezes pode ficar é às vezes pode pode ser uma coisa que impacta né porque eh e aí o que que assim eu não eu não tenho exatamente os números aqui né pessoal mas eh Que tipo de impacto aí no tempo de compilação que eu tô falando né às vezes questão de coisa de eh Uma Questão de eh às vezes duas ou três vezes mais né o tempo de compilação eh alguns casos extremos eh talvez até quatro ou cinco

então como eu falei dependendo do projeto seu projeto demora 2 minutos TRS 5 minutos para compilar às vezes é OK você esperar 10 20 minutos né mas tem projetos que demoram eh às vezes né mais uma hora para compilar E aí isso isso vai ter um impacto considerável eh o o time Tem trabalhado tá trabalhando ativamente nisso né porque a gente quer que esse pipeline seja o o defo então a gente tá trabalhando para para melhorar isso Eh mas mas eh o ganho né ele ele é ele é inegável né então uma coisa que que pode ser feita se você tem um projeto que quando você

compi pelo Viar demora muito né uma coisa que você pode fazer é o seguinte né você deixa para compilar ele só Realmente na hora que você vai eh eh você vai você vai fazer o Deploy mesmo né Você vai precisar né você não compila ele eh em desenvolvimento né ou quando você compila ele em desenvolvimento Ah você não usa o pipeline ir né vai a ã porque muitas vezes a gente tá né só e eh testando né se e o comportamento é o mesmo tá eu esqueci de comentar quando eu falei dos pipelines apesar de serem dois pipelines diferentes pessoal eh o comportamento deles é sempre o mesmo tá você sempre apesar do b c o assembly Né

o evm b ser diferente o resultado final é sempre o mesmo tá isso aí é Garantido e a gente tem testes né Eh inclusive testes testes semânticos verificação formal que a gente usa para garantir que o aportamento permanece então Eh em desenvolvimento você não vai eh em muitas situações você não vai eh você não vai ter nenhuma diferença né compilar ele no Legacy né do comportamento que você vai observar do que você compilar ele pro varar só que na hora de realmente eh fazer o Deploy né implantar aí sim você vai ter uma diferença significativa

eh que vale a pena o tempo de compilação né então só é é comentar isso né Eh porque é eh né a gente sempre tem uma vantagem mas pagando um preço né e mas como eu falei a gente tá trabalhando aí para para melhorar isso para que realmente essa seja opção padrão eh todo mundo posso usar né ã Então pessoal né então deu para deu para ter uma noção aqui né e acho que se alguém né para quem não tava tava sabendo né ou a gente não sabia Dá pra gente explorar aí e aí eh outra coisa que eu queria comentar é ah Mateus mas eh como é que eu sei isso né como que

sabe né como é que eu faço eh tudo isso tá eu vou vou mostrar aqui para vocês né fazer questão de mostrar né todas as opções elas estão eh aqui no acho que eu tinha até uma uma sessão aqui anteriormente né que eu já tenho tudo aberto eh mas tudo ISO tá tá aqui na nossa documentação tá se você abre a documentação oficial aí do solite tá você eh vi aqui de lado e procurar aqui o otimizador aqui ó otimizador né Na parte de internals eh tudo né então todas essas opções elas

vão estar eh descritas aqui tá pessoal né todas as opções que você precisa para ativar E aí já entrando né No No No próximo assunto que eu queria falar eh falar sobre né esses detalhes das otimizações né E otimizações que eh vão estar acontecendo aí né Existem algumas otimizações que que são ligadas né que acontecem vamos dizer assim por padrão tá você só consegue eh eh desligar elas eh através aí do do que eu vou mostrar aqui para vocês né que é essa interface input output aí do Jon tá então por exemplo o PIP hle né que ele faz

otimizações do tipo eh né esse tipo de otimização aqui ó né então se a gente olhar aqui no nesse código assembly né ele tem essa instrução aqui né para duplicar né a instrução que tá acima dele né então isso aqui na verdade Originalmente tá Originalmente isso aqui era era isso aqui né Tá então uma uma das otimizações que aquele ppv lá faz é que ele vê esse tipo de coisa aqui ele fala assim ah é mais barato ao invés de ter essas duas coisas aqui é eu mandar duplicar esse zero que tá aqui na pilha né No stack que isso aqui é um P zero né Eh tem essa instrução lá tá enfim é mais

barato eu fazer isso aqui né Apesar de que se for um zero mesmo tá p agora com a nova versão do cancu aí é o contrário né Mas aí o compilador consegue eh levar isso em consideração né quando ele gera o código né se eu gerar se eu compilar esse código aqui usando a versão do Cancun né ele vai tá com outro zero aqui acho que na última aqui a gente não vai conseguir gerar mas vamos ver se consigo mostrar isso aqui agora né outra né E aí já aproveito para mostrar né a gente também pode né selecionar qual versão que você você quer mas acho que geralmente a Às vezes a ide né Ela faz isso para

você é não não entrou aqui enfim ã É acho que não deu não deu para observar isso que eu falei né que eu comentei Eu tenho certeza já tá também implementado aqui nessa versão latest né ah mas quando entrar aí a cancom virar defo né esse tipo de coisa vai vai mudar né a gente vai ter um pouquinho uma melhora um pouquinho nos cursos de de gas aí por causa do do P zer que tá entrando mas esse é outro assunto que eu tô eh né divergindo aí tá outra otimização né que eu acho interessante comentar aí por padrão né que que até

foi uma otimização que foi eh inserida recentemente tá pessoal essa do antique loop né então agora né Às vezes o pessoal Às vezes a gente fazia eh quando queria fazer um loop né você colocava um ã ess pessoal usava aquele padrão de ter um um bloco unchecked né então ao in vez de de incrementar o i aqui certo porque ess esse incremento aqui eh toda vez ele vai ser checado para ver se não tem um overflow né se isso aqui não tá estourando o valor máximo do I por exemplo né se seesse I for um Ops se o I for um í de 8 eh bytes

né certo então aí para evitar o custo aqui de checar porque um in de 8 bytes nunca vai exceder 10 o tamanho 10 né então para evitar o custo de ficar checando ali um custo eh e é é redundante a gente ficar checando ali se a variável i deu um overflow não era vir aqui colocar isso aqui dentro de um bloco unchecked né E e aí você fazia aqui o eh o incremento aqui certo ah agora isso isso não você não precisa mais fazer esse tipo de coisa o compilador eh em casos como esse né que eu tô mostrando aqui

ah em que a variável que tá sendo incrementada ela também tá sendo testada aqui na condição do do bloco tá e quando ela tá sendo testada com um literal ou com um valor que você tem certeza eh que nunca vai dar overflow certo aí o compilador consegue eh remover os os cheques aqui né de overflow né então são otimizações que o computador já faz por padrão Tá mas tem como a gente desligar ou ligar e mudar todas as otimizações também pessoal através eh né de detalhes do otimizador então a gente consegue fazer um um

ajuste fino certo então aqui na documentação descreve eh tá pessoal quais são espaços de otimização que o compilador usa no caso do pipeline u né do pipeline vi certo ele também descreve do do Legacy Ok mas as opções do Legacy eh elas são bem limitadas né então isso vai ser o Esse controle esse ajuste Fin dos detalhes ele vai ser mais interessante ah pro pipeline R então aqui a gente consegue ver todos os passos do pipeline ar tá na otimização Ah tem uma breve explicação

sobre que que eles fazem eh alguns TM exemplos Ok e a gente consegue então utilizar um Jon né em que a gente ã né esse esse que é esse é o Standard input output interface então compilador solite recomenda que quando você vai fazer esse tipo de coisa esse ajuste fino ou vai fazer uma operação mais complexa no seu projeto você eh utilize esse arquivo aqui de configuração né configurar quais são e as fontes configurar algumas coisas eh algumas outras

eh aluns outros parâmetros né Como por exemplo o otimizador qual que vai ser o pipeline tá então como eu falei o Viar né ele tá desligado por padrão então se você quiser ligar ele você precisa explicitamente falar isso né a gente consegue falar da da versão né talvez você já viu esse tipo de coisa aí então aqui na sessão do otimizador a gente consegue então ajustar alguns detalhes dele né então por exemplo no pipeline Legacy se a gente for lá na documentação a gente consegue ver quais

são eh os módulos que existem tá então basicamente ele tem iner e aquele unchecked loop que eu comentei tem na na parte da da interface vou mostrar aqui aqui né então tem também tá pessoal tá essa sessão aqui OK você for aqui na using the compiler tem essa sessão aqui ó compiler input

Jon description que é isso que eu tô comentando tá então aqui todas as opções estão descritas tá e explicadas Então se a gente aqui a gente consegue ver né Então olha só eh né nas opções do otimizador nos detalhes a gente pode então ligar né ou desligar o piple que é aquele eh que faz pequenas otimizações ali em texos de código de eh três quatro ou cinco instruções tá o inliner inliner ele que que ele faz ele detecta eh funções pequenas que podem ser colocadas diretamente no código né Então em vez de ter uma chamada de função né uma função que vai ser três linhas de código ele consegue fazer o inline delas ali colocar elas direto ali ao invés de

ter uma ah função sendo chamada né ã outro aqui que eu vou comentar né o o o o d duplicador de blocos né então às vezes a gente tem função que elas são a princípio diferentes mas que elas fazem a mesma coisa né ou às vezes elas são completamente iguais né então eu poderia ter uma função aqui vou dar um exemplo bastante bobo tá trivial pessoal mas a gente poderia ter uma função aqui que né soma o x com 1 e a gente poderia ter uma outra função aqui que incrementa ele né Elas são funções diferentes você tem

o mesmo resultado compilador consegue detectar esse tipo de coisa tá e consegue eh D duplicar isso tá então ele que que ele consegue fazer onde aparece por exemplo a função G E aí onde aparece depois a função H ali ó ele consegue eh né no processo de compilação do bcode ele consegue fazer com que uma dessas funções seja removida e toda eh menção a função H na verdade eh se já vamos dizer assim apontada paraa função G né porque o resultado final das 12 é o mesmo eh pode falar aí [Música]

thago cara uma pergunta Tipo ele consegue identificar se uma função ou tipo ela é duplicada para um cenário específico tipo para um caso específico e pros outros infinitos não é porque daí talvez não seja nem bom mexer né entendi Se você falar que fosse por exemplo uma coisa assim deixa eu ver se é isso que você tá falando aqui ó né em vez de ser um x + 1 ali é um X + Y aqui eh mas a única menão que eu tenho pro H é o h com 1 não sei se é isso que você tá falando

é é se a única menção for H1 acho que fica igual mas se sei lá tiver um fora aí e passa pro H1 sabe é não então é como eu falei o compilador ele detecta Se o se o comportamento se ele pode igualar aquelas duas coisas ele tem um módulo tá que que a gente pode também até inclusive ligar e desligar que é esse aqui ó esse CSE aqui ó é o com sub Expression elimination esse módulo ele é o mais complexo né tá até comentado que ele é o mais complexo mesmo H do otimizador por quê Porque ele faz vamos dizer assim ele faz todo um processo de de eh criar classes de equivalência entre as expressões então

eh ele é o esse módulo por exemplo ele consegue reconhecer eh que essas duas expressões aqui elas são equivalentes tá eh então assim eh se se realmente aquela então assim é num nível é que eu falei que né que são duas funções iguais né na questão do do do de duplicar né mas ele ele ele tudo isso é feito Eh vamos dizer assim quem faz o trabalho de Base é aquele CSE lá e aquele CSE ele trabalha no nível de expressões né então para ele falar que essa função é igual a essa é porque todas as expressões dela eh São equivalentes né então no caso aqui né se fosse uma coisa assim né

porque ele viu que falou assim não realmente todas as pressões são equivalentes se existe um caso em que elas podem ser diferentes tá aí ele não faz né Por exemplo acho que eu entendi mais ou menos o que você falou se a gente tivesse aqui um if e vamos dizer if x menor que 10 eu incremento aliás vamos começar assim né if true né então se eu ten aqui um if Pô eu posso falar que esse H é é equivalente ao G realmente né porque isso aqui sempre vai acontecer da mesma forma que isso aqui sempre vai acontecer Provavelmente o compilador consegue detectar isso tá até porque eh antes do

do do CSE detectar que eles são equivalentes né Tem tem eh etapas do compilador que vão detectar que esse esse teste que é desnecessário é E vai vai vai remover ele tá então tem etapas também que vão vão detectar isso né E vão vão transformar isso aqui nisso né Ah então aí por exemplo nesse caso ele falaria Agora se a gente tivesse trabalhando né num outro cenário em que eh talvez é o que você tava falando né nem sempre vai ser né nem sempre vai ser eh então aqui o compilador ele ele nunca vai vai eh falar que essa expressão né esse sequência de expressões é igual a essa sequências

expressões tá eh se isso se is acontecendo é um bug n se tiver acontecendo é um bug a gente tem que consertar Com certeza não sei se ficou respondido ficou ficou boa boa Legal legal eh então tem V vários eh eh tá só vários módulos várias etapas do do otimizador né e aqui eu tô olhando aqui na na na sessão do Jon input tá mas aí na sessão do otimizador aqui ó tá elas estão todas elas estão descritas tá o inline o que que ele faz eh o o Constant optimizer também tem a

sessão que descreve ele tá então tem tem várias etapas que eh Opa perdão que acontece a otimização perdi aqui onde eu tava Eh que que acontece tem várias etapas aqui né de otimização tá desculpa né Por exemplo aqui né outra que eu queria aumentar nessa daqui do do incremento do for tá ela também tá aqui a gente pode ligar ou desligar ela né Por padrão ela tá sempre ligado né elizer ah se eu não me engano Block de duplicator também tá mas aqui então a gente consegue fazer esse controle fino e se a

gente tiver utilizando o pipeline vaiar né a gente consegue ligar aqui então ou eh selecionar quais vão ser as etapas de otimização no vi e aí as etapas de otimização no Viar tá elas estão aqui ó né Elas têm você coloca letras para quais são os passos que você quer que sejam executados certo ã pode falar Guilherme eu tinha deixado aí no chat mas assim eh diga Digamos que você eh executou ali 20 vezes o in liner né a a partir de um momento o aquele liner

ele vai ele eh vai ficar eh essa troca né vai ficar pesada ao ponto de você ter que eh usar que seja melhor usar um Jump né entendi eh para uma função então assim é sem sem eh quando você usa o inline ele tem alguma inteligência que vê assim ó quando que que o o inline ficaria melhor ou quando que o que o Jump ficaria melhor sim sim não sim o Ele só faz o inline de um bloco de uma função eh o custo de de de tá lá né as instruções em Line inline né ali é menor do que o do jump entendeu então na

prática Ele só faz um inline de funções muito muito pequenas tá de de de blocos que só tem duas ou três instruções é isso é interessante porque às vezes a gente fica com medo de quebrar uma lógica que ela seja muito pequena e para ter uma legibilidade melhor no no código solidity e por receio de gas e tal ah at Jump tal e essa dominar esse inline daí é interessante tipo porque assim no na camada mais alta ali você tem você tem uma legibilidade melhor né você consegue separar melhor a as coisas

que você tá fazendo mas assim o que tá acontecendo por debaixo você não precisa se preocupar né sim sim é E aí É acho que é importante frisar que quando eu tô falando né dessas otimizações e por exemplo doline de um bloco com duas ou três instruções né eu tô falando de instruções eh deu ou ou bite code mesmo né no caso ali o inliner ele trabalha no nível do bite code né então Eh o que eu que eu recomendo é assim a princípio Eh claro né assim né e seguindo você você não vai também procurar fazer a coisa do do jeito mais e eh mais Custoso né mas assim a princípio acho que assim às vezes super se

preocupar demais com otimizações né é um pouco prematuro né então eh eu acho que assim é interessante usar esses usar o otimizador do compilador eh fazer o ajuste através desses detalhes aqui testar uma uma outra configuração diferente eh primeiro do que partir às vezes para vamos dizer assim para uma otimização agressiva ou uma otimização mesmo eh no nível do Solid tá e como eu falei né claro né a gente não quer ficar também fazendo coisa vamos dier assim que desnecessária né mas acho que também é ficar se preocupando em otimizar enquanto você você eh faz o código

solite eh eu acho que tem que ter um momento separado entendeu E a nesse momento separado você inclusive fazer os testes utilizando esses detalhes aqui né Eh mudando flags aqui tá de otimização beleza ficou respondido legal legal tá então aí como eu falei né pessoal tem até eh alguns detalhes aqui que eu que eu passei não comentei né mas esse essa Flag por exemplo Run né Ela é uma Flag aqui que que dá uma vamos dizer assim fala quantas vezes dá a intensidade que você espera que seu contrato vai ser executado né então se você tem um contrato que ele vai ser executado só

uma vez né ele só vai fazer um Deploy só vai fazer uma vez né então você coloca o parâmetro aqui por exemplo um pro otimizador aí o otimizador ele vai ele vai entender o quê ele vai falar assim ah esse código aqui ele não vai ser executado muitas vezes então é mais interessante fazer otimização com um viés né buscando um tamanho de código menor certo economizar no no no tamanho do código do que economizar no custo de gás daquele código né porque eu vou rodar ele só uma vez certo agora quando eu coloco um valor de Run maior aí o compilador vai pro outro lado ele fala assim não eh eu vou sacrificar um pouco

do tamanho do do código mas mas eu vou ter um código que eh e que custa menos gás né para executar eh pode falar aí que tinha alguém querendo perguntar hoje eu aprendi porque eu sempre Achava que esse parâmetro runs aí era a quantidade de vezes que o otimizador ia rodar em cima do mesmo código tipo ficar tentando de novo de novo de novo otimizar algo que já foi otimizado não não é é não uma dúvida e tem como você configurar isso por Contrato ou é uma configuração que ela tem que ser tipo porque assim

pensando no caso né bem que você passa um contrato por vez né pro compilador né Eu acho que aí seria mais o nível do Framework a conseguir definir isso por diferentes contratos é é uma boa pergunta aí [Aplausos] Felipe eu acho eu não tenho certeza mas eu acho que você não não consegue definir isso por contrato tá eh Pelo menos nada que indica que você pode fazer isso até porque aqui na nossa no nosso input aqui né h a gente vai ter essa sessão aqui dos sources que a gente

vai falar Quais quais são os nossos eh né os nossos arquivos aqui tá então eu acredito que a gente não consegue fazer essa essa distinção por artigo não mas é uma bo pergunta é É pensando assim né Às vezes você tem alguns contratos que estão no hotp e outros contratos eles estão Sei lá só para inicialização ou então assim ah vão ser usados muito raramente ali então interessante ter né essa possibilidade é às vezes acho que às vezes a solução seria fazer né uma compilação separado aí se for possível né Aham interessante É acho que com o

founder dá para usar uns profiles diferentes se for o caso é entendi talvez ele consegue ele consiga fazer isso criar essas essas compilações em etapas Diferentes né mas no final das contas é integrar aí tudo como se fosse um sol pô Rob achei o tema pro próximo meetup found interessante eu nunca usei Prof cara fazer umas coisas legais versão diferente de compiladores e tal já salvou minha vida já Bom tema aí bom tema pras próximas né então voltando aqui né pessoal pra

gente finalizando aqui então aí a gente tem as flags aqui do do do pipeline do viir né do i1 eh Opa então aqui agora a gente consegue vir aqui e olhar né Cada Flag dessa tá aqui na sessão do U né I base do optimizer aqui tá dentro da sessão do do otimizador E aí cada né letrinha daquela lá vai ser uma etapa de otimização do e u certo e aí aqui a gente também consegue ver né Por exemplo deixa eu pegar um que

a gente ainda não comentou né mas ele tem várias eh Talvez seja mais simples né mas por exemplo Dead code eliminator tá então às vezes até mesmo como um subproduto da otimização a acaba que fica funções que estão sobrando né que elas que elas não são chamadas que elas acabam sendo né eliminadas certo e aí então essa etapa aqui ela ela elimina ã né então o que eu o que eu recomendo aqui o que eu queria comentar aqui dessa desses optimizer steps aqui do pipeline vi é o seguinte que se você eh deixar isso aqui em branco tá o compilador ele

tem uma sequência padrão que ele usa tá que é essa sequência aqui eu vou até abrir aqui uma essa ISO aqui do do projeto né que é exatamente o que eu comentei né que a gente tá investigando maneiras de fazer eh com que esse pipeline de otimização seja mais rápido né Então essa daqui é a é a a sequência padrão do compilador tá então é interessante até ver ela para ver o que que o compilador faz né Por padrão Mas é interessante também ah testar né e e e buscar eh talvez eh sequências diferentes pro seu projeto tá

uma coisa que eu queria chamar atenção aqui é pro seguinte Eh toda vez que a gente tem um um né isso aqui tá escrito na na na documentação né cada letra dessa é uma etapa né E quando eh você tem a letra dentro dos colchetes né quer dizer que aquela etapa vai ser repetida tá até que você não tenha nenhuma melhora ou até que ele eh eh atinga o número máximo que é 12 tá então até acho foi foi a pergunta do Felipe aí ou enfim foi o comentário do de alguém aí que falou que achava que o Run né era Quantas vezes o otimizador ia rodar né não mas o otimizador ele tem os seus limites internos né que ou ele vê que

não tá tendo melhora tá ou então ele chega aí eh nesse limite aí de 12 eh e iterações para cada passo né E aí ele para tá Então essa daqui é a sessão a sequência padrão né de etapas de otimização que o compador usa mas como eu falei né essa etapa aqui ela é essa essa essa sequência aqui tá de Passos pessoal de etapas ela é uma sequência que como ela é a sequência padrão ela vai procurar abranger né de maneira geral todos os projetos né A maioria dos projetos tá então até por isso que às vezes ela é um

pouco lenta né então o por isso que é por isso que é legal por isso que é interessante né num momento separado né quando você tiver aí fazendo uma análise do seu código de pontos que você pode melhorar as coisas é também ter uma uma etapa que você dá uma uma Eh vamos dizer assim uma brincada aqui né então você mexe aqui em alguns parâmetros tá troca a ordem tira alguns Loops né Eh e vê os resultados no seu eh projeto certo eh e aí pessoal isso aqui também é assim eh tá são detalhes que são mais avançados né Eu até deixei aqui mais pro final e e não não vou ficar entrando em

detalhes de cada um desses Passos tá eh porque assim são são coisas mais avançadas mesmo né E são coisas que de novo elas estão acontecendo tá não no nível do Solid tá elas estão acontecendo ou no nível do iu né tá ou no nível do da IVM by code tá do assemble certo mostrar aqui para vocês O Iu tá tá acontecendo aqui tá pessoal nesse nível do iu certo ou tá acontecendo aqui mesmo no nível tá do do aqui Ok eh tá só pra gente não fazer nenhuma

confusão aí eh e achar que À vezes ele tá trabalhando aqui eh no meu contrato ah ele tá né Apesar de que o que você escreve aqui no nível do solite né vai se refletir lá no código I né no código no no B code final Ok eh bom então tô e vou vou Encerrando por aqui tá pessoal essa essa apresentação essa toque tô aberto aí algum mais dúvidas aí que eventualmente Alguém tem para perguntar agora no final eh mas quem quiser depois entrar em contato perguntar falar mais eh alguma coisa comentar tá aí meu e-mail no mais agradeço aí o Robson agradeço aí todo o

pessoal aí que faz parte aí do do rsc55 e eh agradeço aí a atenção todo mundo que compareceu aí muito obrigado e estamos junto Valeu acho que tinha alguém que queria perguntar Henrique Valeu Mateus Valeu op eu queria só para para finalizar eh primeiro obrigado pela apresentação eh muito bom aprendi um bagulho assim que é só ler a a porcaria da documentação mas eu acho que sei lá 90% das pessoas que eu conheço acham que o o runs é aquilo que eu falei tá ligado de

rodar o otimizador várias vezes eh uma dúvida que eu tenho em relação a isso você mencionou que tem alguns testes de teste Não mas é verificação formal né sim e ferramentas que vocês usam para fazer verificação formal e tipo como que é feito esse processo tipo é feito testando tipo com differential test testando contra o o pipeline Legacy ou ele é tipo um form verification tipo first principles al tipo tem lá as spec e tal tem a gente usa tá aí tem um projeto né Tem um SMT checker tá que porque existe o time deificação formal

da etério tá então o time de verificação formal da etum trabalha em parceria com nós eh e tem uma uma vamos di assim uma uma ferramenta uma biblioteca do compilador que é o SM checker que ele faz essa verificação formal para para nós então ele usa alguma Engine de verificação formal por exemplo tem o eh C CVC ch4 Z3 tá eh que são são engines verificação formal então Eh eles ele tem lá especificação E aí basicamente o que elas fazem é tipo assim né grosso modo elas testam né

todos as possibilidades né então se você tem lá um código lá um x+ 1 né ele testa lá todas as possibilidades para ver se o seu x+ 1 é passa né Tá ok ã então se você quiser dar uma olhada nisso você pode procurar aí tá eh SMT checker tá lá no repositório ãã pode E aí você vai ver isso que eu tô comentando deixa eu escrever aqui tá eh puts né tá você olhar lá tem essa lá tem ess SMT checker ã E aí é isso que a gente usa ela tem

uns alguns testes lá no no repositório Beleza boa valeu tem uma que eu acho que conecta um pouco com essa cara eh eu já vi aí no eh tanto deves dizendo que não ligam o otimizador quanto auditores às vezes falando sabe que pode acontecer alguma coisa no processo de otimização então eles recomendam deixar desligado mas eu sempre fiquei encucado com isso porque eu nunca vi na verdade um caso né em que o otimizador sabe resultou num negócio muito diferente Ou algum bug sei

lá Existe algum caso assim tem sentido essa preocupação e existe algum exemplo de sei lá que o otimizador errou por exemplo e causou algum problema em produção alguma coisa assim olha Eh essa preocupação ela não é en fundada tá claro o otimizador ele tá transformando o código né Eh mas da mesma forma também sem otimizar o Né o Code generator do compador ele também pode gerar um código e errôneo tá e a bugs existem e já ocorreram bugs no cod já ocorreram bugs e no otimizador Ok eh felizmente nenhum

desses bugs foram bugs e críticos nenhum foram bugs assim sempre sempre geralmente são são bugs que são e situações muito específicas né corner cases eh então assim Apesar de que não é uma preocupação en fundada e eu acho que que ela não eh né na minha avaliação ela não vale o custo né então você não não vale o custo de você né otimizar seu código eh porque com com né o receio de acontecer alguma falha tá e você perder as coisas mas

eh é como eu disse não é enfundado não é enfundado Tá mas mas eu eu recomendaria deixar ligo otimizador é eh eh enfim é é meio que isso né porque como eu falei até o cachame pode ter uma falha né sim valeu é no caso dos pond duros eu acho que vale ligar sempre né ô eu acho que em geral Vale sim tá Vale sim faz uma auditoria Bem Feita tá tranquilo é muita gente recomenda além da auditoria né você fazer formal verification nos próprios contratos Com certeza aí você elimina esse esse

problema relativo ao optimizer mas é é bem é bem controverso sim porque cara é o tipo de problema que assim basta um problema para ferrar muita coisa né então a galera em geral eles preferem pecar pelo lado do excesso de cautela do que contrário né aí acaba a gente não acaba não usando o optimizer por conta disso entendo não é eu entendo até porque a gente tem vários casos aí né de falhas críticas em outras plataformas aí que resultaram né em em perdas aí de né milhões né então eu entendo e Acho que cada caso é um caso né Ah acho que tem ter mais o Thiago tá

como levantado aí de T um [Música] tempo hum é nada a ver com com tema não tá vocês dão Se quiserem alguma outra pergunta relacionada eu na verdade só queria saber porque cara em algum momento eu li sobre um tal de U mais isso existe como desculpa e o mais tipo você mais mais u mais é não ouvi falar de mais não não tô sabendo ó se você não ou faz um tempinho Faz tempinho mas assim é como é enfim open source é código Alberto né Você pode criar uma um iu mais né Aham não tipo só ouvi falar mesmo não tem nem é poderia existir mas assim não é uma

coisa que tá partindo de ass deum sorit não tá tá Opa eh eh tão me ouvindo pessoal Opa beleza pode falar op Oi Mateus aqui é o Jeff eh queria te agradecer porque você não sei se o pessoal sabe mas acho que quando uma vez vi alguma coisa no gith Hub é do Mateus e E aí eu vi que acho que ele tinha acabado de entrar na equipe do do Solid aí convidei ele para fazer parte lá do grupo né de do de devis e sempre O Mateus foi muito gentil e E participar topou na hora e compartilh tava lá no

grupo com a gente também compartilhando e também agora super também super bacana e super generoso de compartilhar esse essa talca aqui com a gente então queria te agradecer aí Mateus pela pela pela palestra aí por sempre est disposto aí em colaborar com a gente não demorou Obrigado Jeff Parabéns aí também pela iniciativa aí de montar o grupo e tal eh assim eu eu não eu não não olho muito mas sempre que me marcam lá eu eu eu olho lá e Procuro sempre dar uma resposta né Eh enfim para cá na nossa comunidade aí que principalmente que não nós aqui né no Brasil América Latina a gente esteja cada vez mais forte aí é

isso aí estamos juntos Ô Mateus eu tenho uma outra pergunta um pouco fora do desculp tão técnico assim eh queria ouvir a opinião de você lá do do que você da do pessoal que você acessa né do dia a dia ali das conversas paralelo Qual que é a visão que você tem eh sobre o custo alto que a gente tem que eu acho que isso é uma das grandes Barreiras de entrada hoje em desenvolvimento de smart Contract de segurança né n o Henrique comentou aí da verificação formal seria excelente que todo mundo fizesse verificação para mas é inviável E aí a gente fica naquela

ovo galinha né Putz Eu Preciso lançar um código bom para ter usuário formalmente é aí eu fico tipo ah eu preciso lançar um código bom para te usurio usá mas eu preciso de dinheiro primeiro dinheiro demais então para mim é uma grande barreira de entrada hoje esse custo de segurança né Como que você enxerga isso assim eu eu vejo assim a min a minha visão é que e eu acho que é um relacionado com o que eu comentei um pouco no início né acho que eu vejo que a área é uma área que é muito nova né então eh eh sei lá fazendo uma uma metáfora uma analogia aí meio louca né a

gente chegou em entendeu em outro planeta né Eh inabitado e Mas cheio de coisa para explorar né cheio de coisa para descobrir cheio de coisa para ser feita eh então assim né tem tem tem muita coisa para ser explorada muita coisa para ser feita mas a gente acabou de chegar né a gente acabou de chegar e e então é mequis a gente tá um pouco nesse momento ainda mesmo né assim essa é a minha visão n a gente tá um pouco nesse momento ainda em que vai ser necessário um esforço Vai ser necessário eh um pouco de tempo para as coisas maturar pra gente ter por exemplo mais

ferramentas eh automatizadas de verificação formal pra gente ter mais mais gente mais auditor na área mais gente trabalhando nisso eh e e e eu acho que que assim né a web3 né a cripto a gente tá tá numa Vanguarda né a gente tá numa Vanguarda porque eh no dia a dia né a galera não a galera assim tem uma visão até folclórica vamos dizer né quando quando a gente fala de cripto de web TR de blockchain né e é uma coisa que ainda tá muito longe né de uma realidade cotidiana e eu acho que até mesmo no no norte Global né lá lá

nos Estados Unidos na Europa tudo né Apesar de que tá um pouco mais próximo do que para nós aqui no sul Global mas mesmo assim a gente ainda tá numa Vanguarda né a gente tá o que a gente tá construindo aqui e eu acredito é é coisa que a gente tá construindo né a fundação de de coisas que vão que vão vão tá Eh vamos dizer assim florescendo que vão estar se desenvolvendo mesmo daqu 10 15 20 anos né Eh eu vejo assim que eh né Inclusive a gente vê assim até questões do né que o Brasil tá fazendo né o com a com a implatação lá do do real real digital né Eh mas enfim eh São coisas que assim eu acho que que né

Eh eu acho que é isso né A minha perspectiva É essa a gente tá na Vanguarda a gente tá eh desenvolvendo trabalhando explorando uma área muito recente né muito recente eh então assim ainda é muito marcada Realmente acho que assim é uma coisa própria do momento a gente ainda tem muitas incertezas Sabe tem muitas preocupações com segurança eh enfim eu acho que é isso eh assim né A minha visão eu acho que assim a minha visão é é uma visão né como eu comentei da minha história da minha trajetória na na3 é uma visão assim né bastante até limitada né como eu falei eu caí de para-quedas no meio do né no meio do negócio e então eu eu tenho muita coisa

que eu olho em volta que eu tô aprendendo é muito novo para mim também então acho que é isso que essa que é a minha perspectiva aí Legal boa ô legal Mateus agradecer também complementando as palavras do Jeff aí eh obrigado demais por ter topado o convite Compartilhar esse tipo de conhecimento né se saber se o lit já é 1% aí do mundo isso aqui é ainda muito mais limitado que nem o Henrique comentou do runs né um detalhe que você fala Putz mesma a gente trabalhando alguns anos aqui com com Solid fala ah nunca parei para ler a documentação do compilador esses optimizers aí né

É legal legal que bom que bom que deu para para chamar a atenção eh eh e trazer vamos dizer assim mais eh né mais mais levar isso mais às claras aí né trazer atenção trazer os olhos aí do pessoal parece para esses detalhes eh Que bom fico muito satisfeito aí de tá contribuindo agradeço aí de novo pelo pelo pelo seu convite valeu