What do you think?
Rate this book
Reactive Messaging Patterns With the Actor Model: Applications and Integration in Scala and Akka
USE THE ACTOR MODEL TO BUILD SIMPLER SYSTEMS WITH BETTER PERFORMANCE AND SCALABILITY Enterprise software development has been much more difficult and failure-prone than it needs to be. Now, veteran software engineer and author Vaughn Vernon offers an easier and more rewarding method to succeeding with Actor model. Reactive Messaging Patterns with the Actor Model shows how the reactive enterprise approach, Actor model, Scala, and Akka can help you overcome previous limits of performance and scalability, and skillfully address even the most challenging non-functional requirements. Reflecting his own cutting-edge work, Vernon shows architects and developers how to translate the longtime promises of Actor model into practical reality. First, he introduces the tenets of reactive software, and shows how the message-driven Actor model addresses all of them&;making it possible to build systems that are more responsive, resilient, and elastic. Next, he presents a practical Scala bootstrap tutorial, a thorough introduction to Akka and Akka Cluster, and a full chapter on maximizing performance and scalability with Scala and Akka. Building on this foundation, you&;ll learn to apply enterprise application and integration patterns to establish message channels and endpoints; efficiently construct, route, and transform messages; and build robust systems that are simpler and far more successful. Coverage Includes Find unique online training on Domain-Driven Design, Scala, Akka, and other software craftsmanship topics using the for{comprehension} website at forcomprehension.com.
368 pages, Hardcover
First published December 1, 2014
39 people are currently reading
394 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 12 of 12 reviews
December 17, 2015
This book gives you a concise introduction into the benefits of the actor model and how to apply it with Akka and Scala. Its main merit, though, is to bring "Enterprise Integration Patterns" into the next decade and show how the patterns originally described by Hohpe can be applied using the technologies of our time, specifically using Akka. I do think that this is not a replacement for the mentioned classic, as the author often refers to the EIP book without explaining the patterns in as much detail as in the EIP book. As a complement, or upgrade, though, this book is a very good choice.
Disclaimer: I have been a technical reviewer of a few chapters of this book.
Disclaimer: I have been a technical reviewer of a few chapters of this book.
August 12, 2015
I've expected better. I do realize that this is a book about patterns and patterns are aimed to be atomic, simple & re-usable, but ... sometimes it felt like author was matching the simplest behaviours (like mapping or filtering) to patterns. There's still a benefit in that (common language for programmers), but ... because of that half of the book seemed shallow.
Another observations:
* Scala introduction - c'mon, far too brief to be useful for anyone - it'd be better to make a clear requirement that reader should know Scala already
* A lot of valuable stuff about clustering Akka -> I've read here things I didn't find anywhere else; not sure whether they are useful for me atm :) but these parts were really interesting
* CQRS using Akka Persistence -> short, but meaty
* Chapter 10 (last one) seemed like the most interesting part of the book (finally something not on tutorial level!) and ... reading it was a blitz -> each pattern's description was about a page with barely any code samples ...
To summarize: it's not a bad book, but these are VERY low level patterns. I'm not sure whether I've learned much (except some stuff about clustering & Akka.Persistence).
Another observations:
* Scala introduction - c'mon, far too brief to be useful for anyone - it'd be better to make a clear requirement that reader should know Scala already
* A lot of valuable stuff about clustering Akka -> I've read here things I didn't find anywhere else; not sure whether they are useful for me atm :) but these parts were really interesting
* CQRS using Akka Persistence -> short, but meaty
* Chapter 10 (last one) seemed like the most interesting part of the book (finally something not on tutorial level!) and ... reading it was a blitz -> each pattern's description was about a page with barely any code samples ...
To summarize: it's not a bad book, but these are VERY low level patterns. I'm not sure whether I've learned much (except some stuff about clustering & Akka.Persistence).
May 20, 2018
First of all, I think Vernon’s work (IDDD, DDD Distilled, Workshops, etc.) is great. However, this book is ok. It’s a nice review of Messaging Integration Patterns with code examples in Scala and Akka. Code examples are not going to be very surprising if you have been using Akka for a while. Implementations are quite obvious. My recommendation to the reader is that it can be way more interesting to read the Enterprise Integration Patterns (https://www.goodreads.com/book/show/8...). This book will set up the grounds of any other messaging book, as the Vernon’s one.
February 25, 2020
I have no idea what to do about this one - while I did find it useful at times, those times were on the rare side to be honest. The actor model and Akka introduction was well written and it's fairly sad that those are probably the two chapters I got the most out of - the rest of the book features really short descriptions of EIPs (mainly referencing the EIP book) and some sample implementation of those EIPs in Akka. While this sounds great in theory, in practice the examples were too simplistic to be of any use in the real world.
August 9, 2016
interesting but quite a heavy read for me since i have never worked with scala before (though part of my interest was to be able to learn some). The scala intro in the second chapter felt a bit lacking but was really enough to get an understanding of the samples ahead. I would describe the rest of the book as "EIP in scala". I had read EIP previously, so this was a nice review with practical implementations of the patterns as Actors and in scala.
i wobder if, with C# 7's possible integration of pattern matching if we'll see a reedition with Akka.net...
i wobder if, with C# 7's possible integration of pattern matching if we'll see a reedition with Akka.net...
July 14, 2016
If you ever worked with message passing systems, only 2nd and 3rd chapters deserve skimming. Most of the "patterns" are extremely obvious, and the only reason I can imagine to read about them is find out settled naming. Anyway, this book is as unentertaining as any book related to enterprise integration patterns.
October 25, 2020
I decided to read this book as I am interested in both Domain-Driven Design and the Akka implementation of the Actor model, and have previously read the Eric Evans' Domain-Driven Design: Tackling Complexity in the Heart of Software, Vernon's Implementing Domain-Driven Design, and a couple of other books on Akka (Akka in Action, and Reactive Application Development).
From this book I was hoping to glean some glimpses into Vernon's ideas about building an actor based application in a style consistent with DDD thinking. There were some hints of this along the way, but the book's primary focus was on interpreting the patterns from Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions in the context of the Actor model - which is what one can expect from the title.
The book was an interesting read, and introduced me to the EAI patterns, for I have not yet read that book (but started to do so upon realizing it would help me understand the patterns covered here in an Actor model context). The code samples were a little difficult to read in the book due to formatting, but with code available from github, it was good to just pull the code and read that, as well as actually running the examples.
One issue with the book, as with others on Akka, is that the Akka APIs move relatively quickly and the APIs used in the book (while still working) are out-of-date these days. The underlying concepts however are largely the same, which is the main thing. It's not difficult to google up the Akka APIs that are covered in the book, and find out what they have been deprecated in favour of.
Another question mark I have is with the applicability of EAI patterns to Actor model applications. The point of EAI is the integration of enterprise applications, whereas with Akka one can build a single application, but in many if not most cases, one would probably not use Akka to integrate with other applications. This point isn't entirely missed in the book either, as for example Apache Kafka is mentioned at one point as an alternative way to approach a certain type of integration. So to an extent some coverage in the book comes across as more of a mental exercise in interpreting the EAI patterns in an Actor model context, rather than how you would actually go about building and integrating applications.
In this sense, the IDDD book covers object-oriented style application design more comprehensively, but while there is coverage of contemporary DDD concepts (such as Event Sourcing and CQRS) covered in this book, it's not the primary focus.
Overall, I enjoyed this book.
From this book I was hoping to glean some glimpses into Vernon's ideas about building an actor based application in a style consistent with DDD thinking. There were some hints of this along the way, but the book's primary focus was on interpreting the patterns from Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions in the context of the Actor model - which is what one can expect from the title.
The book was an interesting read, and introduced me to the EAI patterns, for I have not yet read that book (but started to do so upon realizing it would help me understand the patterns covered here in an Actor model context). The code samples were a little difficult to read in the book due to formatting, but with code available from github, it was good to just pull the code and read that, as well as actually running the examples.
One issue with the book, as with others on Akka, is that the Akka APIs move relatively quickly and the APIs used in the book (while still working) are out-of-date these days. The underlying concepts however are largely the same, which is the main thing. It's not difficult to google up the Akka APIs that are covered in the book, and find out what they have been deprecated in favour of.
Another question mark I have is with the applicability of EAI patterns to Actor model applications. The point of EAI is the integration of enterprise applications, whereas with Akka one can build a single application, but in many if not most cases, one would probably not use Akka to integrate with other applications. This point isn't entirely missed in the book either, as for example Apache Kafka is mentioned at one point as an alternative way to approach a certain type of integration. So to an extent some coverage in the book comes across as more of a mental exercise in interpreting the EAI patterns in an Actor model context, rather than how you would actually go about building and integrating applications.
In this sense, the IDDD book covers object-oriented style application design more comprehensively, but while there is coverage of contemporary DDD concepts (such as Event Sourcing and CQRS) covered in this book, it's not the primary focus.
Overall, I enjoyed this book.
June 19, 2017
Requires prior reading of at least Enterprise Design Patterns (by Martin Fowler and others), Domain Driven Design (by Eric J. Evans), Enterprise Integration Patterns (by Gregor Hohpe and Bobby Woolf) and quite possibly the authors Implementing Domain Driven Design as well to fully get value out of it. As I personally had not read any of these I feel it was a bit of a waste except for the first few chapters on Scala and Akka, which also have better introductions elsewhere.
The patterns themselves have lengthy examples which didn't always work as well as intended I feel and there wasn't as much discussion in the pros and cons as usually associated with a patterns book but perhaps that was left to it's parent book Enterprise Integration Patterns. I feel it was more of an add-on to the ideas discussed in the other books I mentioned.
The patterns themselves have lengthy examples which didn't always work as well as intended I feel and there wasn't as much discussion in the pros and cons as usually associated with a patterns book but perhaps that was left to it's parent book Enterprise Integration Patterns. I feel it was more of an add-on to the ideas discussed in the other books I mentioned.
October 10, 2017
It does have its problems, but still it's an important book that should be read
December 22, 2015
Great book on EIPs implemented with Actors. However a bit too verbose for my liking.
October 15, 2016
well written, interesting, good partitioning of the book in chapters ... nice!
Read
December 27, 2017Nuttig als naslagwerk!
Displaying 1 - 12 of 12 reviews