AkkA series

I have been idle for a while, which kind of irks me. Thing is I have not really been that idle, it’s just that I have not been doing that much in the .NET space of late. That is not to say I do not like .NET anymore, it’s just that I am spreading my time between .NET and the JVM which I am actually enjoying)

I thought the time has come for me to come out with a few posts of what I have been up to. So to that end I thought I would start out with a series of posts on Akka.

There will be quite a few parts to this mini series. And I will update this page as I bring new posts on line.

This is what I am planning on covering

What Is Akka

I can think of no better way to describe Akka then to screen scrape what the creators of Akka have to say about it. So here is what they say about it

We believe that writing correct distributed, concurrent, fault-tolerant and scalable applications is too hard. Most of the time it’s because we are using the wrong tools and the wrong level of abstraction. Akka is here to change that. Using the Actor Model we raise the abstraction level and provide a better platform to build scalable, resilient and responsive applications—see the Reactive Manifesto for more details. For fault-tolerance we adopt the “let it crash” model which the telecom industry has used with great success to build applications that self-heal and systems that never stop. Actors also provide the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications.


Actors give you:

  • Simple and high-level abstractions for distribution, concurrency and parallelism.
  • Asynchronous, non-blocking and highly performant message-driven programming model.
  • Very lightweight event-driven processes (several million actors per GB of heap memory).

Fault Tolerance

  • Supervisor hierarchies with “let-it-crash” semantics.
  • Actor systems can span over multiple JVMs to provide truly fault-tolerant systems.
  • Excellent for writing highly fault-tolerant systems that self-heal and never stop.

Location Transparency

Everything in Akka is designed to work in a distributed environment: all interactions of actors use pure message passing and everything is asynchronous.


State changes experience by an actor can optionally be persisted and replayed when the actor is started or restarted. This allows actors to recover their state, even after JVM crashes or when being migrated to another node.


So that is the 1000 mile view of what Akka is. You will get more familiar with it as we move through the series I hope.

What Form Will The Examples Take

As I am trying to improve my Scala to get it in line with what I can do in .NET, all examples will be based on

Where Can I Find The Code Examples?

I will be augmenting this GitHub repo with the example projects as I move through this series


I hope you all enjoy the series

That’s all for now, Like I say I will update this page when more posts become available, which may be a while since I have a day job, 2 kids, one wife and a cat, and I like a drink too, and also enjoy my weekends.  So it happens when it happens folks

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s