Archive:

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: too many actor systems

Published on 23 August 2016

Admittedly I’ve seen this one in use only one time, but it was one time too many. For some reason I keep seeing clients come up with this during design discussions and reviews though, therefore it makes it into the list of Akka anti-patterns. What I am talking about is this: Reasons I hear for – Read More

Akka anti-patterns: race conditions

Published on 16 August 2016

The actor model makes it possible to build highly-concurrent applications through the notion that actors obey the actor send rule and the actor subsequent processing rule, hence creating a single-threaded environment inside of an actor. That being said, it’s all an illusion: as we have briefly talked about previously, Akka’s dispatchers make sure that messages – Read More

Akka anti-patterns: shared mutable state

Published on 2 August 2016

When I work with clients on designing actor systems there are a few anti-patterns that seem to make it into initial, non-reviewed designs no matter what. In this series of short articles I would like to cover a few of those. Anti-pattern #1: sharing mutable state accross actors Even though the Akka documentation points this – Read More

Akka Cluster, Java and the Raspberry PI 3 Model B

Published on 19 April 2016

I recently built an architecture prototype for DIMOCO aiming at answering roughly the following questions: what does it entail to run an Akka cluster, how fast can new nodes join, how manageable is such a cluster? are traditional publish-subscribe message distribution semantics supported (one-to-one, one-to-N, one-to-any-of-N)? how can message loss be averted / minimized? how – Read More

A handful Akka techniques

Published on 23 April 2014

I’ve been using Akka for 3 years in a variety of projects and by now, I have a hard time imagining to deal with some of the parts of my work without it. Sure, Scala provides other powerful paradigms for dealing with concurrency, but I find Actors to be one of the most elegant concept – Read More