Scala Collections: Why Not?

(throwaaway here) Before you waste the next few months of your life learning a corrupt programming language: - Typesafe co-founder quits: [VIDEO] - [LINK] : Paul Dix - Why Node and Scala will dry up: Go will drink their milkshake - I can personally tell you, scala is awful at handling large codebases and is so filled with idioms, you have a difficult time reading it. I remember opening scala code, seeing english, but it felt impossible to decipher. - You feel clever when you write it. No doubt about that. Other programmers and your customers don't care. - Compilation time: It's atrocious, we're talking 1 to 10 minutes to compile web apps. - Package dependencies: You end up incorporating java at the end of the day. Version mismatches. - As for the "functional language" thing, just pick real Haskell or Ocaml. Don't fall prey to scala being a functional language. - You need to rely on a huge, laggy IDE with missing / out of date plugin packages to get autocompletion. On the other hand, Golang: - compiles these massive applications in line 2 seconds. - It's highly lintable. - The syntax is just... dumb. - Yet you don't feel limited at all. - It runs fast-fast-fast without having to rely on JVM. - Familiar syntax... like a hybrid between Python and C - You can import packages from github / git repos, automatically grab dependencies with one command. - The build system and tooling is simple and genius - Autocompletion ( [LINK] ) OP: I hope you don't waste your time on a scala ventu

Here's one: [LINK] Apart from occasional issues in the community Scala is criticised for being too complex: [VIDEO]

If you enjoy these types of compiler videos then I would highly recommend the following rants against Scala by Paul Phillips (from TypeSafe and one of the core language contributors). He also talks about wanting to edit abstract syntax trees directly: [LINK] [VIDEO]

> I don't want .Where() called on an array to return another array. I want a lazy IEnumerable<T> almost every time. Yes, good point. There is a lot of space to explore in collections API designs, and the LINQ design is just one of them that makes its own tradeoffs (e.g., only have to implement "GetEnumerator()" to get a watered-down monadic experience). Contrast that with the well-meaning but convoluted and buggy Scala collections API (very difficult for novices to create a custom collection due to CanBuildFrom and other tricky stuff). Paul Phillips came up with a pretty neat collections API [1, 2] that provides a nice feature set, including high-performance and typesafe views when you don't really want to wastefully create a temporary collection just to interact with the first 10 elements. [1] [LINK] [2] [VIDEO]

I think all technologies have sharp edges somewhere, and the way to stay afloat in this business is staying alert. Testing assumptions help, be it through quick REPL experimentation or a unit test. JavaScript has some bad fame around unintuitive behavior but you can find these styles of issues in most languages. A random example: Scala. [VIDEO]

Before choosing Scala I think you should watch this talk: [VIDEO] (note: he's not a troll, he worked 5 years with Scala)