I'm still trying to reason what the value proposition of Scala is in a business sense.

Developer are more expensive and harder to find, the tooling is weaker, the ecosystem less deep, performance suspect, and the overall XP feels clunky.

Plus our hardware is procedural, and contains/manages state within the instruction pipeline.

I strongly believe it doesn't belong as a core business technology.

I don't think this comment reflects reality. A few issues:

* Complaints about tooling and ecosystem were valid maybe 10 years ago, but not now.

* You don't say what your point of comparison is. (weaker than what?)

* Performance has never been an issue for general programming tasks

* You disregard the value that language brings

* Running functional programs on a CPU has not been an issue since, roughly, the 1970s when the basics of compiling FP languages were worked out.

So the starting point is you want the JVM/Java interop, if you don't want the JVM find something else.

From there you have Java, Scala, and Kotlin as primary choices.

Up until 2020 java didn't have pattern matching or records, and kotlin still doesn't have a full implementation.

Scala offers an ecosystem where its very easy to build a robust type system, supporting clear co and contravariance and clear control flow due to pattern matching.

On top of that scala's compiler plugin ecosystem is quite good and it allows large organizations to abstract away a lot of busy work to dedicated internal teams. This is used extensively in large scala codebases I have seen.

Scala is a fantastic language for core business technology, in fact thats probably the single thing its best at. Its why the largest code bases I know of are in financial institutions.

DX/tooling is a valid point, but the large scala codebases that exist within orgs have their own tooling that solves this, at least old twitter and the financial institutions do.

So to answer your question, why would someone choose scala in a business sense. Any JVM project built between like 2009-2019 had a compelling reason to choose scala over the other options and maintains those advantages though other languages have implemented most of the key features so the gap is much smaller.

You're unfortunately right. Every Scala codebase I have seen recently is essentially legacy. New services are not built with it anymore. Other than blaming SBT and the Haskel fans I'm not aware of a technical justification. But the industry/community has shifted since 2015-2018.

The only rare exceptions I heard of were strict FP shops who share nothing with common JVM-based development. You could have a few years of full-time Scala experience with Akka and Spark and they won't even screen you.

In the year of our Lord 2024 the question is if you want to bet on Java21+ catching up with Kotlin or go with Kotlin from day one. The choice is less obvious nowadays. I'd go with a modern language, actual job market sides with Java still. At least on the backend in the Bay Area.

As a side note, I cannot imagine a competent JVM-based developer not familiar with either Kotlin or Scala by now. In a typical Java shop half of the team is dying to switch to one of them in my experience.

The small pool of experienced developers is actually awesome. I waste a lot less time screening candidates and they're usually above average.

Moreover, despite what people claim I've had no issues mentoring juniors or people coming from other paradigms but willing to learn.

Tooling isn't as good as plain Java but good enough, and certainly better than that of more niche FP languages.

The ecosystem is pretty rich in spaces where Scala really shines, in some cases it's even better than libraries and frameworks you can find in Java or Kotlin. Plus you can always consume any Java library.

Performance is good enough for Twitter or big data workloads at major tech companies (many of them use Spark). And nowadays with GraalVM native images you can even reduce the memory footprint to very reasonable levels, not very far from Go.

In the right hands, the terseness and expansive nature of the language (big stdlib, java interop, implicits/givens, higher-kinded types, immutability first, etc) can greatly increase productivity, however it takes a higher caliber of developer to wield it effectively. Not to mention also the rich ecosystem in the functional side of the house with ZIO/Typelevel, or distributed frameworks like Akka.

Poor Scala devs output complete junk, however high performers produce incredibly elegant and concise code.

Apache Flink has deprecated support for Scala.

https://cwiki.apache.org/confluence/display/FLINK/FLIP-265+D...

An aggregation engine like that was otherwise a good fit for a functional-ish language like Scala.

That said - it is a nice language. Native support for simple functional language constructs (map / flatmap, Option, Try), without having to go all-in on functional style.

Hardware is actually functional. It will do whatever is needed to get the results you actually want while secretly rearranging everything. And I mean everything: loads and stores don't execute in anything resembling the order you wrote them in. State? An illusion that doesn't even exist the majority of the execution time and has to be expensively reconstructed when things go wrong.

Circuits are deeply functional: everything is computed all the time and only selected from.

Performance is in the same space as java or go, but it's a much higher level language, so easier to write, easier to read, and easier to review. The language prevents many classes of errors without cluttering the written logic, so it's easier to understand what it's doing in terms of business domain. The jvm ecosystem is also massive.

If developers are more expensive, presumably there's a reason they're able to ask those rates besides "they know scala".

It's a more powerful version of Java. Java is still trying to backport features from Scala.