Reactive Messaging Patterns With the Actor Model: Applications and Integration in Scala and Akka 1st Edition

- To venture a bit into the crucially-important topic of the actor model, which of course is essential to making reactive systems tick responsively to ever-burgeoning user demands. Understanding the actor model deeply will serve you well in grokking the art of designing reactive systems, and you'll find in this book—Vaughn Vernon. Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka (Addison-Wesley Professional)—a terrific and gentle guide. This book is the paragon of sparkling clear prose and unambiguous explanations of all things actor model, especially as they are related to making reactive systems evolve into their finest. As a tech type, this is the kind of stuff I crave for.- I also appreciated the book's nice refresher entitled A Condensed Scala Tutorial. Another stand out quality of the Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka is the marvelously cross-referenced digital edition. Seldom have I seen cross-referencing done by a publisher to such great effect! (The only other book that approaches this lavish navigational finesse has got to be Programming in Scala, Third Edition A comprehensive step-by-step guide by Martin Odersky, Lex Spoon, and Bill Venners)- For a more-detailed review, checkout my post by searching on the keywords "Programming Digressions Best Reactive Programming Books"

A key cornerstone of success in any endeavor is establishing the proper scope of effort. Vaughn establishes a clear scope with this book and fulfills on every point. Other Akka/Actor related books delivered a product that was more diluted as their scope seemed to include all things Akka. As a result, the section on Actors and messaging was thin.This book explores key domain messaging models in depth and implements most patterns using the Scala and Akka/Actor framework, along with very well written explanations. I especially appreciated the comparison of each major reactive message pattern and how it solves specific challenges with other pattern choices that were covered in the book. Moreover, each reference to other similar message patterns included the pattern name(s) and page number(s) for quick reference.The accompanying code examples were complete, self-documenting, runnable examples, allowing the reader to learn not only Akka Actors but Scala language idioms as well.A lot of intellectual effort was placed in this book and the cost, with respect to the value, leaves the buyer/reader well ahead.

This is the book I didn't know I was waiting for. I've been doing event-driven, actor-model programming for many years. This book finally categorized all the various techniques and patterns in a way that allows me to show them to others and talk about them effectively. This book is well written: the examples are clear and then pictures are very helpful. If you've been wondering what all the fuss is about with reactive programming or how the actor model fits into it, then this book will get you going. I bought several copies to give out to colleagues.

The book is okay but oddly enough all it did was reinforce that I really need to read enterprise integration patternsThe book basically rehashed all of the patterns but with AkkaI was hoping for more new ideas and wasn't really looking for how to do stuff with Akka

good overview, would have preferred a more technical book.

The diagrams are not visible on the kindle at all

I Was expecting quality Akka practices and patterns but this is poorly written book, does not worth the money .

I came to this book having been recently exposed to software built with actors, so I read this knowing a bit of the "how?" but a very weak understanding of the "why?" I can assure you this book answered the "why?" question with a bang (while at the same time deepening my understanding of the "how?")Having had some exposure to actor-based architecture, I'm reasonably confident this stuff is coming to a programming shop near you in the not too distant future (hence the review title). Here is the thing - until very recently, the idea of the "actor model" was the domain of academics and a very small subset of developers working in elite shops. But, with the continuing mainstream uptake of hybrid-functional languages (like Scala) and reliable actor libraries (like Akka) the idea of an "average Joe" developer putting an actor-based application into production has suddenly gone from far-fetched to very much possible. I believe this book serves as a vital "foot in the door" to the world of actors.Getting back to my "why?" vs "how?" theme a bit, the first 3 chapters of this book are mostly focused on answering the "why?" question (my main takeaway is that processor speeds have completely flatlined, but we have a bunch of idle cores that would LOVE to work for us, but can't "cuz multithreading is hard" given the tools that most "average Joe" developers have traditionally had at their disposal).Also, mixed into the first 3 chapters is a primer with enough Scala/Akka to get you started (having already had a fair amount of experience with Scala and Akka, I skimmed most of this so I can't speak much to it). One piece of advice I have is that, unless you are a very advanced Akka user, I would skip the sections in Chapter 2 pertaining to remoting and clustering and come back to those later (treat them almost like appendices) - not because those topics aren't important (they are, and they provide vital "big picture" context for why the actor model holds so much promise), but just because I don't feel they are strictly necessary knowledge to get through the patterns that follow in the second half of the book.Chapters 4 through 10 then are the patterns (this is the "how?" side), which is basically "EIP in Akka". Some may scoff at that, but let me say if you are smart enough to reliably implement EIP patterns into Akka, more power to you. That said, for my own purposes, I found this section of the book to be pure gold. The explanations are extremely thorough, so even if you are not familiar with the original pattern, you can easily grok the point of the code. The code examples themselves are also uniformly excellent - I went as far to read this side by side with an Akka test project open in my IDE and created reference implementations of each of the patterns that I can then use both as a reference for myself as well as a teaching tool with other devs.These pattern chapters really underscore the idea that, yes, the actor model really can be used as an elegant and practical problem-solving tool (without having an MIT PhD as a pre-requisite!)Overall, a tremendous read and well worth the time investment!

I love all DDD books of Vaughn Vernon. That's why I blindly bought this book without even having an particular interest in AKKA.But that was a mistake.When I opened the books I immediately saw that 3/4th of the book was a copy of 'Enterprise Integration Patterns' which I already own. Page after page a messaging pattern with an example. Sure, the examples are different and written in Scala, but that is no good reason to publish yet another book on the same patterns.TL;DR;If you own a copy of 'Enterprise Integration Patterns' already, this book is just money wasted.If you don't own a copy of 'Enterprise Integration Patterns' and you are using akka, go ahead and buy this book.

I liked clear and simple way that book discribes integration patterns.

Spätestens mit dem ersten Kapitel hätte mich Vaughn Vernon geknackt, wenn ich nicht schon vorher davon überzeugt gewesen wäre, dass hinter dem Actor Model ein enormes Potenzial und gleichzeitig Eleganz steckt. Die Einleitung macht Lust auf mehr und man mag das Buch gar nicht mehr weglegen.Nach einer groben Einführung in einige Konzepte von Scala und einem sehr knappen Tutorial lernt der Leser auch noch ein paar Grundzüge zur Programmierung von Akka kennen. Für Scala-Unfähige wie mich durchaus praktisch, wenn man das Buch nicht weglegen muss, um ein Konstrukt in einem der sehr zahlreichen und überaus gut erklärten Code-Beispielen verstehen möchte.Die in verschiedene Kategorien eingeteilten Muster werden sehr umfassend erklärt. Meist sind Code-Beispiele dabei, die in der Regel in mehreren Etappen abgedruckt und detailliert erläutert sind. Trotz meiner Skala-Unkenntnis konnte ich den Beispielen gut folgen. Ebenfalls hilfreich empfinde ich die zahlreichen Querverweise zu anderen Mustern nebst dazu passenden Erklärungen auf Unterschiede oder Gemeinsamkeiten. Damit wird das Buch zu einem unentbehrlichen Helfer bei den ersten Projekten werden, denn die Anzahl der Muster, die Vaughn Vernon zusammengetragen bzw. entwickelt hat, ist immens.Nicht vergessen sollte man, dass das Actor Model noch mehr benötigt als nur den Nachrichten-Austausch. Insofern versteht sich dieses Werk nicht als Anfänger-Lehrbuch für Akka und kompatible Systeme (z.B. Akka.NET), macht aber viele der nativ in Akka verfügbaren oder intern verwendeten Nachrichten-Entwurfsmuster deutlich und erklärt viele weitere anwendbare Muster. Für mich die perfekte Ergänzung nach dem Studium einführender Lehrmaterialien.

Das Buch an sicht ist ziemlich gut, hat aber auch Teile wo 1 Pattern auf 20 andere Patterns zuweisen.Das macht es schwieriger lesbar.Ich hätte gern zusätzlich als Beispiel auch etwas reale Applikationen gesehen.

Completa analisi e spiegazione dei pattern. Gli esempi non sono mai superficiali. La conoscenza di scala è obbligatoria, anzi avrei evitato del tutto il capitolo sul linguaggio che risulta comunque insufficiente. Il quick start su akka invece ci può stare. Ottimo libro.