The future is already here—it’s just not very evenly distributed.
1. Intro 📬
As a card-carrying member of the reactive programming community—so I became a signatory several years ago on the Reactive Manifesto—I have put into practice its tenets plus seen firsthand the evolving landscape of our software industry reap the benefits of embracing the reactive programming paradigm.
And as someone who eats, drinks, and breathes the reactive programming paradigm, I’ve recently followed with great excitement something big—and I mean really big in terms of a brand new investment—unfold before my eyes over the past week.
Ever so often, we get to witness thoughtful industry leaders nudge our industry in exactly the direction in which it needs to go. These are leaders who, in addition to being in the vanguard of industry captains, also happen to be incredibly tech-savvy, having been there in the tech trenches themself and having made substantial contributions to the corpus of software deployed out there, software that undergirds the digital fabric of modern life.
Ah, and allow me to elaborate; I purposely chose William Gibson’s prophetic words atop (“The future is already here—it’s just not very evenly distributed“) to illustrate what I have in mind.
Read on to find out.
2. Released From The Shackles Of Constraints 🚀
In shepherding the brand new investment I referred to earlier, leadership has played a pivotal role in helping usher in the future of a “more-evenly distributed” reactive future.
It sure has got this technologist excited. Really excited.
Notwithstanding my propensity for, um, digressing at length when it comes to the vital topics that bedeck our professional world of software—and you are likely all too familiar with the passion that fuels me in this realm—I feel compelled to convey the impact of this move. So here’s the deal. With cloud native application development having become quite the ascendant rocket, which it deserves to be, this move is poised to show the world how things should—and will—be done, going forward.
Just to remind you, the sensible handling of currency in software development is paramount. It weighs heavily on our minds—much more so today than it ever has before—as we navigate our way through a multicore world. Nobody argues with that.
Then we throw some eventual consistency in there. And oh my, the fun we get to have. Nobody argues with that either!
And so it is that the reactive programming paradigm—it once used to be on the fringes of the programming community—became mainstream, having been widely and warmly embraced the world over.
It would be more accurate—and referring here to the heading atop this section—to say that several crucial software development constraints have been wrangled into submission. But that is oh-so Kafkaesque. So yeah, we no longer have to treat concurrency as the intractable, wild beast we had begrudgingly gotten to know concurrency as, and instead treat it on our terms.
How so? Glad you asked. We’ll meet you on the other side of the fabulous cantilever of a bridge coming right next up.
3. Building A Bridge To The Future 🎢
Glad you made it here. But, yes, the question looms as large as ever: How do we get there, as we travel along the reactive road? Well, for starters, a substantial body of knowledge has been assembled over the years, a good portion of which I’ve been covering here on this blog. For example, check these musings:
- The Reactive Programming Mindset
- Some More On The Reactive Programming Mindset
- A Bit About The Underlying Philosophy
So that’s how we do it.
Should you wish to arm yourself with even more knowhow, I suggest you check this out and get a fuller story.
Oh, and speaking of what I had earlier called a “more-evenly distributed” reactive future, I’m willing to wager that William Gibson’s prophetic words—”The future is already here; it’s just not very evenly distributed“—are finally going to see the light of day.
Let’s make this happen!
4. Unpacking The Phrase “Proactively Reactive” 💼
But first, we got some unpacking to do. And this has nothing whatsoever to do with our intrepid sleuth Tintin. You’ll spot him make a cameo appearance—standing atop a stack of tape-flags-aglitter books on a desk in my study—standing shoulder-to-shoulder with an admittedly oversized teapot, whose caffeinated content just might come in handy, should you wish to zip through those books in a sitting (or two).
Seriously, though, the unpacking I’ve got in mind has to do with those two words—”Proactively Reactive”—yep, the ones I chose for the very name of this essay.
So yes, instead of having me take you on a deep-dive through the offerings in the marvelous books stacked up above—and there’s many an oyster and other assorted treasures to be found in there—let’s settle for the distillation thereof, which I’ve done just for you, that distillation coming up over the span of the next four sections.
And while that pile of ragtag, tape-flags-aglow books may appear somewhat random, the hardcover standing upright (containing the erudite, collected works of America’s laureate of light verse, Ogden Nash) is definitely not random; it’s got a mission in life, and will serve a vital purpose in just a few. Stay tuned, won’t you?
So yeah, mentally prepare yourself to witness some unpacking take place before your eyes—remember, we’ll be unpacking that fecund phrase “Proactively Reactive” over the course of this essay—my aim being to model that unfolding on the graceful blooming of a rose under time-lapse photography.
Ah, one more thing: My use of the word unpacking may perhaps have led your fine logical mind to launch a reflexive exploration of the programming construct we know (and love) as destructuring. It serves a useful purpose…
But I digress.
5. A Community Of Growth 📈
When it comes to capturing the gist of evolving software architecture and design, all kinds of metaphors—cities, buildings, communities—have been bandied around over the years. All (generally) good, all (mostly) sensible. But to get to the heart of the matter, looking for the beauty in this all, let’s pause and think about the people behind the growth. Yes, exactly, communities of people are what principally matter. The engines of growth are squarely centered in that area.
So it is especially heartwarming to witness precisely this kind of leadership on display in the context of forging alliances which, IMHO, are destined to propel our industry forward in the relentless quest to keep moving in the right direction.
Put the right technology in the hands of the right people, in your cooking with gas. But what do I know?
Actually, I do know a thing or two (maybe even three!) And that—the heart of the programming paradigm I have in mind—is what we get to check out next.
6. Reactive Software Is Responsive 🚄
The crux of the matter when it comes to this aspect of reactive architectures is that software systems had better respond in a timely manner. Terrific responsiveness—zippiness if you will—translates into terrific usability. Even more so, when a software system is responsive, it means that problems get detected rapidly whereby problems can be nipped in the bud.
Well, guess what? All this translates into simplified error-handling, which, in turn, boosts the confidence of users. Think happy customers.
7. Reactive Software Is Message-Driven 🚁
I was initially going to name the section-heading above “Reactive Software Is Asynchronous And Message-Driven”. But it came across as unwieldy, a bit of a sprawl, shall we say. Come to think of it, let me ask you: Spatially speaking at least, ever heard of the venerable Mall of America, the largest mall in the US, being called not a mall but the sprawl?
But I digress.
While we’re chatting up my home state (Minnesota), and should you wish to find out what happened “One Winter’s Morning (in Minnesota)“, you can do so now. That’s quite all right, we’ll wait for you while you take that brief detour.
Ah, you’re back. Good. Let’s move right along.
8. Reactive Software Is Elastic 🍄
First things first: I don’t know about you, but I sure don’t want to find myself ever within a one-mile radius of the whale shark ahoy. Check the pic above. Methinks—at least judging by the supremely chapped lips of that lumbering oceanic giant—it could use some lip balm. I mean, ChapStick, Vaseline, something! Frankly, you would think that with all the megatons of water in the ocean deep, that whale could keep its lips moist. But oh no, ChapStick it is that its little heart desires.
And the mouth to which those lips are attached is demonstrably elastic. Ever witnessed a whale shark open its mouth—without any signs of stopping—to take in the plankton that is its primary diet? Yeah, that’s what the experts say anyway. But I ain’t taking no chances; I’m plenty happy to watch that ocean giant swimming from after, like really afar.
Anyhow, what I really wanted to say about this particular aspect of reactive software is that the goal here is to keep systems responsive under varying workload. This translates into dollars and cents: Reactive Systems can respond to fluctuations in user requests by increasing or decreasing the resources deployed to service those request. Yep, we get to have cost-effectiveness, on commodity hardware platforms.
9. Reactive Software Is Resilient 🐬
Ever seen a seemingly-dead, leaden landscape in winter come to life with the burgeoning of the spring season? So that’s what I had in mind in selecting the picture above. Hey, is anyone even noticing my thematic artwork—the painstakingly-selected public-domain pictures that I’ve endearingly framed in delicate borders after running each one through a filter—or will I again find myself tracing (yet again) the tracks of my tears?
While your tender heart attends to that matter, allow me to slip in a few words edgewise. For example, we in the reactive programming community aim for software systems to stay responsive in the face of the inevitable failures; they come with the territory of cloud native applications. Replication, containment, isolation, and delegation help us build resilience into systems.
Hmm… I wonder if that’s an aerial view of Wisconsin, the dairyland of America? Either way, if ever you wondered about the design philosophy that underlies and, in fact, powers every conceptual aspect of reactive programming, you positively need to read the next section—I heard someone say, “Don’t you let Akram start waxing philosophical about anything software-related, because we’ve seen for ourselves, many times over, how he can turn into an Energizer bunny every time he does that!”
10. Actors, or All The World’s But A Stage 🎬
Pure and simple, this is the marvelous realm of akka.io. Some have said that this is object-orientation done right. And I agree. Oh yes, it’s message-passing all the way down.
Since I’ve written at length on this topic elsewhere, it strikes me as most efficient to point you in the direction of one such musing.
11. Setting Sail For The Fabled Island ⛵
Are we there yet? Have we alighted on the fabled utopia of software bliss?
Well, it turns out that there’s no silver bullet, but we sure get closer and closer to finding it, to making it happen.
Oh yes. Wicked though the problems may be, we software practitioners are getting better and better at being prepared to take them on with increased confidence, thanks in (large) part to the principles and practice of the reactive paradigm.
It just so happens that the decidedly effective design methodology of Domain-Driven Design (aka DDD) fits hand-in-glove with the reactive paradigm; I’ve seen and done it for myself. In fact, a bunch has been written on DDD, with myself, too, having made some contributions to the practice and dissemination of DDD.
12. Reactive Happenings 📣
When it comes to rubber meeting the road, the reactive style of architecture has got rock-solid support in the Scala programming language. Don’t get me wrong: You can use just about any programming language—okay, maybe not assembly language—to support the reactive style. It’s just that my experience with Scala (over the past eight years or so) has got me convinced me that Scala is a match made in heaven when it comes to making the widespread adoption of reactive architectures a reality.
The Reactive Summits are awesome events where the reactive community comes together in person. Most recently, I attended Reactive Summit 2017 (in Austin, Texas). It was a blast. Next up, I was getting ready to attend Reactive Summit 2018 (in Quebec, Canada) but ended up going to another awesome event (Open IoT Europe 2018), where I also had a blast, which I chronicled here.
Returning to the present moment, I’m genuinely excited by what I earlier referred to as leadership on display, leadership and alliances that are poised to help usher in the future of a “more-evenly distributed” reactive future.
It is my fond hope that I’ve managed to convey the essence of how the call of cloud native application development—a style that’s becoming increasingly pervasive in our industry—will be answered by reactive architectures, ably guiding us in a multicore world.
Is there something you can do?
Oh yeah, and glad you asked. Check the billboard coming right up on the horizon as we barrel down the road. And we’ll meet you on the other side (of the billboard, of course).
13. Go Ahead And Sign That Billboard 🔦
Aha, so that was just to grab your attention—and what better to do that than by making mention of those ubiquitous billboards that line your typical roadside. And no worries, I’m going to make this easy for you: No need to brace yourself for the formidable climb up the billboard scaffolding, with or without the help of that rather rickety and precariously perched 20 foot ladder!
All you have to do is head over there and have a look at the Reactive Manifesto, and then embellish it with your lovely signature. That’s all. See, didn’t I tell you I was going to make this easy?
14. And Witness The Transformation 💰
So this one you’ll just have to experience for yourself to see what I’ve been getting at over the span of this essay: Embracing the reactive paradigm will garner spectacular results when it comes to achieving your software development goals.
It’s been said that “The best way to predict the future is to invent it“. With the best practices, scaffolding, and infrastructure—for all things reactive—in place, you have but to take the next step and try it out for yourself. Much as I said above, this one you’ll just have to experience for yourself to get the full import.
It will be well worth your while!
Wait a sec, and speaking of the future, what in the world is that futuristic behemoth of a whale—goodness, it is a whale, and of the Star Wars kind, too—doing here, coming into our view right next up? This isn’t quite what I had in mind when I quoted a minute ago about how “The best way to predict the future is to invent it“.
Methinks I need to revisit my formula for blending OO and FP, or something.
But I digress.
15. Swimming With The Best 🏄
How many scientists have written
The shark is gentle as a kitten!
Yet this I know about the shark;
His bite is worser than his bark.
~Ogden Nash (in his uber-light poem, The Shark)
As we call it a wrap, and this is especially for those of you who had earlier taken in the sight of the ragtag stack of books on the brown desk in my study and perked up—even more so, in fact, by the sight of the hardcover standing guard over the stack, holding between its two sturdy covers the collected works of America’s laureate of light verse, Ogden Nash—your moment has finally arrived.
So let’s see, with your having taken a peek at Nash’s erudition, by way of the splendid poem quoted above, what do you think? Are you still game for taking a dip in the ocean with one of those lumbering giants swimming a few feet away?
Speaking for myself—and should I somehow end up in the maw of that oh-so gentle giant above or, for that matter, the one cruising in the picture below, though it really doesn’t matter which one of the two—it’s going to get a tad complicated to do my reactive designs and programming from in there. I think I’m good with (and especially on) terra firma.
I wish you every success on your reactive journey. Do please write back. We all would love to hear from you!