June 27, 2018
Exploring the Progression of Modern Software (Part 1)
I wrote recently about learning from the past and I’ve spoken about it on a podcast a couple of times about the lessons we can learn from looking backwards as we prepare for moving forwards. And as I try to limit my future-thinking in my writing (hence, the What’s Ahead Wednesday series) I think about putting my own comments into practice. What does it look like to examine our past as we set our sights on tomorrow? What can we learn? More importantly what trends can we see which when extrapolated allow us to predict the future.
In this post I want to share with you what I’ve found to be one of the greatest personal revelations on this topic. I was talking about this with a friend the other day and the notion dawned on me mid-sentence. After I finished I went home and I mulled over it for a while. I rolled the idea around and I played with it, massaged it, worked on it. What follows is my first pass at articulating it. Is it complete? Absolutely not? Is it perfect? Far from it. But perhaps the act of writing my ideas down and sharing them will trigger your thoughts. Maybe it will start a conversation. Maybe the future starts right here.
Side note: If the sentiment in that paragraph above appeals to you, then you might love one of my favorite books of all-time. Before you think I’m going to recommend a 600 page tome for your weekend reading assignment, listen closely. The book is called simply, “What do you do with an idea?” I’ve shared this book on my blog in the past, used it as motivation when speaking at conferences, shared it at Mautic more than a few times, and I recommend it to everyone. If you don’t have a copy – buy one. Today. In print.
Examining software’s historical progression
Now, I always hesitate before sharing some of these thoughts because I fully recognize what is about to occur is a gross generalization of the fully history. And I also hesitate knowing the vast knowledge and personal experience many of my reader’s have in this space. Many who have knowledge far beyond my own. To quote another, “I speak as a fool” or at least suppose myself to do so. With that very strong word of caution, here is a rough generalization of a thread of continuity I can see occurring as we explore the historical progression of software development over time.
The Personal Computer Era
Things began on a computer, a single computer. Systems were stabilized, functions formed, and programs proliferated. All within the box of a single machine. Advancements were made to increase the CPU, the RAM, the motherboard, but all the software was created to live and run within the beige box sitting atop a desk in front of the user. This was single location software.
But this environment did have a few benefits as well. In addition to being easy to update (usually a floppy disk with the latest version), the user had full control over their information and their data. Nothing left their computer unintentionally and very little left intentionally. This meant these single-location software systems were private. The user data was stored locally and used locally. This closed data system was by its very nature private.
There’s an additional benefit to single-location software. Usually (of course there are exceptions to the rule) this software is secure. Whether this comes from the environment as a forced, by-product the outcome is the same. Software in this stage was typically considered more secure. Hack attempts existed, but they took different and more complex forms with higher level of effort.
Three Word Summary: Single, Private, Secure
The Server Era
The next step in our software evolution saw the migration from single-location software based on a user-computer, to a many-location software based on a server, or server cluster. I realize we’ve taken a giant step forward, we’ve passed by the smaller step of single-location software in the days of the early internet. This was transitional phase (to use the evolutionary term). And although unlike evolution we still see very clear examples of this transitional phase living today, they are far-and-away the minority. As a result, I suggest this next step in modern software progression is the creation of a many-location software system.
Just as with the original, box, single-location software we started with; here to there are a few benefits and detriments which accompanied this shift. While the highlights are evident (faster processing time due to volume and access of high-end compute power, immediate global accessibility, instant updates, constant availability, etc…) I will focus on two other factors which represent shifts from the previous stage.
In juxtaposition to the single-location computer-based software from the early years, server-based software is at best considered to be semi-private. In most cases you might even argue this software is less than semi-private and inclined more to be semi-public. The user’s data is available to the user, but, owned by the software system. This is a major shift from previous. If the data is no longer the users’ then it is by definition no longer fully private.
Finally, in our current stage we are also seeing these many-location server-based software systems are considerably less secure. One need only look to the headlines within the last month to hear multiple stories of data breaches. As the software systems in this era continue to hoard data they exponentially increase the size of the target for malicious attacks on their software. Even though these companies attempt to provide constant fixes and updates and improved security, the bottom line is evident: This server software is semi-secure.
Three Word Summary: Many, Semi-Private, Semi-Secure
The Decentralized Era
Finally, this allows us now the opportunity to begin to explore the future. Currently we are living in the end of an era. We are watching the archaic SaaS dinosaurs of today’s data-driven economy falter. I would be so bold as to suggest we are on the cusp of an event. I believe we will soon see the software equivalent of the Cretaceous–Paleogene extinction event. This is a bold statement, but consider this: if we lived in the age of the dinosaurs, would we have seen it coming? More likely we would have scoffed in the face of such mass extinction! Who could imagine this destruction given the sheer size, considerable strength, and ultimate dominance of such magnificent creatures! (And yet here again, history appears to repeat itself.)
The exact path we take remains to be seen. However, I believe there are two potential paths, but both lead us to the same outcome. First, we may see, as in the age of the computer to the age of the server, a transitional step form to bridge the gap from here to the future. Or we may have some event dramatically shift the landscape overnight. I can’t say for certain which will occur but I’ll share my opinion as I alluded to earlier. I believe given the size, dominance, and control exerted by the existing server-based software companies who are enjoying life as is and don’t see the value of a further evolution (again, this can be identified based on what motivates or drives them – aka, how they make money) the only logical path involves a cataclysmic, seismic shift in the landscape and the economy.
Regardless of the exactitude of the path, I believe the outcome remains consistent. Based on our history as we’ve defined it below we can extrapolate what the idealized future might look like. In this case we’ll start with the three word summary and work backwards.
Three Word Summary: Many, Private, Secure
The next logical progression of modern software takes the best of every past iteration and era of software. This means we should expect to see a many-location software platform, both private and secure. And if that definition doesn’t immediately strike a familiar chord then I’d recommend reading more on the subject of the decentralized web. These are just a few of the core tenants of this software philosophy.
Many-location refers to an expanded and improved upon implementation of the current age of SaaS server-software. This is the natural next step in the following progression: single computer, single server, single-provider cloud, multiple-provider network.
Private refers to the location and storage of the data. This can be done separately and distinctly from the software provider. This point also includes a multitude of encryption possibilities, blockchain stored sovereign identities, and so much more.
Secure refers to the trustworthiness of the software, a decentralized software allows for trusted, verifiable software solutions. Smart contracts and immutable ledgers add an unprecedented layer of security to this decentralized software future.
To be continued…
I did it again, and I apologize. I didn’t mean to go this long and the hardest part is I’m at exactly halfway through the explanation of this theory. I believe there’s a second piece to the puzzle. An equally satisfying piece which fits perfectly into the picture and reinforces the original thesis statement. I hope this has intrigued you and caused you to think about what this future looks like.
What do you disagree with? What do you find compelling? Have I missed anything which might further substantiate this line of thinking? Let me know! I’ll post the next installment soon!