Functinal Approach: What happened to Scala?

Hi Ben,

I remember years ago Scala was becoming popular with its mix of OOP and Functional. Now it seems to have fizzled out. What happened? Thanks.

Hi Carl!

I've never worked with Scala professionally, I mostly played around to get to know it, and compare certain constructs and approaches.
So I don't have much insight on the topic, just my personal experience...

Scala is still a great way to mix OOP and FP, and it does many things "the right way" in my opinion.
I like the syntax and concepts, but whether a language succeeds, though, often doesn't depend on being a "better" solution.
Groovy was once hyped, too, and where is it now?
I remember people talking about Groovy replacing Java in many ways.
It still has its uses, we use it for Geb/Spock and a scripting interface, for example, but it feels fizzled out, too.

An important factor in choosing a language for me is tooling support, and in the case of Scala, I didn't have a great experience with it when I tried to integrate it into my Java projects.

In the last few years, it seems that many JVM languages besides Java, like Scala and Kotlin, concentrate on IntelliJ support and mostly ignore Eclipse users.
At least, it feels that way.

Looking at stats like pushes on GitHub, Scala appears to be the 2nd JVM language to be found, just before Kotlin, so it has its niche/communities, but just haven't reached the mainstream like Java.

With the increased release cadence of Java, many might see the cost of switching to another JVM language no longer as justifiable as before.
Especially with Kotlin as a contender, which will become eventually the dominant language for everything Android, in my opinion.

Still, that's all just speculation from me.

"... it seems that many JVM languages besides Java, like Scala and Kotlin, concentrate on IntelliJ support and mostly ignore Eclipse users."

That is completely the case in the Android world. Google has forced users to basically use IntelliJ as the development environment. Technically you can use Eclipse but it is a royal pain . Google has clearly embarked on a strategy of forcing devs to use Kotlin in an IntelliJ environment. I personally think IntelliJ is an over engineered and intrusive piece of garbage.  Google's approach has really turned me off Android development. Google wishes it was Apple and had a completely closed environment for devs. ( Xcode and Swift).

There are a few things I enjoy in IntelliJ, like its Stream debugger, but it's quite an opinionated IDE.
If you don't do the things it wants you to do, you're often out of luck.
IMO, Eclipse is more flexible, but I'm also quite used to it and know how to use it well.

For mobile development, Android Studio and Xcode give you at least some specific tooling.
But I haven't used Xcode's interface designer in years, and use Reveal for UI debugging, as I think it's more powerful.
For some time, I've tried using the now no longer available AppCode, but it broke with every new Xcode release, so I had to use Xcode anyway.

My frustration with IntelliJ is with the amount of configuration you have to dig through to cut out the intrusive suggestions, hints, etc... I have spent a half hour or more to just turn off some intrusive feature or other . It kills the joy of just getting on with actual programming. The tip on Reveal sounds useful.
The Android tooling is only reason I use IntelliJ .
thanks.
Paul

There's a lot to like about Scala -- and it is a very impressive language in terms of design and concepts -- but there are also a number of downsides.

We used it at work for close to 18 months before giving up on it. We started with 2.7 and went through the 2.8 migration which was absolutely awful: every single milestone build we tested against was binary-incompatible with previous builds and you had to update the entire toolchain to get it all to work together. Apparently, the 2.9 migration wasn't quite as bad but we just couldn't face it...

In addition, the compiler was very slow (and I believe it still is pretty slow?), and the error messages are generally terrible -- especially around the standard library with all of the implicit conversion stuff in collection operations.

The language itself is pretty complex, and some developers struggle with some concepts, so it's hard to figure out an effective "style guide" for what features to use and how to write idiomatic code -- and there's a bit of a schism in the Scala community itself that reflects that: you get the "better Java" crowd, using Scala primarily as a more concise and more expression "Java", and then you get the "pure FP" / Haskell / ScalaZ crowd who mostly eschew the OO side of the language and often produce "beautiful" code that the average Java developer is going to struggle to comprehend. In addition, the evolution of the language has followed a fairly academic arc (understandable, given how/where it was created and maintained) which I feel generates a lot of friction with mainstream Scala users at times.

I loved attending Scala user groups and conferences for a couple of years -- I'm in the San Francisco Bay Area so there was an incredibly active community here for a while! -- and I'm a big fan of FP so that aspect of the language really appealed to me. Ultimately, we switched to Clojure at work (in 2011) and have been very happy with that decision.

As a big fan of FP, I'm very pleased to see several authors encouraging that style in Java, and I think the overall direction of the Java language has been very encouraging (from Java 8 onward -- I had become very disillusioned with Java by the time Java 5 appeared but since 8 came out it has slowly warmed my heart again after I'd been using Java since 1997!)

Thanks for the insight!

I heard more than once about migration issues in Scala from the sidelines, which always sucks.
Languages that force too much work on you for each update drain your energy, and you start disliking the language regardless of how good it might be.

That's something I absolutely hate about Javascript, as I don't do much work in it.
It feels like each time I open a project and want to do a little work or update a dependency, it seems there's completely new and often incompatible tooling required to get it up and running.
It highly depends on the project you're working on, but I still have nightmares about working with React Native...

The schism in Scala seems almost unavoidable, as the language is great for both approaches, and fighting about "the right way to do things" is quite a popular pastime for many developers

Java might even have an advantage here, as it's still, well, the same "old and boring" Java, but now with more and more cool and functional(-akin) features that integrate nicely into its OO/imperative world.
It still has problems and won't support purely functional programming to an extent other languages can any time soon, but you're right, the direction it's taken since Java 8 is very encouraging, especially with the highly increased release cadence for new features.

Aside from Scala's issues with binary compatibility, compile times, complexity and FP purity wars , I think another factor is that Java itself evolved to embrace FP more with lambdas, streams and Optional - and other JVM languages like Kotlin and Clojure have come in as well.  I feel like the high point of Scala buzz was around the time we were still looking at Java 1.7 and wishing for alternatives.  Nowadays it's easy enough to stay on Java, or Kotlin feels like it's adopted many of the most popular parts of Scala, while being much simpler and incidentally much more readable to a Java developer's eye.  (I can't comment much on Clojure for comparison, but I know a lot of people like it.). Anyway, those factors may have diminished the move towards Scala.

One can write code in Scala which looks very like an idiomatic Java code, however, would be no gain from Java to use Scala just that way.

And then, I have a book called Functional Programming in Scala by Paul Chiusano and Rúnar Bjarnason, some pages even today I find very hard to follow. Scala can get very complicated to read and understand, and even more so to learn.

However, it may not became a mainstream language where people would discuss whether to go with Java or Scala on some habitual Java'ish project, but it still has its strong use in some areas, i.e. like Spark world, even though other languages are also supported, i.e. Python or same Java. Don't have statistics, but I imagine Scala is pretty much dominating there.

It's ironic that originally, Eclipse was the IDE of choice, bundled with the Android Development Kit. Now it's IntelliJ.

Part of that is because Android is moving towards Kotlin, and Kotlin is a product developed by IntelliJ. On the whole, you have plugins for virtually any language for Eclipse, even COBOL and shell scripts, but, again, for practical purposes, IntelliJ (JetBrains) owns Kotlin.

There were some significant products out there that had Scala under the covers, but alas, I'm too senile to recall what they were. For a while it seemed every time I sent a debugger into a framework, it would encounter Scala code. But flashy new languages come and go while the stodgy stuff remains.

As for JavaScript, it's bad enough that its datatyping is sloppy. but any platform whose threading model is inside-out (you too, Android!) is a nightmare.