The Dotty experimental compiler for Scala now bootstraps | Hacker News Reader

The Dotty experimental compiler for Scala now bootstraps

infoq.com

75 points_sunshine_21 comments

How about the official Scala compiler? It seems to stagnant a bit... I know there is a lot of work behind the scene, but from developer perspective there aren't many things going on.

E.g. Scala 2.10 Introduced a lot of interesting features like string formatting s"Hello $name!".

Scala 2.11 offered minimal improvements, for me just compilation time improvements and better incremental compilation. I don't see anything exciting on 2.12 roadmap.

It looks like Scala compiler is very complex machinery, few key people left: http://www.slideshare.net/extempore/keynote-pnw-scala-2013 and Typesafe doesn't monetize compiler itself, so it focus on building ecosystem around it (e.g. Akka).

> How about the official Scala compiler? It seems to stagnant a bit

It is. Odersky is spending most of his time on Dotty these days and he doesn't seem that interested in Scala any more, except when he's obligated to talk about it at keynotes (and he tends to talk more about Dotty there anyway). Despite the grandiose plans of possibly back porting Dotty features to Scala at some point in the distant future, Scala has been in maintenance mode for a couple of years now and with more and more people leaving the core team, it's probably going to stay this way.

Such a missed opportunity.

Please see the comment above: even though the main compiler is in maintenance and stabilization mode, innovation has happened in Scala in the form of independent projects, driven by people in Martin Odersky's lab.

This is what we call FUD.

The former developers on Groovy are spending most of their time on their day jobs these days and they don't seem that interested in Groovy any more, except when they're promoting the existing version at conferences (and they tend to talk more about the fabricated number of downloads there anyway). Despite the grandiose plans of possibly improving Groovy with a proper meta-object protocol at some point in the distant future, Groovy has been in decline for a couple of years now and with less and less people using it, and those that do use it only using it for 30-liner test or build scripts, it's probably going to stay this way.

Such a missed opportunity.

I think the only reason Groovy is still around today is Gradle. Once Gradle starts declining, Groovy will probably disappear along with it.

A lot of work in 2.11 has gone in stabilizing the compiler (aka bug fixing) and the backend (the JVM bytecode generator). Unfortunately this is not very visible work, but it had to be done to maintain compatibility with Java 8 lambdas.

As for the new things, they are mainly library-based and compiler plugins, so the scalac compiler remains stable, and new features are self-supporting. Some examples:

* Scala.js (http://www.scala-js.org/)

* Scala.meta (https://github.com/scalameta/scalameta)

* Pickers and spores (https://speakerdeck.com/heathermiller/on-pickles-and-spores-...)

* Scala offheap (https://github.com/densh/scala-offheap)

* RRBVector (https://github.com/nicolasstucki/scala-rrb-vector)

* ScalaBlitz (https://scala-blitz.github.io/)

* Miniboxing (http://scala-miniboxing.org)

Also, I should mention the theoretical work on the DOT type system, which is a sound and more expressive type system to be used for the Scala programming language (compatible with the old type system, as it's more expressive, but also sound -- disallowing any incorrect code).

Regarding Typesafe, they took over releases and maintenance, and did a good job at that. Yet Martin Odersky himself and his team at EPFL are the main drivers for innovation, including dotty and all the projects listed above (which were all developed at EPFL, see http://lamp.epfl.ch).

I was really excited to read about offheap, but I'm disappointed that you make sacrifices in memory safety by using it.

I'm so excited by Rust's memory management, but Scala just have so many nice features, especially in multithreading. I hope Rust will catch up, eventually.

Scala is a complicated language. I would see it as a good thing if new features are rarely added.

My understanding is that Dotty is the next generation of the Scala compiler. See the Scala roadmap for the details: http://www.scala-lang.org/news/roadmap-next. Basically, it's the culmination of research showing that the language's feature set can actually be expressed in a smaller number of primitives than previously thought. A lot of features that are distinct today will become syntactic sugar for more general underlying representations. I think the expectation is that this will actually make the compiler more agile going forward,and let the maintainers cut out some of its gnarliest corners.

That is my understanding as well. That it will be Scala "Don Giovanni", which I believe will be Scala 2.14, or maybe they will bump it to 3.0 at that point.

I'm a tiny bit confused. Is dotty scalac rearchitected or is it new PLT-research/paradigm that will be able to compile scala ?

my understanding is that dotty could be the new scalac,

ATM it compiles a subset of scala, but the plan is to make it compile everything and then still provide support for further plt research/scala features.

Their readme[0] and initial announcement[1] are as much details as I know of.

[0] https://github.com/lampepfl/dotty [1] https://groups.google.com/forum/m/#!msg/scala-internals/6HL6...

Well, the official compiler is going to be replaced by Dotty eventually, so you could say that this is actually work on a far-out beta of an eventual version of the official Scala compiler.

Hi! Typesafe Scala team lead here (formerly in Martin Odersky's lab, where I implemented type constructor polymorphism aka "higher-kinded types" in 2007 and rewrote the pattern matcher in 2.10, before joining Typesafe in 2012).

First of, congrats to the Dotty team -- this is an important (first) milestone! One of our next shared goals is making the Scala standard library cross-compile on Scala and Dotty, by the way.

I'm personally more excited about Scala 2.12, though! The new compilation schemes for lambdas and traits are much more efficient in many ways (bytecode size, runtime performance and binary compatibility) than the old one, forced on us by Java 6's limitations. Both schemes were prototyped in dotc and developed in parallel, as part of our ongoing effort in aligning Scala with Dotty (actual convergence is still years away -- in the mean time, Scala versions will gradually adopt ideas that are proven in Dotty).

As always, evolving the language carefully is a feature in itself! (I understand it may seem too slow to some, but most users are happy with this pace, we think.) We have a responsibility to our fast-growing user base to not pull a Scala 2.10 every 18 months ;-) We will, however, keep moving forward, as witnessed by the ongoing deprecation & modularization in the standard library. Eventually, deprecated features will be removed, even...

Happy programming!

Why do they want to bootstrap themselves? Golang specifically set that as a nongoal, and look how fast their compiler is. Scala being a functional vm based language will always have a performance disadvantage to well written C code. If they really care about the real world usability of the compiler (and thus the language), this implementation seems like a poor strategy.

Bootstrapping is a useful test of the completeness of a compiler, and it makes development easier.

The Go compiler is fast because it does very little. It doesn't do much optimisation and Go is not a very sophisticated language and so does not require much of it's compiler. It is not comparable to the Scala or Dotty compilers.

Turns out go is bootstrapped now too as of 1.5....

http://www.infoq.com/news/2015/10/dotty-scala-bootstraps has some more details.

Thanks! We changed the URL to that from http://www.scala-lang.org/blog/2015/10/23/dotty-compiler-boo..., which doesn't give as much info.

It seems kinda weird that Dotty is referred as "Scala compiler" when the language Dotty compliles sounds fundamentally different from Scala. Bit like saying that DMD (the original dlang compiler) is an experimental compiler for C++?

> Dotty, a platform aimed to develop new technology for Scala tooling as well as try out new concepts for future Scala versions, has reached bootstrap status. This means that its compiler is written in Dotty and can compile itself, thus providing a drop-in replacement for the original one

I would imagine that self-hosting is fairly minor aspect of being a drop-in replacement of exising software compared to backwards compatibility.

Reply on news.ycombinator.com