Scala.js vs ClojureScript

Scala offers type inference, which, while giving the same safety as Java's type system, allows programmers to focus on the code itself, rather than on updating type annotations.

In contrast to other options, Scala.js is a compiler plugin for an already existing and mature language: Scala.
As such, it benefits automatically from the existing compiler, from the language design choices made for Scala, which exists and is established in the industry since years.

The JavaScript-interop of Scala.js is very direct and lightweight.

The strength of Scala (JVM) on the server can not be underestimated, and is probably superior to any other choice listed here (where applicable; many have no server-side equivalent).

Being able to use such a powerful language (and ecosystem) on the server AND on the client, and sharing code between the two, is a big advantage.

Scala.js implements most of the Scala standard library and many parts of the Java one. Among others, it supports Scala's rich collection library.

Scala.js performs dead-code elimination out of the box (when running in the "fullOpts" mode).

Scala supports both Functional and Object Oriented styles of programming. Beginners can learn both paradigms without having to learn a new language, and experts can switch between the two according to what best suits their needs at the time.

Keeps your client and server sources in sync.

Through SBT, Scala.js supports incremental compilation out of the box. That is: SBT automatically picks-up the changes (think "watch" in other tools) and only recompiles what is needed.

This makes the development cycle fast and very pleasant to work with.

The same good and mature tooling that can be used for Scala can be used for Scala.js out of the box (code-completion, refactoring, immediate feedback, etc.).

The immutable values make it perfect for working with concurrency.

Because Scala.js is a plugin to the Scala compiler, the whole power of the Scala language is available at compile-time. Which includes macros. Very expressive things can be done, in a type-safe way, which are difficult or impossible in other languages.

While SBT is arguably not as simple as Maven, it beats the chaos of the JavaScript build ecosystem.

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.