For instance in http://www.infoq.com/presentations/data-types-issues at 26:26 the topic of mapping modular to functional vs. functional to modular is presented. It wasn't some arbitrary decision, but based on the lessons learned earlier.

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?

He is comparing Scala to OCaml, whose module system dates back to 1995, not any current research. My point was that Scala is not the only way to do first-class modules. Subtyping is my biggest issue with Scala and he admits that (variance) is "hard to get your head around" in that talk. 1ML is a research project, which probably would get a lot more funding if it talked about "objects" and "classes".

It's not the only way to do first-class modules, it's just the only currently known way where both modular and functional sides are actually useful without introducing completely separate sub-languages.

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.

This isn't true anymore and 1ML was my counterexample. I sympathise with your point that Scala is a working shipping product.

I prefer to try that myself before coming to such a conclusion. Where is the 1ML compiler? I only found some outdated proof-of-concept 45kB interpreter with version 0.1.

Regarding

   would get a lot more funding 

somebody once said that objects vs modules is like working class vs ruling class: objects do all the work, modules get all the credit.

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.

I like the quote :)