Ask HN: Why do people have a hatred for Scala?

[lnk2w]

I'm learning Java and Ruby, and I saw few posts about functional programming. So I thought that the next step should be learn a FP language. But I saw so many people hating Scala. Is there a reason for this?

edit: Ok, Hatred is a strong word. I shoud have used dislike instead.

[modersky]

People who actually use Scala love it. For instance, Scala is one of the most loved languages in the recent StackOverflow developer survey. The survey had more than 26'000 respondents, so this is pretty significant.

http://stackoverflow.com/research/developer-survey-2015#tech...

But you are completely right that there's also a lot of negative sentiment around it. Here are two possible reasons I can think of (I am sure there are others).

1. Scala does not form part of an established programming language tribe. It is neither a better Java nor a Haskell on the JVM. So people are challenged in their assumptions; they don't know what it is, and react negatively in order not to have to learn more.

2. Scala is pretty successful. So people in neighbouring language communities sometimes feel frustrated that a seemingly (to them) inferior language gets traction and their perfect language gets less. I saw some of that when Java eclipsed Smalltalk in the 90's. I never met a community as spiteful of Java as the Smalltalk one.

[pea]

We used Scala for major projects; love the language, hate the infrastructure / documentation / frameworks / sbt / attitudes of many in the community. I believe this is a pretty common sentiment.

[throwawuy222]

Basically I've seen this in person. Scala was driving the last startup I was in to the ground.

The thing that fascinates me is scala is like an art. It's like a new Obfuscated Perl Contest, but for functional programming. It doesn't really serve a purpose in legitimate business.

Scala code doesn't scale, it compiles too slow due to having too many features in the syntax. They took features normally meant for a standard library / external projects and literally augmented them into the syntax.

Scala, in it's current form, is a pipe dream. It really needs to be start over, but drastically simplified. Perhaps it should try to take a hit from Golang for compiler time advice: Simple languages compile fast and are easier to optimize.

[facorreia]

I would think that "people" were driving the company to the ground. I'm working on a large-scale Scala project that has been going on for years. The codebase is clean, methods are easy to reason about. It not as verbose as Java would be, there's no monkey-patching like you might see in Ruby, refactoring is much safer than it would be in JavaScript, and it runs on Linux much better than C# would. And thanks to FP the code is thread-safe and mostly free of side-effects (except where they're explicitly required). I wouldn't trade Scala for any other language, for this kind of work.

[bnejad]

What kind of project is it? Genuinely curious.

[facorreia]

Web app with complex, distributed back-end processing.

[istvan__]

Is it an accident that you picked the worst offenders for each category? :)

Not as verbose as Java -> Java is probably the most verbose compiled OOP language

Refactoring is safer than it would be in JS -> I think with the IDEs this means almost nothing.

Runs faster on Linux than C# -> I mean seriously, Java's biggest advertised feature was multi-platform support while we know that Redmond guys don't care about other platforms too much.

I feel like you are trying to justify Scala by comparing it to other languages and picking a feature or property of those languages that is the worst or almost the worst.

How about this:

- Scala has such a nice type system that it blows out OCaml from the water - Scala running faster on Linux than C++

etc.

I would expect honesty when it comes to using languages that would drive this twisted and wicked developer world to something better. If we keep using the worst languages to compare to we are not going to improve. This is what I think.

[lmm]

Scala isn't the best at any of these things though. It's great because it's an all-rounder language.

How about this:

Scala doesn't - quite - have the safety and conciseness of Haskell. But it's close.

Scala doesn't - quite - have the enterprise support and tooling infrastructure (monitoring/instrumentation, profiling, debugging, IDEs, library ecosystem) that Java does. But it's close.

Scala doesn't - quite - have the clarity of Python. But it's close.

Scala doesn't - quite - have the performance of C++. But it's close.

[facorreia]

It's a way of saying that I value a language that is not too verbose, that doesn't encourage monkey-patching, that has strong types, and that works on Linux without too much trouble. The languages I listed do not meet at least one of my requirements, that's why I prefer not to work with them.

[eranation]

We use Scala for major projects too, I love the language and also the documentation, frameworks, (even sbt) and attitude of the MAJORITY of the community. Can you give concrete examples of what caused you to hate all of the above? Especially I'm interested in the community aspect. I've found the community very friendly and helpful, but perhaps I'm going to the wrong (i.e. right) places?

[ryandvm]

The problem with a survey asking people how much they love their language is that people will employ all kinds of biases to suppress the cognitive dissonance of choosing a terrible language.

The harder something was to succeed at, the harder you'll try to convince yourself it wasn't wasted effort.

[biokoda]

Erlang is a pretty big omission in that list

[ericssmith]

I have used Scala for building business solutions since 2012. I had been maintaining PHP and Rails systems of 50k to 150k LOC prior to the switch. I still have to maintain PHP and Rails systems. The move to Scala was driven by the need for better performance, system resiliency, and to mitigate the effect of multiple developers coming in & out of a codebase. It turns out to be ideal for this.

Idiomatic Scala is not a grab bag of features or paradigms. It is firmly based on programming with expressions and using the type system to improve abstraction. Statements and mutable data structures show up when interfacing with external systems or for performance reasons. The Collections libraries are arguably "object-oriented" as that term is commonly understood, but this is not typical for application code. However, object-oriented features such as objects, classes, and traits are the basis of Scala's module capabilities.

For programmers coming from 20th century mainstream languages that are all based on programming with statements, mutable variables, and are arguably a thin abstraction over the machine itself, programming with Scala can be a challenge. If you want to do your familiar imperative style of programming, Scala is going to be painful. Use another language. But if you would benefit from a type system and good support for expressions, then Scala is possibly the best choice currently for growing business applications. We are not in 2005 any more.

Scala is not ideal as an introduction to functional programming. Other languages, such as F#, SML, OCaml, and Haskell have better, simpler syntactic support for features associated with functional programming.

People who dislike on Scala are probably either stuck in the past or don't have pain that Scala would solve.

[aurora72]

By idiomatic Scala, perhaps he meant the expressive use of language in contrast to writing an application in Scala using the last century's programming habits.

[throwawuy222]

There is such a thing as idiomatic scala? How? Care to elaborate?

[facorreia]

It's the opposite of "Java without semicolons".

[timclark]

In my opinion (and I have worked on large scale development in Scala in the past) it is just unnecessarily complicated.

Random annoyances off the top of my head - you can't necessarily understand an isolated function unless you know what implicits are being used, crazy overuse of operator overloading and slow compilation times (this has improved over the years).

You don't have to learn Scala, you could learn Clojure, F#, OCaml or Haskell. They would all teach you interesting aspects of programming and then you could come back and examine Scala with a broader perspective.

[vkjv]

+1 Implicits. We put very strict limits on use of implcits. They make code extremely difficult to reason about, but can also be incredibly dangerous. I once stumbled upon an implicit cast of Int to Float... Oh, my.

[throwawuy222]

Is there any linters available for IDE's to ensure conformance with a vanilla ruleset of scala? If that existed, scala would be able to shape itself up nicely.

[hohonuuli]

Their are linters available for scala (e.g. wartremover). Also, the Scala compiler supports a number of flags to warn you if your code is using some of Scala's 'more questionable' features. You can even tell the compiler to fail if any of these warnings occur. A list of useful flags can be found at https://tpolecat.github.io/2014/04/11/scalac-flags.html.

You might also want to look at this excellent talk titled 'Toward a Safer Scala' at https://docs.google.com/presentation/d/1tCmphnyP3F5WUtd1iNLu... that recommends a number of best practices that can be followed using Scala.

If you're using sbt, I put together a giter8 template for scala/sbt projects that follows these best practice recommendations at https://github.com/hohonuuli/basicscala.g8

[readmedotmd]

http://www.scalastyle.org/

There should be a linter for whatever IDE you happen to be using.

[lmm]

Any modern scala IDE highlights implicit conversions with a green underline, which I find is plenty to make them readable.

[M8]

> crazy overuse of operator overloading

F# might not be the best place to go then:

http://stackoverflow.com/questions/2210854/can-you-define-yo...

https://msdn.microsoft.com/en-us/library/dd233204.aspx

[lmm]

Most languages have similar capabilities. E.g. in Java you can define a method called ★★★ if you want (edit: this specific example doesn't seem to work, but certainly non-ascii method names are possible). The difference is cultural; Java libraries generally wouldn't define such a method, while certain Scala libraries might.

[M8]

Example in the wild:

https://bitbucket.org/fparsec/main/src/c234349e7b738e09a1b9e...

[lmm]

FParsec is a port of a Haskell library, so not really reflective of F# culture.

[partisan]

Agreed that implicits were one of the critical things that caused me to move away from Scala. I really couldn't justify in my head the use of such a thing.

[lmm]

The one case I can make for implicit conversions (implicit parameters are brilliant and useful and not normally what people complain about) is the spray-routing DSL, e.g. https://github.com/spray/spray/blob/master/examples/spray-ro... . What would be a separate config file in any other framework is instead ordinary Scala code following the rules of ordinary Scala, which is wonderful - you can factor out and reuse common parts of your routing really easily, because it's all just code.

[wheaties]

That actually sounds like you encountered code that shouldn't have been or you had people using Scalaz (which has weird operators taken from Haskell, looking at you <*>.)

[throwawuy222]

For those who don't understand: Scalaz is an additional layer of syntax and tricks on top of what is already there. It seems to have quite a lot of power!

    implicit val option = new Traverse[Option] with MonadPlus[Option] {
    def point[A](a: => A) = Some(a)
    def bind[A, B](fa: Option[A])(f: A => Option[B]): Option[B] = fa flatMap f
    override def map[A, B](fa: Option[A])(f: A => B): Option[B] = fa map f
    def traverseImpl[F[_], A, B](fa: Option[A])(f: A => F[B])(implicit F: Applicative[F]) =
      fa map (a => F.map(f(a))(Some(_): Option[B])) getOrElse F.point(None)
    def empty[A]: Option[A] = None
    def plus[A](a: Option[A], b: => Option[A]) = a orElse b
    def foldR[A, B](fa: Option[A], z: B)(f: (A) => (=> B) => B): B = fa match {
      case Some(a) => f(a)(z)
      case None => z
    }
  }

Excerpt from https://github.com/scalaz/scalaz#type-class-instance-definit....

[justthistime_]

Looks pretty readable and reasonable.

[lmm]

That part is fine. The trouble with Scalaz is it adds a bunch of extra operators (that is, methods - the distinction doesn't exist in Scala) like |+|, \*> and >=>.

[tormeh]

Scalaz is evil. Some of the operators are even non-ASCII.

Anyway, scala needs less weird operators, not more. Looking at you, parser combinator library.

[lmm]

There has been an... unfortunate community attitude. Some people were quite unwelcoming to newcomers. I think this is down to two individuals; nowadays many friendlier folks are writing Scala libraries and hopefully the community will improve.

I get the sense the Java community is also unused to interacting with other languages, because for a long time the JVM was a world unto itself. Most languages have a spectrum of "neighbour" languages and so users are used to working with at least slightly different alternatives. Scala is possibly Java's closest neighbour (Groovy is not really popular enough to show up on the radar of most Java devs) and it's become something very different, so there's a real culture shock just trying to talk to each other. A lot of Scala folks take a lot of assumptions for granted that are very alien to Java folks.

None of which really takes away from the language itself, if you're willing to learn on your own or tolerate a few insults when you ask for help. IMO it is very much worth it: Scala is genuinely the best practical language available today (it has more than its fair share of warts but they're mostly for JVM/Java compatibility, which makes it so much easier to introduce to business than e.g. Haskell).

[muraiki]

I know the plural of anecdote is not data, but every time I've asked a question in #scala I've received nothing but helpful and welcoming responses.

[lmm]

Most of the time that's what you'll get. But there are (or at least were when last I was there) two or three people who will respond unpleasantly, and I want to be honest about that.

[nrinaudo]

Is this why I don't see you there anymore? This has in my opinion made #scala a markedly less pleasant place to hang out.

[lmm]

Thanks, and sorry to be absent. That's more about work circumstances; it's been an awkward month or so, and I do intend to come back once things shake themselves out.

[facorreia]

This has also been my experience in Stack Overflow and in the Play Framework user group.

[yarper]

I'm a professional java dev - groovy definitely does show up on our radar as it's used as the glue for a lot of tools related to our "production" code.

For example gradle buildscripts are groovy, as is the spock test framework.

[vorg]

Groovy is to the JVM what Bash is to Linux. It's used for writing quick and short scripts that manipulate Java classes and for building them, but you wouldn't use it to write actual systems despite the static typing features made available in Groovy 2.x. Use Java or Scala for that. But even Gradle's use of Groovy is in question -- Gradleware just employed one of the 2 Groovy developers who became unemployed after VMWare's Pivotal stopped funding Groovy last month. I suspect Gradleware will get him to replace the Groovy monstrosity with their own lightweight version of the language which does what a build DSL needs and not much more. This could be a reaction against Grails 3.0, a 130Mb download released alongside Grails 2.5 last month, bundling Gradle in an apparent attempt to take control of its distribution channel, in the same way they bundled Spring with Grails 1.0 back in 2008 then got their company bought out by Spring later that year. When a language's development is driven more by corporate maneuvering than providing functionality for a particular purpose then would you even trust it for scripting? Perhaps look at Xtend or Clojure!

You can read the other unemployed developer's take on Groovy's development history at http://blackdragsview.blogspot.com/2015/04/about-being-paid-...

[lmm]

Plenty of Java shops use it, but plenty don't. My impression is that most people who are aware of Groovy will also be aware of Scala, whereas there are a lot of Java developers for whom Scala is the only "other JVM language" that they've heard of. But that's just my experience.

[nielskrijger]

This might be worth a read:

http://codahale.com/the-rest-of-the-story/

http://codahale.com/downloads/email-to-donald.txt

Having worked with Scala; I'd say I love it.

Having worked with Scala; I'd say don't use it for most projects.

It is not the best language to start learning FP. Wrap your head around a dedicated FP language and if you still feel the need for a hybrid FP/OO language Scala is definitely worth a look.

However as it is a hybrid I've felt it made my code just too complex. Compared to Java there are a dozen more ways in Scala to fix something; and often you struggle to find the best way. This takes a lot of learning and it just isn't worth it. It's a great and elegant language in many ways, but I've come to dislike a lot of features of it.

Simplicity is one of those things that make a beautiful codebase. See also (recently featured on HN);

http://kotaku.com/5975610/the-exceptional-beauty-of-doom-3s-...

[rdrock]

In 2015, XML is a first class citizen but JSON get a third class treatment. JSON parsing in Scala is ridiculous. http://www.reddit.com/r/scala/comments/2l7v5u/json_parsing_i...

[lmm]

XML is in the process of being demoted.

spray-json is quite possibly the best JSON library I've ever seen, in any language.

[facorreia]

I use play-json (on a Play Framework project) and it serves its purpose well.

[user1241320]

We use both play-json and json4s. They're both pretty cool and easy to use

[rikf]

I dabbled in scala for a while a few years ago and ultimately decided not to invest the time becoming an expert in it for the following reasons. 1) Slow compile times, I really value fast feedback and if it takes me over a second to compile and run a unit test that just doesn't cut it for me. 2) No clear idiomatic style and having many different ways of doing things each of which can imply different behaviour in different contexts.

[shubb]

I used to feel the same way about fast feedback, but after working on slower to compile applications for a few years, I'm not sure it's a good way of working.

When I used to work like that, I'd write code, and constantly be checking that it compiled. I'd be watching my test dashboard and feel happy turning the lights green. But it was definitely a crutch.

If you asked me to code without a compiler I'd make basic syntax errors. I'd let basic, predicable bugs slip through because they weren't covered by my tests. In my rush to turn the next light green, I wasn't thinking enough.

Maybe that's not how you work, but if it is, try building once a day and turning syntax highlighting off for a couple weeks. For me, (being forced to) work like that for a while has helped me long term.

[MichaelGG]

I don't hate it. Scala looks cool and I might use it if I had to use the JVM.

What turns be off from looking into it much:

Verbosity. It seems that it can't infer types in as many places as an ML. I prefer rather succinct code. I understand Scala has a powerful type system and it isn't always possible, but... ugh.

OO. Scala seems to want to really embrace Java's OO model fully, and that's a bit ugly. It's probably a good practical decision but feels like a turn off. Again, I haven't used Scala, this is just an impression I have.

[dragonwriter]

> Verbosity. It seems that it can't infer types in as many places as an ML. I prefer rather succinct code. I understand Scala has a powerful type system and it isn't always possible, but... ugh.

I think the problem is that Hindley-Milner type inference doesn't play with OO type hierarchies, and so Java interop (which is a key motivating purpose of Scala) means worse inference than ML-family langs for Scala. Its not really that its a powerful type system that is the issue (Haskell has a more powerful type system, but better inference.)

> OO. Scala seems to want to really embrace Java's OO model fully, and that's a bit ugly.

I think "embrace" is a bit strong, but it wants to support it fully, because its a key part of the interop story.

[tormeh]

You really want a lot of type annotation anyway. They make error messages a lot more informative.

Scala is, by definition, a superset of Java. It's not ideal, but there aren't really any good alternatives.

[manishsharan]

I don't hate Scala but I did not pursue it after only a few 'lessons' : transitioning from Java to Scala was smooth and not intellectually stimulating. On the other hand , Clojure programming forces me to think differently and the solutions are more elegant. I understand Scala is also functional but it is too permissive and I slide back in imperative all too easily. Clojure is highly disciplinarian and opinionated and I find that refreshing.

[lmm]

Interesting, that was exactly my reason for preferring Scala. With Clojure I could see it would take me weeks to get productive. With Scala I could write Java-without-semicolons and be slightly more productive on day 1, hour 1 even, and then gradually pick up the more advanced features.

[coldcode]

But how effective is Clojure in writing server side code? I've never used it so I have no way to know.

[manishsharan]

One of the best decisions I made was to transition from J2EE server code (Spring+ hibernate + Jsf/(some)SpringMVC ) to Clojure ring + Moustache. The code is smaller, simple to understand and concurrency is a breeze. The only downside is you can't write a SOAP server as XML namespace support is missing in its xml library.

edit : typo

[logicchains]

I've used it a little and haven't had any problems. You can run it on Jetty, so performance is excellent, and you get access to the whole Java ecosystem. Things like Core.async, Pulsar (modeled after Go's coroutines/Erlang's actors) and Software Transactional Memory make parallel/concurrent programming a breeze. The biggest "issue" some people have with it is that it's generally dynamically typed, but if you don't mind that then it's at least as effective as other server side dynamic languages.

[user1241320]

I'm curious if anybody has tried http://immutant.org with Clojure

[rodh257]

I've written C# for most of my career, and have in the last couple of years been exploring functional programming. I started learning Scala, and getting involved in the community and I found it to be quite interesting.

Something I find different is that most C# developers like writing C#, they may dislike many other parts of the ecosystem, but they generally enjoy the language. However with Scala developers, I find that many of them seem to dislike the language.

To cast a broad stereotypical brush, it seems like there are 2 main groups of Scala developers. There's those who are really into FP, and would love to be getting paid to write Haskell all day, but unfortunately Scala is the only option they can convince their employer to adopt. So they begrudgingly choose it because it has some of what they want, but they are forever wishing it was better & making their frustrations known.

Then there's the other side, which are developers coming from Java (or other OO languages) after hearing about the benefits of FP/Scala. They're either not using Scala professionally, but want to learn, or are just starting to use it at work. They are much more enthusiastic about the language.

Unfortunately, the first group are often more vocal, and it puts off newcomers.

[hackerboos]

I wouldn't say hate. Scala is a OO-functional language, so it's bound to have people who dislike it from both of those camps.

I started learning Scala (it got me into functional programming) but dumped it for the same reasons as Java. It's bloated. I also question Scala's longevity.

I'm happily using Elixir and Clojure these days, but I mainly do web stuff so YMMV.

[stewbrew]

You question the longevity of Java and Scala, and this is why you use mini niche languages? Seriously.

[hackerboos]

Corrected.

Elixir as a language may or may not last. I'm betting it will, but even if it doesn't, it works well with Erlang which is going nowhere.

There's more a case against Clojure, granted. I think because Scala is seen as a bridge language is the another reason why it won't last.

Also the compiler drama... http://www.infoq.com/news/2014/09/scala-compiler-forks

[justthistime_]

Isn't it positive that the community is so large that it can sustain multiple compilers?

Some time ago people complained that Scala had only one compiler ... so now they complain about the opposite?

[dragonwriter]

> Some time ago people complained that Scala had only one compiler ... so now they complain about the opposite?

I suspect the "they" that are complaining now about multiple compilers are mostly not the same people that were complaining about one compiler previously.

[Verdex]

Programming languages are a new thing for humanity. I'm pretty sure that we aren't making programming languages correctly yet. And even worse there almost definitely isn't a One True Programming Language (it seems suspiciously like there's going to be more than one "right" programming language per domain (ie embedded, web, server side, etc) and to make things even even worse the right language to use might even be different based on the person using it).

If you find yourself in the future "hating" all the programming languages, this isn't necessarily problematic, it might just mean you have a good understanding of programming languages. Just try to remain polite and remember that there's more than one way to see most scenarios.

[mda]

Not hate, but I had a feeling that it was a kitchen sink language, also too much academic influence leaves a bad taste.

[bryanwb]

I am not really sure. I come from a Ruby and Python background and just love scala. It's a joy to work in and relatively easy to introduce at work compared to other FP languages.

[rkrzr]

I'm currently learning Scala (background in Python and Haskell) and I have encountered a few road blocks:

1. The REPL is not very helpful: You cannot look up documentation a la IPython (i.e. myFunc?) or inspect objects easily to find out how things work

2. There always seem to be 10 ways to do the same thing. This makes it much harder to understand other people's code than when there is just one way to do it.

3. The type system seems less helpful than Haskell's (e.g. why is "asdf" + 3 not a type error?)

[yummyfajitas]

(3) is because Scala attempts to preserve Java semantics for strings. I agree that this is a mistake.

[rahilb]

(2) Isn't this true for all languages, and in fact isn't that the hallmark of a _good_ programming language? One could also argue that this provides evidence of simplicity, as many smaller building blocks can be assembled in different orders to produce the same (complex) result.

The antithesis is when we see posts about how "Go's too simple".

[lostcolony]

From 'The Zen of Python' - "There should be one-- and preferably only one --obvious way to do it."

I'm not sure I've seen any "Python's too simple" posts. Maybe Go's criticism is based on some other factor?

[rkrzr]

"Isn't this true for all languages". No, not at all. Many languages have an idiomatic way to write things. Python definitely does and so does Haskell (to a lesser degree).

"One could also argue that this provides evidence of simplicity" Or one could argue that it provides evidence of complexity, since you need to hold much more information in your head to achieve the same results.

[lmm]

2. There are places where this is true, but a lot of people seem to get hung up on the syntactic differences between e.g. "a.foo(b)" and "a foo b", which really are superficial and you learn to read past very quickly.

3. Some of these are backwards compatibility. You can get a more helpful typesystem by setting a few flags: https://tpolecat.github.io/2014/04/11/scalac-flags.html

[tormeh]

Everyone agrees Scala is too complicated. Beyond that, there's a flexibility problem: Scala allows you to write a global mutableMonadFactoryFactoryMonad.

That said, nothing does exactly what Scala does. Fluently mixing imperative, lazy, OO and functional styles isn't really common. Neither is the wealth of concurrency constructs available to Scala programmers through the standard library and Akka.

I'm writing a compiler in (not for) Scala right now and it's pretty sweet.

[benburton]

> Everyone agrees Scala is too complicated.

This is not true.

[vkjv]

Everyone who hasn't used it for at least a year or more than three.

[lmm]

I've been using it for five years and I don't think it's too complicated. (There are plenty of places where I think complication is a necessary evil for the sake of Java compatibility)

[jermo]

Here's one: http://blog.gmane.org/gmane.comp.lang.scala.debate/month=201...

Apart from occasional issues in the community Scala is criticised for being too complex: https://www.youtube.com/watch?v=uiJycy6dFSQ

[modersky]

You realize that the sender of this post (a) has been banned from all Scala mailing lists (b) has become one of the strongest Scala haters since?

[tormeh]

Doesn't Paul Phillips still use Scala? He's actually forked the Scala compiler: https://github.com/paulp/policy

I think Paul Phillips agree with the overall direction of Scala and thinks it's the best programming language out there, but disagrees on design details and compiler inner workings.

[lmm]

He's still someone one frequently encounters when looking for help or getting started with Scala. He's still pretty high-up in scalaz.

[synesso]

Interesting that they were working on a scalaz course and book in 2011. I guess that became Functional Programming in Scala. I'd still like a course on scalaz.

[aurora72]

If you compare it to Java or Groovy, Scala is the winner. Even the designer of Groovy admitted by saying something like "If I knew the Scala back in 2003 I'd probably have never created Groovy" But compare to Haskell, it looks like a bit bloated. On the other hand, Play Framework has been a great catalyst for Scala.

[VaidasC]

For me personally, main problem with Scala is somewhat hard to explain, but can be summarized with few very abstract phrases which are overlapping:

* Dirty (opposite of Clean) language.

* Relationship between theory and practice is so far away from being "1 to 1".

* "Not In My Head" anti-patterns (something that will constantly require checking your notes/internet if you haven't worked with it within e.g. a month) everywhere.

Everything seems to be made overcomplicated on purpose for no reason (apart from JVM compatibility I guess, which is no excuse for me as user). Starting from simple things, variable function declarations, so many ways to declare functions, so much theory on var/val/def/lazy/ and how they differ at some corner cases. Function vs. Method stuff in combination with currying/partial application makes things so overcomplicated with so many corner cases which I will never be able to remember. I mean I have many pages of my notes from time I studied Scala, consisting just of corner cases and explanations of why they are present.

If you consider how Golang is viewed by many - as huge step back in our knowledge of language design. I consider Scala as step back in what is known in clean code, overall lessons from designing nice products. It just makes me feel like, it betrays everything I care internally and if Scala becomes dominant platform, it would just show to me that we as an industry just don't have standards and can accept just anything, we will never have something nice, close to perfect.

So my stance on Scala:

* If you just want to learn functional programming - pick something else, F# for me looked a lot cleaner and much closer to "1 to 1" - you can just apply functional theory without fighting the language.

* If you looking for language to make you happy - don't pick Scala. Unless you're into "The Abyss" thing @ Crockford.

* If this is for the money or because it sucks less than X (e.g. Java) in some ways - Scala is good consideration.

[marktangotango]

I was a big fan of SML, and really wanted to like Scala. The reason I didn't pursue it was the language is really complex (imo) kitchen sink as others have said, and as others have also said, there's no one best way to do things, no clear idiomatic style. Plus there was a bit of churn in the language in the beginning. I concluded that if I was going to use the jvm, may as well just stick with Java, or another jvm language with more wide spread acceptance (jython, groovy, ...).

[seanmcdirmid]

Jython or groovy have more market share than scala?

[marktangotango]

Where does 'market share' appear in my post? At no point do I make any claims on market share. Thanks for the charity[1]

My intent was to imply that since jython is a python implementation, the language itself is more widely 'accepted'. Where accepted may mean "in general use and considered to be a good langauge". Groovy has been called a better java by some. Another example would be JRuby.

[1] http://en.wikipedia.org/wiki/Principle_of_charity

[seanmcdirmid]

Your post said groovy and jython had more "wide spread" acceptance than Scala, and I thought you meant market acceptance. It is a reasonable reading of your post.

Your intended meaning requires a big leap in what side spread acceptance means, so I hope you can see the confusion.

[marktangotango]

It is patently absurd to claim jython or groovy have more marketshare (as you define accepatance). Thats where the principal charity kicks in and oneone might ppose since the claim seems absurd, perhaps the author meant something else. Perhaps the leap was too great, but i stand by it.

[rahilb]

I've been programming in Scala for around a year and a half. I hate one thing about Scala, which is the community.

It's split into two, the people who wish Scala is Haskell (shapeless, scalaz &c) and the people who want Scala to be Enterprise Quality™

It causes lots of issues, as their goals for the language are completely different and Scala devs are usually in one camp or another.

As an aside, I always think that if your problems are much better expressed in Haskell, why are these developers not using Haskell?

[tome]

> if you're problems are much better expressed in Haskell, why are these developers not using Haskell?

Generally because your boss won't let you.

[nika1975]

I don't like Scala for the same reason as C++. Scala has an incredible semantic complexity with a Perl-like syntax. Too much magic going on.

[rikkus]

Yes magic is one thing that makes it difficult to get into a language and to maintain code written in that language, where of course maintaining can mean going back to code you wrote last month.

One of my pet hates in C++ was implicit casting and I'm hearing that Scala does similar, which is putting me off it.

[lmm]

Scala has implicit conversions but the IDEs highlight when they're happening, so they're not completely invisible.

To my mind Scala is a very unmagic language; very complex libraries are written for it, but they're never magic, they're always ordinary Scala code and ordinary Scala features, just combined in clever ways. E.g. typeclasses are a language feature in Haskell, but in Scala they're just a pattern that you implement using implicit parameters. Actors and messages are a language feature in Erlang, but in Scala they're just a library with methods that you call. Type-level functions are a language feature in e.g. Idris, but in Scala (e.g. Shapeless) they're just a technique making use of implicit resolution.

[kamaal]

If any one from the scala community is hearing. This is what I have to say as a newbie who started learning Scala a couple of days back.

Free learning resources. There are no good free scala books which can teach you the language in the way it is supposed to be learned. Not something expected of a language which wishes to compete with something like Java on the longer run. The biggest issue I have faced so far is learning from scattered blog post all over the internet explaining the powers of scala, even before introducing how to use the very basic features to build simple things.

There is too much assumption about what the programmer already knows, or about the programmer's background is; while introducing these features. As some one who is not familiar with the Math behind most of these functional programming concepts, every thing goes over like water poured over a stone when the documentation talks about Types, Category theory, Monads. In fact it took me a great deal of simplification, and thought to understand concepts like map, reduce, foldLeft, foldRight. Most of it was in language totally unpalatable to an ordinary programmer. Talking in a language understandable only to Phd students won't work for nearly all of the programming world.

So far my introduction to Scala has been similar to seven blind men describing an elephant by touch various parts of the elephant's body.

[justthistime_]

Which issues did you experience with http://www.artima.com/pins1ed/? (It's a slightly older version, but there aren't many changes which would be important for newbies.)

Partially free:

Atomic Scala also has at least a free sample, which expects basically no programming experience at all: http://www.atomicscala.com/free-sample/

Scala for the Impatient is also nice, but is more intended to help programmers get up to speed with Scala as fast as possible: http://www.horstmann.com/scala/index.html

[kamaal]

>>Partially free

That kind of says it all. Read different things from different places. No one single coherent documentation.

[justthistime_]

Selective reading much?

[phatmanace]

as a reasonably seasoned non-scala programmer who was fairly new to scala, I think that it's a combination of 3 things combined together. Implicits combined with non-alphabetic dsls (somewhat combined with the removing the dots from the method calls)

.. additionally, I always found the scala equivalent of the javadocs harder to read.

The end result (for me) was that I'd download, say an HTTP library, all the method names would be things like '/' and '?' - and you couldn't actually see what a minimally functioning code should look like due to all of the implicits flying around.

If you compare this to java, which was undoubtably more verbose, but was easier to take and unfamiliar library, squint a bit, and see how the building blocks roughly fit together, using a combination of reading the docs, and looking at the intellisense in your IDE.

[alfiedotwtf]

Taste.

Just like how people won't touch Python because of its whitespace, people won't touch Scala because of the JVM.

[rahilb]

What's wrong with the JVM? I thought it's one of the most well regarded computing abstractions.

[aurora72]

JVM can't be the reason people won't touch Scala or any other JVM language. Actually, being JVM-compatible is an attraction point.

[dragonwriter]

> JVM can't be the reason people won't touch Scala or any other JVM language.

It can be -- and is -- for some people.

> Actually, being JVM-compatible is an attraction point.

Sure, for some people. People have different preferences.

[rikkus]

Previous discussion may be pertinent:

https://news.ycombinator.com/item?id=7458588

[drabiega]

Hate is too strong a word, but I've seen some poorly written Scala that over used overridden operators and it left a bad taste in my mouth.

[vkjv]

I can speak from my own experience with using it on a growing team: Don't.

It's a very powerful and expressive language. That translates to "completely unreadable by people without at least a few months direct experience in it." If you plan on introducing people with little to no scala experience to your code base regularly you will probably want a different language or to severely limit your allowed feature set.

[tel]

Scala grew really fast off of an interesting, new academic ideas. There are a lot of stretch marks.

[justthistime_]

Could you give an example?

[lmm]

A lot of Scalaz and Shapeless duplicates things that were implemented less well in the standard library. E.g. standard-library tuples can't be abstracted over (supposedly will be addressed in Don Giovanni but that's at least 3 years away). Standard-library futures aren't completely controlled (and overuse implicits) so there is scalaz-concurrent Future which is almost but not quite the same. The macro implementation is clunky and really needs a couple of minor changes that are going to be in the next release but aren't at the moment, quite possibly because it was implemented by an academic whose time didn't quite sync up with the scala language release cycle.

[tel]

Slow compilation, many ways of doing things instead of a well-defined Scala-style, inheriting lots of Java libraries and having their perhaps very un-Scala-like behavior littered all around, two communities of programmers (roughly) the Java-alikes and the Haskell-alikes

[justthistime_]

How is slow compilation an "academic feature"? Same for the rest?

There might be valid criticism, but to me your comment doesn't make a good job bringing the "stretch marks" across ...

[tel]

The stretch marks come from bringing a small academic endeavor up to "production strength", not that there are specific academic ideas.

[morpheous]

Hatred is such a strong word ....

[anon3_]

It's disappointing to see Scala diehards coming here and downvoting anything that isn't glowing sycophantic love of scala. That's not leaving a good impression to the neutral crowd at all.

Here's an example of a post censored from StackOverflow: http://stackoverflow.com/questions/3606591/why-does-intellij...

Here's a backup of the post that was mirrored: http://w3facility.org/question/why-does-intellij-idea-compil...

There is one word to describe the mind of a scala die-hard: Solipsism. The view or theory that the self is all that can be known to exist. [1]

[1] https://news.ycombinator.com/item?id=9389563

You see the way they squirm? They can't accept any criticism and therefore refuse improvement. They just want to sit there and be hobbyists. Not on my investors' dime!

[justthistime_]

Not seeing many pro-Scala comments in here.

Isn't it more likely that some comments are downvoted by the general HN population, because they don't add anything useful to the debate?

By the way, I just clicked your link, and I can't really how they support the point you are trying to make...

[gaius]

I think it's because they went into it for the wrong reasons. If you jump into a language because it is the latest fashion, and not for solid engineering reasons, then it will be an uphill struggle to reach your goals.

I have only dabbled in Scala myself, kicked the tyres as it were. My question was, is this an Ocaml or Haskell with good interop with the Java ecosystem? The answer is no but I don't hate Scala for it, I just moved on. But many folks would have persisted and tried to make it into something it's not and gotten miserable in the process.

[logicchains]

There's actually a port of OCaml to the JVM that has pretty good interop with the Java ecosystem, or at least it will once it's out of beta: http://www.ocamljava.org/.

[gaius]

Looking back at my blog, this was in 2011. I am not doing much OCaml these days either, actually.

[marvel_boy]

Bloated,complex, perl syntax, slow compilation times, bad attidude of the Scala community. Please, don't waste your time trying to learn Scala.