Archive:

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

Tour of Akka Typed: Cluster Sharding

Published on 9 November 2019

Update 21/11/2019: Fixed comment about shardId extraction in relation to ShardingEnvelope Welcome to the fifth part of the Akka Typed series! In this part, we’ll leave the safe harbor of a single JVM and sail into the seas of distributed systems by exploring a key features of Akka Cluster with the typed API: Cluster Sharding. – Read More

One step closer: exploiting locality in Akka Cluster based systems

Published on 28 October 2019

When it comes to the latency of processing a request in a distributed system, everyone knows (or should know) that doing things over the network is the most expensive thing you can do (alongside with disk reads): Modern architectures have recognized this and will favor keeping data in memory, avoiding the need to go to – Read More

Tour of Akka Typed: supervision and signals

Published on 5 September 2019

Update 18.10.2019: fixed wrong syntax for handling multiple exceptions, clarifying a few points Welcome to the third part of the Akka Typed series. In the first part we had a look at the the raison d’être of Akka Typed and what advantages it has over the classic, untyped API. In the second part we introduced – Read More

Tour of Akka Typed: Message Adapters, Ask Pattern and Actor Discovery

Published on 7 August 2019

In the previous article of this series we’ve explored the basics of the Akka Typed API: why it was created and what are its benefits in comparison to the classic Actor API, how to build typed actor systems via protocols and behaviors and how to create typed actors. In this series we’re going to go – Read More

Raspberry PI Akka Cluster LED strips

Published on 2 May 2019

Ever since Eric Loots from Lightbend first showed me the Raspberry-PI based Akka Cluster with special LED stripes, I’ve wanted (at least) one of them. This is a 5 node cluster with special LED stripes setup in such a way that the LED colour and status (on, off, blinking, etc.) show in which state each – Read More

Akka anti-patterns: too many actors

Published on 6 August 2018

Update 07.08.2018: clarified optimal vs. suboptimal use cases of having many actors at runtime (it could have been misunderstood that Akka isn’t meant to build systems with many actors – it entirely is – but it is questionable whether that’s always the best approach) It occurred to me that I haven’t written yet about this – Read More

Tour of Akka Cluster

Published on 3 August 2018

Here’s an overview of the Tour of Akka Cluster article series: Tour of Akka Cluster – Akka Distributed Data Tour of Akka Cluster – Eventual consistency, persistent actors, message delivery semantics Tour of Akka Cluster – Cluster Sharding Tour of Akka Cluster – Testing with the multi-node-testkit and a handful Raspberry PIs

Akka anti-patterns: Java serialization

Published on 20 July 2018

Akka makes use of serialization when messages leave the JVM boundaries. This can happen in mainly two scenarios: sending messages over the network when using Akka Cluster (do not use Akka Remote directly) or using Akka Persistence. Now here’s the catch: the default serialization technology configured in Akka is nothing but the infamous Java serialization, – Read More

Akka anti-patterns: stateless actors

Published on 30 May 2018

Actors are object-orientation done right (as opposed to say, objects in Java): their state is not visible from the outside and they communicate via messages. There’s no way to break encapsulation because you can’t peek into an actor’s state while it is running. That’s the entire point of actors: they provide you with the illusion – Read More