Reactive Design Patterns

I bought this through the Manning Early Access Program (MEAP). Since I paid for it, I keep picking it up to force myself to read. I tell myself that there is something of value in there, but it is way too wordy. I expect a book about "Design Patterns" to follow the style of Gang of Four's "Design Patterns: Elements of Reusable Object-Oriented Programming" or "Enterprise Integration Patterns". This book spends a lot of time describing the problems of distributed systems, but at the end of each chapter that I've read I am scratching my head and wondering how can I solve it. As another reviewer said, I walk away thinking "What have I learned?".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.

- If you're looking for the best-written, most-comprehensive treatment of reactive design, look no further than Reactive Design Patterns by Roland Kuhn, Brian Hanafee, and Jamie Allen (Manning Publications). The contents of this book are overwhelming—in a good way—as there is so much that is of such high quality: the caliber of writing, the sparkling-clear illustrations, and the stellar code snippets.- 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"

I am three chapters in and I love the way the authors approach the concepts, very fluent, clear and to the point. As I progress in the book I'll update this review. But since there is no table of contents available on amazon (yet), these are the chapters:1 Why Reactive?2 A walk-through of the Reactive Manifesto3 Tools of the trade4 Message passing5 Location transparency6 Divide and conquer7 Principled failure handling8 Delimited consistency9 Nondeterminism by need10 Message flow11 Testing reactive applications12 Fault tolerance and recovery patterns13 Replication patterns14 Resource-management patterns15 Message flow patterns16 Flow control patterns17 State management and persistence patterns

== Edit1: 03/17I 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/17Started 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.

I was interested in reading this book because the author's Coursera class is pretty good, so I really had very high expectations. However, I got very disappointed by both the book's writing style and its content.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.