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 is a nice way to ... Read More
The post Akka anti-patterns: being out of touch with the hardware appeared first on manuel bernhardt.
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 uncommon to rely on DEBUG ... Read More
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 this design: isolation of concerns: ... Read More
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 are being processed by actors ... Read More
One of the fundamental ideas built into Akka is the one of failure handling through parental supervision. In other words this means agencing actors in such a way that parent actors that depend upon the correct execution of a child to perform their work are also responsible for deciding what to do when one of the child actor crashes. An ... Read More
The post Akka anti-patterns: flat actor hierarchies or mixing business logic and failure handling appeared first on manuel bernhardt.
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 out in various places, one ... Read More
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 fast is the message sending, ... Read More
MAINTAINER Nikolay Kushin firstname.lastname@example.org
ENV SCALA_VERSION 2.11.7
ENV SBT_VERSION 0.13.9
ENV SBT_OPTS -Xmx2G -XX:+UseConcMarkSweepGC -XX:+CMSClassUnloadingEnabled -Xss2M -Duser.timezone=GMT
# install sbt
RUN wget https://dl.bintray.com/sbt/debian/sbt-$SBT_VERSION.deb
RUN dpkg -i sbt-$SBT_VERSION.deb
# install scala
RUN wget https://downloads.typesafe.com/scala/$SCALA_VERSION/scala-$SCALA_VERSION.deb
RUN dpkg -i scala-$SCALA_VERSION.deb
# fetch base dependencies
RUN sbt compile
docker build -t sbt-docker .
docker run -it --rm -v $(pwd):/src sbt-docker sbt docker:stage