Hacker News Reader

Comment by steven2012 | Hacker News Reader

steven2012

What sort of support does Scala have going forward? My understanding is that although there are a lot of scala users, a lot of major corporate users have backed away from it, ex. LinkedIn, Twitter, etc, because of fundamental issues with the language.

View on HN

Never heard of Twitter abandoning Scala. They actually seem committed. LinkedIn changes technology often. But that does not have to mean much. It is still well used and on surveys immediately after the regulars such as java, python, c++,c#, js.

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.

> 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.

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.

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.

> 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.

> 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.

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.

Dunno, I know plenty of major corporate users that are adopting Scala, I bet I can name two adopters for each one you know that backed away from it... And not "we use it in this dark corner where nobody cares", more like "is the backbone of our new business"

I keep hearing this, but the fact is that both companies continue to use Scala for core functions. There are plenty of Scala jobs out there.

I'm currently on the job market after spending two years working with Scala. There's definitely no shortage of companies out there hiring Scala talent. In the last two days I've been contact by at least five companies using Scala. Over the course of my job search it's been many more. Just last week I found out that Verizon has at least 300 Scala developers on staff.

An added benefit: due to the scarcity, lots of Scala shops are open to remote developers. I abhor the idea of moving back to the Bay Area so that's important to me.

Do note that the article is pretty far away from real-world, day to day use of Scala in mainstream programming. The author is merely having fun with types.

Having said that, what evidence do you have that Twitter is backing away from Scala? What are they supposed to be replacing it with? My own experience is that mainstream jobs in my country are very slowly and timidly starting to adopt Scala, and only in the most controlled fashion, as "just a better Java".

Reply on news.ycombinator.com