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

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

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

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.

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.

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