Why Senior Engineers Disagree About Scala

In the world of software, few languages inspire as much passion—and frustration—as Scala. It's a tool praised for its immense power and scalability, yet often criticized for its steep learning curve. So why do smart, senior engineers disagree so fiercely?

The Allure of Expressive Power

To its advocates, Scala is the best of both worlds. It seamlessly blends object-oriented programming (the dominant paradigm of languages like Java) with functional programming (a style focused on immutable data and mathematical functions). This hybrid nature allows developers to write incredibly concise and expressive code. Where a Java developer might write ten lines, a Scala developer can often accomplish the same in three. This isn't just about typing less; it's about reducing complexity and the potential for bugs. Proponents argue that Scala’s strong type system catches errors at compile time—before the code ever reaches production—which is a massive advantage for building reliable, high-stakes systems in fields like finance and data engineering. For engineers tasked with building complex, high-throughput applications, Scala provides a toolset that feels uniquely capable of taming that complexity.

The 'Curse' of Complexity

The very features that Scala’s fans love are often the source of its criticism. The language's flexibility is a double-edged sword. Because Scala offers so many ways to solve the same problem, two different codebases can look like they were written in entirely different languages. This makes teamwork and code maintenance a significant challenge. One senior engineer might use advanced functional programming concepts that are completely opaque to another, leading to what some call “clever” code that only a handful of people can debug or extend. This creates a steep learning curve, not just for new developers but for experienced engineers coming from other languages. The complaint isn't just that Scala is hard to learn, but that its complexity can actively slow down teams, increase onboarding costs, and make projects harder to staff.

The Shadow of the JVM

Scala runs on the Java Virtual Machine (JVM), which gives it two huge advantages: access to Java's massive ecosystem of libraries and raw performance that is on par with Java itself. However, this relationship also creates tension. Modern versions of Java have adopted features that once made Scala unique, narrowing its competitive edge. Furthermore, another JVM language, Kotlin, has surged in popularity, particularly after Google named it a first-class language for Android development. Many developers see Kotlin as offering the key benefits of a modern language—like conciseness and null safety—without Scala's daunting complexity. For many teams, Kotlin represents a more pragmatic, easier step away from traditional Java, leaving Scala to occupy a more niche, specialist role.

Context is Everything

Ultimately, the disagreement among senior engineers isn't about whether Scala is a "good" or "bad" language. It's about context. An engineer leading a small, elite team building a complex data processing pipeline for Apache Spark might find Scala to be the perfect tool for the job. In that context, its power justifies the investment. However, an engineering manager at a large company who needs to hire quickly and ensure hundreds of developers can contribute to a shared codebase might see Scala as an unacceptable risk. The debate reflects a fundamental tension in software development: the trade-off between the power of a tool and the practicality of using it at scale. As one developer put it, the language's brilliance comes with a "delivery tax" that not every project can afford to pay.