

Paul Phillips explains why he lost faith in Scala and left Typesafe [Slides] - pooya72
http://www.slideshare.net/extempore/keynote-pnw-scala-2013

======
StefanKarpinski
I was hoping for a more coherent critique. The one complaint that is concrete
and clear enough to evaluate is about floating-point behavior, namely this:

    
    
       scala> val x1: Float = Long.MaxValue
       x1: Float = 9.223372E18
    
       scala> val x2: Float = Long.MaxValue - Int.MaxValue
       x2: Float = 9.223372E18
    
       scala> println(x1 == x2)
       true
    

This is just the way floating-point arithmetic works – its granularity
increases as the values you represent increase; at 2^63 its so coarse-grained
that adding 2^32 has no effect. To explain in more detail, a 32-bit float only
has 23 bits of significand, so at 2^63, the next representable float is
2^63/2^23 = 2^40 larger. Yes: 32-bit floats cannot represent any numbers
between 2^63 and 2^63+2^40. That's a huge gap, but there's only so much you
can do with 23 bits of precision. That gap is _much_ larger than the largest
32-bit integer (2^31-1). Thus, adding the max int value has no effect
whatsoever, since that delta doesn't get you anywhere close to the next
representable float. The best you can do is leave the value alone when adding
something so (relatively) small to it. If you want better than this, you need
to use more bits.

All of this is a minor detail, but if Paul Phillips is complaining about this
behavior without even taking the time to understand what's going on, for me
that really undermines the credibility of the rest of his presentation.

[1]
[https://en.wikipedia.org/wiki/IEEE_floating_point](https://en.wikipedia.org/wiki/IEEE_floating_point)

~~~
dagw
Yea, I caught that as well. It's really depressing how many seemingly smart
competent programmers there are out there whom are completely oblivious to
IEEE 754. Don't get me wrong, you're certainly free to criticize how computers
do floating point, but smart people have thought long and hard about this and
there are reasons for their decision, so at least try to understand those
reasons first.

------
virtualwhys
The 2nd slide speaks volumes, his commit history vs. that of Odersky.

PaulP was trying to strip down the language while Odersky was adding on to it.
The two must have been butting heads behind the scenes, and Odersky, the
creator of Scala, probably wasn't wanting to follow PaulP's crazy wisdom.

Sucks, that's a lot of talent going out the window with PaulP's departure, big
shoes to fill.

~~~
moox
I browsed some of his commits and there's a lot of aesthetics and refactoring.
Without him the scala project might quickly become hard to maintain.

------
lazyjones
Unfortunately, he doesn't share where he is heading now. It does sound like he
might find Go attractive (with its very small language and well-designed
toolset).

~~~
virtualwhys
In the comments on Reddit he doesn't find Clojure attractive (due to lack of
static types), so dynamic langs are out the window for him.

As for Go, maybe, but assume he'd be more inclined to go with Kotlin and pull
a James Strachan (former Scala advocate who created the Kotlin standard
library; also creator of Groovy).

Or do something entirely different, god knows, he follows his own way.

