let-go - linguagem da família Clojure feita em Go com inicialização em 7 ms

 (github.com/nooga)
1 pontos por GN⁺ 11 시간 전 | 1 comentários | Compartilhar no WhatsApp
  • let-go é um dialeto de Clojure escrito em Go, com compilador de bytecode e VM de pilha, funcionando sem JVM como um único binário de cerca de 10 MB
  • O cold start é de cerca de 7 ms e, com base na jank-lang Clojure test suite, a compatibilidade com Clojure é apresentada como 4696 / 4921 assertions aprovadas (95,4%)
  • O autor o utiliza para CLI, scripts e servidores web; também criou sobre o let-go um runtime de contêiner sem daemon, e ele pode ser compilado como binário executável independente ou página web WASM autocontida
  • O objetivo é implementar muitos recursos do Clojure, como persistent data structures, lazy seqs, transducers, protocols, records, multimethods, core.async, BigInts, além de oferecer interop bidirecional com funções, struct e channel de Go
  • Não é um drop-in replacement do Clojure na JVM, não carrega JARs, e projetos reais com dependências de bibliotecas exigem ajustes
  • Em benchmarks no Apple M1 Pro, são apresentados binário de 10 MB, tempo de inicialização de 6,7 ms e memória ociosa de 13,5 MB, com vantagem em unidade de execução menor frente a Babashka, Joker, go-joker, gloat e Clojure JVM
  • Em tarefas maiores de computação numérica, o WASM JIT do go-joker ou a JVM com HotSpot já aquecida ficam à frente; o let-go é resumido como semelhante ao Babashka na maioria dos benchmarks algorítmicos e mais de 10 vezes mais rápido que o Joker upstream
  • Os namespaces padrão incluem clojure.core, clojure.string, clojure.set, clojure.edn, clojure.test, clojure.core.async, io, http, json, transit, os, System, syscall, pods e outros
  • É possível carregar Babashka pods, usando o ecossistema de pods para SQLite, AWS, Docker, monitoramento de arquivos etc., e compartilhando ~/.babashka/pods/ com o bb
  • Entre as limitações conhecidas estão ausência de implementação de Refs / STM, Agents, hierarchies, reader tagged literals, deftype, reify, clojure.spec, alter-var-root, subseq / rsubseq, além da falta de detecção automática de overflow de int64
  • Como diferenças de comportamento, o bloco go é uma goroutine real, não uma máquina de estados IOC; regex usa re2 do Go em vez de regex de Java, e o sistema numérico é composto por int64 + float64 + BigInt
  • A instalação pode ser feita via Homebrew no macOS/Linux, pelos Releases para amd64/arm64 em Linux, macOS e Windows, ou com go install github.com/nooga/let-go@latest no Go 1.22+
  • O lg oferece REPL, avaliação de expressões e execução de arquivos, além de compilação para bytecode .lgb, empacotamento como executável standalone e geração de app web em WASM
  • A saída WASM consiste em um index.html autocontido de cerca de 6 MB gzipped com WASM inline e service worker; ao usar o namespace term, fornece emulação de terminal baseada em xterm.js
  • O servidor nREPL embutido funciona com CIDER, Calva e Conjure, e dentro de programas Go é possível embutir o let-go como camada de script via pkg/api, passando valores, funções, struct e channel de Go para a VM

Leituras relacionadas

1 comentários

 
GN⁺ 11 시간 전
Comentários do Hacker News

  • Muito bom! Recentemente fiz um experimento de colocar sintaxe Lisp por cima da semântica do Go: https://codeberg.org/veqq/Joe
    Entre as linguagens da família Clojure sem JVM, Janet também é realmente muito boa, e venho usando em produção há algum tempo: https://janet-lang.org/
    Se quiser a VM e as bibliotecas do Lua, também tem Fennel

    • Joe parece bacana. Nunca usei Janet diretamente, mas sempre achei que é uma linguagem que segue seu próprio caminho, em vez de tentar acompanhar Clojure

  • Também vale testar este REPL no navegador com Wasm: https://gloathub.org/repl/
    Gloat é uma ferramenta de automação AOT do Glojure
    No verão passado, tornei o AOT do Glojure possível junto com James Hamlin, e desde então venho evoluindo isso. Também estou trabalhando com marcingas(nooga) para que Gloat/Glojure/let-go cooperem bem entre si

  • Surpreendente que rode no Plan 9
    Seria legal se Go se tornasse uma linguagem de primeira classe no 9front, ou seja, incluída por padrão
    Estou mexendo numa rede social para Plan 9: https://youtube.com/watch?v=q6qVnlCjcAI&si=MBCeM0QdA0WsKAe7
    Está tudo feito em rc e awk, mas há trechos em que teria sido bom ter Go ou Clojure no meio

    • Gostei da demo do 9social. Não sou usuário de Plan 9, mas sempre me inspiro no jeito Plan 9
    • Comecei a distribuir binários amd64 e arm de 32 bits para Plan 9 nas releases do GitHub
      Testei amd64 no 9front e parece que está tudo funcionando bem. A CLI não é muito no estilo do Plan 9, mas em algum momento pretendo tornar o port mais nativo

  • Como agora existem alguns dialetos de Clojure em Go, o que eu mais queria saber é qual deles é totalmente hospedado sobre Go e oferece um nível de interoperabilidade comparável ao que o Clojure da JVM tem com Java
    Seria ótimo poder usar no Go o que eu fizer, e também usar Go dentro do Clojure, até mesmo criando projetos mistos. Também seria bom ter um detalhamento do que é igual, do que não é e de como difere, além da interoperabilidade

    • Gloat/Glojure parece ter a melhor história em termos de runtime hospedado, graças ao pipeline AOT para código-fonte Go. Dá para importar qualquer coisa de Go em tempo de compilação
      Já o let-go consegue fazer ida e volta com qualquer valor de Go, incluindo structs, funções e canais, mas não consegue puxar diretamente bibliotecas Go arbitrárias sem wrapper. Essas bibliotecas precisam estar compiladas no runtime

  • Pequena observação, mas no README está cold start de 7 ms e algumas linhas abaixo fala em 6 ms. Talvez ele fique mais rápido quanto mais se lê o README

    • Corrigi. Na minha máquina fica em 6~7 ms, e a mediana parece ser algo em torno de 6,5 ms

  • É exatamente o tipo de port de Clojure que eu sempre procurei
    Sempre achei que a biblioteca padrão do Go e a abstração de canais formavam uma API-base mais simples e melhor, além de parecer combinar bem com APIs do tipo core.async. Também atende ao desejo de um grande binário único
    Valeu pelo trabalho, e quando minha nova paixão por C++26 esfriar um pouco, com certeza vou olhar isso de novo
    Além disso, não sei por que Glojure não estava no meu radar, e esse também parece um projeto excelente

    • Já pensei na ideia de criar uma DSL no estilo do PHP antigo aproveitando internamente o runtime e os pacotes do Go
      Digo PHP antigo porque PHP originalmente era mais próximo de uma DSL centrada na web; hoje já não é mais. Uma linguagem de backend fácil de escrever, parecida com PHP, mas com o poder do Go por trás, parece algo interessante, e Clojure seria uma ótima escolha
    • Se você realmente chegar a usar isso depois, seria ótimo se abrisse um issue ou dois

  • Como alternativa, também existe o Joker: https://joker-lang.org
    É realmente excelente e acho que é completamente subestimado

    • O que mais valorizo no Joker é que o wrapping de bibliotecas Go é muito fluido. Parece cobrir tudo o que o Go oferece
      Dito isso, não quero acrescentar coisa demais ao let-go. Gosto do fato de ele caber em 10 MB

  • Seria melhor se o nome da linguagem fosse algo melhor do que simplesmente “lets-go”. Que tal “clogo”?

    • Dar nome é difícil, mas eu gosto de let-go. É um trocadilho em várias camadas
      (let [...] (go ...))
      Ele deixa você usar let em Go!
      Para mim, Clogo é no-go. Se houver outras boas ideias, posso considerar

  • Se você mandar um PR para https://github.com/chr15m/awesome-clojure-likes, será muito bem-vindo