lumo

Is this similar to Lumo (https://github.com/anmonteiro/lumo)? I would assume Lumo has a faster start time since it boots from a V8 snapshot, but otherwise I'd assume the two projects are similar (except that, of course, lumo is EOL)

> I just with there was a Lisp like it that didn't run on the JVM. There are a few, with varying degrees of distance from the JVM and varying degrees of similarity to Clojure. - There's ClojureScript, which is Clojure transpiled to JavaScript. - See also Lumo (<https://github.com/anmonteiro/lumo>) and Planck (<https://planck-repl.org/guide-all.html>) - There's Babashka (https://github.com/babashka/babashka), which is a natively-compiled Clojure interpreter, implemented with the Small Clojure Interpreter (https://github.com/babashka/sci) and GraalVM for native compilation. - There's Joker (https://github.com/candid82/joker) with a similar mission to Babashka, but commonly used as a linter. - There's ClojureCLR (https://groups.google.com/g/clojure-clr) on the Common Language Runtime. - There's Cloture (https://github.com/ruricolist/clot

Lumo as well. https://github.com/anmonteiro/lumo

I think you will get the hacker vibe a lot more when you start browsing around Clojure libraries and stuff people have built with it for fun. Re startup time, maybe you prefer to run on JS. See eg https://github.com/anmonteiro/lumo (Though you can also use GraalVM to get fast startup time on prod builds of JVM Clojure projecs)

If you really want to script in Clojure you should probably use Lumo https://github.com/anmonteiro/lumo . Starts up almost instantly (including a repl!). Still wouldn't recommend. But it's workable.

Nonsense, you can learn it in your spare time bit by bit, the trick is really to take it in small pieces. If you want something for scripting aka fast startup time, then look no further than Clojurescript. There are two standalone Clojurescript environments that you can use to run clojure scripts. [1] Lumo and [2] Planck. For Clojure compiler that spits binaries there is [3] Ferret, but I haven't tried it yet, so I don't know how much of Clojue is implemented. [1] https://github.com/anmonteiro/lumo [2] https://github.com/planck-repl/planck [3] https://github.com/nakkaya/ferret

Support for NPM modules out of the box is a hot topic in the cljs community, imo things have greatly improved even in the past few months. Checkout https://github.com/anmonteiro/lumo And https://andrearichiardi.com/blog/posts/lumo-npm-dependencies...

It can, look at lumo: https://github.com/anmonteiro/lumo Its a ClojureScript compiler built in ClojureScript, which creates NodeJS targets. Self-Hosted ClojureScript's current downside is that it does not support as many of the ClojureScript libs. That said, the use of the JVM by ClojureScript is just as a build tool. Don't you already have Java installed on your computer anyways?

Is this the only big success story for Clojure or other companies using the Lisp family of programming languages? I know there is Paul Graham's Viaweb. [1] Does anyone know of other examples? I like the fact that they are a practical company, using Go when needed where "static dependency compilation and fast start-up are more important". I wonder if the ClojureScript's annoucement on integration of NodeJS modules [2] changes that? Also, Lumo [3] is definitely a move in the right direction for this, addressing the slow start-up times for Clojure/ClojureScript, making it suitable for shell scripts and CLI binaries. > Having a lingua franca also helps reduce overhead when engineers want to move between layers of the stack. The way I see it, Clojure allows you to use a single language and syntax from the super heavy backend stuffs, to the fro

It's really not though. ClojureScript runs on Node.js just fine, and you have stuff like Lumo https://github.com/anmonteiro/lumo for scripting, and even a full blown framework for web development https://macchiato-framework.github.io/ The main advantage of keeping Clojure hosted is in being able to leverage the host ecosystem. It's simply not practical to implement an ecosystem comparable to the JVM or Node from scratch, especially for a niche language.

Lumo (https://github.com/anmonteiro/lumo) or Planck may fit your requirements, though they lack a C FFI. They're based off ClojureScript/Javascript, and startup way faster than the JVM Clojure. Could probably try the node-ffi library with Lumo. There's the abandoned ClojureC project (https://github.com/schani/clojurec). There's also JVM-to-native compilers like gcj or ExcelsiorJet. But at the moment, it doesn't seem like there's an established way to do all that.

> I have to say, the only thing that annoys me about it occasionally is its marriage to the JVM. Clojurescript can be hosted entirely in js; here's a repl: https://github.com/anmonteiro/lumo/

Lumo[1] probably fits your use case perfectly. It's a ClojureScript REPL running in a NodeJS context. You have access to both bootstrap-ClojureScript-compatible libs as well as the whole NodeJS ecosystem. The REPL has some nice ergonomic features and comes with a TCP socket REPL you can use with Emacs inf-clojure and (I hear) Cursive. [1]: https://github.com/anmonteiro/lumo

There are a few efforts out there to provide something with near instant start up time. Can be useful for scripting, for example. Planck, which runs on JavaScriptCore: http://planck-repl.org/ Lumo, which runs on V8: https://github.com/anmonteiro/lumo

Boot is too slow to start. Use Lumo, which is based on Node.js and boots really fast. And npm packages are available too. Well, it's more JavaScript than Java. https://github.com/anmonteiro/lumo