Scala (pronounced "scah-lah") was originally developed as a research language in 2003. It is often described as a multiparadigm language because it combines elements from different programming philosophies. At its core it is a pure object-oriented language (that is, everything is an object) with functional capabilities.
Functional, in this context, refers to a programming style popular in academia that favors the use of functions with no side effects (functions that do not alter the state of variables or other functions), the use of first class functions (functions become objects that can be passed to other functions), and to the extent possible, the use of constants over variables. The last preference might sound peculiar, but it's already found in many languages, including Java. For example, strings in Java cannot be modified. Any attempt to change an existing string results in the creation of a completely new string.
Functional programming has been a favorite area of research, and Scala might be a vehicle by which it enters the mainstream. Its big advantage over traditional programming approaches is that it greatly facilitates parallel programming, the ability to have multiple portions of a program executing simultaneously. As multiple cores become the norm in modern processors, parallel programming represents an excellent way of exploiting the full capabilities of the hardware. To this end, Scala is unique among the languages for the JVM in having actors, another parallel programming construct, built into the language. (Fantom has actors as an add-on. The difference is small, but important for some developers.)
Scala enjoys a singular advantage over the other languages reviewed here: performance. The language is compiled to optimised bytecode and runs essentially as fast as native Java. The remaining languages are either somewhat or very far behind Scala in execution speed.
Scala does have shortcomings, however. The first of these is sometimes opaque syntax. Every language can be used to generate impenetrable code, but it is easier to do so in Scala. The second problem is one of binary compatibility.
The maintainers of Scala have several times released new versions that are not binary compatible with previous versions. This is a huge obstacle to widespread adoption, certainly among enterprise developers, who will find no enjoyment in recompiling existing code to be able to work with more recent code. Nonetheless, good tools for Scala have emerged, and the community of users is active and enthusiastic. I fully expect Scala to be in the top tier of JVM languages within a couple of years.