Do you really mean concurrent or distributed?
If you mean concurrent (multi-threaded, multi-core etc.), then I’d say Clojure is the natural solution.
- Clojure’s STM model is perfectly designed for multi-core concurrency since it is very efficient at storing and managing shared state between threads. If you want to understand more, well worth looking at this excellent video.
- Clojure STM allows safe mutation of data by concurrent threads. Erlang sidesteps this problem by making everything immutable, which is fine in itself but doesn’t help when you genuinely need shared mutable state. If you want shared mutable state in Erlang, you have to implement it with a set of message interactions which is neither efficient nor convenient (that’s the price of a nothing shared model….)
- You will get inherently better performance with Clojure if you are in a concurrent setting in a large machine, since Clojure doesn’t rely on message passing and hence communication between threads can be much more efficient.
If you mean distributed (i.e. many different machines sharing work over a network which are effectively running as isolated processes) then I’d say Erlang is the more natural solution:
- Erlang’s immutable, nothing-shared, message passing style forces you to write code in a way that can be distributed. So idiomatic Erlang automatically can be distributed across multiple machines and run in a distributed, fault-tolerant setting.
- Erlang is therefore very well optimised for this use case, so would be the natural choice and would certainly be the quickest to get working.
- Clojure could do it as well, but you will need to do much more work yourself (i.e. you’d either need to implement or choose some form of distributed computing framework) – Clojure does not currently come with such a framework by default.
In the long term, I hope that Clojure develops a distributed computing framework that matches Erlang – then you can have the best of both worlds!