Akka

This is a collection of articles I wrote over the years, presently with a strong focus on building reactive systems with Akka.

Akka anti-patterns: overusing ActorSelection

Published on 20 March 2018

Akka’s ActorSelection makes it possible to look up actors by logical path in the hierarchy:

This selection can then be used like ActorRef in order to send messages to it using the tell or ask patterns:

ActorSelection is therefore quite useful and allows more flexibility when designing an actor system given that trees – Read More

Tour of Akka Cluster – Akka Distributed Data

Published on 3 January 2018

Building distributed systems is hard. Pesky things like the laws of physics get in the way of maintaining state accross geographically (and chronologically) disparate systems, and, if that weren’t already outrageous enough in itself, those systems may be subject to network failures, forcing us to think about annoying tradeoffs regarding consistency, availability and the meaning – Read More

Akka anti-patterns: naming your application components after Akka concepts

Published on 26 August 2017

So you’ve just learned Akka and are tremendously excited. It’s got dispatchers, routers, supervisors – so many shiny things to play with, and in style (I mean, come on, a dispatcher sounds a lot nicer than, say, an AbstractSingletonProxyFactoryBean). And so it happens that, perhaps even unknowingly to you (you’re busy configuring a pool router), – Read More

A new adaptive accrual failure detector for Akka

Published on 26 July 2017

Akka uses the The Φ Accrual Failure Detector for failure detection, which is to say for answering the question of whether a node is alive or not. That’s one of the harder problems of distributed systems since it is virtually impossible (from the point of view of one node) to tell the difference of a – Read More

Akka anti-patterns: trusting the network

Published on 20 June 2017

One anti-pattern I’ve observed in networked Akka applications is a tendency to forget that it is, well, networked and to treat the network as a friendly place. How does that look like? Well, consider the following piece of code:

Akka’s default message sending mechanism is the fire-and-forget tell method. And that works great – – Read More

Akka anti-patterns: using remoting

Published on 8 June 2017

Whilst I have always successfully discouraged my clients from using Akka Remoting in their application, I often get questions regarding remoting while talking about anti-patterns at conferences and user groups. Don’t get me wrong. I love Akka remoting. Especially the new Aeron-based Artery remoting version that is based on UDP rather than TCP. Whilst it – Read More

Akka Streams – What is NotUsed all about

Published on 22 May 2017

Akka Streams is a powerful implementation on top of the Reactive Streams SPI for non-blocking asynchronous communication with back-pressure on the JVM. This post is not about explaining what this means, nor what Akka Streams does. The purpose of this post is to explain what on earth the NotUsed type in type signatures of Akka – Read More

Akka anti-patterns: blocking

Published on 15 May 2017

This is probably one of the most frequent (and dangerous) anti-patterns when it comes to working with Akka. Let’s look at an adequate description of the mindset you must be in in order to use it: So maybe you didn’t actually want to see the world burn. Maybe you thought that this one time it – Read More