The first day was definitely under the sign of scala.meta, so Eugene gets a full section. Scala tooling is sufferring greatly from the lack of reusable tools. The Scala compiler itself (via the presentation compiler) has severe shortcomings that appeared in all talks except Pavel’s (IntelliJ decided to write their own type-checker):
Eugene’s work is the holy grail of Scala development tools: a single model for Scala code, based on concrete syntax trees suitable for source transformations, with semnatic information (notably, types). The project is still under heavy development, but it can already handle purely syntactic tasks (such as automatic formatting). Next step: converters from existing type-checkers (think: different versions of the Scala compiler, Dotty, IntelliJ) to the new lingua-franca of the Scala world!
This last step proved to be problematic, and Eugene’s talk, and the later brainstorming session – more about that later – have toned down our expectations. We can summarize this as “there is no magic”: the first point makes a come-back: the converter needs to solve exactly the same problem as all tool writers, and there seem to be fundamental limitations in what can be achieved. A couple of ideas:
xs.map(x => x + 1)coming from the same source, or maybe the user wrote
for (x <- xs) yield x + 1? Or maybe he wrote
for (x <- xs) yield (x+1)?
En bref, hope is still there, but Eugene has some tough work ahead. The whole community counts on it and needs it.
As the first day drew to a close and my tired brain was dreaming of a beer to wash it all out, there was “one more thing” to be done: since all Eclipse plugin developers were under the same roof, we’d have a planning session.
What happened instead became the highlight of this conference: we had an all-hands meeting with practically all tool authors in the same room! IntelliJ, Ensime, Scala.Meta, Eclipse, Scala Refactoring and even Dotty were up to some serious brainstorming for the greater Scala good!
It all stated with the stringent problem of Scala refactorings: how can we improve their reliabilty, in the short-term and the long-term?
This should be the subject of a whole post in itself (hopefully a joint one), suffice to say: there’s some cool stuff coming out, and the Free Monad might be part of it (this is Karma)!
What else? Sbt had a couple of appearances, but unfortunately I missed Nepomuk’s talk so I can’t speak conclusively about auto-plugins.
Coursier is a library for dependency fetching entirely written in Scala that aims to fix Sbt. It’s easy to use programmatically, it’s really fast, and has an Sbt plugin. Keep an eye on it, it may solve one of the main complaints against Sbt: slow resolution.
Simon Ochsenreither talked about challenges in cleaning up the Scala specification and its corresponding implementation, focusing on two corner cases: automatic import of
java.lang._ and numeric promotions. A good primer on language design and the challenges of maintaing compatibility but evolving the language. At this point in Scala’s evolution my personal take is that compatibility is, in the vast majority of cases, a more worthy goal than purity.
Simon Schäffer’s talk on an uber-platform to supersede them all was an ambitious overview of our field and the futile cycle of innovation and reinvention of the wheel. Thought provoking, and the kind of ambitious talk that gets one dreaming of a better future. Personally I’m not sure if I like the perspective of a single tooling platform for everyone (.NET tried and got the closest to that goal). Watch it for yourself once talks are online!
Lukas Wegmann showed a pretty awesome search tool: a Hoogle for Scala. Search Scala libraries for a specific type! Say, you need to get from a sequence to a set? type in
Seq[A] => Set[A] and let Scala Search answer that for you. If we can have it index most popular Scala libraries this will become indispensable. Even better, this should integrate with IDEs and suggest completions based on the type context (something we actually had but fell into oblivion once the author graduated).
Rapture is a library for everyday Scala programming. It has nothing to do with Scala tools, as noted by Haoyi Li, but Jon did a great job at showing clear use-cases, elegant APIs and sense of humor! Watch it when its out, especially if you deal with i18n. I’d definitely give it a go in my next project.
I missed a few talks during the second day, so appologies for not covering “Play-Swagger: Swagger support for the Play Framework” and “Custom deployments with Sbt plugins and sbt-native-packager”.
Unfortunately, the panel had only nice people so no controversial, outrageous claims that lead to a heated discussion! Something to be fixed next year! Sbt came up several times, with everyone trying to be nice and look at the “good parts”. Definitely, Sbt should have been represented at this conference.
The conference was fantastic, and I will definitely return. The whole conference was organized in a very short time, and understandbly missed important pieces of the ecosystem (such as Sbt) whose main authors live across the ocean. All in all, a great success, and kudos to VirtusLab for a great job!