Scala 2.12 is late, and not having easy java8 interoperability is becoming more and more of an issue.
I love the language but it is becoming harder to recommend it for new things due to the ambiguous roadmap.
And I think a bit of simplification and formalization is exactly what Scala needs, in the long run.
It's becoming easier for me to recommend it due to the slow moving roadmap. So are you going to tell people to stay away from the JVM for its ambiguous roadmap (openjdk projects being delayed, etc)?
While the theme for 2.12 is easily summarized (Java 8), I assure you the changes behind the scenes go all the way to the core. Compiling lambdas and traits to the best Java 8 bytecode we can think of, unifying type checking of Single Abstract Method types and Scala's built-in function types, as well as rewriting the whole optimizer and byte code emitter was no small feat! It's been very satisfying to rework these parts of the compiler, and I'm excited to see 2.12 going live soon!
We're cutting the last milestone (M5) this week, with RC1 scheduled for the second half of July -- assuming M5 is well received. We're pretty confident, as we build over 1MLoC of OSS Scala every night using dbuild (see scala/community-builds on github).
We at Lightbend care deeply about language stability and compiler robustness, as we believe they are key for driving Scala adoption by the community and the enterprise alike. Being PL researchers, we are also excited about simplifying and evolving Scala! This is why we're working on a smooth & steady migration path towards the ideas being incubated in Dotty.
Scala's process is a dialogue, which means coordinating with Martin Odersky and his teams at EPFL and the Scala Center, as well as the whole Scala Community. Ultimately, we at Lightbend set the Scala 2.x roadmap based on this consensus (since 2.10), and take on OSS development and maintenance (as well as commercial support for our customers). With the founding of the Scala Center, we're happy to share governance, while remaining as committed to the day-to-day engineering and representation of the pragmatic robustness and careful evolution voice :-)
This dialogue comes naturally to us, as half of our team are alumni from Martin's lab (Lukas & I have been working on the Scala compiler for almost 10 years, ranging from adding support for type constructor polymorphism in Scala 2.5, rewriting the pattern matcher in 2.10, implementing named & default arguments, while working on the theoretical foundation of an effect system for Scala as well as the core of Dotty), while the other half are long-time contributors to all aspects of Scala.
Sure, releases sometimes slip a bit -- we are a small team (we're a small company -- our team size is no outlier), and while we get to spend the vast majority of our time working on OSS, we also have some commercial obligations inside the company (e.g., Scala support tickets are handled by us). The other reason is that we have worked on 2.11 for 6 months longer than we usually spend on a major release, because we wanted our Java 6 users to get as many of the 2.12 features as possible on their platform (2.12 requires Java 8), as well as providing a preview of the new ASM-based back-end and optimizer.
The Scala team at Lightbend takes care of half of all PRs, with the other half being contributed by our awesome community (including EPFL, though they mostly focus on their research and Dotty, which is how things are supposed to be). We've worked hard on making it easier to contribute to Scala, and I'm very glad to see the rate of community contributions trending up!
The Scala and Dotty teams talk regularly (we just had a Dotty & Scala summit before Scala Days), to exchange tips on compiler performance as well as to work towards convergence for Scala 2.x and Dotty. For example, the 2.12 trait and lambda encodings were tried first in Dotty, with our real world adoption of these ideas feeding back into the Dotty compiler. For 2.13, we're planning feature flags to implement the first wave of Dotty features and restrictions (and vice versa for Dotty emulating Scala 2), so that you can start migrating your code bases. For some more background, here are our roadmap updates: http://www.scala-lang.org/news/2016-schedule/, http://www.scala-lang.org/news/roadmap-next/, http://www.scala-lang.org/news/2.12-roadmap/.
Are you saying two new compiler engineers were hired by Lightbend?
Because if they're working on Lagom that's a different (mostly Java) story https://github.com/lagom/lagom
Different projects require different approaches. The introduction of the community process added 5 new maintainers and the merge of Slick and FreeSlick caused a lot of activity and contributions, so I'm pretty happy.
> Are you saying two new compiler engineers were hired by Lightbend?
Yes.
> Because if they're working on Lagom that's a different (mostly Java) story https://github.com/lagom/lagom
No.
I do think 2.12 (and 2.11 before it) either had unrealistically optimistic deadlines or suffer from poor project management. 2.12 has slipped by well over a year at this point, which is sad for frameworks like Spark which are going to stick to 2.11 for their next MV cycle.
https://groups.google.com/forum/#!topic/scala-internals/lv4s...
The fact that the 2.11.x series had a number of "dead on arrival" minor releases also confirms: better not to hurry to adopt a new Scala release.
(I don't mean to be terse, I just don't know how to ask that with more words...)
Are you based in the UK? It would be interesting to compare notes. :)
Look me up in the GAL (My username is my name).