- Paperback: 392 pages
- Publisher: Manning Publications; 1 edition (March 5, 2017)
- Language: English
- ISBN-10: 1617291803
- ISBN-13: 978-1617291807
- Product Dimensions: 7.2 x 1 x 9.2 inches
- Shipping Weight: 1.2 pounds (View shipping rates and policies)
- Average Customer Review: 6 customer reviews
- Amazon Best Sellers Rank: #136,537 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Reactive Design Patterns 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
From the Publisher
About this Book
This book is intended to be a comprehensive guide to understanding and designing Reactive systems. Therefore, it includes not only an annotated version of the Reactive Manifesto, but also the reasoning that led to its inception. The main part of the book is a selection of design patterns that implement many facets of Reactive system design, with pointers toward deeper literature resources for further study. While the presented patterns form a cohesive whole, the list is not exhaustive—it cannot be—but the included background knowledge will enable the reader to identify, distill, and curate new patterns as the need arises.
Whom this book is for:
This book does not require prior knowledge of Reactive systems; it builds upon familiarity with software development in general and refers to some experience with the difficulties arising from distributed systems. For some parts, a basic understanding of functional programming is helpful (in the sense of programming with immutable values and pure functions), but category theory does not feature in this book.
This book was written for everyone who may want to implement Reactive systems:
- It covers the architecture of such systems as well as the philosophy behind it, giving architects an overview of the characteristics of Reactive applications and their components and discussing the applicability of the patterns.
- Practitioners will benefit from a detailed discussion of the scenario solved by each pattern, the steps to take in applying it—illustrated with complete source code—as well as a guide to transfer and adapt the pattern to different cases.
- Learners wishing to deepen their knowledge, for example, after viewing the course material of Principles of Reactive Programming, will be delighted to read about the thought processes behind the Reactive principles and to follow the literature references for further study.
About the Author
Dr. Roland Kuhn leads the Akka team at Typesafe. Together with Martin Odersky and Erik Meijer, Roland presented the Coursera course Principles of Reactive Programming and co-authored the Reactive Manifesto.
Brian Hanafee is a Principal Systems Architect at a large financial institution, with experience building reliable and secure web-based applications and backing services for millions of customers.
Jamie Allen is the Director of Consulting for Typesafe and author of Effective Akka.
Author interviews, book reviews, editors picks, and more. Read it now
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Maybe this would be a good primer for someone who doesn't know anything about distributed systems. It is definitely not a "Design Patterns" book.
- I cannot think of a better book from which to learn the reactive programming landscape than this amazing volume.
- For a more-detailed review, checkout my post by searching on the keywords "Programming Digressions Best Reactive Programming Books"
For beginners Part I & II might be worth for a quick glossing over. For experienced programmers in Akka who look for "design patterns", maybe Part III could serve as a reference.
I am currently reading the book (approx. 100 pages), but since there are few reviews, I'd like to give my contribution.
Of course I will update this review once I get a better idea of the book.
For now, I am not very satisfied: the book is quite verbose and uses a lot of words for introducing very basic concepts. Moreover, I would expect it to be more precise, better distinguishing concepts and explaining the ideas in a more compact and punctual way. I also perceive some redundancy (e.g., consider the following subsection titles in first 3 chapters: "1.3 Making the system responsive", "2.1 Reacting to users", "3.3 Responsiveness to users"). In other words, I deem Parts 1 and 2 not very effective. It is true that it says "This book does not require prior knowledge of Reactive systems", but I would have preferred a more advanced stance (e.g., à la GOF Design Patterns). But I do have quite a lot expectations for Part 3, about patterns :)
== Edit2: 10/17
Started reading again, finding again Part II too wordy/unstructured/fuzzy (especially Ch. 6, 'Divide and conquer'), and finding quite difficult to effectively draw notes, and I see this as a lack of structure and precision.
When I arrived to Part III (you have to read almost half-book to get there), I expected the pattern catalogue to begin, but there I found a chapter about testing of reactive apps -- which is interesting, anyway. The first pattern you encounter is the Single-Component pattern, which basically is the Single Responsibility Principle, and in fact I believe it is more a 'principle' than a 'design pattern'.
After having read half book, I find myself asking "what have I learnt?". Too much fluff. I am quite disappointed.
1 Why Reactive?
2 A walk-through of the Reactive Manifesto
3 Tools of the trade
4 Message passing
5 Location transparency
6 Divide and conquer
7 Principled failure handling
8 Delimited consistency
9 Nondeterminism by need
10 Message flow
11 Testing reactive applications
12 Fault tolerance and recovery patterns
13 Replication patterns
14 Resource-management patterns
15 Message flow patterns
16 Flow control patterns
17 State management and persistence patterns