5 Things a Ruby developer needs to know about Scala

1. Performance and stability. Scala is fast. It's very fast. It's (in my experience) 10-100 times faster than Ruby. Scala is fast without sacrificing programmer productivity because Scala's got all the goodness of Ruby's "functional" side. Scala support native OS threads so you can write a Scala program that takes advantage of all the cores and CPUs you've got on your machine. Scala doesn't crash. I don't get [BUG] and a program termination (one of my Ruby projects is a parallel calculation job that runs on 10 machines and I get random failures on 0.5% of my jobs... they crash, usually when doing floating point math.) Yeah, YARV and other things are coming real soon now (Christmas 2007) but Scala's got them today.
2. Richer XML and collection classes. Scala has built-in syntactic support for XML (it's kind of like having eRB as part of the language) and the XML classes are richer (and much, much faster) than Ruby's. Scala's collection classes are richer than Ruby's (mutable and immutable, linked lists, etc.) so that you have a broader range of how you can build your application.
3. More of a functional flavor. Scala makes it easy (and intuitive) to write functional style code. "So?" you say. "Much of Ruby's beauty and productivity comes from its functional side," I say. Scala makes it easy to write recursive functions that manipulate sets (think of when you realized that Ruby's looping constructs were more powerful than for (x = 0; x < 10; x++)). This means more "writing code that is side effect free" which means writing more maintainable code.
4. Much better facilities for writing DSLs. Scala's syntax is more flexible and expressive that Ruby's. Scala Domain Specific Languages can be constructed from existing language elements (like Ruby.) Here's an example:

   val query = select fields ("first" of characterVarying(50)) from "person" 
                     where ("last" in "person")=="'D.'"
   

   Another example is Scala's parser library which allows you to have BNF style expressions right in your Scala code. From a Textile Parser (which has a similar line count to RedCloth), you can see valid Scala code:

      def lineElem : Parser[Textile] = 
          not(blankLine) &&& (beginingOfLine ||| endOfLine ||| image ||| footnote_def ||| anchor |||
   			  dimension ||| elipsis |||
    			  copyright ||| trademark ||| registered ||| emDash ||| enDash ||| italic |||
    			  emph |||
    			  cite |||  span ||| code ||| delete ||| insert  ||| sup |||
    			  sub ||| bold  ||| html||| single_quote ||| quote ||| acronym  ||| charBlock)
   

5. Static typing without getting in your face. Scala is strongly typed, but not an ugly, repeat, repeat, repeat yourself sort of way. You have to declare the type of function (method) parameters. The compiler figures almost everything else out for you.
   myList.map {i => i.toString}.toList.mkString("{",",","}") is a legal construct
   Scala's typing doesn't "get in your face" on the other hand, Scala catches silly mistakes like mistyping a variable name, etc.

There are also strengths that Ruby has over Scala. Ruby is much better than Scala at scripting tasks. Scala doesn't have Regexs at the language level (they're libraries.) Ruby scores big time in my book for having Regex in the language. Ruby's syntax is marginally cleaner to me than Scala's. Ruby's open classes are nicer than Scala's implicit type conversion, but implicit type conversion is more secure and maintainable than open classes. Ruby's meta-programming features are easier to access than Scalas, but Scala supports run-time class generation. I find that chaining and currying functions is more maintainable and easier to debug than meta-programming in Ruby.