Is Java *really* less complex than Scala?

Question

I frequently hear claims that Scala is much more "complex" than Java.

Can anyone therefore provide an example of Java code that can't be improved by writing it in Scala, or Scala code that can be improved by writing it in Java (but not by just rewriting within Scala)

By "improve", I mean that the code is better with regards to one (or more) of the following characteristics:

• readability - how quickly can another developer, familiar with the language, understand the code
• maintainability - how much work is involved in a simple refactoring
• thread safety

... but doesn't sacrifice any of the above qualities.

It must be a plausible example, something that could potentially exist in a real program.

I also don't expect the API to match 100% after the transformation, and would prefer that Scala code sticks to Scala idioms, while Java sticks to Java idioms.

Answer 1

No.

Answer 2

The only examples I can think of where a pure Java implementation may be more concise than a Scala one is if you need to use a Java library, and don't want to write your own Scala wrapper around it. That said, there's nothing stopping you writing the same code in Scala.

Some examples from Progrmaming in Scala of why Scala is more concise than Java

Java

class MyClass {
    private int index;
    private String name;

    public MyClass(int index; String name) {
        this.index = index;
        this.name = name;
    }
}

Scala

 class MyClass(index: Int, name: String)

Java

boolean nameHasUpperCase = false;
for(int i =0; i < name.length(); ++i) {
    if (Character.isUpperCase(name.charAt(i))) {
        nameHasUpperCase = true;
        break;
    }
}

Scala

val nameHasUpperCase = name.exists(_.isUpperCase)

When it comes to thread safety the idea is that because Scala prefers objects with immutable state you can pass them to separate threads without worrying about concurrency. Its still possible to make non thread-safe Scala code using var instead of val

Answer 3

If you compare Scala type system with Java type system, Scala is more complex. This does not mean that Scala is less capable, but for a new developer Java will be easier to understand.

Answer 4

I guess Martin Odersky already answered your question putting it in slightly different terms.

Anyway just give a look at this code example of a calculator implemented with monads. Personally I took some days to completely understand how it works. I suppose I could have implemented the same in java with a far more verbose but also far more straightforward way.

I posted here my personal opinion about this question.

Answer 5

Sorting a list of lists by their sizes, and then printing the result:

In Java,

@SuppressWarnings("unchecked")
List<List<Integer>> xss = Arrays.asList(
  Arrays.asList(2, 4, 5, 6),
  Arrays.asList(3, 6),
  Arrays.asList(78, 52, 11),
  Arrays.asList(9)
);
Collections.sort(xss, new Comparator<List<Integer>>() {
  @Override
  public int compare(List<Integer> x1, List<Integer> x2) {
    return x1.size() - x2.size();
  }
});
System.out.println(xss);

In Scala,

val xss = List(List(2, 4, 5, 6), List(3, 6), List(78, 52, 11), List(9))
println(xss.sortBy(_.size))

Clearly, Java is simpler than Scala! :P

Answer 6

Hmm, I can see this response getting lots of downvotes.

I believe the key really comes down to what you stated in the question :

How quickly can another developer, familiar with the language, understand the code

I think Scala's complexity portrays itself if the question was rephrased as

How quickly can another developer, unfamiliar with the language, become productive at writing code

In many ways Scala reminds me of C++. There's really tons of small (and big) things a developer needs to learn, practice and internalise before achieving any reasonable degree of competence with the language.

These are two completely different dimensions of measuring complexity. Not sure if other opinions on Scala's are driven by the same factors as those I described above.

Answer 7

I think you're mixing two things in your question.

Scala is much richer in features than Java (thus the language is more complex), but that allows the programmer to write more concise and expressive code most of the time (thus the resulting programs are simpler).

Answer 8

There is just one case that I've encountered where a Java->Scala translation can be difficult.

Scala requires that all classes have a primary constructor, any other constructors must ultimately delegate to the primary.

This can cause an issue when attempting to convert a Java class that has multiple constructors which don't interact with each other. Having said all of that, the design pattern is invariably a code smell in Java.

so I can't claim in good conscience that this Java pattern is simpler than the corresponding Scala pattern, not when it should never pass a code review in the first place!

Answer 9

Prior to working in Scala I never had to:

1. Disassemble my own code to figure out what was going on in order to diagnose bugs
2. Spend hours (or days) tweaking JVM parameters and reading arcane JVM documentation
3. Scala has made me thankful that HotSpot is open source, not for the community reasons, but so that I could look at the source to help diagnose problems with my programs.

So ironically I've found that working in Scala, which is a much higher-level language than Java, has forced me to be far more aware of lower-level details about the compiler and the JVM. Not that this interferes with writing Scala or that I even mind it. It was just a learning curve I had to climb, and I personally enjoyed it.

I'm also not claiming that my experience is typical. I don't shy away from low-level details, and usually avoid magic (or, rather, learn enough such that I don't consider it magic anymore). For example, in order to comfortably transition from C++ to Java, I had to read papers on GC algorithms. Not because I had problems with Java's GC, but because treating it as magic just felt so wrong. So you could say I'm neurotic. But I think it's helped me debug and tune Scala code on many occasions.

Overall, I would say Scala, and especially some idiomatic patterns in Scala, tend to greatly obfuscate what the code is doing in favor of the intent of the code. 95% of the time that's a great trade. But that remaining 5% can be a real drag.

Answer 10

The only case I know of is when you have the additional demand of performance; here's the already-properly-written Java code (I don't see the point in starting with poorly written Java and making it better, but I can always use some other less-suitable loop construct):

// Java (fast)
public double maxsum(double[] x, double[] y) {
  double sum = 0.0;
  for (int i = 0; i < x.length ; i++) sum += (x[i]>y[i]) ? x[i] : y[i];
  return sum;
}

In contrast:

// Scala (fast)
def maxsum(x: Array[Double], y: Array[Double]) = {
  var sum = 0.0
  var i = 0
  while (i < x.length) {
    sum += if (x(i) > y(i)) x(i) else y(i)
    i += 1
  }
  sum
}

In this particular case, Scala has less compact syntax (Array[Double] vs. double[]), a less powerful looping construct with more chance for error (the index variable floats around on three separate lines), and a less compact alternate-assignment (if/else vs. ?:) that clutters the code unnecessarily.

There are compact ways to do this in Scala:

// Scala (slow)
def maxsum(x: Array[Double], y: Array[Double]) = (x,y).zipped.map(_ max _).sum

but this rewrite is unhelpful if you want the result computed quickly (i.e. at C speeds). If, in contrast, you want to write the code quickly and your performance bottleneck is elsewhere, this is an improvement.

Edit: I managed to get the inequality backwards the first time. It's fixed now, but it does highlight how nice it would be if the "slow" Scala version performed as well as the "fast" one....

Answer 11

Sure. Here:

// Scala
val sum = (0.0 /: l)(_ + _)

// Java
double sum = 0.0;
for (int i = 0; i < l.length; i++) {
  sum = sum + l[i];
} 

Of course, the Scala code could be written to look just like the Java code, but that's irrelevant to Joe Enterprise. All Joe Enterprise cares about is that he is trying to fix or add a feature to some code through which dozens of different programmers have gone before, and which does contain that line.

Those dozens of other programmers may perpetrate all sorts of absurdities in the code, but at least it is always pretty clear what the code is doing (as long as one ignores the perils of mutability) in Java, where the same cannot be said about Scala.

Not that I in any way agree with that notion. I think one should be an expert in whatever language one is a professional programmer for. You wouldn't want a contractor who knows "more or less" how to use his tools, right?