Ten years ago this August, Marc Andreessen made his famous declaration that “software is eating the world.”
In the decade since, the “dramatic and broad technological and economic shift” that Andreessen illuminated has only accelerated, disrupting nearly every industry and transforming our daily lives.
If software is eating the world, open source is the kitchen where the meal is prepared. Without open source, it’s impossible to imagine innovations such as cloud computing, artificial intelligence and the Internet of Things (IoT), or innovators from Amazon to Zoom.
Thanks to open source, businesses can freely download high-quality source code and flexibly adapt it to their own needs, without constantly building everything from scratch and sans the cost and licensing frictions of proprietary commercial software. No wonder 99% of enterprise codebases are reported to contain open source components.
Open Source Challenges
Nothing is perfect, however, and open source’s popularity also has brought a downside for enterprises: a tough array of software management challenges.
While it’s certainly easy for organizations to acquire a tremendous amount of useful open source software, many companies then struggle with complexity in operational tasks such as onboarding, integration, patching and upgrading all that software.
In a way, open source adoption is being threatened by its own success. A huge amount of outstanding software is being published across the industry, coming from tech giants and tiny startups, and organizations have proven eager to consume it. But these operational hurdles are hindering many companies from realizing the full benefits of open source.
The entire promise of a software-defined landscape is greater agility in everything a company does, from improving the end-to-end digital experience with customers to better serving employees. Businesses can’t allow software complexity to stand in the way.
Yet when one looks across the enterprise computing spectrum of public cloud, private cloud, micro clouds and IoT, that is what’s happening. The number of moving parts keeps growing exponentially.
For example, one trend in particular – the shift away from monolithic applications and toward microservices (collections of independently deployable services that can be more easily developed, tested and modified) – has dramatically added to the management burden.
In a single cloud deployment, an organization may be managing a stack of several technologies – OpenStack, Kubernetes, data lakes, machine learning infrastructure and transcoding, to name a few.
The organization must deal with a plethora of head-spinning technical pain points: application-specific configuration file management, app-specific update and upgrade processes, app-specific packaging, app-specific networking, scenario-specific configuration, service dependency mappings, custom integration code, layer admin segregation and substrate-specific behaviors.
The list goes on and on. And each task must be tuned and tweaked for the specific public cloud an organization is using.
Consider that a billing database in 2005 may have required three pieces of software on two machines to be integrated. Now, that same function may have 20 pieces of software spread across 60 machines. Each has to be configured, integrated, patched and upgraded – a massive explosion in complexity.
So what’s the answer? What should enterprises be doing to reduce this inefficient operational complexity?
The answer lies in automation technology that can handle the skyrocketing number of application lifecycle management chores that have become a natural byproduct of the open source-driven, software-defined world.
Operational packages that can automatically handle software installation, configuration, updating, scaling and patching saves time and money across organizations, industries and almost any application scenario.
Instead of needing to understand each function in detail, model-driven operations handle all the work without the need for human intervention.
As software continues to eat the world, we can’t allow software complexity to block innovation. The solution is to, in effect, let software eat software.