
Ask HN: Why do people have a hatred for Scala? - lnk2w
I&#x27;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?<p>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...](http://stackoverflow.com/research/developer-
survey-2015#tech-super)

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.

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

~~~
istvan__
Right. Let me take this from a different angle. I like to hear about projects
moving away from technology much more than jumping onto a band wagon. Right
now, Scala feels to me as a band wagon. Some of the guys who moved to use
Scala from Java just simply moved back because they realized that almost all
of the features are available (emphasis on almost) in Java (especially in Java
8). On the other hand, learning Scala takes time so for a while you are
writing inefficient code. On the top of that you need to make sure everybody
is on the same page in your team, that is also additional effort. All of these
were driving projects (like Kafka) away from Scala (look at the new producer
code).

To summarize: Scala to me is just a better Java with too many trade offs.

~~~
justthistime_
That's interesting, because weren't Kotlin and Ceylon created because people
wanted to have "just a better Java", which Scala is not really interested in
being?

> they realized that almost all of the features are available

Interesting too. Looking at the stuff I'm currently doing, there is plenty of
stuff which is just impossible in Java.

By the way, isn't "Scala has such a nice type system that it blows out OCaml
from the water" already the case?

~~~
lmm
> weren't Kotlin and Ceylon created because people wanted to have "just a
> better Java", which Scala is not really interested in being?

Scala was that at first. Arguably that's still Typesafe's primary interest.

> By the way, isn't "Scala has such a nice type system that it blows out OCaml
> from the water" already the case?

Yes and no. It's more featureful (higher-kinded types are really nice), but
less elegant and type inference works less well (in part because scala has
both inheritance and typeclasses).

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

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

~~~
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...](https://github.com/scalaz/scalaz#type-class-instance-definition).

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

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

------
nielskrijger
This might be worth a read:

[http://codahale.com/the-rest-of-the-story/](http://codahale.com/the-rest-of-
the-story/)

[http://codahale.com/downloads/email-to-
donald.txt](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-...](http://kotaku.com/5975610/the-exceptional-beauty-of-
doom-3s-source-code)

------
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...](http://www.reddit.com/r/scala/comments/2l7v5u/json_parsing_in_scala/)

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

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

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

~~~
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](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](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?)

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

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

------
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...](http://blog.gmane.org/gmane.comp.lang.scala.debate/month=20110301)

Apart from occasional issues in the community Scala is criticised for being
too complex:
[https://www.youtube.com/watch?v=uiJycy6dFSQ](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](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.

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

------
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/](http://www.ocamljava.org/).

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

------
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](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/](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/](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](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.

~~~
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](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?

~~~
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...](http://stackoverflow.com/questions/3606591/why-does-intellij-
idea-compile-scala-so-slowly/3612212#3612212)

Here's a backup of the post that was mirrored:
[http://w3facility.org/question/why-does-intellij-idea-
compil...](http://w3facility.org/question/why-does-intellij-idea-compile-
scala-so-slowly/)

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

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

