What do you think?
Rate this book
Reactive Design Patterns
Modern applications present incredible design challenges: we expect near-realtime performance while managing petabyte-scale data and distribution across environments ranging from traditional servers to cloud systems to mobile devices. The Reactive Application model addresses these demands through new patterns designed to "react" effectively to user and system events, changes in load, competition for shared system resources, and unanticipated failures. Although reactive design patterns can be implemented using standard enterprise development tools, you best realize the benefits when you pair them with a functional programming language like Scala and an Actor-based concurrency system like Akka.
Reactive Design Patterns is a clearly-written guide for building event-driven distributed systems that are resilient, responsive, and scalable. Written by the authors of the Reactive Manifesto, this book teaches you to apply reactive design principles to the real problems of distributed application development. You'll discover technologies and paradigms that can be used to build reactive applications including Akka and other actor-based systems, functional programming, replication and distribution, and implementation techniques such as futures, iteratees, and reactive streams. While the book presents concrete examples in Scala, Java, JavaScript, and Erlang, the primary goal is to introduce patterns and best practices that you can use to apply reactive principles to common problems you'll face when building distributed systems.
WHAT'S INSIDE
* Discover best practices and patterns for building responsive applications
* Build applications that can withstand hardware or software failure at any level
* Patterns for fault tolerance, scalability, and responsiveness
* Maximize multicore hardware using asynchronous and event-driven solutions
* Scale applications under tremendous load
Readers should be familiar with a standard programming language like Java, C++ or C# and be comfortable with the basics of distributed systems. Software engineers and architects will learn how to avoid common pitfalls and apply patterns for solving day-to-day problems in a fault-tolerant and scalable way to maximize their application's responsiveness to users and clients. Project leaders and CTOs will gain a deeper understanding of the philosophy behind resilience and scalability in distributed systems, as well as their limitations, challenges and benefits.
Reactive Design Patterns is a clearly-written guide for building event-driven distributed systems that are resilient, responsive, and scalable. Written by the authors of the Reactive Manifesto, this book teaches you to apply reactive design principles to the real problems of distributed application development. You'll discover technologies and paradigms that can be used to build reactive applications including Akka and other actor-based systems, functional programming, replication and distribution, and implementation techniques such as futures, iteratees, and reactive streams. While the book presents concrete examples in Scala, Java, JavaScript, and Erlang, the primary goal is to introduce patterns and best practices that you can use to apply reactive principles to common problems you'll face when building distributed systems.
WHAT'S INSIDE
* Discover best practices and patterns for building responsive applications
* Build applications that can withstand hardware or software failure at any level
* Patterns for fault tolerance, scalability, and responsiveness
* Maximize multicore hardware using asynchronous and event-driven solutions
* Scale applications under tremendous load
Readers should be familiar with a standard programming language like Java, C++ or C# and be comfortable with the basics of distributed systems. Software engineers and architects will learn how to avoid common pitfalls and apply patterns for solving day-to-day problems in a fault-tolerant and scalable way to maximize their application's responsiveness to users and clients. Project leaders and CTOs will gain a deeper understanding of the philosophy behind resilience and scalability in distributed systems, as well as their limitations, challenges and benefits.
386 pages, Paperback
First published March 28, 2014
44 people are currently reading
527 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 - 17 of 17 reviews
October 12, 2017
TL;DR
> I didn't like this book. If you're looking for a good book in almost the same topic checkout https://www.goodreads.com/book/show/2...
In General didn't like this book. While the topic is great, the material was not that great. I expected more that this from the author. Basically this book is not about reactive design patters, it's about selling Akka.
Pros: The subject of the book is cool and quite popular.
Cons:
* By reading this book you're going to feel that actor model is the ultimate answer to everything. ( which is wrong btw). There are more that one correct way to solve distributed systems problems and different paradigms exist to solve different set of problems.
* The author is not honest with cons of actor model or solutions which he provides.
* If you know about distributed systems or big data you can safely ignore about 60% of the book.
* There are lots of situations which author compares oranges with apples in this book. In some cases he even compare orange with a shoe. Lots of uneven, unrealistic comparisons of tools with different purposes. For example comparing Actor model to promises for distributed systems is totally wrong.
Most of the comparisons of this book is in favor of actor model by ignoring the fact that other tools and paradigms might have different and specific existence goals. Or comparing NodeJS ( I'm not a fan ) with Erlang/OTP and Scala/Akka for location transparency is wrong ( Ignoring the goals of the tool and language )
* There are lots of cases like "X is not good at doing Y" with no reference to prove it at all. In general author didn't provide enough references for most of dropped facts.
* Author constantly keep talking about what they did in Akka ( Apparently he is part of the team ).
Which is not related to the book title.
* The last one is a little bit picky and harsh but author uses "you" when ever he wants do declare some wrong decision and "we" otherwise. Like: "If you want to design X you might use...." and it leads to a bad thing or "We designed X like ....." which leads to a good thing. In general i didn't felt good when I was reading this book.
> I didn't like this book. If you're looking for a good book in almost the same topic checkout https://www.goodreads.com/book/show/2...
In General didn't like this book. While the topic is great, the material was not that great. I expected more that this from the author. Basically this book is not about reactive design patters, it's about selling Akka.
Pros: The subject of the book is cool and quite popular.
Cons:
* By reading this book you're going to feel that actor model is the ultimate answer to everything. ( which is wrong btw). There are more that one correct way to solve distributed systems problems and different paradigms exist to solve different set of problems.
* The author is not honest with cons of actor model or solutions which he provides.
* If you know about distributed systems or big data you can safely ignore about 60% of the book.
* There are lots of situations which author compares oranges with apples in this book. In some cases he even compare orange with a shoe. Lots of uneven, unrealistic comparisons of tools with different purposes. For example comparing Actor model to promises for distributed systems is totally wrong.
Most of the comparisons of this book is in favor of actor model by ignoring the fact that other tools and paradigms might have different and specific existence goals. Or comparing NodeJS ( I'm not a fan ) with Erlang/OTP and Scala/Akka for location transparency is wrong ( Ignoring the goals of the tool and language )
* There are lots of cases like "X is not good at doing Y" with no reference to prove it at all. In general author didn't provide enough references for most of dropped facts.
* Author constantly keep talking about what they did in Akka ( Apparently he is part of the team ).
Which is not related to the book title.
* The last one is a little bit picky and harsh but author uses "you" when ever he wants do declare some wrong decision and "we" otherwise. Like: "If you want to design X you might use...." and it leads to a bad thing or "We designed X like ....." which leads to a good thing. In general i didn't felt good when I was reading this book.
October 14, 2019
Great tips for writing code. This is a keeper and should be reveiwed at least annually.
March 6, 2016
Remark: review based on MEAP version (v10) - all chapters present, needs some fine-tuning, pics & gaps filled.
I find a big difference between two underlying parts of this book: philosophy & patterns. While the first part is perfectly elaborated, understandable & written in a way that doesn't cause slightest objections, the patterns part (presumably far more important) is very uneven - some chapters are very rough (but to be honest - authors admit that in MEAP notes) & sometimes the content is poorly balanced: either a chapter is just to brief or over-elaborated. But the truth is that even these imperfect (& incomplete - Vaughn's book is much more comprehensive in terms of reactive patterns, I believe) chapters are a great source of knowledge & interesting remarks that can make you thinking about reactive programming in a slightly different way than before.
One more remark before the conclusion - vast majority of code samples are in Scala & Akka - personally I don't mind, quite the opposite - it's a great opportunity to see how some things can be implemented using latest Akka features.
To summarize: this may be a rough read (sometimes), but still - it's just too good to miss. Recommended.
I find a big difference between two underlying parts of this book: philosophy & patterns. While the first part is perfectly elaborated, understandable & written in a way that doesn't cause slightest objections, the patterns part (presumably far more important) is very uneven - some chapters are very rough (but to be honest - authors admit that in MEAP notes) & sometimes the content is poorly balanced: either a chapter is just to brief or over-elaborated. But the truth is that even these imperfect (& incomplete - Vaughn's book is much more comprehensive in terms of reactive patterns, I believe) chapters are a great source of knowledge & interesting remarks that can make you thinking about reactive programming in a slightly different way than before.
One more remark before the conclusion - vast majority of code samples are in Scala & Akka - personally I don't mind, quite the opposite - it's a great opportunity to see how some things can be implemented using latest Akka features.
To summarize: this may be a rough read (sometimes), but still - it's just too good to miss. Recommended.
November 18, 2019
Invaluable advcie and very well written.
February 19, 2015
Disclaimer: this is a review of the MEAP v3 of the book with a big hope for improvement.
The book is not written in the patterns language (probably the missing 3rd will), which was unexpected to me given the title. It is very biased towards the Erlang's actor model being the one true way of building reactive systems. I found the first 151 pages (all available to date) to be a quite handwayvy and philosophical; the important ideas could've been delivered in 30-50% of the text.
Look forward to the released version, though not sure if I'll want to re-read the first half again.
The book is not written in the patterns language (probably the missing 3rd will), which was unexpected to me given the title. It is very biased towards the Erlang's actor model being the one true way of building reactive systems. I found the first 151 pages (all available to date) to be a quite handwayvy and philosophical; the important ideas could've been delivered in 30-50% of the text.
Look forward to the released version, though not sure if I'll want to re-read the first half again.
February 17, 2020
This book has a good introduction, but the actual content is very shallow. It's wordy but there are actually not a lot of useful knowledge. The whole book can be compacted into few chapters. Also, the author puts too much weight on the Actor model, as it is the only solution for reactive application.
March 6, 2017
I like the book where exposes 10 km hight level architectures and design patterns but next goes 10 feet hight in low level scala Akka implementation. It looks to be 2 different books.
January 27, 2017
Disclaimer: review based on MEAP v11, all chapters available.
This is one of those books that you either like or hate with a passion. The core concepts introduced in the book are described in great detail. The style of writing is mostly engaging. As the book progresses, the writing becomes more hectic. There is unequivocally a need to redo some of the chapters.
The code and examples are all written in Scala and utilise the Akka framework (despite what the book online description would have you believe). You should be pretty familiar with Scala's syntax as otherwise code will feel foreign. Understanding of the actor model is expected, but not strictly required to follow through the examples.
I love that you do get little light-bulb moments every now and again as you move through the pages. Whilst not using Scala myself, the concepts and patterns are applicable in general in any distributed system.
This is one of those books that you either like or hate with a passion. The core concepts introduced in the book are described in great detail. The style of writing is mostly engaging. As the book progresses, the writing becomes more hectic. There is unequivocally a need to redo some of the chapters.
The code and examples are all written in Scala and utilise the Akka framework (despite what the book online description would have you believe). You should be pretty familiar with Scala's syntax as otherwise code will feel foreign. Understanding of the actor model is expected, but not strictly required to follow through the examples.
I love that you do get little light-bulb moments every now and again as you move through the pages. Whilst not using Scala myself, the concepts and patterns are applicable in general in any distributed system.
October 24, 2019
It's an 'okay' book.
Quite verbose - in particular the first two parts - which could easily be comdensed into one chapter or two at max.
Last part where author covered the actual patterns was okay - still verbose to some extent but fine.
Writing style felt bit unmotivated and examples author used felt boring. Perhaps people new to these patterns may find the book useful.
Verbose but motivating writing like the book 'Designing Data Intensive applications' is far better than verbose and dull writing. Ofcourse these books have different topics but one can see the difference in the common topics they cover(like replication).
I lost interest by the time i reached last chapters and ended up skimming them.
Quite verbose - in particular the first two parts - which could easily be comdensed into one chapter or two at max.
Last part where author covered the actual patterns was okay - still verbose to some extent but fine.
Writing style felt bit unmotivated and examples author used felt boring. Perhaps people new to these patterns may find the book useful.
Verbose but motivating writing like the book 'Designing Data Intensive applications' is far better than verbose and dull writing. Ofcourse these books have different topics but one can see the difference in the common topics they cover(like replication).
I lost interest by the time i reached last chapters and ended up skimming them.
November 20, 2017
Had a great time reading it.
The first part of the book is a "smooth" almost code free introduction to the reactive manifesto and to reactive applications.
As a newcommer to Reactive apps and reactive desing I think I have done the right decision by starting with this book. After reading the first part I know have a clear understanding (or at least the tools to start understanding) how to plan for a reactive app and why/when to do go for a reactive app.
I'll read through the patterns more as a curiosity than of a need and will store the book for later consult.
And that´s why I'm giving it a 4. It is what I expected it to be.
The first part of the book is a "smooth" almost code free introduction to the reactive manifesto and to reactive applications.
As a newcommer to Reactive apps and reactive desing I think I have done the right decision by starting with this book. After reading the first part I know have a clear understanding (or at least the tools to start understanding) how to plan for a reactive app and why/when to do go for a reactive app.
I'll read through the patterns more as a curiosity than of a need and will store the book for later consult.
And that´s why I'm giving it a 4. It is what I expected it to be.
June 6, 2023
7/10
I think the book is nicely organized and can be a good introduction to reactive design.
The code examples are written in Scala and Akka. This allowed to present most of the concepts. I suspect using only those two technologies was supposed to make the book more timeless (without necessarily tying to currently used frameworks), but but because of the Akka team moving away from open-source license I wouldn't be so sure any more. We can already see major projects (like Apache Flink) trying to find a replacement for Akka.
Diving deeper into some patterns is highly advised, I wish the book gave more thorough discussion of some of the topics it covers though.
I think the book is nicely organized and can be a good introduction to reactive design.
The code examples are written in Scala and Akka. This allowed to present most of the concepts. I suspect using only those two technologies was supposed to make the book more timeless (without necessarily tying to currently used frameworks), but but because of the Akka team moving away from open-source license I wouldn't be so sure any more. We can already see major projects (like Apache Flink) trying to find a replacement for Akka.
Diving deeper into some patterns is highly advised, I wish the book gave more thorough discussion of some of the topics it covers though.
May 21, 2017
Book is good and informative, patterns are generally illustrated with Akka examples.
It covers the broad set topics and gives a decent ground for further explorations. I lacked some details in some chapters (say in Chapter 13 about replication challenges). There is a short interesting use case modelling in Appendix B.
It covers the broad set topics and gives a decent ground for further explorations. I lacked some details in some chapters (say in Chapter 13 about replication challenges). There is a short interesting use case modelling in Appendix B.
August 5, 2017
I really liked this book, although the intro was a bit long, the contents was really good and the examples / source code was OK ... I will use this book in the future for my work that is for sure ...
October 12, 2021
Not exactly sure where to put this one.
On one hand, the described patterns are nothing new and most of them have been around for quite a while and from that perspective I don't feel like the book brings much original content (unlike the classics that it's being compared to) or that I've gained significant insight or knowledge from reading it.
On the other hand, I thoroughly enjoyed reading it and seeing how all these patterns are viewed from the Actor model's perspective and how they'd be implemented Akka (no, don't be fooled by the books description - the examples are mostly Scala and Akka). Plus, the book still serves like a good reference/cheat sheet for a lot of distributed computing-related best practices and patterns that we've adopted over the years.
TLDR - if you have experience with distributed system but not Actors and Akka, you may find this book enjoyable. Otherwise, you may want to look elsewhere.
On one hand, the described patterns are nothing new and most of them have been around for quite a while and from that perspective I don't feel like the book brings much original content (unlike the classics that it's being compared to) or that I've gained significant insight or knowledge from reading it.
On the other hand, I thoroughly enjoyed reading it and seeing how all these patterns are viewed from the Actor model's perspective and how they'd be implemented Akka (no, don't be fooled by the books description - the examples are mostly Scala and Akka). Plus, the book still serves like a good reference/cheat sheet for a lot of distributed computing-related best practices and patterns that we've adopted over the years.
TLDR - if you have experience with distributed system but not Actors and Akka, you may find this book enjoyable. Otherwise, you may want to look elsewhere.
April 19, 2015
Kniha zatím obsahuje jen první 3 kapitoly, které jsou i tak celkem obsáhlé. Reaktivní architektura je věc o kterou se zajímám již několik let a tak jsem si chtěl přečíst nějaký ucelený kousek na toto téma. A byla to poměrně dobrá volba. Autor je sice architektem Akka a tak často dochází k vychvalování Akky a Scaly, ale člověk to musí brát trochu s rezervou. Jde hlavně o architektonická řešení a postupy. technologie přicházejí a odcházejí a nejsou zas tak důležité...
August 21, 2016
based on meap10: the book lacks cohesion to some degree. hope they work on the stucture in further versions. I havent enjoyed out-of-touch isolation and bumpy leaps between 3 existing main parts.
April 1, 2017
Full disclosure: I was the technical editor (aka, proofreader) on this book -- work for which I was compensated.
Displaying 1 - 17 of 17 reviews