Moonbit: un lenguaje WebAssembly rápido, conciso y fácil de usar

 (moonbitlang.com)
2 puntos por GN⁺ 2023-08-20 | 1 comentarios | Compartir por WhatsApp
  • A medida que WebAssembly gana importancia en la computación en la nube y en el edge, Moonbit apunta a ser un lenguaje Wasm-first que facilite aprovechar la eficiencia, seguridad y tamaño reducido de Wasm.
  • Moonbit busca resolver las limitaciones de Rust y C/C++, como la dificultad de aprendizaje y los largos tiempos de compilación, así como las de Go, cuyo código generado es más grande e ineficiente.
  • Su diseño se enfoca en compilaciones y ejecución rápidas, salida Wasm pequeña y facilidad de uso, e incluye optimización con múltiples representaciones intermedias, análisis semántico paralelo por función y reanálisis incremental.
  • En el ejemplo de Fibonacci, destaca la inferencia de tipos en funciones locales, la salida Wasm más pequeña, mejor rendimiento que Go y un desempeño similar a Rust, además de soporte para cierres recursivos y exhaustive pattern match.
  • Actualmente ofrece IDE en línea, herramientas CLI, documentación y extensión para VSCode, y apunta a alcanzar el beta status a finales del segundo trimestre de 2024 y publicar el código fuente después de llegar a calidad beta.

Un lenguaje con WebAssembly como prioridad

  • WebAssembly es una arquitectura de conjunto de instrucciones multiplataforma cuya relevancia crece en la computación en la nube y en el edge por su eficiencia, seguridad, tamaño reducido y estándar abierto.
  • Consideran que las opciones existentes no aprovechan del todo el potencial de Wasm.
    • Los lenguajes Wasm de bajo nivel como Rust y C/C++ son difíciles de aprender, y sus largos tiempos de compilación pueden ralentizar el desarrollo.
    • Los lenguajes de alto nivel como Go generan código ineficiente y más grande, por lo que cuesta aprovechar las ventajas de velocidad y tamaño reducido de Wasm.
  • Moonbit busca ser un lenguaje Wasm-first que compile y ejecute rápido, genere una salida Wasm pequeña y sea fácil de aprender, como Go.

Diseño del lenguaje y equipo

  • Moonbit está liderado por Hongbo Zhang y un equipo con más de 10 años de experiencia en diseño y desarrollo de lenguajes.
  • Zhang ha contribuido a OCaml, ReScript y Flow, y fue chief architect del compilador rápido, la biblioteca estándar y el sistema de build del toolchain de ReScript.
  • El diseño del lenguaje recibe influencias tanto de Go como de Rust.
    • Adopta la simplicidad de Go, en especial su sistema de paquetes.
    • Incorpora la expresividad de Rust, incluyendo pattern matching, inferencia de tipos, genéricos y ad-hoc polymorphism similar a traits.
  • Su sistema de tipos fault tolerant fue diseñado teniendo en cuenta velocidad, paralelización y verificación incremental, y pone el soporte para IDE como objetivo central.

Compilación y ejecución rápidas

  • Moonbit apunta a ser un lenguaje rápido en toda la pila, abarcando tanto el rendimiento de desarrollo como el rendimiento en tiempo de ejecución.
  • Usa representaciones intermedias (IR) de múltiples niveles para la optimización de programa completo.
    • Busca mejorar el layout de memoria para reducir cache misses.
    • Ofrece mejor contexto para el análisis de flujo de datos y de control.
    • Considera que permite optimizaciones eficaces al comprender la estructura del programa de forma más integral que la mayoría de las arquitecturas existentes de link-time optimization.
    • Puede detectar y eliminar redundancias de alto nivel que no son visibles en niveles bajos.
  • Para lograr un rendimiento de compilación rápido, crucial para las funciones del IDE, permite análisis semántico paralelo por función.
    • A diferencia de ReScript y Rust, hace posible el análisis semántico paralelo por función.
    • También realiza reanálisis incremental con la misma granularidad, lo que, según afirman, permite manejar monorepos grandes y ofrecer tiempos de respuesta en milisegundos.

Salida Wasm pequeña

  • Moonbit fue diseñado pensando en una dead code elimination efectiva.
  • Excluye características del lenguaje que dificultan este análisis, y su biblioteca estándar también está estructurada para facilitar la eliminación de código muerto.
  • Busca reducir considerablemente el tamaño final del código mediante optimización de programa completo.
    • Consideran que reducir el tamaño del código mejora la seguridad y disminuye la superficie de ataque.
    • También afirman que garantiza inicios rápidos en entornos de computación serverless.

Funciones y herramientas orientadas a la usabilidad

  • Moonbit ofrece gestión automática de memoria, diferenciándose de Rust.
  • A diferencia de Go, afirma evitar elementos riesgosos como punteros o left values.
  • Proporciona funciones seguras para la programación orientada a datos.
    • algebraic data types
    • ad-hoc polymorphisms
    • pattern match
  • También busca funcionar como plataforma más allá del lenguaje, y ofrece un conjunto de herramientas incluso en esta etapa inicial.
    • herramienta de build de alta velocidad
    • gestor de paquetes
    • compilador
    • IDE
    • Cloud IDE sin contenedores, accesible desde cualquier lugar con solo un navegador
    • Afirman que este Cloud IDE también ofrece funciones offline, lo que lo diferencia de otros Cloud IDE existentes.

Diferencias vistas con el ejemplo de Fibonacci

  • El ejemplo de Fibonacci compara implementaciones de la función fib en MoonBit, Go y Rust.
  • Según el benchmark, MoonBit muestra diferencias en inferencia de tipos, tamaño de código, rendimiento y usabilidad.
    • Inferencia de tipos local: MoonBit infiere el tipo de la función local aux.
    • Tamaño Wasm pequeño: MoonBit genera la salida Wasm más pequeña.
    • Rendimiento: es más rápido que Go y similar a Rust.
    • Usabilidad: soporta cierres recursivos como Go, mientras que en Rust dicen que implementarlos es muy difícil.
    • Al igual que Rust, soporta exhaustive pattern match, y lo consideran mucho más potente que el switch case de Go.

Estado actual y hoja de ruta

  • Moonbit es un objetivo que cambia rápidamente, pero actualmente ofrece puntos de entrada utilizables.
  • Señalan que el desarrollo de toolchains de lenguaje solía tomar desde varios años hasta una década, pero que han simplificado el proceso gracias a la experiencia acumulada y a un equipo dedicado conformado desde el inicio.
  • Esperan alcanzar el beta status para finales del segundo trimestre de 2024.
    • beta status significa estabilidad relativa, pocos bugs y un FFI robusto para interactuar con el host de Wasm.
  • Planean publicar el código fuente después de alcanzar calidad beta.
  • Sus planes estratégicos incluyen la integración de Wasm GC para Wasm 2.0 y un GC propio para Wasm 1.0, alineados con las propuestas de Wasm.

Canales de la comunidad

Lecturas relacionadas

1 comentarios

 
GN⁺ 2023-08-20
Opiniones de Hacker News

  • Soy el líder de este proyecto. Ya se puede probar directamente en el IDE en línea https://try.moonbitlang.com, y se ejecuta con F5
    La documentación está en https://github.com/moonbitlang/moonbit-docs, y el compilador se hará público cuando llegue al estado beta. La fecha estimada es fines del segundo trimestre de 2024

    • Estas son las preguntas que reviso primero cuando veo un nuevo lenguaje de programación: cómo se escribe el código asíncrono, si tiene funcionalidades menos mainstream como efectos algebraicos (algebraic effects), contextos/capacidades (contexts/capabilities) o tipos lineales (linear types), si el sistema de tipos es sólido y si hacen falta casts de tipos, si soporta interfaces/traits/protocolos, y qué tan ricos son los genéricos
      Por ejemplo, también quiero revisar si tiene anotación explícita de varianza en parámetros de tipo, restricciones de límite inferior/superior, tipos de orden superior (higher-kinded types), si se centra más en subtipado estructural o nominal, y si tiene tipos de datos algebraicos y tipos de datos algebraicos generalizados
      Referencias: https://v2.ocaml.org/manual/effects.html, https://docs.hhvm.com/hack/contexts-and-capabilities/introdu..., https://austral-lang.org/linear-types
    • Creo que mucha gente querrá saber sobre la licencia, el precio y el control del proyecto. Publicarlo ahora podría ser desfavorable para la estrategia comercial, pero el secretismo y la incertidumbre pueden enfriar el interés
    • La documentación en https://moonbitlang.com/docs/syntax/ es difícil de leer por el color del texto y el color de fondo
    • Me pregunto si de verdad hace falta una palabra clave dedicada fn. No entiendo cuál es la diferencia fundamental entre func y fn
    • Me pregunto si es necesario distinguir entre func y fn, y si la flecha -> para indicar el valor de retorno en la firma de una función es realmente necesaria
      La sintaxis para nuevos tipos es struct User, pero en ese caso creo que sería mejor algo como Go, type User struct. Así también se podrían crear tipos de función para variables fn, como type AssignUser func(name: String, id: Int) -> Int
      También me pregunto si : ayuda al lexer o al parser. Quisiera preguntar si en la firma de una función no se podría escribir func(name String) en vez de func(name: String), y si las declaraciones de tipos no podrían ser mut elems List[int] en vez de mut elems: List[Int]. Es una objeción menor, pero en general me gusta

  • El sitio lo compara con Rust y Go, pero a mí me parece más adecuada la comparación con AssemblyScript. AssemblyScript también es nativo de WASM, y se parece en que su ecosistema todavía es pequeño
    Pero, a diferencia de Moonbit, es un lenguaje familiar para quienes han usado TypeScript, así que me pregunto por qué habría que usar Moonbit en lugar de AssemblyScript

    • Porque Moonbit es un lenguaje moderno, mientras que AssemblyScript hereda errores del pasado. Por ejemplo, Moonbit soporta pattern matching y la mayoría de los elementos del lenguaje son expresiones
      AssemblyScript no tiene pattern matching y está compuesto principalmente por sentencias (statements). Moonbit tiene tipos de datos algebraicos; no estoy seguro de si AssemblyScript tiene algo así. También puede haber más diferencias de runtime, pero solo viendo el sitio web es difícil juzgarlo
    • Parece mucho más cercano a Grain que a AssemblyScript: https://grain-lang.org/
    • Supongo que la comparación con Rust y Go se debe a que ambos son lenguajes populares y con soporte WASM de primera clase, pero estoy de acuerdo en que deberían compararlo con AssemblyScript

  • No me parece bien usar la palabra clave func para definiciones de funciones de nivel superior y fn para definiciones de funciones anidadas. Deberían unificarlo en una de las dos, independientemente del contexto específico

    • Puede ser porque las funciones anidadas son closures. A diferencia de las declaraciones de nivel superior, pueden omitir nombre y tipo y capturar valores, así que no es raro que un lenguaje tenga una sintaxis separada para closures/lambdas
      Si eso es realmente necesario o un buen diseño es otra cuestión, pero hay muchos precedentes
    • Lo veo como un diseño elegante porque permite definiciones de funciones más cortas y legibles para funciones anidadas. fn permite omitir el nombre y el tipo, y la palabra clave corta muestra que la definición de función también puede ser más breve

  • Me entusiasma que aparezca un lenguaje moderno con garbage collection orientado a WASM. El punto de comparación más cercano probablemente sea Grain: https://grain-lang.org/

    • Dicen que el compilador de Grain está escrito en ReasonML, no en OCaml puro. Me parece un poco cómico ver cómo estas tecnologías de nicho se apilan unas sobre otras sin ningún reparo

  • “El desarrollo de toda la toolchain de un lenguaje antes tomaba de varios años hasta una década, pero se simplificó gracias a la experiencia acumulada y a un excelente equipo dedicado formado desde los inicios de Moonbit. Se espera que Moonbit llegue al estado beta para fines del segundo trimestre de 2024, lo que significa una etapa relativamente estable, con menos bugs y una FFI sólida para interactuar con hosts Wasm. Al alcanzar calidad beta, se publicará el código fuente. Estratégicamente, de acuerdo con las propuestas de Wasm, se planea integrar Wasm GC para Wasm 2.0 y un GC propio para Wasm 1.0”.
    Por eso ahora https://github.com/moonbitlang/ está vacío

  • Viendo los comentarios aquí, parece que Moonbit tiene garbage collection. Pero si el binario resultante de Fibonacci pesa 253 bytes, probablemente no incluya el GC
    Me pregunto si usa el GC nativo de WASM que está en propuesta, o si el sistema de build es lo bastante inteligente como para darse cuenta de que aquí no hace falta y quitar el GC

    • Si haces clic derecho en el archivo y eliges el penúltimo menú, Compile to Wat, puedes ver directamente el texto WASM
      En la salida del ejemplo de Fibonacci solo se ve el import print_i32, las definiciones de memoria y funciones, y la exportación de _start; no parece que venga pegado un runtime de GC
    • Probablemente lo omite de forma inteligente. Porque el tamaño del código es uno de sus objetivos

  • Me recuerda a Grain. Como es otro lenguaje de programación con Wasm como prioridad, estaría bien agregar Grain como punto de comparación
    https://grain-lang.org/

  • El enlace About Team lleva a una página edu.cn en chino. Parece un proyecto universitario, aunque no estoy seguro. La página Join Us también está en chino, y el ejemplo de la página principal parece requerir JavaScript de baidu.com

    • Incluso con el plugin umatrix activado, la demo sigue funcionando. Los scripts necesarios vienen de unpkg y msecnd (dominio de Microsoft), y baidu no hace falta

  • En Go no se implementa Fibonacci así

    • No me gusta Go, pero hay que reconocer que ese benchmark no tiene sentido. Si usas llamadas de cola en un lenguaje que no soporta optimización de llamadas de cola, obviamente el resultado será malo
      Parece que fue más fácil meter unos cuantos números que comparar implementaciones idiomáticas y discutir los trade-offs con detalle. Aunque sea solo un teaser sencillo del lenguaje, sería bueno incluir una nota sobre TCO para no confundir a la gente
    • Usar WASM y Go en un ejemplo forzado sin mencionar TinyGo no parece muy honesto
    • En Rust tampoco se implementa así. Es un benchmark bastante malo. Por mi experiencia, diría que la causa es la falta de recursión de cola y la sentencia switch, que en Go puede ser lenta
      Aun así, como teaser para presentar Moonbit está bien

  • Me pregunto si este proyecto tiene relación con Meta. Su creador, Hongbo Zhang, trabajó en Meta en proyectos open source de lenguajes de programación como ReasonML y Flow, y según LinkedIn todavía trabaja en Meta