La reescritura de Bun en Rust es un logro impresionante
MMaximilian Schwarzmüller
Computing/SoftwareSmall Business/StartupsInternet Technology
Transcript
00:00:00BUN fue portado de SIG a Rust.
00:00:02Probablemente ya hayas oído hablar de eso,
00:00:04pero hay mucho que analizar aquí.
00:00:06Ha habido mucho drama la semana pasada,
00:00:08pero están ocurriendo muchas cosas interesantes.
00:00:10Y sin importar si te interesa BUN, SIG o Rust,
00:00:14esto es realmente interesante.
00:00:15También con respecto a cómo se aprovechó la IA
00:00:18y lo que eso podría significar para proyectos similares
00:00:20en nuestra industria en general.
00:00:22Ahora, solo como una pequeña nota al margen,
00:00:24personalmente me gusta bastante BUN.
00:00:26Es mi entorno de ejecución de JavaScript predeterminado que uso
00:00:29en la mayoría de mis proyectos.
00:00:30Y, de hecho, como una buena coincidencia,
00:00:32publiqué un curso nuevo sobre BUN la semana pasada.
00:00:35Y por supuesto, funciona para la versión de Rust
00:00:37igual que para la versión de SIG.
00:00:39Así que si quieres profundizar un poco más en BUN
00:00:41y aprender sobre todas las API principales que tiene para ofrecer,
00:00:44porque esa es una de las mayores ventajas de BUN,
00:00:46que tiene muchas cosas integradas.
00:00:48A algunas personas no les gusta, a mí me encanta.
00:00:50Si quieres aprender más sobre eso,
00:00:51ese curso podría ser interesante.
00:00:53Pero echemos ahora un vistazo más de cerca
00:00:54a la cronología general de la portabilidad, ¿te parece?
00:00:58En realidad ocurrió hace dos meses.
00:01:01Así que la publicación del blog salió la última semana de julio,
00:01:04pero la portabilidad en sí ocurrió en mayo.
00:01:08Y comenzó a principios de mayo,
00:01:10cuando la rama CloudFaserPort fue descubierta
00:01:13en el repositorio oficial de GitHub de BUN.
00:01:15Esa rama contenía un archivo MD de portabilidad,
00:01:18un archivo markdown con instrucciones
00:01:21sobre cómo convertir código SIG a código Rust,
00:01:23cómo portar ese código, tablas de traducción,
00:01:27e instrucciones generales.
00:01:28Y volveremos a cómo se creó ese archivo,
00:01:30porque por supuesto, la IA estuvo involucrada,
00:01:32como habrás adivinado, un poco más tarde.
00:01:34Eso fue lo que se descubrió.
00:01:36Así que, naturalmente, surgieron discusiones en Hacker News y en X.
00:01:40Y hubo gente entusiasmada por eso.
00:01:43Hubo gente muy crítica al respecto.
00:01:46Pero en ese momento, no sabíamos mucho.
00:01:47Obviamente, existe mucha polarización en torno a Rust.
00:01:52Hay personas que aman Rust, como yo mismo.
00:01:55Hay personas que odian Rust.
00:01:57Hay personas que odian
00:01:58que todo debería ser reescrito en Rust,
00:02:00porque muy a menudo lees
00:02:03que la gente quiere que el programa XYZ sea reescrito en Rust.
00:02:06Y entiendo que esto es molesto.
00:02:08Pero naturalmente, por lo tanto,
00:02:09había mucha polarización allí.
00:02:11Pero la portabilidad aún no había ocurrido.
00:02:15Eso cambió más tarde en mayo.
00:02:16Y el 14 de mayo, se abrió una solicitud de extracción oficial,
00:02:22y luego también se fusionó,
00:02:24que realmente migró la base de código de BUN,
00:02:28toda, de SIG a Rust.
00:02:30Ahora, como puedes ver, es una enorme solicitud de extracción.
00:02:32Se añadieron más de un millón de líneas de código.
00:02:35Y la eliminación del código SIG ocurrió
00:02:39en una etapa diferente.
00:02:40Así que sí, por eso no es un intercambio.
00:02:42Pero es un cambio enorme, como puedes ver,
00:02:44con casi 7,000 confirmaciones.
00:02:46Ahora, naturalmente, ese código no fue revisado por humanos,
00:02:51al menos no completamente.
00:02:52Fue revisado por IA.
00:02:54Tenía pruebas que pasaban, pero no fue revisado por humanos.
00:02:59Y volveremos a cómo se usó la IA en un segundo.
00:03:02Pero eso fue publicado o fusionado.
00:03:06Y, por supuesto, siguieron más discusiones ahora.
00:03:08Como acabo de mencionar, no fue revisado por humanos.
00:03:10Eso es imposible de hacer en ese marco de tiempo, por supuesto.
00:03:14Pero la comunidad profundizó y echó un vistazo
00:03:17y analizó partes.
00:03:19Y luego hubo otra, o una primera publicación de blog,
00:03:23no la oficial sobre todos los detalles,
00:03:25sino una primera publicación o declaración lanzada por el equipo de BUN
00:03:29sobre el uso de "unsafe".
00:03:32Porque una gran crítica que surgió después de esta solicitud de extracción
00:03:37es que el código Rust allí no era Rust idiomático.
00:03:41No era el tipo de código Rust que escribirías o deberías escribir
00:03:44si estuvieras construyendo esto desde cero.
00:03:46En cambio, realmente fue como una traducción de SIG a Rust.
00:03:50Y eso significaba que no todos esos procedimientos recomendados y patrones de Rust
00:03:54fueron utilizados.
00:03:55Y especialmente, hubo una cantidad considerable
00:03:58de uso de "unsafe" allí.
00:04:00Ahora, para entender "unsafe", tienes que entender
00:04:03cómo Rust gestiona la memoria,
00:04:05porque esa es una de sus mayores ventajas,
00:04:08y es bastante diferente de otros lenguajes.
00:04:10Porque en la mayoría de los lenguajes, tienes un recolector de basura,
00:04:14que es un proceso que básicamente detecta
00:04:16cuando un valor ya no se usa en ninguna parte del programa
00:04:19y luego libera la memoria, lo cual es conveniente,
00:04:21pero consume recursos adicionales.
00:04:24O tienes que hacerlo tú mismo.
00:04:26En lenguajes como C, por ejemplo,
00:04:28tienes que asignar y liberar memoria manualmente.
00:04:31Y es lo mismo en SIG.
00:04:33Puedes asignar memoria allí, pero también tienes que llamar a "free"
00:04:37o tienes que liberarla cuando ya no la necesites.
00:04:40Puedes usar "defer", lo cual es bueno.
00:04:43Eso básicamente significa que puedes llamar a eso
00:04:47antes de que realmente se ejecute.
00:04:49Se difiere y se llamará automáticamente
00:04:52cuando este ámbito termine, esencialmente.
00:04:55Y eso es bueno porque hay diferentes situaciones
00:04:58donde un valor puede ya no ser necesario.
00:05:00Pero aun así, cuando tienes que limpiar la memoria manualmente,
00:05:04hay muchas situaciones
00:05:05donde puedes dispararte en el pie.
00:05:07Tienes un control más preciso
00:05:09y eso puede ser muy útil, muy eficiente,
00:05:11pero también es fácil olvidar situaciones
00:05:15en programas más complejos
00:05:16donde luego puedes no estar limpiando la memoria,
00:05:19por lo tanto introduciendo una fuga de memoria,
00:05:20o donde puedes estar limpiando dos veces,
00:05:23lo cual también causará un error.
00:05:25Y, por tanto, hay una compensación.
00:05:27Y Rust tiene un enfoque diferente.
00:05:30En Rust, tienes un concepto llamado propiedad,
00:05:32que significa que cada valor tiene exactamente un propietario,
00:05:36y está ligado al ámbito.
00:05:38Entonces, si tienes un ámbito,
00:05:39y puedes crear un ámbito usando llaves,
00:05:41o una función también tendría su propio ámbito.
00:05:43Puede que conozcas ese concepto de JavaScript.
00:05:46Si tienes un ámbito,
00:05:47entonces cuando se crea un valor allí,
00:05:49es propiedad de ese ámbito.
00:05:51Y si el ámbito termina, se libera.
00:05:53Y eso, por supuesto, es muy conveniente
00:05:55porque no tienes que preocuparte por liberarlo.
00:05:58Tampoco tienes un recolector de basura.
00:06:00En su lugar, tienes esa regla clara.
00:06:02Eso puede llevar a la complejidad en programas más complejos
00:06:05donde necesitas pasar valores.
00:06:07Puedes hacer eso en Rust,
00:06:08pero requiere una forma diferente de pensar.
00:06:11Pero, por supuesto, te da seguridad de memoria,
00:06:14a menos que uses la palabra clave "unsafe".
00:06:19Si usas eso, puedes crear un ámbito inseguro.
00:06:22Y allí, esas reglas ya no se aplican.
00:06:24Y entonces es tu trabajo asegurarte
00:06:26de que la memoria se gestione adecuadamente.
00:06:28Ahora, ¿por qué harías eso?
00:06:29Bueno, por ejemplo,
00:06:31si estás usando alguna biblioteca de C,
00:06:33lo cual puedes hacer en Rust,
00:06:34puedes mezclar algo de código C, por así decirlo,
00:06:37o llamar a algunos métodos y funciones de la biblioteca C,
00:06:40entonces como C es naturalmente inseguro,
00:06:44el código donde accedes a ese código C también es inseguro.
00:06:48Así que necesitas esa función para interactuar con nuestro código inseguro.
00:06:52Y eso también es una cosa que señalaron
00:06:54en esa declaración oficial,
00:06:56que todos esos usos de "unsafe" en la base de código
00:07:00en una parte decente estaban realmente relacionados con llamadas,
00:07:04a otras bibliotecas, bibliotecas de C, etcétera,
00:07:07lo cual no cambiará.
00:07:08Pero también identificaron áreas
00:07:10donde realmente podrían mejorar el código
00:07:13y deshacerse de "unsafe".
00:07:14Y mencionaron que harían esto
00:07:15en solicitudes de extracción posteriores.
00:07:18Y lo hicieron y todavía lo están haciendo.
00:07:20Así que puedes pensar en esta portabilidad inicial
00:07:22como un punto de partida,
00:07:24que luego se refinó con el tiempo.
00:07:26Aún vale la pena mencionar que esta solicitud de extracción inicial,
00:07:28o esa enorme solicitud de extracción,
00:07:30ya tenía pruebas que pasaban.
00:07:32Así que era estable, las pruebas pasaban,
00:07:35pero el código no era de la calidad de código
00:07:37que tal vez esperarías si estuviera escrito en Rust
00:07:40desde cero, porque ese no era el objetivo.
00:07:43Así que eso fue el 21 de mayo.
00:07:45Luego hubo silencio.
00:07:46Y también vale la pena señalar que esta versión de BUN
00:07:49no se ha lanzado todavía.
00:07:50Y cuando estoy grabando esto, todavía no está activa.
00:07:52Cuando instalas BUN ahora mismo,
00:07:54todavía obtienes la versión de SIG,
00:07:56pero eso debería cambiar en cualquier momento.
00:07:58Pero luego, el 8 de julio,
00:07:59se publicó la entrada oficial del blog
00:08:02donde encontramos muchos detalles interesantes
00:08:04sobre esta portabilidad.
00:08:06Y realmente vale la pena leerlo.
00:08:07Lo enlazaré a continuación
00:08:08porque hay mucho que aprender aquí.
00:08:11Toda esta portabilidad, y eso no es ningún secreto,
00:08:13se realizó con la ayuda de la IA.
00:08:15Vale la pena recordar que BUN es propiedad de Anthropic.
00:08:18Así que tuvieron acceso libre a todos esos tokens
00:08:22y especialmente también a Fable 5
00:08:24antes de que se lanzara al público.
00:08:26Este puerto se realizó con Fable 5.
00:08:29Y si estás instalando Cloud Code ahora, por cierto,
00:08:32aunque BUN 1.4, la versión de Rust, aún no se ha lanzado,
00:08:36Cloud Code ya se está ejecutando sobre
00:08:39una versión de BUN no lanzada, por así decirlo,
00:08:42que es la versión de Rust.
00:08:44Así que ahí está.
00:08:45Pero sí, este puerto se realizó con Cloud Code
00:08:48basado en Fable 5 con tokens gratuitos, por supuesto,
00:08:52esencialmente, ya que BUN es parte de Anthropic.
00:08:54Y eso es importante tenerlo en cuenta
00:08:56porque en esa entrada de blog,
00:08:58aprendemos que si combinaras todos los tokens,
00:09:03o si sumaras todos los tokens
00:09:04que se gastaron y cobraras precios de API,
00:09:08todo este puerto habría costado alrededor de 160 000 dólares.
00:09:13Esa es una cifra alucinante, pero en realidad,
00:09:18si piensas en el alcance de este proyecto,
00:09:20y el alcance es que BUN tenía 535 000 líneas de código SIG,
00:09:26si piensas en ese alcance
00:09:28y cuánto tiempo les tomaría a los humanos portar eso a Rust,
00:09:32entonces los 160 000 dólares en realidad podrían no sonar tan mal,
00:09:36dependiendo de dónde te encuentres.
00:09:38Ahora, no obstante, está claro que ningún proyecto de código abierto
00:09:43podría hacer eso.
00:09:44Y la mayoría de las empresas probablemente no podrían
00:09:47o no estarían dispuestas a gastar esa cantidad de dinero en un puerto.
00:09:50Esto es posible porque BUN es parte de Anthropic.
00:09:54Y, por supuesto, esto también es una buena estrategia de marketing
00:09:58para Anthropic.
00:09:59Puede que esa no haya sido la intención principal.
00:10:03No lo sé.
00:10:04Pero, por supuesto, es un buen marketing.
00:10:06Todo eso es importante tenerlo en cuenta.
00:10:08No obstante, en esta entrada de blog,
00:10:10podemos aprender cómo Jared hizo ese puerto
00:10:14o cómo hizo que ese puerto funcionara.
00:10:18Y todo eso comenzó con ese archivo MD de portabilidad,
00:10:21que creó en una discusión con Claude,
00:10:25en una discusión de tres horas,
00:10:26como mencionó en la entrada del blog,
00:10:28donde esencialmente decidió junto con Claude Code
00:10:32y los modelos de Anthropic,
00:10:35cómo tendría que verse un archivo MD de portabilidad
00:10:37para poder traducir el código SIG a Rust.
00:10:40Luego, una vez que lo iteró y estuvo contento con él,
00:10:44lo probó inicialmente en tres archivos.
00:10:46Y una vez que estuvo contento con eso,
00:10:48desató a Claude en toda la base de código de BUN.
00:10:53Ahora, en esta entrada de blog,
00:10:54deja claro que no solo le dio instrucciones a Claude
00:10:57para reescribir BUN en Rust, que no haya dudas,
00:11:00sino que en su lugar configuró un sistema elaborado
00:11:03donde tenía un agente principal,
00:11:07lanzando subagentes también, por supuesto,
00:11:09haciendo el puerto de acuerdo con el archivo MD de portabilidad.
00:11:13Y luego tenía dos agentes de revisión adversarios
00:11:16que revisaban el trabajo de ese agente principal una vez terminado
00:11:19y proporcionaban retroalimentación,
00:11:21y luego un agente de corrección para aplicar esa retroalimentación.
00:11:24Y tenía todo eso funcionando en un bucle
00:11:25y, por supuesto, distribuido a través de múltiples árboles de trabajo
00:11:30para procesar toda la base de código
00:11:33y avanzar a través de ella.
00:11:35En la entrada del blog,
00:11:35mencionó que reescribió BUN en Rust
00:11:38usando 50 flujos de trabajo dinámicos en Claude Code,
00:11:40que son estos flujos de trabajo que lanzan muchos subagentes
00:11:43a lo largo de 11 días.
00:11:46Y también tiene un gráfico agradable allí.
00:11:48En general, en la entrada del blog,
00:11:49hay gráficos agradables allí
00:11:51que lo hacen un poco más fácil de digerir,
00:11:53que muestran la cantidad de confirmaciones que se crearon
00:11:56y luego se enviaron en los diferentes días
00:11:58y luego los momentos del día.
00:12:00Así que todo eso sucedió con la ayuda de bucles en Claude Code,
00:12:04con la ayuda de muchos subagentes
00:12:05y el proceso claro de un agente principal,
00:12:08los agentes de revisión y el agente de corrección.
00:12:10Y luego también hizo otro camino separado
00:12:15por así decirlo, haciendo que todas esas pruebas funcionaran.
00:12:20Y eso trajo sus propios desafíos
00:12:22porque la suite de pruebas es tan grande y compleja
00:12:25que se topó con varias restricciones de infraestructura
00:12:29porque algunas pruebas consumen mucha memoria
00:12:31y ejecutar muchas pruebas en paralelo,
00:12:33por lo tanto no funciona.
00:12:34Pero finalmente hizo que todo eso funcionara también con la ayuda de la IA,
00:12:39ejecutando las pruebas, corrigiendo el código,
00:12:42volviendo a ejecutar las pruebas, etcétera.
00:12:43Así que muchos bucles, muchos agentes y subagentes involucrados,
00:12:47naturalmente, y muchos tokens quemados.
00:12:49165 000 dólares en tokens quemados.
00:12:53Ahora, de nuevo, puedes profundizar,
00:12:55y eso es lo que recomendaría hacer
00:12:57si estás interesado en todos los detalles precisos.
00:12:59Es una gran entrada de blog que documenta el viaje para llegar allí.
00:13:03Pero eso es, en pocas palabras, cómo ocurrió el puerto durante 11 días
00:13:08con todos esos agentes y subagentes distribuidos en múltiples flujos de trabajo,
00:13:1250 de esos flujos de trabajo, como aprendimos a lo largo o durante 11 días,
00:13:17165 000 dólares gastados en tokens a precios de API.
00:13:24Ahora, finalmente, una vez que terminó en la entrada del blog,
00:13:29mencionó que Bun 1.4 corrige varios errores que tiene la última versión de SICK,
00:13:35que es más eficiente en memoria, que es más pequeña.
00:13:38Y como aprendemos por la respuesta de Andrew Kelly, el creador de SICK,
00:13:43algunas de estas mejoras probablemente también podrían haberse logrado con SICK.
00:13:47Pero esa entrada de blog es bastante interesante porque fue editada.
00:13:53Ahora está menos llena de ira de lo que estaba inicialmente.
00:13:57La primera versión estaba llena de ataques personales,
00:14:00solo para luego decir que no fue un ataque personal,
00:14:03pero estaba llena de ataques personales.
00:14:05La última versión, que también enlazaré a continuación, todavía es bastante picante.
00:14:11Al final, puedes decir claramente al leer la primera versión,
00:14:14pero también esta versión,
00:14:16que Andrew, el creador de SICK, y Jared, el creador de Bun,
00:14:21ya no volverán a ser mejores amigos.
00:14:26Ahora, agradece a Bun por apoyar a SICK, también financieramente,
00:14:31solo para básicamente enfurecerse por todo este puerto y cómo no habría sido necesario
00:14:41si el código de Bun se hubiera escrito en SICK adecuado.
00:14:44Deja muy claro que no siente que el repositorio de Bun,
00:14:48la versión de SICK, tuviera una alta calidad de código y eso llevó a muchos problemas.
00:14:53Y eso puede ser cierto o no.
00:14:56Creo que es absolutamente posible que en un proyecto de la escala de Bun,
00:15:01moverse a la velocidad a la que se mueve Bun,
00:15:06la calidad del código puede no haber estado a la altura de los estándares del creador de SICK.
00:15:12Definitivamente podrías argumentar que la mayoría de los proyectos de código
00:15:15no necesariamente tienen la mayor calidad de código, sin embargo.
00:15:18Así que puedes inventar lo que quieras.
00:15:21Ahora, lo dejaré ahí.
00:15:24Siento que la entrada de blog de respuesta general es bastante débil
00:15:29porque está llena de ira.
00:15:33Tiene algunos puntos válidos.
00:15:35Como, por ejemplo, en la entrada de blog que hace Jared,
00:15:40menciona que el puerto de SICK a Rust fue validado,
00:15:46por supuesto, con todos estos agentes revisores,
00:15:48pero también ejecutando la suite de pruebas y haciendo que eso funcione.
00:15:51Y Andrew afirma correctamente que, por supuesto, esa misma suite de pruebas
00:15:56debería o no debería haber sido suficiente para probar que la versión de SICK es genial.
00:16:00Así que tal vez la suite de pruebas debería haber sido mejorada también.
00:16:04De cualquier manera, definitivamente estos dos no se convertirán en mejores amigos.
00:16:09Y no tengo opinión sobre si SICK o Rust es el mejor lenguaje en general o para Bun.
00:16:17Creo, sin embargo, que con la IA, Rust y su modelo de memoria y el hecho
00:16:23de que obtienes errores en tiempo de compilación para muchos problemas relacionados con la memoria es una gran ventaja,
00:16:30especialmente en la era de la IA, porque, por supuesto, todo este puerto es realmente impresionante
00:16:38cuando se trata del uso de la IA.
00:16:41Y claro, es una forma de usar la IA que la mayoría de nosotros no podremos permitirnos
00:16:45o no estaremos dispuestos a permitirnos en las empresas.
00:16:48Pero es impresionante que la IA pudiera hacer eso.
00:16:52Y no es codificación de vibras o simplemente instrucciones rápidas y sin pensarlo.
00:16:56Hay un proceso claro detrás de todo eso.
00:16:59Se pensó mucho en esto, lo cual espero haber dejado claro, lo cual definitivamente también queda claro
00:17:05si profundizas en los detalles técnicos precisos.
00:17:08Pero con toda la planificación, toda la iteración con la configuración, con la forma en que se abordó,
00:17:13claramente esto no fue solo una instrucción lanzada al azar.
00:17:17Y luego veremos a dónde llegamos; esto muestra lo que puedes hacer con la IA.
00:17:21Y, por supuesto, portar una base de código de un lenguaje a otro es un muy buen caso de uso para la IA.
00:17:27Si lo piensas, la IA puede, por supuesto, tener problemas para escribir código nuevo.
00:17:32Puede que no escriba el código que querías escribir, no siga las convenciones de código
00:17:36o estilos que querías seguir, y también puede arruinar cosas.
00:17:40Ahora, definitivamente la IA es increíble para crear nuevo software también.
00:17:43Pero te enfrentas a un conjunto diferente de problemas allí con un puerto.
00:17:47La gran ventaja es que tienes una base de código para que la IA simplemente la mire y traduzca,
00:17:53que es algo que la IA puede hacer, y tienes una suite de pruebas allí.
00:17:57Así que hay mucho sobre lo que construir.
00:17:59Es un buen caso de uso para la IA, al parecer, y como este puerto demuestra claramente.
00:18:04Y creo que esa es la conclusión más interesante aquí.
00:18:08También que puedes abordar proyectos que simplemente habrían sido imposibles
00:18:12de abordar antes.
00:18:13De nuevo, no para todos, pero para ciertas empresas de ciertos tamaños.
00:18:18Esto puede ser interesante.
00:18:19Modernizar software heredado con la ayuda de la IA puede ser o es un gran caso de uso.
00:18:26Y esto muestra y prueba que esto se puede hacer.
00:18:30Ahora, por supuesto, BUN 1.4 aún no ha salido.
00:18:32Veremos si todo falla y tienen que revertir en un mes a partir de ahora.
00:18:36No puedes descartarlo totalmente, pero personalmente no creo que eso suceda.
00:18:40Ya se está utilizando en producción por algunos de los primeros usuarios, como la CLI de Cloud Code.
00:18:47Ha sido probado y revisado extensamente, aunque, por supuesto, por IA, no por revisores humanos.
00:18:54Pero estoy bastante seguro de que esto funcionará y me parece una hazaña bastante impresionante y también un uso bastante impresionante de la IA.
00:19:03Pero como siempre, también me interesa escuchar cuáles son tus pensamientos sobre todo esto.