Scalar 2019 might be over, but the memories remain! Some of them in the form of the traditional whiteboard voting results, where we uncover the current trends and the future of Scala.

While we are waiting for all the videos from the talks to come up, let’s dive right in into your votes!

First board from day one:

And the most pressing question: Is tagless final really dead? Some claim it is, some say “it depends”, some say it is definitely not.

The majority of Scalar attendees seem to have seem tagless final alive: 39 vs 10. For the 6 which are not yet sure what tagless final is, we definitely hope that some of the talks or the hallway track cleared things up!

On a related note, we asked about the favourite effect wrapper in Scala. We’ll gloss over the discussion whether Future[_] is an effect wrapper or not and just discuss the votes. The opinions are quite balanced:

Lazy wrappers, such as Task , IO and ZIO are in the lead, comparing to eager ones, represented by Future . However, it’s an abstract effect, F[_] , which is in the lead. We suspect that even when the effect is abstract, in the end people use a concrete one, which is a take-away for next year: ask about favourite concrete effect wrapper. Also, contrast favourites with reality — as one effect wrapper might be the favourite, but a completely other one might be the most commonly used.

Moving on to the second board:

Scala 3 is coming! What’s the most anticipated feature? Intersection/union types are the winner, but other features also attract attention:

Coming back from the future to reality, what about connecting to relational databases? We’ve been asking this question 4 years in a row (the results from previous editions: 2017, 2018), and here are the results combined together:

It’s the first year when Doobie overtook Slick!

Wrapping up boards from day 1, everybody’s favourite subjects: JSON and IDEs:

Surprisingly, this year we haven’t seen a new major player in the area of JSON! Are we getting old? Looking over the years, Circe is strengthening its lead:

In terms of IDEs, IntelliJ is a clear leader. The competition has some catching up to do — but with the recent development of metals, I think we might see the status quo shaken up in the future!

On the second day of Scalar we had a fresh set of whiteboard votings; however, probably partly due to the party the day before, the turnout was a bit smaller. But, starting with server-side HTTP and streaming libraries:

In both categories, akka http/streams is the clear winner, getting over 50%. The runner-up is http4s+fs2 combo, with about 30% of users.

We’ve also wanted to find out what kind of tools and libraries people would like to use — as already mentioned, this might be different from libraries that they are using daily:

It turns out, people are quite happy with sbt! Some are looking forward to trying out Mill, Fury, or (presumably?) going back to Gradle and Maven. There’s also a small group waiting for the perfect build tool to be discovered (or are build tools invented?).

What about libraries? Not a lot of propositions here, but all three mentioned libraries have one theme in common: functional programming.

17 people would like to try out ZIO, 8 Monix and 3 Monocle. Hopefully they are already happily coding in their new stacks!

The final voting board got more attention:

I’ll gloss over the “Dependency Injection in Scala” votes: the overwhelming majority just uses constructors, and rightly so! There are also some macwire, guice and reader monad users, but it’s a small group. Surprisingly, no Spring users at all!

The final question was open — what is the biggest problem of Scala? It has been an occasion to express your frustrations and as everybody enjoys some complaining, we got quite a lot of responses. The top ones being:

What should we work on to make Scala even better?

Three main areas:

Trust: making sure companies big and small trust Scala to be a stable, quality and future-proof platform. Education: lowering the learing curve for Scala. Blogging, conferencing, writing books and creating programmer-friendly APIs. Performance: compilation speed is a constant problem for Scala programmers. Maybe Dotty will help? Or maybe the answer will be to use GraalVM?

With these themes in mind, see you next year!

Experience Scalar beyond an annual event and shape the Scala community with us!

If you missed Scalar, make sure to follow us on Twitter or sign up for updates by email.

If you’d like to receive a weekly digest of Scala news, consider subscribing to Scala Times! Send us your recent articles too. We curate the content and sent it out weekly.