When comparing Elixir vs ClojureScript, the Slant community recommends Elixir for most people. In the question“What is the best programming language to learn first?” Elixir is ranked 9th while ClojureScript is ranked 41st. The most important reason people chose Elixir is:
Leverages the existing Erlang BEAM VM
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Great for concurrency
Leverages the existing Erlang BEAM VM
Pro Great getting started tutorials
The tutorials are very clear and concise (even for a person not used to functional programming). Plus they are also very mobile friendly.
Pro Powerful metaprogramming
Write code that writes code with Elixir macros. Macros make metaprogramming possible and define the language itself.
Pro Full access to Erlang functions
You can call Erlang functions directly without any overhead: https://elixir-lang.org/getting-started/erlang-libraries.html
Pro Scalability
Elixir programming is ideal for applications that have many users or are actively growing their audience. Elixir can easily cope with much traffic without extra costs for additional servers.
More details can be found here.
Pro Great as a first functional programming language!
Pro Great documentation
Elixir's documentation is very good. It covers everything and always helps solving any problem you may have. It's also always available from the terminal.
Pro Syntax is similar to Ruby, making it familiar for people used to OOP
All of the benefits of Erlang; without as steep a learning curve of prolog based syntax. Elixir is heavily inspired by Ruby's syntax which many people love.
Pro Easy to download libraries
Comes with built in build tool called "mix". This will automatically download libraries and put them in the scope of the application when you add them to the "deps" function and run mix deps.get
Pro Live interactive programming with figwheel
Figwheel builds your ClojureScript code and hot loads it into the browser as you are coding! Every time you save your ClojureScript source file, the changes are sent to the browser so that you can see the effects of modifying your code in real time.
Pro Simple syntax
Lispness makes ClojureScript trivial to comprehend after an initial learning overhead.
Pro Easy to use existing JavaScript libraries
Clojure and ClojureScript are designed to be able to interact with their host. So the language by design makes it is easy to use existing JS libraries.
Pro Targets Google Closure-ready JavaScript for immense optimizations
Google's Closure Library converts regular JavaScript into a highly optimized form - including dead code analysis/elimination. It can even remove pieces of unused code from 3rd party libraries (eg, if you import jQuery but only use one function, Google Closure includes only that piece).
Pro Share application logic between browser and Clojure server
Clojure is also able to run web servers, so one can reap similar benefits to NodeJS in terms of sharing code between client and server.
Pro Can be used with React out of the box
Pro Excellent build tools
Both Leiningen and Boot are great build tools that manage code dependencies and deployment.
Pro Excellent tools for web development
ClojureScript has superb wrappers around React.js (see Reagent) that make building single-page apps a breeze. With figwheel, it's a web dev experience unlike any other -- hotloaded code, repl interaction, and instantly reflected changes make good development fun and fast. You can add things like Garden to make CSS-writing part of the same holistic experience and suddenly all development is a pleasant, smooth process.
Pro The Spec core library
From the creator of Clojure:
Spec is a new core library (Clojure 1.9 and Clojurescript) to support data and function specifications in Clojure.
Writing a spec should enable automatic: Validation, Error reporting, Destructuring, Instrumentation, Test-data generation and Generative test generation.
Cons
Con Deployment is still not as easy as it should be
Con Some design choices may seem strange
Some design choices could have been a little more appealing, for example: using "do...end" comes natural in Ruby for blocks but Elixir uses them for everything and it looks pretty weird:
Enum.map [1, 2, 3], fn(x) -> x * 2 end
or
receive do
{:hello, msg} -> msg
{:world, msg} -> "won't match"
end
Con Tooling is horrible
I've never seen worse tooling before. Writing tests and getting test coverage reports is near impossible. Tooling is brittle and clunky. Feels prehistoric.
Con Syntax may seem cryptic to people not used to Lisp
Lisp is sometimes called "syntax-less" and this is bewildering to those steeped in Algol-type syntax (Java, Javascript, C, etc). Being a dialect of Lisp, ClojureScript's syntax may seem cryptic and hard to understand for people not used to it. While Lisp has very little syntax compared to other languages and it's generally considered pretty terse, there's still an initial overhead in learning the language.