Do you use Scala?

Do you use Scala?
What are your opinions about it?

Attached: Scala_logo.png (493x202, 29K)

Nice language.

Too complicated. It's made by scientists for scientists.

Attached: 1535625287923.jpg (1440x1632, 155K)

I'm currently learning Scala. It's definitely not a language for brainlets but slowly everything makes sense and your realize how powerful Scala is.

In the fucking sweatshop ecosystem for beta degenerates even good things become J2EE-or Hadoop like fucking crap.

Odersky is god-like based, Odersky >> Carmack >>>>>> BS

Everything else is fucking crap.

Nope. Scala is easy for any *proper* Scheme/ML *based* classic CS student.

please translate

Attached: kokoroslide.gif (450x253, 2.6M)

Sure, dear Satan

The whole fucking crap has been designed from the ground up to become a tool of choice software sweatshops - a conveyor belt assembly line staffed with uniform, easily replaceable cheap drones, mass-produced by third-world shit-tier universities.

They hired the leading programming languages expert of the time - Guy Steele Jr, to make sure that the language will be as rigid, restricted and brain-dead as one use on army ground or a construction site. They even force you how to name files and where to place them.

The whole project has been an enormous success - there are billions of lines of over-verbose, meaninglessly repetitive statically but unsoundly typed (ints are not objects, what a farce!) fucking crap on the planet, and there is no end in sight.

Obviously, since a typical Java coder is an beta or delta low IQ faggot, the quality of libraries is correspondingly low. Things like Hadoop is a such a bloated clusterfuck of idiocy, second only to J2EE and this fork of J2EE to create apps for mobile devices they call Android - an insult to human intelligence.

If we consider, however, that millions of Java coders suddenly got a job of creating crappy apps, the success is self-evident. It entirely unique situation, while the same pile of crap could be successful 2 times in a row. (No magic here - this world is dominated by idiots).

Last but not least, the whole Java sweatshop ecosystem is a paradise for bone-headed pointy-haired managers, because the assembly line is so fucking complicated that it requires constant micro-management 24/7.

Scala is plagued by choosing this fucking clusterfuck as its target platform and failed, because Java coders are too stupid to be Scala programmers. Sad story though.

It's the only usable language with a working type system

Swift.

Haskell

Native Scala built on LLVM is in beta now, so it won't be locked to JRE forever.

> no typeclasses
Try again

> usable
You are correct though

>usable

he said usable languages

what is unusable?

C#?

MLfags and even Haskellfags say that Scala is more complicated than ML/Haskell. It is easy to start using Scala when you know OCaml or Haskell + Java, but proper understanding is more difficult to reach than with a real functional language.

Haskell requires actually doing things kind of correctly and cleanly which is a big problem for Enterprise Solution® Engineers™

Scala will let you do shitty poo code, albeit in a less verbose way than Java at the very least.

Does Scala allow you to just use Java libraries in an otherwise functional application or are they too painful to use without a wrapper?

Libraries. Narcissistic hipsters pile up unnecessary type-classes and redundant abstractions, to show off how they "got it", so the whole pile of crap become unusable. Parsec is okay, but network libraries are fucking layered bullshit.

Haskell's only major problems are the difficulty of reasoning about performance and the unmaintained libraries.

>network libraries are fucking layered bullshit
Amen.

you can easily force strict evaluation, ghc also has some nonstandard extensions to help with this

Oh, yes, it does, so you have a few GB of dependencies, Jetty calls Netty, Netty calls Shitty and so on. Everything has been re-implemented inside JVM, for great good, of course.

Try Finagle or even Akka - the whole torrent of crap will follow.

Finagle will hide all that layered crap nicely and still be Fast™.

Akka will be an absolute maintenance and debugging nightmare if you don't know EXACTLY wtf you're doing up front.

>easily
Are you speaking from experience? In my (admittedly pretty limited) experience with Haskell I have found that often it wasn't just my code that was causing trouble due to lazy evaluation/data structures. What needed strictness optimization was somewhere in the dependencies of my dependencies.

Why is Akka so bad? I don't know Akka, but actor-based Erlang code is fairly maintainable.

just roll it all yourself friend

Things tend to get coupled to the actor itself and end up being hard to test.

Also, back then we didn't have typed actors, so "it compiles" didn't mean much.

Maybe. It seems that Twitter is the only based Scala shop in existence, and that they regret this decision every single day.

That's due to OO stuff. Caseclasses are unnatural concepts to people used to almost math-like conciseness of ML and Haskell.

Actually, it is almost impossible to match ML and Haskell (and Scheme) in perfection and approaching pure math in clarity and uniformity.

Scala is cluttered compared to ML, and the OO stuff is not actually necessary.

Interfaces (and duck-typing or type-classes) are the essence of programming, not classes. Traits (interfaces and protocols), not classes must be the core concepts. This is where Scala went too far.