When the first mainframes were running businesses seven decades ago, software was an afterthought. The real, differentiated and thereby commercial value lay in the design and construction of the hardware – everything from the processor to the storage. Thus it was that the SHARE user group was afforded access, by IBM, to the source code for the operating systems that ran this hardware, which in turn enabled its members to distribute amongst their number fixes, patches and other improvements in a process that today would be called open source but that lacked that descriptor at that time.
Over the course of a few decades, that value inverted. Hardware became cheaper and easier to manufacture, while the complexity of software, and the attendant difficulty of producing it, accelerated at an increasing rate. That difficulty, combined with the increasing importance of and reliance on software, meanwhile, generated almost from whole cloth unanticipated and arguably unprecedented financial returns for large software franchises – franchises, importantly, that were proprietary, not shared amongst its users. And franchises that remain with us today.
But for the uncoordinated and unplanned actions of an assorted number of frustrated software authors and users who unwittingly spawned a movement in open source that upended, enabled and transformed the technology industry as we know it, the world would yet be one of proprietary software. That was the world, after all, that made economic sense, the only kind of sense that groups like investors understand. Software is difficult to author, ergo it must command a singular return for the entity that authored it.
That is not, of course, the world we live in. Software developers the world over have found it more efficient and generally preferable to work on software in the open, that can be shared, modified and reused according to a largely codified, understood and accepted set of rules.
Over the past two decades, the technology industry has accepted this developer-led reality, against its better judgement, or more accurately against the judgement of its most aggressive investors. Startups and large software vendors alike found ways to bend or even break their existing software development models to accommodate the unflinching and relentless demand for open source software by software developers.
Thus was the status quo for a few brief years.
Eventually, however, investors’ appetites and agitations led to a strategy in which the gains open source had made could be clawed back. Countering the wishes of developer populations in this way would have been unthinkable even a few years ago, but an apathy from developers that had recently come of age in a world in which open source was the boring default rather than something that had to be actively fought for and thus took it for granted instead left these investors feeling empowered. At the heart of their strategy was an approach that sought to redefine open source, to blur its definition to such an extent that it could be plausibly portrayed as open source while being, in practice, proprietary software. Specifically, this involved the creation of a new class of licenses, one which looked like open source – and in which the source itself was available – but which came with the kinds of restrictions that legitimate open source projects explicitly forbid.
From an investor’s perspective, this is the equivalent of having your cake and eating it: it looks like open source – and there have been investors and portfolio companies that have actually referred to it as open source – and thereby can theoretically win over developer populations, but commands the returns of proprietary software. Such as they are these days, anyway, in a world in which the commercial value of software overall is in decline.
The challenge, however, is that while developers aren’t overly particular about open source licenses – the overwhelming majority of projects on GitHub, for example, carry no license at all – they tend to advantage true, understood open source licenses. This, in turn, has forced investors to adapt their strategy, which they have done. The new approach is a two part strategy which, boiled down, is a version of what the retail world refers to as “bait and switch.”
The first phase is one in which a given project is released into the world with a legitimate, OSI approved software license. It competes in the market with other, similar projects and it succeeds or fails on its merits, or more likely, the hundred other ancillary factors that are, in the aggregate, more determinative than its merits. But the license, at least, is no impediment, because it’s recognized and accepted open source, and more often than not these days, a permissive license carrying minimal restrictions for the developers that use it.
The industry itself, and the developers and enterprises that occupy it, are the proving ground for these projects. When a given project begins to succeed, or at least establish a level of enterprise traction that represents realizable commercial value, investors home in on this opportunity. The problem, however, is that their opportunity is non-exclusive. Open source licenses, after all, offer the same equitable terms to all players, and limit neither competition nor usage. This being less appealing from an investor’s perspective than the virtual monopoly offered by the old proprietary model, they approach the project’s backers with a proposal: retire the open source license in favor of this new class of license.
For many software authors, the arguments are simple and persuasive. The new class of license limits competition and usage, and in doing so can inflate revenue, which in turn can be applied to growing the project. Never mind the fact that the projects were already growing quickly, and in many cases allowed the commercial arm of the project to go public – that’s what attracted the attention of the investors in the first place – shouldn’t software authors be fairly compensated for their hard work and effort? Was it fair that users – the number of which might include large, wealthy companies – benefitted from the labor of software authors for no compensation? Just make this one, simple change, the investors argue, and you’ll make more money and we’ll make more money, and besides: the source is still available. Some of the licenses created by these investors even magnanimously allow the covered software to graduate to open source after a period of several years, which seems like generosity itself but is in fact allowed because the investors know that the value of software that is several years old is zero.
This is the new industry approach, and the new industry approach is a dead end. Not for the projects, of course. While there are instances in which a relicensing action has temporarily shaved off billions in market cap, once a project has hit a critical mass of usage – as the investors and their boards are aware, the upwards trajectory of the software is difficult to arrest.
For the industry as a whole, however, this approach is a dead end. Open source was once the industry default, and developers and users alike benefitted immensely. Proprietary software took that all away in less than twenty years for more than twenty years, and it was only through an immense and unlikely set of events that proprietary software’s grip on the industry was rolled back.
If we normalize projects baiting developers with an open source license to gain traction and switching to a non-open source license to monopolize the returns on that traction, then the logical next step for investors will be skipping that first step entirely.
And that, for the industry, is nothing but a dead end.