Ruby (via Opal) vs Scala.js

Ruby has a very clean syntax that makes code easier to both read and write than more traditional Object Oriented languages, such as Java. For beginning programmers, this means the focus is on the meaning of the program, where it should be, rather than trying to figure out the meaning of obscure characters.

presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0...presidents.length
    print ss, ": ", presidents[presidents.length - ss - 1], "\n";
end

Ruby is one of the most popular languages for developing web sites. As a result, there's an abundant amount of documentation, sample code, and libraries available for learning the language and getting your project up and running. The most popular features are just 'gem install' away.

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.