Upon reflection, I’ve come to realize that the relicensing trend towards non-compete licenses has exposed single-vendor Open Source software for what it truly is: proprietary software in hiding (or neo-proprietary, as Dirk Riehle said a few years ago). This post will go into detail on how I came to this conclusion.
The backstory
All relicensing stories are built on the same narrative around Open Source. A story that goes like this:
At the dawn of the computer age, software was not considered valuable, it was all about the hardware. Very expensive proprietary machines would be sold, but the people using those would develop the software running on them as a commons and share it freely.
The 80s and the rise of the PC made the hardware more and more of a commodity, and that made the software more and more valuable. Software companies like Microsoft were created and with it the proprietary software approach: A single entity owns the software that is produced, and that entity intends to capture all value that derives from the software, thanks to restrictive licensing conditions.
That approach led to a lot of excesses, especially as Microsoft decided to exploit that dominant position. Openly-developed Open Source software grew in the 90s in reaction to this evil proprietary approach. In this model, software is produced as a commons by a community of organizations and individuals openly collaborating, and value is shared among the participants in the community. This is all made possible thanks to free and Open Source licenses which guarantee a number of freedoms, like the freedom to build on it without asking for permission, and the freedom to use it for any purpose, including making money.
In the next 20 years, Open Source got overwhelmingly popular and unleashed a software revolution. A recent study by researchers at Harvard Business School estimated the demand-side value of Open Source software to be $8.8 trillion! In other words, without Open Source, companies would have to pay 3.5 times as much for software than they currently do. It’s estimated that 96% of software contains an Open Source component. Developing new software today without using any Open Source would be a pretty challenging endeavor.
Like everyone else, companies that produce software massively adopted Open Source. They leveraged tons of libraries and software produced as Open Source, they benefited from not having to ask for permission before innovating and used those freedoms to write their own software. They released the end product under an Open Source license and they vouched they would forever be Open Source. We called their software “single-vendor Open Source.”
With the internet becoming more ubiquitous, some of those also turned to a software-as-a-service (SaaS) monetization model. But with the rise of the cloud, hyperscale public cloud companies also turned to providing Open Source software at scale, and that’s seen as unfair competition for those small Open Source software companies using a SaaS model. That means today those same companies say that while Open Source is good for initial visibility, it’s bad for monetization. It’s bad for business. As is, Open Source is not business-friendly, so they need to invent new licenses to continue defending openness against evil proprietary software while making a living. They still provide access to their code for free and in some cases, those licenses transform into real Open Source licenses after a few years… What’s not to love?
Three misconceptions
The last part of this narrative is built on three misconceptions worth deconstructing. First, it’s built on the idea that Open Source is great because you don’t have to pay for it. So if you preserve that aspect, all is good. The trouble is that Open Source is not great because you don’t have to pay for it. Open source is great because everyone is free to use it. It’s a subtle distinction: Cost is definitely a factor in your freedom to use Open Source. But this goes beyond monetary barriers: What matters is not having to ask for permission. Just use it. Anyone, anywhere, to do anything. Not just people with deep pockets and not just the ones in certain countries.
This permissionless innovation has enabled a ton of valuable software (itself often released as Open Source), which fed into the virtuous cycle that we benefit from today. The non-compete licenses some companies come up with restrict you from doing anything with the software that they disagree with or consider “competition,” under pretty vague and untested legal terms. The result is that it ends permissionless innovation: you can no longer just use it.
The second misconception is that single-vendor Open Source is, somehow, the reasonable and business-conscious way to do Open Source. You should be on board if you want Open Source to win against proprietary software. But those companies are still doing what is, essentially, proprietary software: like the proprietary software companies of the 80s, they very much consider the software being produced as their exclusive property. They still intend to capture all the value that derives from it. And thanks to copyright aggregation or permissive licensing, they still can change the license any time they want. So it’s still proprietary: they just choose, for now, to release their software under an Open Source license.
Single vendor isn’t a reasonable way to do Open Source and resist evil proprietary software. It’s just another way to do proprietary software. It’s just a relicensing time bomb. And sure enough, a lot of those time bombs exploded over the past year. The proprietary development model is moving back to restrictive licensing, in a predictable attempt to capture incrementally more value. This was predictable if only we had seen single-vendor Open Source as the temporary tactic of proprietary development that it always was.
The last misconception is that proprietary software is evil. This whole rationale wouldn’t hold if we didn’t demonize proprietary software in the first place and opposed Open Source and proprietary. But, as we’ve seen, you can be proprietary and do Open Source as a temporary tactic! So it’s not as simple as Open Source vs. proprietary.
Here’s what it looks like in quadrant form:
On one axis, the license used is either Open Source (as defined by the Open Source Initiative (OSI), which I would summarize as coming with all freedoms necessary to enable the permissionless innovation I mentioned earlier) or it’s not. On the other axis is the development model: it’s either developed as a commons, by a community working in open collaboration, or it’s developed (and ultimately owned) by a single entity.
What we’re seeing today is that proponents of the proprietary development model are abandoning their Open Source licensing tactic and are moving back to restrictive licensing. They hope they can retain enough aura from their Open Source days to hide the fact that it’s just restricted software and pretend to keep the fight for openness against evil proprietary software. But proprietary software is not evil. It’s just inferior.
Anyone who truly thinks that software developed by a diverse set of actors working in an open collaboration is not better should just adopt the proprietary model. But they should be honest about it. True evil lies in deception and hypocrisy: Claiming openness while practicing proprietary tactics (openwashing), diluting the meaning of Open Source by creating deceptively-named restrictive licenses (like “Commons Clause”) or switching licenses from under your community after having promised, like Hashicorp, to remain Open Source forever.
A call to action
It’s time to remind everyone that the permissionless innovation they benefit from can’t be taken for granted. It’s a direct consequence of the prevalence of Open Source licenses, as defined by the OSI. And it requires all of the Open Source freedoms, including the freedom to use the software for any purpose.
It’s time to fight back and describe what a world where the relicensing proponents win would look like. If their vision wins, if everyone adopts this approach, all the innovation that Open Source freedoms allowed to unleash would come to a halt and we’d quickly be back to where we were in the 80s.
Imagine a world where you have to ask lawyers for permission before using any library, or any programming language! They’ll say for some licenses it automatically becomes Open Source after some time, so it’s not a big deal. But that’s a trap, too: Imagine a world where you have to run a buggy two-year-old version with known vulnerabilities because that’s the Open Source one.
Finally, it’s also time to reassert the value of software developed in an open collaboration. Everything else is proprietary. Everything else is a relicensing time bomb. Beware of Contributor License Agreements (CLAs) when they are not held by an openly-governed non-profit. Beware of single-vendor Open Source software, it’s a proprietary development model that happens to temporarily use Open Source licensing. So yes, let’s all agree: Single vendor is the new proprietary.
General Manager at OpenInfra Foundation, and Vice-chair at OSI.
