A reescrita do Bun em Rust é um feito impressionante
MMaximilian Schwarzmüller
Computing/SoftwareSmall Business/StartupsInternet Technology
Transcript
00:00:00O BUN foi portado de SIG para Rust.
00:00:02Você provavelmente já ouviu falar disso,
00:00:04mas há muito o que analisar aqui.
00:00:06Houve muito drama na semana passada,
00:00:08mas há muitas coisas interessantes acontecendo.
00:00:10E não importa se você se interessa por BUN, SIG ou Rust,
00:00:14isso é realmente interessante.
00:00:15Também sobre como a IA foi aproveitada
00:00:18e o que isso pode significar para projetos semelhantes
00:00:20em nossa indústria em geral.
00:00:22Agora, apenas como uma pequena observação,
00:00:24eu pessoalmente gosto bastante do BUN.
00:00:26É o meu runtime de JavaScript padrão que uso
00:00:29na maioria dos meus projetos.
00:00:30E, de fato, como uma boa coincidência,
00:00:32publiquei um curso novo sobre BUN na semana passada.
00:00:35E ele funciona, é claro, para a versão Rust
00:00:37assim como funciona para a versão SIG.
00:00:39Então, se você quiser mergulhar um pouco mais no BUN
00:00:41e aprender sobre todas as APIs principais que ele tem a oferecer,
00:00:44porque essa é uma das maiores vantagens do BUN,
00:00:46o fato de ter tanta coisa integrada.
00:00:48Algumas pessoas não gostam, eu adoro.
00:00:50Se você quiser aprender mais sobre isso,
00:00:51esse curso pode ser interessante.
00:00:53Mas vamos dar uma olhada mais de perto
00:00:54na linha do tempo geral da portabilidade, que tal?
00:00:58Na verdade, aconteceu há dois meses.
00:01:01Então, a postagem no blog foi lançada na última semana de julho,
00:01:04mas a portabilidade em si aconteceu em maio.
00:01:08E começou no início de maio,
00:01:10quando o branch CloudFaserPort foi descoberto
00:01:13no repositório oficial do BUN no GitHub.
00:01:15Esse branch continha um arquivo MD de portabilidade,
00:01:18um arquivo markdown com instruções
00:01:21sobre como converter código SIG para código Rust,
00:01:23como portar esse código, tabelas de tradução,
00:01:27e instruções gerais.
00:01:28E voltaremos a falar sobre como esse arquivo foi criado,
00:01:30porque, é claro, a IA esteve envolvida,
00:01:32como você pode imaginar, um pouco mais tarde.
00:01:34Isso foi descoberto.
00:01:36Então, naturalmente, surgiram discussões no Hacker News e no X.
00:01:40E havia pessoas entusiasmadas com isso.
00:01:43Havia pessoas muito críticas a isso.
00:01:46Mas naquele momento, não sabíamos muito.
00:01:47Obviamente, há muita polarização em torno do Rust.
00:01:52Há pessoas que amam o Rust, como eu.
00:01:55Há pessoas que odeiam o Rust.
00:01:57Há pessoas que odeiam
00:01:58que tudo deva ser reescrito em Rust,
00:02:00porque muitas vezes você lê
00:02:03que as pessoas querem que o programa XYZ seja reescrito em Rust.
00:02:06E eu entendo que isso é irritante.
00:02:08Mas, naturalmente, por isso,
00:02:09havia muita polarização acontecendo.
00:02:11Mas a portabilidade ainda não tinha acontecido.
00:02:15Isso mudou mais tarde, em maio.
00:02:16E no dia 14 de maio, um pull request oficial foi aberto,
00:02:22e então, também mesclado,
00:02:24que realmente migrou a base de código do BUN,
00:02:28toda ela, de SIG para Rust.
00:02:30Agora, como você pode ver, é um pull request enorme.
00:02:32Mais de um milhão de linhas de código foram adicionadas.
00:02:35E a remoção do código SIG aconteceu
00:02:39em uma fase diferente.
00:02:40Então, sim, é por isso que não é uma troca.
00:02:42Mas é uma mudança enorme, como você pode ver,
00:02:44com quase 7.000 commits.
00:02:46Agora, naturalmente, esse código não foi revisado por humanos,
00:02:51pelo menos não inteiramente.
00:02:52Foi revisado por IA.
00:02:54Passou nos testes, mas não foi revisado por humanos.
00:02:59E voltaremos a falar sobre como a IA foi usada em um segundo.
00:03:02Mas isso foi publicado ou mesclado.
00:03:06E, claro, mais discussões surgiram agora.
00:03:08Como acabei de mencionar, não foi revisado por humanos.
00:03:10Isso é impossível de fazer nesse prazo, é claro.
00:03:14Mas a comunidade mergulhou nisso, deu uma olhada
00:03:17e analisou as partes.
00:03:19E então houve outro, ou uma primeira postagem no blog,
00:03:23não a oficial com todos os detalhes,
00:03:25mas uma primeira postagem ou declaração lançada pelo Buntine
00:03:29sobre o uso de “unsafe”.
00:03:32Porque uma grande crítica que surgiu após esse pull request
00:03:37é que o código Rust ali não era um Rust idiomático.
00:03:41Não era o tipo de código Rust que você escreveria ou deveria escrever
00:03:44se estivesse construindo isso do zero.
00:03:46Em vez disso, parecia realmente uma tradução de SIG para Rust.
00:03:50E isso significava que nem todas as melhores práticas
00:03:54e padrões de Rust foram usados.
00:03:55E, especialmente, havia uma quantidade razoável
00:03:58de uso de “unsafe” ali.
00:04:00Agora, para entender “unsafe”, você precisa entender
00:04:03como o Rust gerencia a memória,
00:04:05porque essa é uma de suas maiores vantagens,
00:04:08e é bem diferente de outras linguagens.
00:04:10Porque na maioria das linguagens, você tem um garbage collector,
00:04:14que é um processo que basicamente detecta
00:04:16quando um valor não é mais usado em lugar nenhum do programa
00:04:19e então libera a memória, o que é conveniente,
00:04:21mas consome recursos extras.
00:04:24Ou você tem que fazer isso sozinho.
00:04:26Em linguagens como C, por exemplo,
00:04:28você tem que alocar e liberar memória manualmente.
00:04:31E é o mesmo no SIG.
00:04:33Você pode alocar memória lá, mas também precisa chamar “free”
00:04:37ou você tem que liberá-la quando não precisar mais dela.
00:04:40Você pode usar “defer”, o que é bom.
00:04:43Isso significa basicamente que você pode chamar isso
00:04:47antes de ser realmente executado.
00:04:49É adiado e será chamado automaticamente
00:04:52quando esse escopo terminar, essencialmente.
00:04:55E isso é bom porque existem situações diferentes
00:04:58onde um valor pode não ser mais necessário.
00:05:00Mas, ainda assim, quando você tem que limpar a memória manualmente,
00:05:04existem muitas situações
00:05:05onde você pode dar um tiro no próprio pé.
00:05:07Você tem um controle mais refinado
00:05:09e isso pode ser muito útil, muito eficiente,
00:05:11mas também é fácil esquecer situações
00:05:15em programas mais complexos
00:05:16onde você pode não estar limpando a memória,
00:05:19portanto, introduzindo um vazamento de memória,
00:05:20ou onde você pode estar limpando duas vezes,
00:05:23o que também causará um erro.
00:05:25E, portanto, há um compromisso.
00:05:27E o Rust tem uma abordagem diferente.
00:05:30No Rust, você tem um conceito chamado propriedade,
00:05:32o que significa que cada valor tem exatamente um proprietário,
00:05:36e ele está vinculado ao escopo.
00:05:38Então, se você tem um escopo,
00:05:39e você pode criar um escopo usando chaves,
00:05:41ou uma função também teria seu próprio escopo.
00:05:43Você pode conhecer esse conceito do JavaScript.
00:05:46Se você tem um escopo,
00:05:47então quando um valor é criado ali,
00:05:49ele pertence a esse escopo.
00:05:51E se o escopo terminar, ele é liberado.
00:05:53E isso, é claro, é muito conveniente
00:05:55porque você não precisa se preocupar em liberá-lo.
00:05:58Você também não tem um garbage collector.
00:06:00Em vez disso, você tem essa regra clara.
00:06:02Isso pode levar à complexidade em programas mais complexos
00:06:05onde você precisa passar valores por aí.
00:06:07Você pode fazer isso no Rust,
00:06:08mas requer uma maneira diferente de pensar.
00:06:11Mas, claro, isso lhe dá segurança de memória,
00:06:14a menos que você use a palavra-chave “unsafe”.
00:06:19Se você usá-la, pode criar um escopo inseguro.
00:06:22E lá, essas regras não se aplicam mais.
00:06:24E então é seu trabalho garantir
00:06:26que a memória seja gerenciada de forma adequada.
00:06:28Agora, por que você faria isso?
00:06:29Bem, por exemplo,
00:06:31se você estiver importando alguma biblioteca C,
00:06:33o que você pode fazer no Rust,
00:06:34você pode mesclar algum código C, por assim dizer,
00:06:37ou chamar alguns métodos e funções da biblioteca C,
00:06:40então, como C é naturalmente inseguro,
00:06:44o código onde você alcança esse código C também é inseguro.
00:06:48Então você precisa desse recurso para interagir com nosso código inseguro.
00:06:52E essa também é uma coisa que eles observaram
00:06:54nessa declaração oficial,
00:06:56que todos esses usos inseguros na base de código
00:07:00em uma parte decente estavam, na verdade, relacionados a chamadas,
00:07:04para outras bibliotecas, bibliotecas C e assim por diante,
00:07:07o que não mudará.
00:07:08Mas eles também identificaram áreas
00:07:10onde eles poderiam realmente melhorar o código
00:07:13e se livrar do “unsafe”.
00:07:14E mencionaram que fariam isso
00:07:15em pull requests subsequentes.
00:07:18E eles fizeram e ainda estão fazendo isso.
00:07:20Então, você pode pensar nessa porta inicial
00:07:22como um ponto de partida,
00:07:24que então foi refinado ao longo do tempo.
00:07:26Ainda vale a pena mencionar que este pull request inicial,
00:07:28ou aquele enorme pull request,
00:07:30já tinha testes passando.
00:07:32Então era estável, os testes estavam passando,
00:07:35mas o código não tinha a qualidade de código
00:07:37que você talvez esperasse se fosse escrito em Rust
00:07:40desde o início, porque esse não era o objetivo.
00:07:43Então, isso foi em 21 de maio.
00:07:45Depois houve silêncio.
00:07:46E também vale a pena notar que esta versão do BUN
00:07:49ainda não foi lançada.
00:07:50E quando estou gravando isso, ainda não está disponível.
00:07:52Quando você instala o BUN agora,
00:07:54você ainda está obtendo a versão SIG,
00:07:56mas isso deve mudar a qualquer dia.
00:07:58Mas então, no dia 8 de julho,
00:07:59a postagem oficial no blog foi lançada
00:08:02onde encontramos muitos detalhes interessantes
00:08:04sobre essa porta.
00:08:06E realmente vale a pena ler.
00:08:07Vou colocar o link abaixo
00:08:08porque há muito o que aprender aqui.
00:08:11Toda essa portabilidade, e isso não é segredo,
00:08:13foi feito com a ajuda de IA.
00:08:15Vale lembrar que o Bun pertence à Anthropic.
00:08:18Então, eles tiveram acesso livre a todos aqueles tokens
00:08:22e, especialmente, ao Claude 3.5
00:08:24antes de ele ser lançado ao público.
00:08:26Essa migração foi feita com o Claude 3.5.
00:08:29E, a propósito, se você estiver instalando o Claude Code agora,
00:08:32mesmo que o Bun 1.4, a versão em Rust, ainda não tenha sido lançada,
00:08:36o Claude Code já está rodando em cima
00:08:39de uma versão do Bun ainda não lançada, por assim dizer,
00:08:42que é a versão em Rust.
00:08:44Então, é isso.
00:08:45Mas sim, essa migração foi feita com o Claude Code
00:08:48com base no Claude 3.5, com tokens gratuitos, é claro,
00:08:52essencialmente, já que o Bun faz parte da Anthropic.
00:08:54E isso é importante ter em mente,
00:08:56porque naquele post do blog,
00:08:58aprendemos que se você combinasse todos os tokens,
00:09:03ou se somasse todos os tokens
00:09:04que foram gastos cobrando os preços da API,
00:09:08toda essa migração teria custado cerca de 160 mil dólares.
00:09:13É um número impressionante, mas, na verdade,
00:09:18se você pensar na escala desse projeto,
00:09:20e a escala é que o Bun tinha 535 mil linhas de código em Zig,
00:09:26se você pensar nessa escala
00:09:28e em quanto tempo levaria para humanos migrarem isso para Rust,
00:09:32então os 160 mil dólares talvez não pareçam tão ruins,
00:09:36dependendo de onde você está.
00:09:38No entanto, fica claro que nenhum projeto de código aberto
00:09:43seria capaz de fazer isso.
00:09:44E a maioria das empresas provavelmente não seria capaz
00:09:47ou não estaria disposta a gastar essa quantia em uma migração.
00:09:50Isso é possível porque o Bun faz parte da Anthropic.
00:09:54E, claro, isso também é uma boa jogada de marketing
00:09:58para a Anthropic.
00:09:59Essa talvez não tenha sido a intenção principal.
00:10:03Eu não sei disso.
00:10:04Mas, claro, é um bom marketing.
00:10:06Tudo isso é importante ter em mente.
00:10:08No entanto, nesse post do blog,
00:10:10podemos aprender como o Jared fez essa migração
00:10:14ou como ele fez essa migração funcionar.
00:10:18E tudo começou com aquele arquivo de migração MD,
00:10:21que ele criou em uma discussão com o Claude,
00:10:25em uma discussão de três horas,
00:10:26como ele mencionou no post do blog,
00:10:28onde ele essencialmente decidiu junto com o Claude Code
00:10:32e os modelos da Anthropic,
00:10:35como um arquivo de migração MD teria que ser
00:10:37para conseguir traduzir o código Zig para Rust.
00:10:40Então, uma vez que ele iterou sobre isso e ficou satisfeito,
00:10:44ele testou inicialmente em três arquivos.
00:10:46E uma vez que ficou satisfeito com isso,
00:10:48ele liberou o Claude em toda a base de código do Bun.
00:10:53Agora, nesse post do blog,
00:10:54ele deixa claro que não apenas pediu ao Claude
00:10:57para reescrever o Bun em Rust, não se engane,
00:11:00mas que, em vez disso, ele montou um sistema elaborado
00:11:03onde ele tinha um agente principal,
00:11:07acionando subagentes também, é claro,
00:11:09fazendo a migração de acordo com o arquivo de migração MD.
00:11:13E então ele tinha dois agentes de revisão adversários
00:11:16que revisavam o trabalho daquele agente principal assim que terminava
00:11:19e forneciam feedback,
00:11:21e depois um agente de correção para aplicar esse feedback.
00:11:24E ele deixou tudo isso rodando em um loop
00:11:25e, claro, distribuído por várias árvores de trabalho
00:11:30para processar toda a base de código
00:11:33e trabalhar nela.
00:11:35No post do blog,
00:11:35ele mencionou que reescreveu o Bun em Rust
00:11:38usando 50 fluxos de trabalho dinâmicos no Claude Code,
00:11:40que são esses fluxos de trabalho que acionam muitos subagentes
00:11:43ao longo de 11 dias.
00:11:46E ele também tem um gráfico legal lá.
00:11:48Em geral, no post do blog,
00:11:49há gráficos bonitos lá
00:11:51que facilitam um pouco a digestão,
00:11:53que mostram a quantidade de commits que foram criados
00:11:56e então enviados nos diferentes dias
00:11:58e nos horários do dia.
00:12:00Então tudo isso aconteceu com a ajuda de loops no Claude Code,
00:12:04com a ajuda de muitos subagentes
00:12:05e o processo claro de um agente principal,
00:12:08os agentes de revisão e o agente de correção.
00:12:10E ele também fez outro caminho separado
00:12:15para, por assim dizer, fazer todos esses testes funcionarem.
00:12:20E isso trouxe seus próprios desafios
00:12:22porque o conjunto de testes é tão grande e complexo
00:12:25que ele encontrou várias restrições de infraestrutura
00:12:29porque alguns testes consomem muita memória
00:12:31e rodar muitos testes em paralelo,
00:12:33portanto, não funciona.
00:12:34Mas, finalmente, ele fez tudo isso funcionar também com a ajuda de IA,
00:12:39rodando os testes, corrigindo o código,
00:12:42rodando os testes novamente e assim por diante.
00:12:43Então, muitos loops, muitos agentes e subagentes envolvidos,
00:12:47naturalmente, e muitos tokens queimados.
00:12:49165 mil dólares em tokens queimados.
00:12:53Agora, novamente, você pode mergulhar mais fundo,
00:12:55e é isso que eu recomendaria fazer
00:12:57se você estiver interessado em todos os detalhes técnicos.
00:12:59É um ótimo post de blog documentando a jornada até lá.
00:13:03Mas, em resumo, é assim que a migração aconteceu ao longo de 11 dias
00:13:08com todos esses agentes e subagentes distribuídos em vários fluxos de trabalho,
00:13:1250 desses fluxos de trabalho, como aprendemos ao longo de 11 dias,
00:13:17165 mil dólares gastos em tokens a preços de API.
00:13:24Agora, finalmente, uma vez que ele terminou o post do blog,
00:13:29ele mencionou que o Bun 1.4 corrige vários bugs que a última versão em Zig tem,
00:13:35que é mais eficiente em memória e que é menor.
00:13:38E como aprendemos com a resposta de Andrew Kelly, o criador do Zig,
00:13:43algumas dessas melhorias poderiam ter sido alcançadas com o Zig também.
00:13:47Mas esse post do blog é bastante interessante porque foi editado.
00:13:53Está menos cheio de raiva agora do que inicialmente.
00:13:57A primeira versão estava cheia de ataques pessoais,
00:14:00apenas para dizer que não foi um ataque pessoal,
00:14:03mas estava cheio de ataques pessoais.
00:14:05A versão mais recente, que também vou linkar abaixo, ainda é bem ácida.
00:14:11No final, você pode ver claramente ao ler a primeira versão,
00:14:14mas também nesta versão,
00:14:16que Andrew, o criador do Zig, e Jared, o criador do Bun,
00:14:21não se tornarão melhores amigos novamente.
00:14:26Agora, ele agradece ao Bun por apoiar o Zig, inclusive financeiramente,
00:14:31apenas para basicamente ficar furioso com toda essa migração e como ela não teria sido necessária
00:14:41se o código do Bun tivesse sido escrito em Zig adequado.
00:14:44Ele deixa muito claro que não acha que o repositório do Bun,
00:14:48a versão em Zig, tivesse uma alta qualidade de código e que isso levou a muitos problemas.
00:14:53E isso pode ou não ser verdade.
00:14:56Acho absolutamente possível que em um projeto da escala do Bun,
00:15:01movendo-se na velocidade em que o Bun se move,
00:15:06a qualidade do código pode não ter atingido os padrões do criador do Zig.
00:15:12Você poderia definitivamente argumentar que a maioria dos projetos de código
00:15:15não tem necessariamente a mais alta qualidade de código, no entanto.
00:15:18Então você pode inventar o que quiser.
00:15:21Agora, vou deixar por isso mesmo.
00:15:24Sinto que o post de resposta no blog é bastante fraco
00:15:29porque está fervendo de raiva.
00:15:33Ele tem alguns pontos válidos.
00:15:35Como, por exemplo, no post que o Jared faz,
00:15:40ele menciona que a migração de Zig para Rust foi validada,
00:15:46claro, com todos esses agentes revisores,
00:15:48mas também rodando o conjunto de testes e fazendo tudo funcionar.
00:15:51E Andrew afirma corretamente que, claro, esse mesmo conjunto de testes
00:15:56deveria ou não ter sido suficiente para provar que a versão em Zig é ótima.
00:16:00Então, talvez o conjunto de testes devesse ter sido melhorado também.
00:16:04De qualquer forma, definitivamente esses dois não se tornarão melhores amigos.
00:16:09E não tenho opinião sobre se Zig ou Rust é a melhor linguagem em geral ou para o Bun.
00:16:17Acredito, no entanto, que com a IA, o Rust, seu modelo de memória e o fato
00:16:23de você obter erros de compilação para muitos problemas relacionados à memória é uma grande vantagem,
00:16:30especialmente na era da IA, porque, claro, toda essa migração é realmente impressionante
00:16:38quando se trata do uso de IA.
00:16:41E claro, é uma maneira de usar IA que a maioria de nós não conseguirá pagar
00:16:45ou não estará disposta a pagar nas empresas.
00:16:48Mas é impressionante que ele tenha conseguido fazer isso.
00:16:52E não é 'vibe coding' ou apenas 'YOLO prompting'.
00:16:56Existe um processo claro por trás de tudo isso.
00:16:59Muito pensamento foi colocado nisso, o que espero ter deixado claro, o que definitivamente também fica claro
00:17:05se você mergulhar nos detalhes técnicos.
00:17:08Mas com todo o planejamento, toda a iteração com a configuração, com a forma como isso foi abordado,
00:17:13claramente isso não foi apenas um prompt lançado.
00:17:17E veremos onde chegaremos, isso mostra o que você pode fazer com a IA.
00:17:21E, claro, migrar uma base de código de uma linguagem para outra é um caso de uso muito bom para a IA.
00:17:27Se você pensar bem, a IA pode, é claro, ter dificuldades em escrever código novo.
00:17:32Ela pode não escrever o código que você queria escrever, não seguir as convenções de código
00:17:36ou estilos que você queria seguir, e também pode estragar as coisas.
00:17:40Agora, definitivamente a IA é incrível para construir novos softwares também.
00:17:43Mas você enfrenta um conjunto diferente de problemas lá com uma migração.
00:17:47A grande vantagem é que você tem uma base de código para a IA apenas olhar e traduzir,
00:17:53que é algo que a IA pode fazer, e você tem um conjunto de testes lá.
00:17:57Então, há muito para construir.
00:17:59É um bom caso de uso para a IA, ao que parece, e como essa migração prova claramente.
00:18:04E acho que essa é a lição mais interessante aqui.
00:18:08Também que você pode enfrentar projetos que simplesmente seriam impossíveis
00:18:12de enfrentar antes.
00:18:13Novamente, não para todos, mas para certas empresas de certos tamanhos.
00:18:18Isso pode ser interessante.
00:18:19Modernizar softwares legados com a ajuda de IA pode ser um ótimo caso de uso.
00:18:26E isso mostra e prova que isso pode ser feito.
00:18:30Agora, claro, o Bun 1.4 ainda não foi lançado.
00:18:32Veremos se tudo trava e eles precisam reverter daqui a um mês.
00:18:36Você não pode descartar totalmente, mas eu pessoalmente não acho que isso acontecerá.
00:18:40Ele já está sendo usado em produção por alguns usuários pioneiros, como o CLI do Claude Code.
00:18:47Ele foi testado e revisado extensivamente, embora, claro, por IA, não por revisores humanos.
00:18:54Mas estou bastante confiante de que isso funcionará e considero um feito bastante impressionante e também um uso bastante impressionante de IA.
00:19:03Mas, como sempre, também estou interessado em saber quais são seus pensamentos sobre tudo isso.