Nothing succeeds like success.
~ Popular saying.
Your work is going to fill a large part of your life, and the only way to be truly satisfied is to do what you believe is great work. And the only way to do great work is to love what you do. If you haven’t found it yet, keep looking. Don’t settle. As with all matters of the heart, you’ll know when you find it.
~ Steve Jobs
Introduction
Some of the stellar books we’ll be checking out in a bit here (on all things reactive programming) have stood the test of time—they remain every bit as relevant today as they were when they hit the bookstands—while others have also continued to age well. And yet other books are appearing brand new on this (updated) list! (Some of you may recall the original, great-granddaddy set of reviews, by yours truly, which had appeared elsewhere on this blog, a few years ago…)
But first things first: Should you have the faintest interest in (1) the Internet of Things (IoT), in (2) micro-services, or in (3) reactive programming, then I urge you to bookmark the following coordinates. Keep them in mind as you wend your merry way reading through the reviews in this post:
You got that? Cool, and while we’re at it, I’ve got when one more: Pondering the far reaches of the amazing Actor Model!
If you’re new to our digs, please know that I’m opinionated—never in a rude way, at least I hope not, because that’s just not my style!—so yes, I don’t mince my words: Hence the Steve Jobs quote atop (Longtime readers, of course, will need no such subtle terms of endearment to soothe their jangled nerves!)
So it all goes back to the basics: How to slay that red-eyed complexity monster, you know the one that has taken one redeye flight too many? Seriously, though, read on to find the answer…
How, Exactly, Does One…
So, how, exactly, does one slay complexity when it threatens to hang, albatross-like, over our lovingly-crafted bits of code? For starters, allow me to remind you of these prescient words:
Almost all the constructs we have invented in 60-odd years of computer programming have been attempts to manage complexity. Higher-order, pure functions are called combinators, because they compose together very well as flexible, fine-grained building blocks for constructing larger, more complex programs. We’ve already seen examples of collection methods chained together to implement nontrivial logic with a minimum of code. Pure functions and immutability drastically reduce the occurrence of bugs. Mutable state is the source of the most pernicious bugs, the ones that are hardest to detect with testing before deploying to production, and often the hardest bugs to fix.
~ Dean Wampler and Alex Payne (in Programming Scala — O’Reilly Media, Inc.)
Here’s the deal: The confluence of functional programming, steeped as it is in the queen of the sciences, mathematics—and math doesn’t get stale—of OOP, of hard-won concurrency best practices gleaned from the trenches, of the actor model, of the industry-reenergizing (open-source) Akka project, as well as a host of other factors, has revitalized our industry! In the words of The Reactive Manifesto:
We believe that a coherent approach to systems architecture is needed, and we believe that all necessary aspects are already recognized individually: we want systems that are Responsive, Resilient, Elastic and Message Driven. We call these Reactive Systems.
And yes, I’ve been there, done that—and got the T-shirt!
The Scoop
To help guide newcomers—and veterans, too, coming back for a refresher—through the landscape of the reactive programming paradigm, we’ll be checking out the very best (book-format) resources out there. My hope in doing so—and I have spent serious time grappling with the material in each book—is that you, too, will thereby be equipped to design systems that are (one more time!) Responsive, Resilient, Elastic and Message-Driven (Yay!)
Without further ado, here, then, is my list of the final word on reactive programming wisdom, folklore, and insider information:
- Reactive Design Patterns by Roland Kuhn, Brian Hanafee, and Jamie Allen (Manning Publications) 💰
- Reactive Application Development by Duncan DeVore, Sean Walsh, and Brian Hanafee (Manning Publications) 🐳
- Reactive Web Applications: With Play, Akka, and Reactive Streams by Manuel Bernhardt (Manning Publications) 📶
- Functional and Reactive Domain Modeling by Debasish Ghosh. (Manning Publications) ⛰
- Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka by Vaughn Vernon (Addison-Wesley Professional) 🚅
- The Tao of Microservices by Richard Rodger (Manning Publications) ⛰
With that, I submit to you a review each of the cool stuff above…
#1. Reactive Design Patterns by Roland Kuhn, Brian Hanafee, and Jamie Allen (Manning Publications) 💰
If you’re looking for a fabulously-written, uber-comprehensive treatment of recurring patterns in 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. After you have mastered the basics, I cannot think of a better book (than this amazing volume) from which to really grok and navigate the reactive programming terrain.
It’s no wonder, then, that Jonas Boner, the driving force behind the reactive programming movement—now a truly full-fledged community of its own—was so pleased by the publication of this book, a couple of years ago (in 2017). In his Foreword to Reactive Design Patterns, Jonas said:
I’m grateful that Roland has taken the time to write this foundational book, and I can’t think of anyone more capable of pulling it off. Roland is an unusually clear and deep thinker; he coauthored the Reactive Manifesto, has been the technical lead for the Akka project for several years, has coauthored and taught the very popular Coursera course on Reactive programming and design, and is the best technical writer I have met.
It outlines what Reactive architecture/design is all about, and does an excellent job explaining it from first principles in a practical context. Additionally, it is a catalog of patterns that explains the bigger picture, how to think about system design, and how it is all connected—much like what Martin Fowler’s Patterns of Enterprise Application Architecture did 15 years ago.By now, the Reactive principles have had a big impact on the industry, and as with many successful ideas, they get overloaded and reinterpreted. This is not a bad thing; ideas need to evolve to stay relevant. However, this can also cause confusion and lead to dilution of the original intent. One example is the unfortunate emerging misconception that Reactive is nothing but programming in an asynchronous and nonblocking style using callbacks or stream-oriented combinators—techniques that are aptly classified as Reactive Programming. Concentrating on this aspect alone means missing out on many of the benefits of the Reactive principles. It is the contribution of this book to take a much larger perspective—a systems view—moving the focus from how individual components function in isolation to the design of collaborative, resilient, and elastic systems: Reactive systems.
This future classic belongs on the shelf of every professional programmer, right next to the GoF book (Design Patterns: Elements of Reusable Object-Oriented Software by Gamma, Helm, Johnson, and Vlissides) and Domain-Driven Design by Eric Evans. Enjoy the ride—I certainly did!
Remaining mindful of my earlier remark about just how comprehensive this fine book is in its treatment of the exciting field of reactive design, I present here the table of contents to give you a flavor of the breadth (and depth) of the topics covered:
1. Introduction
Chapter 1. Why Reactive? Chapter 2. A walk-through of the Reactive Manifesto Chapter 3. Tools of the trade2. The philosophy in a nutshell
Chapter 4. Message passingChapter 5. Location transparencyChapter 6. Divide and conquerChapter 7. Principled failure handlingChapter 8. Delimited consistency Chapter 9. Nondeterminism by need Chapter 10. Message flow3. Patterns
Chapter 11. Testing reactive applicationsChapter 12. Fault tolerance and recovery patternsChapter 13. Replication patternsChapter 14. Resource-management patternsChapter 15. Message flow patternsChapter 16. Flow control patternsChapter 17. State management and persistence patternsAppendix A. Diagramming Reactive systems
Appendix B. An illustrated example
Appendix C. The Reactive Manifesto
Index
Among my favorite sections includes the one on compartmentalization and bulk-heading. I first became aware of these crucial design strategies from another fine book entitled Release It! Design and Deploy Production-Ready Software by Michael T. Nygard in which the author gently educated us, beginning with these sobering advice: “Feature complete” is not the same as “production ready!
Two standout chapters (in Reactive Design Patterns) that especially resonated with me—and IMHO are not-to-be-missed—which I want to bring to your attention are these, along with the titles of sub-sections, to better give you a flavor of the coverage:
Chapter 9. Nondeterminism by need 9.1. Logic programming and declarative data flow 9.2. Functional reactive programming 9.3. Sharing nothing simplifies concurrency 9.4. Shared-state concurrency 9.5. So, what should we do? 9.6. Summary
Chapter 17. State management and persistence patterns 17.1. The Domain Object pattern 17.1.1. The problem setting 17.1.2. Applying the pattern 17.1.3. The pattern, revisited 17.2. The Sharding pattern 17.2.1. The problem setting 17.2.2. Applying the pattern 17.2.3. The pattern, revisited 17.2.4. Important caveat 17.3. The Event-Sourcing pattern 17.3.1. The problem setting 17.3.2. Applying the pattern 17.3.3. The pattern, revisited 17.3.4. Applicability 17.4. The Event Stream pattern 17.4.1. The problem setting 17.4.2. Applying the pattern 17.4.3. The pattern, revisited 17.4.4. Applicability 17.5. Summary
Here is a link to the book’s accompanying source code, available freely on Github.
In sum, Reactive Design Patterns provides sparkling clear insights into the value proposition that reactive design brings to the proverbial programming table 😎
So take a deep breath, and start reading. The contents of this book are overwhelming—in a good way—so much that is of such high quality: the caliber of writing, the sparkling-clear illustrations, the stellar code snippets
#2. Reactive Application Development by Duncan DeVore, Sean Walsh, and Brian Hanafee (Manning Publications) 🐳
We got a brand new entrant to the field of this select list, which is, IMHO, featuring the very best in reactive programming books published to date (we’re currently in Q1 of 2019, right?)
This book is packed with lesson that could only have been gleaned by those who have been there and done that. Theory is one thing (an indispensable one, to be sure, but still only a start) and practice quite another! No wonder, then, that it’s garnered the following glowing review—it’s by Jonas Boner and appears in the Foreword to Reactive Application Development—which clearly highlights the value its study will bring to your (ongoing) education, on the way to reactive enlightenment:
This book makes it clear that the authors have been there, getting their hands dirty, learning by doing. The book is packed with hard-won wisdom and practical advice that will set you on the path toward effective reactive application development. Along the way, you learn how bounded contexts, domain events, futures, actors, streaming, and Event Sourcing/CQRS compose into highly responsive, scalable, and available systems while keeping complexity under control. The book is a working book, and you have a lot of work in front of you. If you put in the hours, you’ll be rewarded in spades.
Several standout chapters, which deserve careful reading—and rereading—are worth pointing out:
- Chapter 1. What is a reactive application?
- Chapter 5. Domain-driven design
- Chapter 7. Reactive streaming
- Chapter 8. CQRS and Event Sourcing
While you won’t find any annoying hand-holding, the authors do take great care to show you the way, starting with basics, and taking you all the way to expert practitioner-level knowledge! To take just example–this one from their thoughtful coverage of Domain-Driven Design aka DDD–you will find starter material (“What is domain-driven design?”), the larger context of an anti-patterns that plagues our industry (“The Big Ball of Mud”), some hard-core DDD wisdom (specifically on the topics of “Bounded context”, “Ubiquitous language”, “Entities”, “Aggregates”, and a handful more), and even some advanced DDD topics (for example the “Anticorruption layer”). To top it off, fully-working code examples (in Scala) are thoughtfully provided for this chapter—virtually every chapter has corresponding worked (and annotated) examples which I found super-helpful in driving home the explanations!
Here is a link to the book’s accompanying source code, available freely on Github.
Profusely illustrated, lavishly cross-referenced with entries to top-notch resources, this one is a winner!
#3. Reactive Web Applications: With Play, Akka, and Reactive Streams by Manuel Bernhardt (Manning Publications) 📶
This next title is an excellent, no frills introduction to building reactive web applications with Play and Akka. It is entitled Reactive Web Applications: With Play, Akka, and Reactive Streams by Manuel Bernhardt (Manning Publications). The book’s unerring focus on practicality—all the while highlighting best practices—is very pleasing and helpful. One reviewer (Antonio Magnaghi, PhD, OpenMail) has correctly pointed out this book is
A complete and exhaustive source of best practices for large-scale, real-world reactive platforms.
I heartily agree with this assessment. When reading books, we’re all gotten used to doing the inevitable google searches periodically—to compensate for the equally inevitable gaps in the narratives of any given technology book—but this book is mercifully free of the aforesaid read-some, search-online-some, resume-reading syndrome, yay!
Check out these observations in the book’s Foreword by James Roper, who is the lead developer of the Play framework:
Until four years ago, every major web application that I had written used the tried-and-trusted thread-per-request execution model… At that time in our industry’s history, the word “reactive” was virtually unheard-of.
The switch to reactive applications has been the biggest architectural change since the web itself, and it has swept across our industry at lightning speed. What I considered far-fetched four years ago, I now use every day, and I am lead developer of Play, a framework that embraces it. With the concept evolving from relative obscurity to mainstream best practice in such a short time, it’s no wonder that countless web developers are asking the question, “What is reactive?” This is where Reactive Web Applications perfectly fills a gap.
I’m glad to see that Manuel has so articulately captured these leading-edge best practices for web application development in this time of great change in our thinking. The practical application of this book to web development will put you in a great position to produce software for the high demands of today’s world.
One thing I really, really like about this book is the abundance of useful diagrams and code snippets, all of which are profusely annotated with thoughtful comments! I would say that the barrier-to-entry to this book is not all that high—hastening to add that this is most emphatically not the same as saying that the contents are trifling.
That’s right, this book reveals hard-won wisdom from an author who has clearly been in-the-trenches of sophisticated software development 🚀
One thing I appreciated a lot was the liberal sprinkling of Scala tips throughout the pages. And the author (Manuel Bernhardt) did not copy snippets the Scaladoc and dump them; instead, he has clearly put a lot of thought into bringing out the relevance of the Scala tips in an original way ⛳
Here’s a typical Scala tip from the book:
Scala tip: implicit parameters
Implicit parameters are a language feature of Scala that allows you to omit one or more arguments when calling a method. Implicit parameters are declared in the last parameter list of a function. For example, the index.scala.html template will be compiled to a Scala function that has a signature close to the following:def indexTemplate(message: String)(implicit request: RequestHeader)
When the Scala compiler tries to compile this method, it will look for a value of the correct type in the implicit scope. This scope is defined by prepending the implicit keyword when declaring anonymous functions, as here with Action:
def index = Action { implicit request: RequestHeader => // request is now available in the implicit scope }
You don’t need to explicitly declare the type of request; the Scala compiler is smart enough to do so on its own and to infer the type.
OK, now that is my kind of stuff 📫
Finally, for a fuller flavor of the book, here is the Table of Contents of this fine volume:
1. Getting started with reactive web applications
Chapter 1. Did you say reactive? Chapter 2. Your first reactive web application Chapter 3. Functional programming primer Chapter 4. Quick introduction to Play
2. Core concepts
Chapter 5. FuturesChapter 6. ActorsChapter 7. Dealing with stateChapter 8. Responsive user interfaces
3. Advanced topics
Chapter 9. Reactive StreamsChapter 10. Deploying reactive Play applicationsChapter 11. Testing reactive web applications
Appendix A. Installing the Play Framework
Appendix B. Recommended reading
Appendix C. Further reading
Index
Here is a link to the book’s accompanying source code, available freely on Github.
I look forward to (many!) more books by Manuel Bernhardt 💹
#4. Functional and Reactive Domain Modeling by Debasish Ghosh. (Manning Publications) ⛰
Allow me to re-introduce a book that is almost lyrical in the beauty and elegance with which it tackles an incredibly tough subject, actually three whole subjects, to be precise: Functional and Reactive Domain Modeling by Debasish Ghosh. What the author has accomplished with this stellar book is not for the faint of heart: It takes three strands—functional programming, reactive programming, and domain modeling—and manages to weave them into a tapestry of awesome.
Did I actually say that (lyricism, beauty, elegance, and all)? Well, I guess people have been known to grow lyrical when gripped by a narrative that is told with such uncommon insight and perspicuity that it leaves them with a heady feeling 😆 I am, though, reassured that I’m in good company as I recall what the mathematician and philosopher Bertrand Russel had to say on these very elements—lyricism, beauty, elegance, and all:
Mathematics, rightly viewed, possesses not only truth, but supreme beauty—a beauty cold and austere, like that of sculpture, without appeal to any part of our weaker nature, without the gorgeous trappings of painting or music, yet sublimely pure, and capable of a stern perfection such as only the greatest art can show. The true spirit of delight, the exaltation, the sense of being more than Man, which is the touchstone of the highest excellence, is to be found in mathematics as surely as poetry.
What I appreciated the most about this book is the thorough and pragmatic approach taken by Debasish to weave three topics—each broad (and deep) in their own right—into a coherent narrative, copiously illustrated by high-quality code that you can load into your IDE (I used IntelliJ IDEA) and run.
Jonas Boner (Founder of the Akka Project) articulates this point really nicely in his Foreword to Functional and Reactive Domain Modeling in noting thatWhat captured me about this book is that it sets out on the rather bold mission of bringing together these three very different tools—domain-driven design, functional programming, and reactive principles—in a practical way. It teaches you how things like bounded contexts, domain events, functions, monads, applicatives, futures, actors, streaming, and CQRS can help keep complexity under control.
The magnificence of this book is nothing short of amazing. for any fellow programmer who has bludgeoned their head over how much math they need—specifically, category theory—to really grok how to use these mathematical concepts of category theory in their daily programming—and apply salve to your hurting head—this book is a balm 😅
I hasten to add that Functional and Reactive Domain Modeling will challenge you: It’s an incredibly idea-dense volume—yes, in an eminently mathematical and SNR kind of way—reminding me in many ways of the seminal GoF book that started quite the revolution in our industry when it was published in 1995. Here is Jonas again, gently reminding the reader in his Foreword to Functional and Reactive Domain Modeling that:
This is not a book for the faint of heart. It is demanding. But if you put in the hours, you will be rewarded in spades. Fortunately for you, dear reader, you’ve already taken the first step. All you have to do now is keep on reading.
Here is a link to the book’s accompanying source code, available freely on Github.
So if you are a fellow programmer who has bludgeoned their head through repeated, and dare I say, valiant attempts at grokking category theory, then you owe it to yourself to check out this splendid book.
Debasish is a prolific blogger, and I’ve followed his work, going all the way back to his fine volume on Domain Specific Languages (DSLs)—little languages, implemented atop conventional programming languages—and he has been graciously making us developers become more comfortable with the underlying conceptual (mathematical) machinery. I can think offhand to a fine post by Debasish: Does Category Theory make you a Better Programmer?
Don’t miss this book. It’s like the GEB (Gödel, Escher, Bach: An Eternal Golden Braid) of programming, in the richness of its content!
#5. Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka by Vaughn Vernon (Addison-Wesley Professional) 🚅
Let’s now segue a bit into the crucially-important topic of the actor model, which of course is essential to making reactive systems tick responsively to ever-burgeoning user demands. Understanding the actor model deeply will serve you well in grokking the art of designing reactive systems, and you’ll find in this book—Vaughn Vernon. Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka (Addison-Wesley Professional)—a terrific and gentle guide.
This book is a paragon of sparkling clear prose and unambiguous explanations of all things actor model, especially as they are related to making reactive systems evolve into their finest. As a tech type, this is the kind of stuff I crave for 👍
To appreciate the value proposition of this book, I invite you to spend some time poring over its Foreword. Here’s Jonas Boner again, this time articulating how this superb book will help you navigate the terrain of reactive programming. In particular, look for the pointer on how you are in store to find—in the pages of this volume—guidance on bridging the sometimes-perplexing chasm between actors and traditional enterprise messaging, by seeing actors in the context of building reactive systems:
When Carl Hewitt invented the Actor model in the early 1970s he was way ahead of his time. Through the idea of actors he defined a computational model embracing nondeterminism (assuming all communication being asynchronous), which enabled concurrency and, together with the concept of stable addresses to stateful isolated processes, allowed actors to be decoupled in both time and space, supporting distribution and mobility. Today the world has caught up with Hewitt’s visionary thinking; multicore processors, cloud computing, mobile devices, and the Internet of Things are the norm. This has fundamentally changed our industry, and the need for a solid foundation to model concurrent and distributed processes is greater than ever…
I’m really excited about Vaughn’s book. It provides a much-needed bridge between actors and traditional enterprise messaging and puts actors into the context of building reactive systems. I like its approach of relying only on the fundamentals in Akka—the Actor model and not its high-level libraries—as the foundation for explaining and implementing high-level messaging and communication patterns. It is fun to see how the Actor model can, even though it is a low-level computation model, be used to implement powerful and rich messaging patterns in a simple and straightforward manner. Once you understand the basic ideas, you can bring in more high-level tools and techniques…
This book also does a great job of formalizing and naming many of the patterns that users in the Akka community have had to discover and reinvent themselves over the years. I remember enjoying reading and learning from the classic Enterprise Integration Patterns [EIP] by Hohpe and Woolf a few years ago, and I’m glad that Vaughn builds upon and reuses its pattern catalog, putting it in a fresh context. But I believe that the most important contribution of this book is that it does not stop there but takes the time to define and introduce a unique pattern language for actor messaging, giving us a vocabulary for how to think about, discuss, and communicate the patterns and ideas.
In further amplifying and elaborating this theme, the author himself (Vaughn Vernon) notes in the Preface to Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka that:
Today, many software projects fail… At the same time, some notable successes can be found among companies that use Scala and Akka to push the limits of performance and scalability. So, there is not only success but success in the face of extreme nonfunctional requirements. Certainly it was not Scala and Akka alone that made these endeavors successful, but at the same time it would be difficult to deny that Scala and Akka played a significant role in those successes. I am also confident that those who make use of these tools would stand by their platform decisions as ones that were key to their successes.
My goal with this book is to make you familiar with the Actor model and how it works with Scala and Akka. Further, I believe that many enterprise architects and developers have been educated by the work of Gregor Hohpe and Bobby Woolf. In their book, Enterprise Integration Patterns, they provide a catalog of some 65 integration patterns that have helped countless teams to successfully integrate disparate systems in the enterprise. I think that leveraging those patterns using the Actor model will give architects and developers the means to tread on familiar turf, besides that the patterns are highly applicable in this space.
To boot, there is good humor sprinkled across its pages, pixie dust fashion 💥 I was ROTFL when I came across this jolly—embedded in the excerpt below—during my very first reading of this fine book:
As a parting caveat, I suggest you stay away from the complex libraries, such as scalaz, at least in the beginning. You won’t need to solve problems with libraries meant to satisfy a specific programming style. So, if Functor and Monad sound like viruses you caught as a child, steer clear of scalaz for a while. You will still be productive with the Scala language features you will review in this chapter and throughout the book. After you are grounded in common Scala, it would make sense to venture into scalaz and the “pure functional data structures” it offers, as well as other advanced libraries and language features.
I hasten to add that Scalaz is an awesome Scala library for functional programming. It is billed—very accurately, and modestly, so, if I may add—as providing …purely functional data structures to complement those from the Scala standard library. It defines a set of foundational type classes (e.g. Functor, Monad) and corresponding instances for a large number of data structures.
I also appreciated the book’s nice refresher entitled A Condensed Scala Tutorial. Another stand out quality of the Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka is the marvelously cross-referenced digital edition. Seldom have I seen cross-referencing done by a publisher to such great effect! (The only other book that approaches this lavish navigational finesse has got to be Programming in Scala: A comprehensive step-by-step guide, Third Edition (Artima Press) by Martin Odersky, Lex Spoon, and Bill Venners.
Here is a link to the book’s accompanying source code, available freely on Github.
Using IntelliJ IDEA, I loaded and ran the examples without the slightest hitch—Good stuff 😂
#6. The Tao of Microservices by Richard Rodger (Manning Publications) ⛰
Another brand new entrant to this select list that is the best in reactive programming books published to date is… a book on micro-services proper?! Now wait a second, what is a book on micro-services doing here, cheek to jowl with others on reactive programming proper? Tell me quick!
OK, first things first: Just to break the news, micro-services are crucial to doing reactive programming properly. Are we good now with the propriety, properness, and, in general, with all things proper, at least those having to do with the relevance of micro-services to reactive programming? Cool. We’re all set then to check this out!
Oh my, what have you got ourselves into here? No sooner do I plunk down my copy of The Tao of Microservices—its cover adorned by an illustration of the benevolently meditating beatific Emperor Reigen of Japan, the 112th emperor of Japan—than there is hushed silence. And what, exactly, is that owl (the one with its wings outstretched) doing there, seemingly making obeisance to… A blue pyramid-like object! What’s up with that? Well, hushed silence notwithstanding, it sure seems like prime for yoga! 💁
Hey, hey, now. Wait, yoga can wait… First, though, we’re going to chat a bit about—you guessed it—micro-services. Oops, my fountain pen is running out of ink; this one needs to wait (How about that for an excuse? Yeah, right up there with, “Sorry, but Fido ate my homework last night while I wasn’t watching.”)
Jesting aside, this is one awesome book; ignore it at your own peril. Oodles and oodles of hard-won industry wisdom and experience of a programmer—a really smart programmer—is what you will find distilled in the pages of The Tao of Microservices!
Enough said. Now start reading, and please don’t stop until, um, you see the fabled stop sign 📵 Wrap-up is next…
The Road goes ever on and on,
Down from the door where it began.
Now far ahead the Road has gone,
And I must follow, if I can,
Pursuing it with eager feet,
Until it joins some larger way~ J.R.R. Tolkien (from The Fellowship of the Rings)
Wrap-Up
So this is where we bring our journey to a close. I hope that our brief foray through the landscape of reactive programming resources has sparked your interest in this profound area; if you were already interested, but continuing to look for reactive programming resources, then I hope that these ideas will be of some use to you. Truth be told, our journey has only begun. And yes, you may go past the glaring stop sign at this time—traffic signs remind me of image processing which, in turn, brings back exciting memories of my research and dissertation on pattern recognition methods using neural network algorithms, back in the day, when I was a graduate student, based in College Station (Texas). But I digress 🌈
Final Word (Really!)
One last word—and don’t you be groaning now, like, here goes Akram again, cuz’ I ain’t gonna be droning much longer now—that I want you to take with you is the primacy of polyglot programming, which has permeated the fabric of the programming community like nothing I’ve seen (in over two decades of industry experience). So I invite you to broaden your programming horizons and check out some no-holds-barred programming languages goodies:
Should you be feeling adventurous this very moment—emboldened no doubt by a sip or two of that polyglot programming potion—I invite you to check out some more stuff, headier still (I’m telling you!) on programming paradigms themselves: When Object Orientation Met Functional Programming.
Bon voyage through the reactive programming landscape, as well as, of course, through the vistas of the elegant universe in which we dwell, reactive programming and all 🐳
