let-go – In Go geschriebene Clojure-artige Sprache mit 7 ms Startzeit

• let-go ist ein in Go geschriebener Clojure-Dialekt, der über einen Bytecode-Compiler und eine Stack-VM verfügt und ohne JVM als einzelnes, etwa 10 MB großes Binary läuft
• Der Kaltstart liegt bei etwa 7 ms; die Clojure-Kompatibilität wird anhand der jank-lang Clojure test suite mit 4696 / 4921 bestandenen Assertions (95,4 %) angegeben
• Der Autor nutzt es für CLI, Skripte und Webserver, hat darauf auch eine daemonless container runtime aufgebaut, und es kann zu eigenständigen ausführbaren Dateien oder selbstenthaltenden WASM-Webseiten kompiliert werden
• Ziel ist die Umsetzung vieler Clojure-Funktionen wie persistent data structures, Lazy Seqs, Transducers, Protocols, Records, Multimethods, core.async, BigInts sowie bidirektionaler Interop mit Go-Funktionen, -Structs und -Channels
• Es ist kein drop-in replacement für JVM-Clojure, lädt keine JARs, und echte Projekte mit Bibliotheksabhängigkeiten müssen angepasst werden
• In Benchmarks auf einem Apple M1 Pro werden 10 MB Binary-Größe, 6,7 ms Startzeit und 13,5 MB Leerlaufspeicher genannt; damit wird bei kleineren Ausführungseinheiten ein Vorteil gegenüber Babashka, Joker, go-joker, gloat und Clojure auf der JVM dargestellt
• Bei größeren numerischen Rechenaufgaben liegen der WASM-JIT von go-joker oder eine aufgewärmte JVM mit HotSpot vorn; let-go wird in den meisten Algorithmus-Benchmarks als ähnlich schnell wie Babashka und mehr als 10-mal schneller als das Upstream-Joker zusammengefasst
• Die Standard-Namespaces umfassen clojure.core, clojure.string, clojure.set, clojure.edn, clojure.test, clojure.core.async, io, http, json, transit, os, System, syscall, pods und weitere
• Es kann Babashka pods laden, sodass sich das Pod-Ökosystem für SQLite, AWS, Docker, Dateiwatching usw. nutzen lässt; ~/.babashka/pods/ wird mit bb geteilt
• Zu den bekannten Einschränkungen zählen nicht implementierte Refs / STM, Agents, Hierarchies, Reader Tagged Literals, deftype, reify, clojure.spec, alter-var-root, subseq / rsubseq sowie das Fehlen einer automatischen Erkennung von int64-Überläufen
• Zu den Verhaltensunterschieden gehört, dass ein go-Block keine IOC-State-Machine, sondern eine echte goroutine ist, dass Regex statt Java-Regex auf Go-re2 basiert und dass das Zahlensystem aus int64 + float64 + BigInt besteht
• Die Installation ist über Homebrew für macOS/Linux, über Releases für Linux, macOS und Windows auf amd64/arm64 oder unter Go 1.22+ mit go install github.com/nooga/let-go@latest möglich
• lg unterstützt REPL, Auswertung von Ausdrücken und das Ausführen von Dateien sowie die Bytecode-Kompilierung nach .lgb, das Bündeln zu eigenständigen Executables und die Erstellung von WASM-Web-Apps
• Die WASM-Ausgabe besteht aus einem selbstenthaltenden index.html von etwa 6 MB gzipped mit inlined WASM und Service Worker; bei Nutzung des term-Namespaces wird eine auf xterm.js basierende Terminal-Emulation bereitgestellt
• Der integrierte nREPL-Server funktioniert mit CIDER, Calva und Conjure; in Go-Programmen kann let-go über pkg/api als Skripting-Schicht eingebettet werden, um Go-Werte, -Funktionen, -Structs und -Channels an die VM zu übergeben

[GN⁺]

Hacker-News-Kommentare

• Gefällt mir! Ich habe kürzlich mit einem Experiment gespielt, Go-Semantik mit Lisp-Syntax zu überlagern: https://codeberg.org/veqq/Joe
  Unter den Clojure-ähnlichen Sprachen ohne JVM ist auch Janet wirklich großartig, und ich nutze es seit einiger Zeit in Produktion: https://janet-lang.org/
  Wenn man eine Lua-VM und Bibliotheken will, gibt es auch Fennel

  • Joe sieht gut aus. Janet habe ich selbst noch nicht verwendet, aber ich hatte den Eindruck, dass es eher seinen eigenen Weg geht, statt zu versuchen, Clojure zu folgen

• Dieses Wasm-Browser-REPL ist ebenfalls einen Blick wert: https://gloathub.org/repl/
  Gloat ist ein Automatisierungstool für Glojure AOT
  Letzten Sommer habe ich zusammen mit James Hamlin Glojure AOT möglich gemacht und seitdem kontinuierlich weiterentwickelt. Ich arbeite auch mit marcingas(nooga) daran, dass Gloat/Glojure/let-go gut zusammenarbeiten

• Überraschend, dass es auf Plan 9 läuft
  Es wäre cool, wenn Go auf 9front eine Sprache erster Klasse, also eine standardmäßig enthaltene Sprache, würde
  Ich bastle an einem sozialen Netzwerk für Plan 9: https://youtube.com/watch?v=q6qVnlCjcAI&si=MBCeM0QdA0WsKAe7
  Alles ist in rc und awk geschrieben, aber es gab zwischendurch Stellen, an denen Go oder Clojure schön gewesen wären

  • Die 9social-Demo gefällt mir. Ich selbst bin kein Plan-9-Nutzer, aber ich lasse mich von der Plan-9-artigen Herangehensweise immer inspirieren
  • Ich habe angefangen, in den GitHub-Releases amd64- und arm-32-Bit-Binaries für Plan 9 bereitzustellen
    amd64 wurde auf 9front getestet, und es scheint alles gut zu funktionieren. Die CLI ist nicht besonders Plan-9-mäßig, aber ich wäre bereit, den Port irgendwann nativer zu machen

• Inzwischen gibt es ein paar Go-Dialekte von Clojure, daher interessiert mich vor allem, welcher davon vollständig auf Go gehostet ist und Interoperabilität auf dem Niveau bietet, das JVM-Clojure mit Java hat
  Es wäre schön, wenn ich in Go Geschriebenes nutzen und aus Clojure heraus auch Go verwenden könnte, bis hin zu gemischten Projekten. Außerdem wäre es hilfreich, wenn abgesehen von der Interoperabilität detailliert aufgeschlüsselt wäre, was gleich ist, was nicht und wie genau die Unterschiede aussehen

  • Gloat/Glojure hat dank der Go-Source-AOT-Pipeline wohl die beste Geschichte in Bezug auf eine gehostete Laufzeit. Zur Compile-Zeit kann man alles aus Go importieren
    let-go hingegen kann beliebige Go-Werte, einschließlich Structs, Funktionen und Channels, in beide Richtungen durchreichen, aber es kann nicht ohne Wrapper direkt beliebige Go-Bibliotheken einbinden. Solche Bibliotheken müssen zur Laufzeit eingebaut sein

• Kleine Anmerkung, aber im README steht Cold Start 7 ms, ein paar Zeilen weiter unten dann 6 ms. Vielleicht wird es schneller, je länger man das README liest

  • Habe ich korrigiert. Auf meiner Maschine sind es 6–7 ms, und der Median scheint ungefähr bei 6,5 ms zu liegen

• Das ist genau die Art von Clojure-Port, nach der ich immer gesucht habe
  Ich fand die Core-Bibliothek und die Channel-Abstraktion von Go immer einfacher und als grundlegende API besser, und ich dachte, das würde auch gut zu einer core.async-artigen API passen. Außerdem erfüllt es den Wunsch nach einem großen einzelnen Binary
  Danke für die Arbeit, und sobald meine neue Begeisterung für C++26 etwas abgeklungen ist, werde ich es mir definitiv noch einmal ansehen
  Außerdem weiß ich nicht, warum Glojure bisher nicht auf meinem Radar war; auch das sieht nach einem großartigen Projekt aus

  • Ich habe schon einmal über die Idee nachgedacht, eine DSL im Stil von altem PHP zu bauen, die intern Go-Runtime und Pakete nutzt
    Mit altem PHP meine ich, dass PHP ursprünglich eher wie eine Web-zentrierte DSL war; heute ist das nicht mehr so. Eine leicht zu schreibende Backend-Sprache im PHP-Stil mit der Power von Go im Hintergrund wäre interessant, und Clojure wäre dafür eine hervorragende Wahl
  • Wenn du es später tatsächlich ausprobierst, wäre es großartig, wenn du ein oder zwei Issues hinterlassen würdest

• Als Alternative gibt es auch Joker: https://joker-lang.org
  Wirklich großartig, aber ich halte es für stark unterschätzt

  • Was ich an Joker schätze, ist, dass das Wrappen von Go-Bibliotheken sehr reibungslos ist. Es scheint alles abzudecken, was Go bietet
    Ich möchte let-go allerdings nicht zu sehr mit zusätzlichen Dingen aufladen. Mir gefällt, dass es unter 10 MB bleibt

• Ich wünschte, der Sprachname wäre besser als einfach nur „lets-go“. Wie wäre es mit „clogo“?

  • Namen zu finden ist schwer, aber let-go gefällt mir. Es ist ein mehrschichtiges Wortspiel
    (let [...] (go ...))
    Es lässt einen in Go ein let machen!
    Clogo ist für mich ein no-go. Wenn jemand andere gute Ideen hat, schaue ich sie mir gern an

• Ein PR für https://github.com/chr15m/awesome-clojure-likes wäre sehr willkommen

  • Hinzugefügt: https://github.com/chr15m/awesome-clojure-likes/pull/27