Types on the end are very common in many languages, a lot more common (and IMO readable) than lisp-style (+ a b) which you have to learn to use clojure.<p>An optional type system is almost useless (believe me I spent a lot of time trying to use the checker framework in Java before switching to Scala), because libraries don&#x27;t have to follow it, and you never know whether the type definitions for a given library are true or not.<p>Scala is generally immutable by default and has persistent data structures.<p>STM is great but you can do it fine in Scala. It&#x27;s just not a language-level feature because it doesn&#x27;t need to be - Scala is expressive enough that you can write an STM implementation in a library.<p>Scala&#x27;s DSL support is great (look at e.g. Spray route definitions) and can usually done in ordinary code without macros, which in turn means you have full IDE and tool support for them. The trouble with lisp DSLs is that your syntax still has to look like lisp - the support for e.g. infix operator syntax is quite limited (you have to use reader macros which are more complicated and harder to work with). But for a lot of business domains the natural language of the domain uses infix operators.