Articles

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

IntelliJ IDEA OS X Shortcuts on Ubuntu Gnome

Published on 10 April 2017

I recently got myself a new desktop computer with nice and fast hardware (more about this in another post) and am setting up Ubuntu Gnome on it. Since I’ll still be using my MacBook Pro for some time I don’t want to learn another set of keyboard shortcuts, so I set out to use IDEA’s – Read More

Akka anti-patterns: being out of touch with the hardware

Published on 21 November 2016

Choosing Akka as a tool is often – if not always – driven by the need for good performance. Surely, the actor model itself is appealing as a means for organizing and reasoning about code, but this isn’t in itself a good reason enough to use the Akka toolkit. If all you are concerned about – Read More

Akka anti-patterns: logging (the wrong way)

Published on 31 August 2016

Update: removed rogue toString call in the second code example, since it was unnecessary (and harmful). Debugging actor systems is no small feat, even when there is IDE support for it. In fact, debugging any asynchronous system for that matter is a rather complicated task. Which is why, especially during development, it is not entirely – Read More

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

The reality of writing a technical book

Published on 15 July 2016

Two days ago I received my copies of Reactive Web Applications. Needless to say, I had been waiting for this moment for some time. Even though the final PDF version had been out for a few weeks prior to this, nothing compares to holding in your hands an actual, physical, printed book and seeing the – Read More

The microservices marathon

Published on 14 June 2016

Everyone is talking about microservices. And many people are betting on it. At this year’s Voxxed Days Vienna over 60% of the submissions contained the word microservices. At JAX 2016 in Mainz, the word microservices was spoken out aloud on average 40 times per minute accross the entire venue. It’s hard to go one day – 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