Matching strings in Scala

Over December I had a lot of fun doing the Advent of Code coding challenges with some colleagues.

Many of those, such as day 21, require interpreting some kind of string input. While normally I’d probably marshall those strings into case classes before processing, in this case that seemed like overkill: a quick pattern-match should be sufficient.

It turns out there’s a couple of ways to approach that, which is also a good excuse to look under the hood and see which Scala concepts they’re built on.

Read more →

Compile-Time Evaluation in Scala with macros

Many ‘compiled’ languages used to have a strict separation between what happens at ‘compile-time’ and what happens at ‘run-time’. This distinction is starting to fade: JIT compilation moves more of the compile phase to run-time, while conversely various kinds of optimizations do ‘run-time’ work at compile time. Powerful type systems allow the expression things previously only checked at run time, especially with the recent renaissance of dependent types popularized by Idris.

This post will show a very simple example of compile-time evaluation in Scala: we’ll write a regular ‘factorial’ function, and use macros to apply it (to constants) at compile time.
Read more →

Profiling zsh shell scripts

With today’s blazingly fast hardware, our capacity to “make things slow” continues to amaze me. For example, on my system, there is a noticeable delay between the moment a terminal window is opened, and the moment the command prompt actually shows up.

This post explores how we can quickly quantify the problem and and pinpoint the main causes of the delay.

Read more →

Interpreting Scala in the Browser

At this years’ Scala Exchange keynote, Jessica Kerr got a nice round of applause when she asked us all to, please, include our import statements when sharing code snippets.

That’s great advice – but can’t we do better? What if we could share actual running, hackable code?

Turns out we can: there’s a number of ‘JSFiddle‘-style projects around, and I’ll take a brief look at some of them.

Read more →

Creating an Immutable MultiMap in Scala

This post shows a couple of neat Scala tricks by implementing an immutable MultiMap.

A MultiMap is a special kind of Map: one that allows a collection of elements to be associated with each key, not just a single value. For this example, we will start by using Lists to contain the values, hence creating a ListMultiMap

Read more →

The Sunk Cost Fallacy Fallacy

Imagine two football fans planning to attend a match 60 miles away. One of them paid for a ticket in advance; the other was just about to buy a ticket when he got one from a friend for free. The night of the game, a blizzard hits. Which fan do you think is more likely to drive through a blizzard to see the game?

You probably (correctly) guessed that the fan who paid for his ticket is more likely to drive through the blizzard. What you may not have realized, though, is that this is an irrational decision, at least economically speaking.

Read more →

HTTP/2 Server Push

The HTTP/2 standard was finalized in May 2015. Most major browsers support it, and Google uses it heavily.

HTTP/2 leaves the basic concepts of Requests, Responses and Headers intact. Changes are mostly at the transport level, improving the performance of parallel requests – with few changes to your application. The go HTTP/2 ‘gophertiles’ demo nicely demonstrates this effect.

A new concept in HTTP/2 is Server Push, which allows the server to speculatively start sending resources to the client. This can potentially speed up initial page load times: the browser doesn’t have to parse the HTML page and find out which other resources to load, instead the server can start sending them immediately.

This article will demonstrate how Server Push affects the load time of the ‘gophertiles’.
Read more →

Scala development with GitHub’s Atom editor

GitHub recently released version 1.0 of their Atom editor. This post gives a rough overview of its Scala support.

Basic features

Basic features such as Scala syntax highlighting are provided by the language-scala plugin.

Some work on worksheets as found in e.g. Eclipse has been done in the scala-worksheet-plus plugin, but this is still missing major features and not very useful at this time.

Navigation and completion


Atom supports basic ‘Go to Declaration’ (ctrl-alt-down) and ‘Search symbol’ (cmd-shift-r) support by way of the default ctags-based symbols-view.

While there are multiple sbt plugins for generating ctags, the easiest seems to be to have Ensime download the sources (more on that below) and invoke ctags manually: put this configuration in your home directory and run the ‘ctags’ command from your project root.

This is useful for searching for symbols, but limited for finding declarations: for example, when checking the declaration for Success, ctags doesn’t know whether this is scala.util.Success,, spray.http.StatusCodes.Success or some other 3rd-party or local symbol with that name.


This is where the Ensime plugin comes in.

Read more →

Monitoring Akka with Kamon

Kamon is a framework for monitoring the health and performance of applications based on akka, the popular actor system framework often used with Scala. It provides good quick indicators, but also allows in-depth analysis.


Beyond just collecting local metrics per actor (e.g. message processing times and mailbox size), Kamon is unique in that it also monitors message flow between actors.

Essentially, Kamon introduces a TraceContext that is maintained across asynchronous calls: it uses AOP to pass the context along with messages. None of your own code needs to change.

Because of convenient integration modules for Spray/Play, a TraceContext can be automatically started when an HTTP request comes in.Read more →