There are some big places using clojure - the Daily Mail uses clojure heavily for it's website, as do SoundCloud; also, like Scala, it's used internally at some financial institutions - CitiBank have some clojure, and we've been using clojure at IOOF (an Australian superannuation company).

Performance is probably the last thing you need to care about when choosing a programming language for most businesses - unless you are doing hard-core analytics or handling huge scale, you just won't hit the sort of performance problems that are solved by a faster programming language (as opposed to a faster algorithm or architecture).

It really frustrates me that people _still_ put such weight on low level performance. In 1997 I had people saying "don't use Java, it's performance is far worse than C++". It was mostly untrue for business problems then - and computers are many orders of magnitude faster now.

Some other examples are Prismatic, Runa (recently bought by Staples), Climate Corporation (recently bought by Monsanto), Twitter (via acquisition of Backtype), etc. And there are a number of other big name companies very quietly using it to just get stuff done.

As far as automated trading is concerned, performance is critical, which is why C++ still is king in this domain.

Real life performance generally favors Scala over Clojure, but by a relatively small factor (2x). This is mostly due to the clojure implementation's use of reflection to achieve dynamism. Dynamism? You know what I mean. You can make this up with some really clever tools for parallelism though, if your problem fits.

This is totally bogus. Clojure will only use reflection if calling into Java interop with ambiguous types and even those cases can be addressed with type hints (if they even matter).

I think the real world popularity of scala is significantly higher than that of clojure (e.g. TIOBE rankings). I don't think there is any more "future focus" on clojure - scala is still making big new releases all the time, and IMO it will be easier for scala to gain clojure's flexibility and compile performance than for clojure to gain scala's safety and runtime performance.

TIOBE is garbage but I would not dispute that Scala use is higher today. However, Scala and Clojure use both continue to rise.

Well-written Scala and Clojure can provide comparable (ie Java level) performance.

Clojure has tools (like core.typed and Prismatic's schema library) to optionally provide you with static typing where you want it, without the burden where you don't need it.

Clojure does regular releases every year (that continue to be high quality and maintain backwards compatibility) and now has paid developers and support that will continue to accelerate progress. Because of the flexibility of the language, a great deal can be done outside the language in libraries (such as the entirely new concurrency paradigm in core.async).