Writing Performant Scala

Keep in mind that the while loop is 3x faster because the loop itself is doing a trivial amount of work. As your loops get larger, call functions that do more work, or operate on objects instead of primitives, the overhead of using idiomatic Scala drops considerably.

Another important point: the idiomatic Scala version is one concise, purely functional line. The second version on the other hand is 6 lines and involves mutation. If you were to embed it in another part of the program in a purely functional way, you'd have to wrap it in curly braces and add an extra expression to return the final value of x, upping it to 9 lines. Claim what you want about readability, but lines of code impose a cognitive burden, both in reading them and scrolling through them. I'd much rather express an idea in one line of pure code if possible than with 6-9 lines of code that modifies state.

In real production code, things like this are rarely bottlenecks. The count version, frankly, is less error prone. There are a few different ways that you can easily mess up the while loop version. In places where a loop like this really is the bottleneck we'll drop in the C-style version.

In general though, we find the code just kind of balloons if you use patterns like this everywhere.

I agree in principle that one shouldn't have to understand the implementation of collections to use them effectively, but these limitations are by no means exclusive to Scala. Haskell's lists, difference lists and seqs work exactly the same way as Scala's list collections. Iteratively concatenating strings in Python will murder your performance. Most (all?) sufficiently complex systems involve tradeoffs.

I'm not sure what you mean by "hasn't taken off". Scala is pretty thriving in these parts: I.e., we use Scala where I work. Headhunters contact me about open Scala positions. A few months back there was a Scala symposium down the street that had several hundred attendees. There is a local user group that is "sold out every month. I.e., the room holds 75 people, and more than that number always wants to attend. Etc.

It takes a long time for a new general purpose programming language to displace existing general purpose programming languages if it doesn't fill a very particular niche for which there is a great demand.

Re performance, I recently implemented an algorithm in Scala that performs quite well. It didn't at first, but it was very easy for me to profile it using Java profiling tools and to tighten a couple of loops where most of the CPU was being consumed. I don't have any deep knowledge of Scala collections, but I know how to use a profiler. I don't think the initial implementation would have performed any better if it had been written in Java.

Once I had gotten things speedy enough, I was further able to speed everything up by 4X just by changing a collection to the parallel version of the collection. Then all four cores could crunch on it. If I had 8 cores, it would have no doubt run 8X faster. That parallelization came from tweaking only one line of code! I would have never achieved this 4X speedup in Java.

Data structures have inherent time and space complexity tradeoffs. This is just as true in C as it is in Scala.

"performant" may become legitimate soon, but it seems destined to be another tech buzz/weasel word.

Thanks for pointing that out Don.