process VS cloroutine

Check out babashka/fs and babashka/process as well. These are still based on Java interop underneath but they have some more features than the clojure.java.io and clojure.java.sh libraries. I tend to reach for these first when I need to do something filesystem or process related.

A bit off-topic but if you're looking for an up-to-date maintained library to shell out in Clojure, take a look at process

Nothing prevents you from using babashka and still use it as a glue for Unix programs. The difference is you get a nicer language (my opinion), a REPL if you want, and also you do get access to a lot more libraries from Java and Clojure and the pod concept of you want too as well.

So to be clear, you can easily use ImageMagick, curl, jq, pup, etc. See: https://clojure.github.io/clojure/clojure.java.shell-api.htm... and https://github.com/babashka/process

Other benefits are that you only need to learn Clojure and suddenly you can use it for everything, backend apps, frontend apps, scripts, etc. You don't need to learn bash, js and Java/go, make, etc.

> Then I did a very brief search for clojure libraries, things like parsing html. Most of the github projects were not seeing much activity (like last commit in 2020)

This surprises everyone, but those libraries still work, have no bugs, are missing no features, and can be used without issues in production.

Clojure is one of the most stable language, so things never break and almost never need updating.

People have a kind of Stockholm syndrome I think coming to other languages that if something didn't need a bug fix in a year it must be abandoned and broken.

And the reason you often don't need to update those libraries to keep up with the environment, like OS versions, is because they all leverage existing runtimes under the hood like JVM and that's the one that updates. So they're all secure and kept up to date, working with new OS and new architecture for free as JVM updates. This applies to Babashka as well, because it is implemented using a JVM.

Thanks for sharing! I think these restarts could definitely be implemented as a library in Clojure with the help of a coroutine library like https://github.com/leonoel/cloroutine#guides

Do you mean the example here https://github.com/leonoel/cloroutine/blob/master/doc/01-generators.md , with the `*tail* binding? It took me a long time looking at it to finally grok it, and it's really hard to explain in English but basically when the coroutine comes across one of these symbols that are "breaks" (in our case, "yield" is such a breaking symbol), then it will pause the coroutine, and actually call what the symbol points to (the implementation of "yield"), which returns (cons x *tail*), and keep in mind that it is all run within a recursive call to gen-seq where *tail* is bound to a lazy-seq of the remainder of the generator (binding [*tail* (gen-seq gen)] (gen)), it's pretty confusing but yeah just have to stare at it for a long time I think haha.

I think Clojure is really missing python/js-style generators, like what is implemented in https://github.com/leonoel/cloroutine/blob/master/doc/01-generators.md

The next level up is core.async go blocks which compile your AST to a state machine. Also see cloroutine which also compiles the AST to a state machine or something, one of the tutorials uses cloroutine to add async/await to Clojure.

Coroutines are a more general concept, and can be used to implement conditions/delimited continuations. There’s an example in their docs.