Confreaks
2 HN recommenders · recommended in 13 months, 2013–2020
50:43 · 65K views · Oct 25, 2013
Paul Phillips, a former Scala core contributor, argues after moving a million lines of code that much of what the software industry does is wrong. He critiques Scala and compiler design and calls for better approaches.
Cited as an insider's critique of Scala and of non-incremental compilers, often by people warning others off Scala.
16 comments from Hacker News
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: this video [LINK]
5 years ago, Paul Phillips was still a core contributor to Scala. Anyone seriously considering Scala should listen to his talk, titled “We’re doing it all wrong”, and take a look at Policy, his fork of the Scala compiler. this video [LINK] Previous discussion: [LINK]
>Edward Kmett is a Haskell evangelist Really? Could you point me to some of his evangelizing? Or did you mean "he uses haskell and is quite happy with it"? Because that isn't the same thing. >inconsistencies that the average programmer will never even realize exist. Do you honestly believe that? this video >Scala that only when you leave it's confines do you realize, shit, I miss But the very point Edward makes is that you don't give up those things when you leave scala. You only give up those things if you leave scala for something worse. You could leave for something better, keep all those things, and get tons of important things that you also won't realize you are missing until you get used to them and then try to live without them.
a) Martin Odersky has admitted as much[1]. b) The compiler internals are reportedly a mess[2]--likely due at least in part to the extreme number of different syntax variants. c) I find rule 4.1 in OP interesting ("SHOULD avoid concurrency like the plague it is"). According to Odersky's Coursera course[3], one of the main advantages of functional programming as enabled by Scala is easy, safer concurrency (reduced/absent mutable shared state). Yet here we see a presumably seasoned Scala veteran basically saying that this is a failure and we should avoid concurrency whenever possible because it results in too many bugs. 1. [LINK] 2. this video 3. [LINK]
Paul, why do you say it's wrong that Float(Long.max - Int.max) is equal to Float(Long.max)? Float has less than 32 significant binary digits, and Long.max - Int.max has the same MSBs as Long.max. You would need to use Double to see the difference. I'm not sure what implicit conversions/promotions have to do with that - you want a warning or error when going from Long to Float? That would be reasonable. You can even lose significant digits between Int->Float and Long->Double even though they have the same total number of bits, so you could require those to be explicit. (from a slide in this video )