Java – scalablity of Scala over Java

Disclaimer: I'm not a Scala guru.

Scala does two things extremely well which Java (currently) does not.

Solve functional problems

• At the most basic level, Scala has fully fledged closures with collections support. This means you no longer have to write boiler plate code such as (shamelessly ripped off a DZone post)

  public List<Item> bought(User user)
  {
      List<Item> result = new ArrayList();
      for (Item item : currentItems)
      {
          if (user.bought(item))
          {
              result.add(item);
          }
      }
      return result;
  }
  

But instead write something like:

def bought(user: User) = items.filter(user bought _)

• There's more functional love, but I'm not qualified to talk about it since I currently still suck at functional programming :)

Solve concurrency in a safer way

• Scala has an actors model (+ some other goodness) which is inheritly safer than Java's mutable data + locks on Thread model (no matter how good the libs are getting, Java is still hindered by the language).

I can't honestly think of too much else that makes Scala stand head and shoulders above Java. Lots of small gains and improvements yes, but also far more rope to hang yourself with. YMMV

HTH a little

When Martin Odersky talks about scala as a scalable language choice, what he means is that the language itself is appropriate for:

• scripting stuff
• writing applications
• writing monster "enterprise" (for the want of a better word) applications

He is most certainly not referring to scalability from the perspective of performance!

The fact that he can claim that scala is as appropriate for quick'n'dirty scripting as it is for large-scale enterprise deployment is roughly as follows:

Scripting

Scala is great for scripting because its type inference and functional style make it both concise and great for slicing and dicing collections etc.

Applications

Scala is great for writing applications because it is a statically type checked language with some great features for working in both functional and imperative styles. Scala is compatible with Java and hence you can leverage an enormous ecosystem of libraries.

Enterprise Deployment

Scala compiles to bytecode and runs on the Java Virtual Machine, a stable system with great performance, when compared to (so-called) dynamically typed (i.e. untyped) languages. Again, the fact that it is statically typed means that refactoring is made much easier on large codebases.