I've had the same experience. On the front-end, reagent is a joy to use. Haven't found a framework that feels more elegant/smooth than what reagent does with components and hiccup (maybe adding re-frame for state management).

There are some great choices for the server side too. Plus libraries for pretty much every DB. When something is missing, there's definitely a fallback option in Java.

Plus you get hot-reloading on both sides (e.g. boot-reload and ring-reload). And the ability to bundle everything into one neat jar file so the only dependency for deployment is Java.

Here's a getting started project that I found helpful: https://github.com/oakes/full-stack-boot-example

Although Clojure is my favourite language I find web development difficult with it due to auth for which Buddy is the standard. Buddy's integration with Luminus is opaque at best and the Buddy docs themselves I found unhelpful. You're left with the impression that Clojure web development is for experts who already understand how it all works. Total contrast with Rails where there are great resources for average developers and newcomers. I think this stems from the Clojure community's reluctance to embrace web frameworks.

Does Clojurescript support stuff like hot code reloading? And does Clojure have any good framework for an actor system implementation?

Because I've been interesting to get an excuse and try Clojure out and what you're saying is really interesting.

Clojure has its own very effective strategy for multi-threading, and it is not the actor model. The language is built for concurrency and much careful language design was tailor-made for the challenges on modern threaded applications. Rich Hickey investigated the actor model considerably, and decided on a different model. In the core language, you have the choice of using its normal futures/threads with highly efficient and lock-free data structures, or using core.async, which is a model like Go channels. The latter is particularly popular in the community and generally the recommended approach.

Clojurescript offered the first and still (in my opinion) best option for hot reloading via "figwheel" which nearly all Clojurescript developers use. It automatically updates the UI as you code it.

Clojure, on the server, being a proper lisp with a real REPL, lets you poke and inspect and reload parts of the running program with no recompile cycle. A typical workflow there is to reload individual expressions or functions in the context of the running program to alter behavior as you develop.

Yeah, that's nice for multi-threading but it does not seem as good for distributed systems. This is why I still don't know if I should invest in Clojure or Elixir.

Can the REPL on the server be used to update production systems with no downtime?

Yes you can easily REPL into a live remote server and work with it while it is running. But more typically, the REPL-driven development happens on your own machine while you build, and then you just deploy the whole app. But it can be useful for remote debugging when necessary.

For distributed computing across multiple machines, you are right that the actor model has an edge there. Most applications don't require that, however. There is however Onyx and other tools for this in Clojure:

http://www.onyxplatform.org/index.html

I think the choice between Clojure and Elixir really comes down to how much your particular idea or requirement genuinely depends on the actor model. The vast majority of applications don't specifically require that, in which case you have more flexibility.

I was just looking into Onyx right now actually, haha. It's the first result when googling for distributed clojure. Not quite sold on the model, I don't yet know how the internals work so it feels a bit too magic. But I only got a quick peek so it would be unfair to dismiss it.

The vast majority of apps don't require distribution but I'd like to use a model of computation that would support it when needed so as to avoid large refactoring. And, preferably, allow for code reuse with systems that are distributed.

EDIT: Watching a talk about the internals of Onyx made by the creator. I gotta say, I'm liking it more and more.

Don't forget that with Clojure, anything you would do in Java or on the JVM using any language, you can do in Clojure. So for example, Scala has Akka, a powerful actor model. And of course, you can use that in Clojure if you want:

https://github.com/gaverhae/okku

(This is just one way to use Akka).

Interesting, okku seems completely outdated but I'll try to look out for an Akka integration as it is a really powerful and stable actor model implementation. Has backpressure and all of the other reactive niceties too.

You might just have converted me to clojure, haha.

I think most Clojure developers will tell you that it is wise at first to just use Java libraries directly, if you can. Look at wrapper libraries to see how the author approached the Java interop, then do it yourself. You are more likely to attain something that is maintainable, flexible and appropriate for your individual style and needs than using what someone else built for the purpose of interop for their needs.

Yeah, I'll probably do just that. Thankfully, I can research it more in my spare time.

I think I'll start with a hobby-project and see how well it goes.

The Clojurians Slack channel can be very helpful if you hit any snags.

Thanks for letting me know and for the many replies.

It does support hot-code reloading, the preeminent build tool for Clojurescript:

https://github.com/bhauman/lein-figwheel

has that out of the box. As for an actor model implementation, there is pulsar:

http://docs.paralleluniverse.co/pulsar/

Which has erlang-like actors, though some might suggest that core.async and its channel implementation provides everything you might need an actor for, YMMV.

Hmm, I guess I better look deeper into Clojure. Finally I get to play with a Lisp.

My main interest with actors is that these can be made to support hot code reloading on the server side. They also tend to be easily composable. Also also, they can be optimized by locality (eg. same-node, same-cluster, different-cluster)

I'm biased though, having not worked with CSP or other models.

I think you will find that as far as composability and hot code reloading, the combination of proper functional programming with a true REPL make this a powerful combination in Clojure that will at least match what you would get in a language built around actors.

For interactive Clojure/Script prototyping with Datomic, check out http://www.hyperfiddle.net/

> As an example I once ported an Elm project to Clojurescript and it was a 4x reduction in lines.

I'm curious to hear more about this. I'm someone who's used Elm at work, and on the side is interested in Lisp.

I think it is much easier to get real-world nontrivial work done in Clojurescript compared to Elm.

Can you go into any more specifics? I'm genuinely interested! Do you think it'll stay true as Elm matures?

Personally I think Elm is dying. It relies on a single language designer who works very very slowly. Since Elm came on the scene, vibrant languages with static typing for the front end have sprouted up and are better alternatives, like ReasonML if you want a language with static guarantees and workflow.

Elm could have been something, but I don’t expect it gain any mindshare, and the boat has sailed.

Clojurescript is a dynamic language, with easy JS interop and nearly zero boilerplate, so I still think it is the fastest route to a production app.