This book will explain how to create Akka applications using best practices based on several years of experience with Actors. The content will be general enough that it would apply to actor-based and asynchronous applications on the whole, but the examples are shown in Akka using the Scala programming interface. The ideal audience are developers who are building systems with Akka and are looking for guidance with regards to patterns and how best to write code that is correct, debuggable and understandable in production.
A short book focused on good practices to use Akka. Assuming the reader is well versed with Akka (in Scala) and familiar with concurrent and distributed systems, it covers nuances involved in making Akka applications more performant via concurrency and parallelism; good amount of focus on considering compute resources. While the nuances it describes is applicable to distributed systems, the exposition does not make it explicit.
A good book to read after picking up Akka and, preferably, reading about concurrency issues.
I'll start with an interesting fact - that was my 2nd approach to "Effective Akka". The first one was a year ago, but just after the few pages I've decided to give up for now. If I remember well, that was about a high threshold in terms of required knowledge level. So now I was a bit reluctant - did I learn enough to go through this time? And ... now I'm a bit confused, because I don't really think about myself as a Masta-hakka, but I've pretty much swallowed the book in 1.5 day without stopping. And I can't really recall what in particular was that challenging a year ago.
Odd.
Anyway, back to the book. I'll try to be brief.
1.) It's not for beginners. You already have to be acknowledged with Akka. 2.) It's about practical / situational usage of Akka - don't expect many low-level undocumented functions, but rather sort of design patterns (because seriously, you can twist the way you're using Akka VERY easily) 3.) It's very brief - and it's a biggest issue I had with it
If you're interested in reactive programming & Akka in particular, it's a no brainer - go for this book without hesitation. But if you're just starting your adventures with Akka, don't start it here.
It doesn't require an "advanced practising level" for Akka, not much of design patterns were mentioned (exactly 2 design patterns). You could just tell by looking that some of the written code weren't logically accurate. The last chapter was good, the same applies for the examples in the whole book. Generally it was a light book - like 80 pages or so- with some good catches, but it won't be a sufficient reference for developing Akka apps, you might like to go for "Akka in Action" for that exact reason.
I just want to emphasize what the author clearly states at the beginning of the book - it makes certain assumptions as to the reader's knowledge of Scala, Akka and asynchronous/multithreaded programming in general. For me, even having grasped the basics, it was not enough. Only after getting back to the book having had hands-on contact with a commercial Akka project, have I understood the practical patterns and managed to absorb the knowledge contained within this title.
Good book about using Akka in a proper way. Shows many patterns and anti-patterns so you can avoid mistakes and apply good practices on your daily coding.
One important note: this book requires deeper than basic knowledge about Akka, so if you are newbie in actors world, plan some additional time to read Akka specs or another book about Akka :)
This book is short, but every advice there is priceless for every Akka practitioner. Some people say that they already knew most of the things in the book; well, they are probably working in excellent teams. Lucky them.
A lot of the advice was not new to me, and, as is to expected given the page count, none of this goes into a lot of depth. Still, this is a pretty good overview of current best practices when using Akka.
It's really a good book. I suggest that all Akka beginner developers should read it ASAP. While reading it I got so many: "I thought so" moments, that I'm just disappointed I haven't read it way sooner.
This is an excellent and informative book about successful actor system architecture. It assumes a significant degree of familiarity with the topic, but also contains code examples.
I found this rather short book helpful, but wouldn't recommend it as an introduction to Akka. Contains common patterns and best practices which aren't found in the online Akka documentation.