The MetaComputer™ (Part "Why" of 3)
It’s been a quite a while since I truly enjoyed programming at work. Don’t get me wrong. I like wrangling with code to make interesting stuff happen. The problem is that for a long time now, making interesting stuff happen with code hasn’t been the end game. Since the last ten years or so, it’s become incredibly more complex to get finished code to start working in the real world (aka production). Some say it’s because we OD’d on microservices. That probably true but there’s more to it than that alone.
The MetaComputer™ (Part "What" of 3)
In part “Why” of this series that appeared previously, I talked about the need for a new computing model that simplifies modern cloud-native distributed application development. In this part, I’ll go into some details of what this new computing model should be and what it should provide.
The MetaComputer™ (Part "How" of 3)
In the previous articles of this series, I talked about why we need a new computing model and what that model should look like. The “why” was pretty clear – we’re drowning in accidental complexity while building distributed systems. The “what” painted a picture of a unified computing environment that makes building distributed applications more tenable. Now comes the challenging part – how do we get there?
Starting at the Foundation
When you’re building a skyscraper (yes, I’m bringing back that analogy from Part “Why”), you don’t start with the penthouse. You start with the foundation. In our case, that foundation is a programming model that treats distributed computing as a first-class citizen rather than a bolt-on addition.
Ritchie, A Distributed Programming Language
If you drive a car, you might know that most of the complexity of driving is with the traffic, i.e. the decisions you make in response to your environment. Controlling the car itself is very simple. You have a slow-down pedal, a speed-up pedal, a turning wheel and a drive mode (PRND) selector.
Yet, beneath this simplicity, a car is a very, very complex system. There are tens of thousands of mechanical parts in a car, several thousand of them in the internal combustion engine itself, that easily do a few hundred million revolutions of the crankshaft over the lifetime of a car. You don’t need to know about it because collectively the automobile industry has figured out how to build a car so easy to use and so reliable that it would work faultlessly with nobody having to maintain it beyond a couple of hours every year.
The automobile industry has pared down, distilled and improved the driver operations to the minimal 3-control model over centuries.