The Rise and Fall of Scala: A Love Letter to the Language That Broke My Heart
7 points by b--man
7 points by b--man
I remember the exact moment. I was refactoring a gnarly Java service — hundreds of lines of boilerplate, null checks nested three levels deep, and a for loop that made my eyes water. Then a colleague showed me the Scala equivalent. Twenty lines. Pattern matching. Immutable data structures. It was like watching someone solve a Rubik's cube in six moves while I'd been peeling off the stickers.
It’s getting impossible to find anything human in writing. Slop is getting uncontrollable. This was a technical news aggregator, but GPT adds so much flourishing it becomes just bad literature.
It’s a big word wall, and the symmetry of the paragraphs make it so bland.
Scala didn’t fail because it was bad. It failed to achieve mainstream adoption because it was too good — too powerful, too expressive, too demanding. In programming, as in life, sometimes good enough beats perfect.
Can a similar case be made for Common Lisp (or other lisps and forths for that matter), that they also are "too powerful, too expressive, too demanding"?
Code reviews turned into graduate-level seminars on category theory.
I remember that some bug report into the Scala compiler required some type/category theorist to find/figure out, however this "seminar" sounds like an exaggeration.
I think Scala failed because if you pick different codebases they each use different dialects of the language.
They’re technically all Scala but some code looks like Java, some looks like Haskell and some other they are a weird mix of the two. Last time I checked there were also competing libraries doing the same thing in different ways, with their own dialect that doesn’t mix well with other libraries using a different dialect
If the reality is just as you describe, it's going to be rather disappointing to see the failing to have been caused by "too much" diversity, which would be such a shame. That uniformity would have been preferrable over diversity is quite disheartening to know.
The thing about all the gnarly type signatures is that for the most part it’s a choice. We do it because it feels good; arguably it can be part of making a nice flexible library but a lot of it is nerdsniping ourselves.
As a non rust user, it strikes me that rust should be susceptible to this sort of type level nerdsniping. Is it? Or is this also a cultural thing that rust programmers mostly avoid it?
You can definitely find very complex/sophisticated uses of the type system in the Rust ecosystem. But many FP idioms don't really translate because Rust doesn't have higher-kinded types, so you can't define functors and monads and so on.