Lambda Island

You can check with Clojure and ClojureScript to target JS specifically. You can write your backend in Clojure and the front part in ClojureScript. Having the possibility to use the same language for both is great.

It's a mature functional language with interesting properties, it's practical, data oriented. Libraries quality are top notch, you'll find no big framework but libraries working together to achieve what you want.

Some ClojureScript libraries are awesome, for example if you're on React you have Reagent or Rum that are fantastic libraries to work with React.

OP post could be written like this in Clojure (if you want to be explicit with all the screens):

(defn needs-cancel-button [screen]
(case screen
:screens/loading true
:screens/code-entry true
:screens/success false))

You'll notice that this is not typed but you can use Clojure spec to have some validation (this way being less explicit just returning false for the Success Screen, and true otherwise):

(def screens #{:screens/loading :screens/code-entry :screens/success})
(defn needs-cancel-button
[screen]
{:pre [(s/valid? screens screen)]}
(case screen
:screens/success false
true))

Union types can be mimicked using spec, you'll find how here: https://lambdaisland.com/blog/25-09-2016-union-types

OCaml is also great, IMO you won't lose your time by learning these languages, you'll find some way to improve…

I'm not arguing that Clojure is as widely used as Java or Python, which are two most popular languages in the world. I'm saying that it's a ridiculous bar to set for calling something mainstream.

However, there are some other metrics we can look at. For example, if we look at downloads for popular libraries, we can see that Ring's been downloaded 9,058,741 times, and obviously there are repeat downloads for the same users, but even accounting for that it indicates a much bigger user base than you're suggesting. https://clojars.org/ring/ring-core

Other data points would be commercial tooling like Cursive and commercial funding for projects with organizations like Clojurists Together indicates that there is a critical mass of commercial users who are willing to fund projects

https://lambdaisland.com/blog/2020-02-03-open-collective-lambda-island-open-source

https://www.clojuriststogether.org/

Finally, Clojure usage is growing for new projects both in enterprise and government sectors in countries like Finalnd

https://twitter.com/autiomaa/status/1235944730267193345

https://docs.google.com/presentation/d/1nCZ-GmWLcH8Dcz3XJHY00xbm42V9-rBL9n2PGkKYp0k/edit?folder=0AM-3FGnMl8asUk9PVA

This is a very different picture from a tiny isolated community of a few thousand developers that you seem to be painting.

Sorry if it came across that way!

I recognise that it's easy online to mistake enthusiasm for overselling, and that wasn't my intention at all.

I have no stake in this other than to encourage people to give Clojure a try (I just enjoy the language and want to see it grow). I shared my perception that the site owner is well-respected (based on the community's reactions to blog posts, forum posts, and talks), and gave my own reasons (the education style works for me and he speaks with clarity and authority on a topic that can often be mired in academic concerns).

The good thing is that others teach Clojure actively if you're looking for a less job-oriented marketing pitch. For example, https://lambdaisland.com/ is worth learning from (and run by a developer with a popular Clojure project called Chestnut, if that matters to you), http://www.4clojure.com/ and http://clojurescriptkoans.com/ are free practise sites, and the https://www.braveclojure.com/ and Living Clojure books were helpful to me when getting started.

Some people are probably going to throw some shade on me for saying this since it's so out of fashion but in my mind, when it comes to some types of basic monitoring (SNMP monitoring of switches/linux servers, disk space usage, backups running and handling them when they don't) then Nagios does get the job done. It's definitely olives and not candy[1] but it's stable, modular, relatively easy to configure (when you get it) and it just keeps chugging away.

If anyone has any Nagios questions, I'd be happy to answer them. I'm a Nagios masochist.

(Also, I can recommend Nagflux[2] to export performance data, metrics, to InfluxDB because noone should have to touch RRD files)

[1]: https://lambdaisland.com/blog/2019-08-07-advice-to-younger-self

[2]: https://github.com/Griesbacher/nagflux

True! For a long time I was looking for the mythical "livecoding" setup, thinking some experimental programming language was needed or something, when all the while Clojure was there, just waiting for me :-)

In that way I feel Clojure's defaults to immutability go a step beyond what's offered in most Lisp's setups. Not everything "just works" though, thought is still needed in order to have certain things be easily reloadable. I'm talking things like using "defonce" forms and having a setup like described here [1].

I'm still exploring this space but I think the gist of it is to create a direct acyclic graph of dependencies, so you can start and stop exactly what you need, not unlike what build systems do.

1: https://lambdaisland.com/blog/2018-02-09-reloading-woes

Another good blog post that is IMO in the same vein: https://lambdaisland.com/blog/2022-03-10-mechanism-vs-policy (“Improve your code by separating mechanism from policy”). This blends harmoniously with “functional core, imperative shell”—the "mechanism" code is the "functional core", and the "policy" code is the "imperative shell"—and also a little bit with John Ousterhout's idea in A Philosophy of Software Design of "deep modules" (in this context, don't put policy stuff, i.e. arbitrary decisions, inside the module).