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 (this post)
- “hello world”
- Heirachies / Lifecyles
- Dead letters and how to monitor for them
- Persistent Actors
- Finite state machines
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).
- 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.
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
- Scala 2.11
- SBT (for the build system)
- ScalaTest (where tests are concerned)
- All examples will be IntelliJ IDEA community edition projects
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