Scala Days 2014

Scala Days 2014 Banner

Scala Days 2014 is over and I assume during those days Berlin was the place with the highest density of Scala talent in the world. Apart from several hundred participants, a lot of people from Typesafe and EPFL who work on projects like Scala and Akka were there. In this post I would like to share some of my favorite talks with you.

Is Scala simple?

Scala Days 2014 - Scala - The Simple Parts - Keynote

Since Scala is now 10 years old there were multiple talks which provided a retrospective about Scala. Most prominently, Martin Odersky talked about the simple parts of Scala. He described the most useful elements of Scala – the core features of the language so to speak – but he also looked critically at some not so simple parts like implicit conversions. He gave a similar version of this talk at SF Scala:

As an example where the simple parts of Scala are applied he used an experimental compiler which he is working on (called dotty, see also the original announcement). It is intended to test ideas which may ultimately lead to a much more stringent compiler for Scala 3.

In that spirit Simon Ochsenreither gave a talk about weird behavior of Scala in edge cases. He is a prolific contributor who works on ironing problems out such as deprecating automatic () insertion or deprecating procedure syntax.

Going Reactive

A lot of talks also covered various angles on building reactive applications: Viktor Klang and Roland Kuhn talked about reactive streams. Björn Antonsson, Patrik Nordwall and Konrad Malawski talked about Akka persistence which is based on the idea that an actor executes commands. These commands generate events which get persisted in a journal. When an application needs to recover the events are replayed to restore its state.

Duncan DeVore presented Akka persistence from a practical perspective. A few years ago his team struggled with a monolithic Spring and Hibernate application and redesigned it using reactive principles. In the talk he shared some key design considerations they went through, such as using an immutable domain model which is based on command query responsibility segregation (CQRS). He is currently co-authoring the book “Building Reactive Applications” (unfortunately no link available yet).

Lee Mighdoll from Nest Labs talked about Sparkle (slides) which combines reactive streams, websockets and D3.js to visualize timeseries data on interactive dashboards. In his talk he also presented a protocol for visualization servers and streaming data.

Leaving a Legacy

Quick: What do you think when you hear “legacy”? Spaghetti code? Weird bugs? Scrap and rewrite the thing?

In his keynote, Chad Fowler reminded us that “legacy” has negative connotations in software engineering but in the arts it is actually a very good thing. Consider the great legacy of Beethoven or Van Gogh. He argues that to build software systems that leave behind a legacy (in the positive sense) we can take inspiration from biological systems (see also Peter Gabriel’s presentation Design Beyond Human Abililties [PDF]). Biological systems change all the time: cells are dying every second and are replaced by new cells. Individual cells may not live very long in contrast to the system they are part of. He believes that we can apply this approach for software too to leave a legacy:

  • Simple interfaces are essential: Unix pipes for example are extremely simple but also very powerful.
  • Kill parts of your software regularly: Small components can be easily removed or rewritten from scratch if they have done their job but the overall system survives.
  • If something is difficult, do it all the time: If you are afraid that your software might crash, crash it regularly (think Netflix’s Chaos Monkey)

Here’s an older version of his talk from Aloha Ruby Conf 2012:

Take Aways

I appreciate that the community does not only put effort into new features such as Spores or async but also into simplifying the core language.

Thinking about system design according to the principles of the reactive manifesto is getting more important and Akka and its ecosystem provide a good fit for applying these principles.

Scala Days 2014 was definitely worth the trip to Berlin. Apart from advanced topics, various frameworks like Scala.js, Macroid (Scala for Android), Sparkle or Delite were presented, which was very interesting for Scala beginners. Chatting with experienced Scala developers helped getting the right direction when starting with Scala. I am already looking forward to Scala Days 2015. Happy hakking in between!


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s