ClojureScript vs Haskell

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.

Lispness makes ClojureScript trivial to comprehend after an initial learning overhead.

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.

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).

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.

Both Leiningen and Boot are great build tools that manage code dependencies and deployment.

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.

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.

Haskell's referential transparency, consistency, mathematics-oriented culture, and heavy amount of abstraction encourage problem solving at a very high level. The fact that this is all built upon little other than function application means that not only is the thought process, but even concrete solutions are very transferable to any other language. In fact, in Haskell, it's quite common for a solution to simply be written as an interpreter that can then generate code in some other language. Many other languages employ language-specific features, or work around a lack of features with heavy-handed design patterns that discourage abstraction, meaning that a lot of what is learned, and a lot of code that is needed to solve a particular problem just isn't very applicable to any other language's ecosystem.

It is pure and does not mix other programming paradigms into the language. This forces you to learn functional programming in its most pure form. You avoid falling back on old habits and learn an entirely new way to program.

All Haskell implementations are completely free and open source.

As Haskell lends itself exceedingly well to abstraction, and borrows heavily from the culture of pure mathematics, it means that a lot more code conforms to very high-level abstractions. You can expect code from vastly different libraries to follow the same rules, and to be incredibly self-consistent. It's not uncommon to find that a parser library works the same way as a string library, which works the same way as a window manager library. This often means that getting familiar and productive with new libraries is often much easier than in other languages.

Haskell's Purely Functional approach means that code is referentially transparent. This means that to read a function, one only needs to know its arguments. Code works the same way that expressions work in Algebra class. There's no need to read the whole source code to determine if there's some subtle reference to some mutable state, and no worries about someone writing a "getter" that also mutates the object it's called on. Functions are all directly testable in the REPL, and there's no need to remember to call methods in a certain order to properly initialize an object. No breakage of encapsulation, and no leaky abstractions.

Conciseness of Haskell lets us to write the expression on the whiteboard or paper and discuss with others easily. This is a strong benefit to learn FP over other languages.

The base language relies primarily on function application, with a very small amount of special-case syntax. Once you know the rules for function application, you know most of the language.

It's often said that, in Haskell, if it compiles, it works. This short feedback loop can speed up learning process, by making it clear exactly when and where mistakes are made.

Every function that expects more than one arguments is basically a function that returns a partially applied function. This is well-suited to function composition, elegance, and concision.

Haskell is a very terse language, particularly due to its type inference. This means there's nothing to distract from the intent of the code, making it very readable. This is in sharp contrast to languages like Java, where skimming code requires learning which details can be ignored. Haskell's terseness also lends itself to very clear inline examples in textbooks, and makes it a pleasure to read through code even on a cellphone screen.

Haskell is really popular in universities and academia as a tool to teach programming. A lot of books for people who don't know programming are written around Haskell. This means that there are a lot of resources for beginners in programming with which to learn Haskell and functional programming concepts.

Since the basic syntax is very similar to mathematics, Haskell syntax should be easy for people who have taken higher math courses since they would be used to the symbols used in maths.

Makes categorical higher order abstractions easy to use and natural to the language.