Not actually using any, but if scale problems come, we have the following order: Jruby, Clojure, Scala. The reasons behind the order:<p>* Jruby, because we really like the level of metaprogramming of ruby, the readability, the ammount of libraries, the effort Charles Nutter put into making it a very good port of ruby, and the library support that feels like ruby (dsl-ish, easy to use, easy to change, with tests as documentation, etc), even if you are not using Rails.<p>* Clojure, because it is dynamic, and enforces immutable state (most of the time), it has great metaprogramming support as well (which is very important for readbility), and you can use type annotations to remove all reflection code, and use direct invoking (as fast as java).<p>* Scala, because it is much more convenient to use than Java (and has other advantages, <a href="http://bit.ly/4DIKy4" rel="nofollow">http://bit.ly/4DIKy4</a>), while still being compiled to very efficient java bytecode. Its static typing has issues (<a href="http://bit.ly/asQ7FC" rel="nofollow">http://bit.ly/asQ7FC</a>), as its lack of metaprogramming. Implicit conversions, on the other hand, can deal with it for most part.<p>*Java/Groovy: Scala should be the lowest level we would like to handle. Groovy feels a bit like Ruby, it has more metaprogramming facilities (like categories, and AST manipulations are builtin, unlike Ruby's Parse Tree, which doesn't work on 1.9). However, Jruby is the same language we use everywhere else, and Groovy is not faster than clojure. So it is a "master of none" type of language. Not to mention that its stack trace is riddled with java garbage, and it feels a lot like Java, which is really a put off.<p>This is mosty for backend, as with are probably sticking with Sinatra on front end for a looong while. Twitter uses Rails on front end even nowadays, so it seems like we won't have too much problem with it as well.