Scala – 1 Star – Would Not Program Again

    > My belief though is that there is some peace of mind that comes from the 
    > idea of what you might call "page composition" -- that this piece of data
    > sits in this template, that it rides on top of this simple model, that it
    > is in ORM from database. There is a huge amount of linearity and convention
    > throughout the stack and because of the dynamic nature of Ruby lots of gems 
    > can be sprinkled throughout without one really understanding what they do.

Actually, the problem with OO and my experience with Rails is this linearity quickly becomes a web where deriving the sequence of events encompasses more and more of your time as the project grows.

Objects call objects across the system and change the state of each other without care. Making a trivial change involves unrolling this web every time.

And that's why I think you have this backwards:

    > Now, I'm certain this level of abstraction and functional/mixin kindof stuff can be 
    > achieved in a Clojure framework but I think it is generally perceived as being a bit
    > more non-linear and DIY (libraries not necessarily playing nicely together). As in 
    > "yes I can get all of these pieces together but then if down the line I have to change
    > this piece, how will I accomplish it without breaking everything".

`require`ing a Ruby gem is as non-linear as you can get. It's global with no entry-point. A gem's presence and effects are not obvious. They're often configured with some mutation like:

    MyGem.config do |c|
      c.key = "secret"
    end

Meanwhile, it's obvious when a namespace of Clojure functions is included. And since they're just functions, they're trivial to compose. Completely different experience from what I was used to in Ruby.

So I am curious what npm gives you that sbt doesn't. I have heard it a few times how much better npm is but i haven't seen anything it does that sbt doesn't

I've been a critic of Play 2 on a number of occasions on HN but I don't understand the complaint. What is causing you to create URLs with trailing slashes?

Java 8 for me is still far from making me move from Scala. Lambda expressions is only a small part of what I like about Scala. For me Scala is a statically typed Ruby / Python / JavaScript that runs on the JVM, and is very Java like. I would change some things in it, but a language doesn't have to be revolutionary to make me want to use it.

Things I have in Scala that I like and Java 8 won't provide (many are syntactic sugars and non critical stuff, I know, but I like it, I'm spoiled)

- implicit conversions. some hate it, I love it. It allows much better "pimp my library" mechanism than Ruby's and it's very easy to write extensions to your or 3rd party extensions in a safe and easy manner

- duck typing, e.g. allows to write a "try with resource" without native support for anything that implements "close"

- automatic tuples

- better type inference

- semicolons, hate them

- automatic equals and hashcode for case classes

- case classes

- futures and promises

- by name parameter passing (passing a block of code without running it)

- partial functions, multiple parameter lists

- for comprehensions

- pattern matching

- nested functions

- lazy vals

- everything is an expression

- String interpolation

- multiline string

- default parameters

- named parameters

- pattern matching

- everything is immutable by default

- very string type system

I think that's it. Yes, Scala is infamous as the language that took many many features from other languages and piled it all together, well, fine with me! you say more features that are great in other languages and make people productive? (and are kind of expected, like default parameters etc) I say bring them on and the more the merrier. I can choose which features I want to use out of the way too many features the languages, much better than waiting years for features to be added. Hater's gonna hate, I'm still going to write Scala until something better comes around. (Nimrod? Kotlin? Ceylon? TypeScript? Dart? perhaps even Go? Don't know... time will tell)

T is covariant (positive) if A ≤: B ⇒ T ≤: T. T is contravariant (negative) if A ≤: B ⇒ T ≤: T (i.e., the other way around). Pretty simple stuff.