Scala World 2017

scalaworld intro

Wait, is it autumn already? Seems to be the case. Well then…​

A one-of-a-kind conference

Scala World benefits from its choice of venue, a small town called Penrith in the English Lake District.

Thanks to that, in contrast to usual pre-conference meet-and-greets, the organizers offered a set of physical activities - mostly geared towards the surrounding mountainous terrain. There was a long hike set up for Saturday, and a choice of additional hiking, mountain biking or canoeing the following day.

It is certainly an interesting planning choice, and allows for a more natural interaction between conference-goers. This effect was compounded by most people staying in a relatively small area, increasing the probability of chance encounters on the street, at the pub, and the like.

The weather was also quite passable, certainly not living up to the typical English stereotypes of constant fog and rain.

The venue itself, accessible by the conference-provided bus, was nothing to be ashamed of either. Literally embedded into rolling hills, it was spacious, functional, and provided excellent catering.

But enough about the incidentals - you’re probably reading this mostly to learn about the talks and trainings during the conference itself.

A variety of topics

Scala World has a serious reputation as a solid conference for Scala professionals, and thus a selection of quality topics was available.

Like with any major conference of this type, trends prevailing in the language itself can be garnered from what is talked about. I will provide some highlights below, grouped by similarity.

scalaworld headliner

The Language proper

Being the next incarnation of Scala, Dotty had of course a prominent podium this year.

Felix Mulder talked about Real-World Dotty, i.e. highlights of new languages features relevant for the everyman developer.

Of particular note was the discussion of union types, where Felix outlined some pitfalls related to type erasure, and included a comparison between union types and other, existing implementations of coproducts ("or types") - e.g. he made the important point that while shapeless' Coproduct s are ordered, Dotty’s union types are not.

Another noteworthy tidbit was the typer improvements. For example, it looks like the Aux pattern will no longer be necessary in Dotty, and dependent types will be usable in signatures directly. Also, more relevantly for most developers, Dotty’s type inference is "smarter", e.g. fold can be usable with a single parameter list [1].

As a contrast, Nada Amin guided us in a dive into the theoretical underpinnings of Dotty in her DOT: Scala Types from Theory to Practice presentation. I find such talks vitally important, as they allow the majority of developers, who usually are not acquainted with the formal underpinnings of programming language constructions, to gain additional insight into why various particular design choices were made. And Nada’s done very well in this regard - the only reason I wasn’t able to follow the talk with full attention was due to being in the darkest depths of a post-lunch food coma. I’ll update this post with the link to the recording once it becomes available.

As a more specific facet Stefan Zeiger in his The New Collections Library - for Scala 2.13 and Dotty talk has outlined the design decisions going behind the current collections "strawman", that will relatively soon be developed into the new implementation. The major focus here is on computational laziness and limiting the the total implementation "surface". The latter means reducing the number of interfaces necessary to implement - and understand! - a collections class. By the way, the current prototype is available here.

Performance is important

We all know that one shouldn’t optimise prematurely - but all developers should likewise know about optimization in general, in case it becomes necessary.

And that’s why the Day One closing keynote by Dimitry Petrashko served well as a palate cleanser. Dimitry provided a relatively comprehensive bird’s-eye view of low-level optimizations in the context of the JVM. All of that was spiced up with examples for specific hardware generations and architectures.

A Tale of Two Monix Streams by Alex Nedelcu (the creator of Monix née Monifu) was similarly performance-related. However, the focus here was on API design, specifically on how seemingly innocuous design decisions can have far-reaching run-time efficiency consequences, and the differences between the "internals" of a library and it’s user-facing API.

scalaworld presentation
Figure 1. Alex Nedelcu staying true to form.

Trond Bjerkestrand in his talk Boring Enterprisy Webapps concentrated, in turn, on developer performance. He talked at length about his own experiences designing various applications, and what technologies, platforms and libraries he considers productive (or not). In other words, a sort of "self case study".

Functional Programming

Scala World is billed as an intermediate-and-up conference, so thankfully we were spared a 100th explanation of monads.

What we got instead is quite a few talks about functional programming design. The first two were Simplicity in Composition by Adelbert Chang and How to build a Functional Programming API by Julien Truffaut. It is difficult to summarize while doing them justice, other than stating that Adelbert went with top-down, theory-first approach while Julien provided a more bottom-up, hands-on view (I will update this article with recording links when available).

Similarly, Aaron Levin’s Mastering Typeclass Induction for Type-Level APIs concentrated more on the underlying theory of typeclass-based APIs, while Tamer AbdulRadi’s Validating SQL at the Type Level was built on a specific example, and went from there.

Last but not least, there was Exploring Decision Trees with Matryoshka by Zainab Ali, a sterling example on how to introduce and "advertise" an API/library well. A sane and practical example of usage was initially employed as the canvas, and terminology necessary to understanding the code was steadily dripped into the presentation in a seamless way.


Apart from the talks, there was also an optional "Day Three" that consisted of two workshops and a Scala Center Open Source Spree.

I had the opportunity to frequent the "benchmark" workshop by Dimitry Petrashko (which was a nice extensions to his keynote), the Akka Typed workshop by Ronald Kuhn (who you may recognise as one of the more instrumental persons in the Akka ecosystem), as well as see a bit of the shapeless workshop by Dave Gurnell (which was an adaptation of his book - much recommended, by the way!).

I was unfortunately too fatigued to take part in the Scala Center’s OS spree, and I somewhat regret it - the "Scala Contributor" T-shirts promised as a reward for getting a PR accepted looked pretty nice.


There were a couple of presentations that don’t fit any of the themes described above, but are worth mention nonetheless.

Paul Chiusano had shown An Introduction to the Unison Language and its Scala-based Runtime. You may be familiar with the name as one of the authors of Functional Programming in Scala, a.k.a the "Red Book". Unison itself looks like Haskell synthetically, but the important part is that remote computations are first-class-citizen concepts in the language. In other words, computing node orchestrations and remote executions is "baked in" into Unison.

I will wrap up with this summary with Heather Miller’s Some Trends in Open Source & The State of the Scala Center. Heather covered a multitude of topics, chiefly:

  • the importance of Open Source, specifically the importance of contributing to Open Source projects as opposed to just consuming it;

  • a summary of what the Scala Center is, what it isn’t (most importantly, it isn’t an extension of Lightbend), and how it contributes to the Scala ecosystem,

  • including a highlight of selected, developed projects, such as Scalafix.

In closing

The conference won’t be organised next year, as Jon Pretty thought it prudent to take a breather. Nevertheless, judging by this year’s edition, I sincerely hope for a Scala World 2019.

scalaworld path

1. For context - in current Scala, fold has a signature like: fold[A,Res](zero: Res)(acc: (Res, A) ⇒ Res): Res, so it has 2 parameter lists. Otherwise, the user would have to manually specify the argument types for acc as the typer does not know how to limit the types in a single signature. In Dotty, this is fortunately no longer the case.

scala times
Interested in Scala news?

Subscribe to Scala Times Newspaper delivered weekly by SoftwareMill straight to your inbox.