# Exploring the Progression of Modern Software (Part 1) By [dbh.eth](https://paragraph.com/@dbh) · 2022-03-14 --- 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?](https://www.amazon.com/What-Do-You-Idea/dp/1938298071)" \*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](https://en.wikipedia.org/wiki/Cretaceous%E2%80%93Paleogene_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._) > Two PathsThe 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! --- *Originally published on [dbh.eth](https://paragraph.com/@dbh/exploring-the-progression-of-modern-software-part-1)*