I agree that that 1ML is interesting. Some of the warts come from JVM/Java compatibility. In what sense would you argue that OOP can be successfully encoded on top of a typed lambda-calculus? Finally, the relative simplicity of DOT [1] indicates that Scala's core is not that complicated.
[1] N. Amin et al., The Essence of Dependent Object Types. http://infoscience.epfl.ch/record/215280/files/paper.pdf
I expect Scala to gravitate more towards DOT in the future, as early mistakes in Scala's design will be ironed out.
It might be interesting to see how the form of OOP that you are interested in can be expressed in DOT, for example by removing subtyping form D_{<:}. Have a go at it!
1ML is based on F-omega, which has higher kinds but not dependent sums or products, while D_{<:} has path-dependent products but no apparent higher kinds, if I understand the paper correctly.
- The existence of a reasonably well-funded organisation (Typesafe/Lightbend) stewarding Scala was well-received.
- Typesafe/Lightbend's independence also helped, in the sense that I cannot see a Scala-like language succeeded if it had come from e.g. Oracle.
- Scala's open-sourcing of everything helped.
- The well-executed and well-timed Scala-MOOC also helped a great deal.
- Odersky's fame and track-record helped too.
None of those might have driven your Scala adoption (or mine), but they might have helped others to shift their dev towards Scala.
The "new" 1ML paper is already old, and nothing ever happened. (Which is the core issue of ML: Cool papers, but nothing ever ships.)
Since then, DOT has been proven to be sound, dotc can bootstrap itself, and large subsets of "Scala 2" can already be compiled with dotc.
Dotc also sports a very interesting design with its mini-phases + phase-fusion approach, denotations, less desugaring, and a more immutable AST. The speed improvements have been very promising even though no performance tuning has happened so far.
TASTY is on track as a standard IR to express code as an entity that can be produced by different compilers and compiled to different targets like (JVM, JS, ...).
SBT recently gained a compiler interface to drive compilation with dotc, and dotc gained support for producing Scala.js IR.
What happened to 1ML since the paper was published?
Of course it's a lot harder than building one side and then claiming that the other side sucks because the whole paradigm sucks (but we still wanted some research grants (looking at you, OCaml)).
Scala's OO+FP approach allows me to appreciate both sides where they have their strengths. This is in contrast to languages like Haskell which can declare that FP is the best thing ever (because that's the only way to write programs in Haskell ("but, but, you can do these terrible contortions and write things that look like OOP in Haskell" – let's just skip that point, it doesn't add anything to the debate)).
it's just the only currently known way where
both modular and functional sides are actually
useful without introducing completely separate
sub-languages.
would get a lot more funding
In case people were wondering, the 1ML project can be found here: https://www.mpi-sws.org/~rossberg/1ml. The key idea here is that ML-style modules (which in the past were though to need a separate module language) can be coded up into System F-omega (the "workhorse of modern compilation").
I don't think any of the 3 main guys behind it (Russo, Dreyer, Rossberg) works on modules all that much right now. That may explain the relatively tardy speed of development.