Josep Prat (14) [Avatar] Offline
#1
Chapter 12 looks like it looks not completely uploaded as it ends abruptly and last patterns are not defined:
12.4 The Active–Passive Replication Pattern
12.5 The Active–Active Replication Pattern
12.6 The Proactive Failure Signal Pattern

Also it looks like a wrap up is also missing.

Thanks!
roland.kuhn (39) [Avatar] Offline
#2
The MEAP email should probably have been a bit more informative here: this time we decided to release a half-chapter because a lot of my time is taken by the Coursera course right now and we didn’t want to hold back the existing material any longer. How do you like the part that does exist?
Josep Prat (14) [Avatar] Offline
#3
OK, that makes sense.
I like the way the description about the patterns are structured. If I could change something, I would add some more code, so it becomes easier to follow what you are explaining. Maybe it's only me, but I really like it more when some piece of code is also included, for example like in the Circuit Breaker Pattern description, I really appreciated the code snippet.
roland.kuhn (39) [Avatar] Offline
#4
Just to make sure: you like how it is done for CircuitBreaker but would like to see the same for the earlier two patterns as well? I thought about that, but those patterns are really architectural, so I found it difficult to present code that is concise enough—if you have a brilliant idea I’m all ears!
Josep Prat (14) [Avatar] Offline
#5
Yes, that's what I meant. I know those patterns are pretty much in the architectural area, but I'll think about some way to get code examples, and come back to you if anything interesting pops up
roland.kuhn (39) [Avatar] Offline
#6
Thanks! Most of the remaining patterns (in the following chapters as well) are much more concrete and therefore easier to demonstrate on concrete code.
Phil Derome (48) [Avatar] Offline
#7
This chapter is a gem.

Likes:
  • The code supports very nicely the discussion. The code is as simple as it can be, very well done.

  • folklore tidbit about origin of Akka name, Netflix, RxJava, Hystrix, and AWS

  • motivates concretely very well the premise of the book and is very, very convincing. In particular, the code demonstrates nice composition of functions and types to achieve easy to understand higher levels of abstraction (despite some industry detractors)

  • smart active heartbeats with meaningful metrics data for greater possible sophistication of supervision

  • 12.4.3 and 12.4.4 discussion of not running at full capacity and advising to plan for intentional leg room to go below having advantages in terms of CPU time, mem bandwidth, caches, IO channels




  • Very minor nitpicks:
  • the use of italic font for emphasis seems to be overloaded for different purposes and is a bit confusing (sometimes to introduce specific terms, sometimes for common longer phrases within reactive world, sometimes for plain emphasis (e.g. why or The task) while some specific terms remain in normal font throughout (Error Kernel), so maybe two fonts would have worked better?

  • It takes a little time to figure out the details of Figure 12.12 and what it means to represent being new to the notation. I didn't see immediately in the left box that the flow above was right-bound and below left-bound; mostly I didn't make clearly the distinction of the neg.reply induced by per-client breaker and the one from rate limiter (despite the captions that say so!). I wonder if the text could have followed a little more in detail what goes on in the diagrams. Perhaps after 2-3 chapters, it all settles down getting used to it all.

  • The discussion of gating could have explained how 10% is computed in "a rate that is at least 10% higher than allowed (CircuitBreaker.failuresInArow=10/RateLimiter.requests=100) and adding a few words of explanation or even some simple math formula to make it explicit". Some programmers are a little slower with math or queueing-related calculations