Hacker News Reader

Comment by lmm | Hacker News Reader

As someone who's recently been jobhunting, Scala feels more popular than ever. It may no longer be as hyped as it was (which is probably better for everyone), but it's still growing.

And really there is no alternative - once you've used higher-kinded types there's no going back. Some organizations make the switch to Haskell, but that's not an option in many environments. Other than that, if you want higher-kinded types there's nothing that's remotely as mature as Scala out there.

I can't speak to "fundamental issues with the language" because I haven't found any.

View on HN

The problem with Scala is that architects can and sometimes will get giddy and create monsters. Scala is not like C++ where some features are dangerous, but Scala has features that should be used with caution. The amount of times where defining a partially applied higher-order function is the best way to solve a problem is nonzero, but still really really low. So you let a team of giddy developers eager to learn and apply new concepts loose and soon you have a monster of a code base.

> The amount of times where defining a partially applied higher-order function is the best way to solve a problem is nonzero, but still really really low

I disagree. Once you learn to use partially applied higher-order functions, they end up being useful everywhere. I'm using them right now in Scala for my day job, and my code is not particularly fancy.

> The problem with Scala is that architects can and sometimes will get giddy and create monsters.

> The amount of times where defining a partially applied higher-order function is the best way to solve a problem is nonzero, but still really really low.

I was with you until this. Using partial application doesn't create monsters, and in fact is rather easy to follow and understand (assuming you know what partial application is, of course).

There are however, features of Scala that can be abused to create monsters, the most obvious of which is implicit conversions. An extremely useful feature, but can cause a mess if you're not careful. And even with those, it's still entirely static, and your IDE can highlight which ones happened where, as opposed to something like Ruby, where you can update classes at runtime.

> The amount of times where defining a partially applied higher-order function is the best way to solve a problem is nonzero, but still really really low.

Not sure about Scala, but I find partially applied higher order functions to frequently be the best choice in Haskell code.

It's called code review. Unless you have stupid time constraints, you don't let that happen.

Scala is like C++ where some features are dangerous. We've had significant problems with parts of the standard library and had to resort to banning them and writing our own alternatives.

Which portions of the standard library?

Trying to perform a sequential operation on a parallel collection will not go well, but other than that I haven't seen anything.

Given that higher-kinded types are not included by default in Scala 2.11 (e.g. they're considered "advanced" and optional), I'm not sure that's true.

That was a controversial decision; typesafe is not always entirely aligned with the wider community.

And you're not exactly contradicting me. They are an "advanced" feature partly because they're not found in (many) other languages.

> And really there is no alternative - once you've used higher-kinded types there's no going back.

Do companies that have adopted Scala really value higher-kinded typing that much?

Higher-kinded types themselves, not necessarily, but the abstractions they afford are, once you've gotten used to them, a huge time saver.

I've gotten used to handling concurrency as a monad, for example, and honestly dread the time when I have to manually deal with manual synchronisation again.

Companies are made of people, and the people writing the code certainly do, IME. (In some companies that will have little bearing on the company's decisionmaking, but I view that as an indictment of those companies' processes). It's not something that immediately jumps out, but having written code for a while with higher-kinded types available, it would be horrible to have to expand that out into cases.

It just seems weird that this feature would stand out when compared to everything else Scala has to offer.

There are plenty of features in Scala that I couldn't live without, but most of them are features that I could find in other languages (e.g. Ceylon, F#). Higher-kinded types are the big "blocker" that really keeps me Scala-only.

Reply on news.ycombinator.com