In the long run, GPL code becomes irrelevant.
I wrote this in response to a comment thread on hackernews Defending GCC considered futile. There's been a megathread in the last week about whether Emacs should support LLVM, with Richard Stallman and now Eric Raymond joining the frey.
Personally, I use a BSD license for all my code and contribute to BSD/Apache licensed software whenever I can. I do it because I think opensource will eventually eat the world anyway, and I think when it does a BSD/Apache implementation of any given piece of software will emerge as the victor.
With evidence from history, I'm convinced of these two claims:
- Given enough time, many high quality opensource version of every useful piece of software will be written. Particularly amongst infrastructure code (kernels, databases, compilers, libraries).
- With enough time, any sufficiently large company can implement their own version of any software that anyone else has written. They usually won't write their own version if a high quality opensource version exists with a permissible license.
With this in mind, if your eventual goal as an opensource developer is to have a working opensource ecosystem & software stack, we're going to get that regardless of our license choices. (Which is great news - we're going to win anyway! YAY!) For most parts of the software stack, this is already true. I suspect >50% of the code running on my mac laptop to help me write & post this is opensource code. That number has and will keep going up over time as opensource software improves. On the server the number is well over 90%.
The GPL strategically leverages a monopoly of technological superiority to push the goal of software freedom. Its quite clever, because it feeds back on itself to in turn maintain its own technological dominance. There is a cost on developer freedom, but in the long run, the idea is that the GPL version will maintain technical dominance through coercion and keep user freedom by using that technical dominance to outcompete in the marketplace.
The flaw is that in the long run, it keeps getting easier to write software. And people love reinventing the wheel. Look around you - any useful software problem has lots of implementations. Databases are my go-to example at the moment, because holy cow there are so many! The implementations are usually licensed with a mix of GPL, BSD(/Apache/friends) and proprietary. All implementations will try and compete on features, but the value of additional features decreases over time as a software category matures. (I'm sure there are ways in which Chrome is better now than it was 6 months ago, but despite being a web developer and using it every day I couldn't tell you what the changes are).
How do the licenses help and hinder the implementations?
The first thing to note is that at this point, the GPL license does nothing for users. In any category at this stage in development, users have lots of great opensource choices if thats important to them. But the GPL is still annoying for me as a developer - I'm restricted in my choice of what I'm allowed to do with the code. (Is static linking to non-gpl code allowed? Is dynamic linking? Do I need to opensource my custom
config.h?) And god help me if the code I want to use is GPLv3 licensed or I work at a large company - I might have to get legal signoff.
Meanwhile the proprietary implementations simply can't compete against good quality GPL/BSD versions. The opensource code is free and can be edited to suit developers' needs. People are more likely to use free software for hobby projects, so its easier to hire people who know it.
Any BSD/MIT/apache version has none of these problems, and as a result it simply has better survival characteristics than either GPL or proprietary implementations.
There's another feedback loop here - the version that gets used by companies will sometimes get patches back from said companies. Its cheaper to submit patches than maintain a fork. But companies generally prefer a BSD/Apache version over a GPL version for legal reasons. Sure - lots of companies freeload. Thats ok. But the companies which do contribute contribute vast amounts of resources, overwhelmingly to BSD/apache licensed code.
This process has already happened to databases, web servers, most programming languages and web browsers. Once you notice this trend, you see it everywhere.
This trend is happening right now to C compilers - slowly but surely, LLVM is eating GCC's lunch. For legal reasons LLVM was more palatable to Apple and now they fund it. In an attempt to preserve the GPL's constraints, the GCC project refuses to accept patches which would expose its internal parse tree. This is inconvenient for everyone. So more developers and more corporate money is funnelled into LLVM - which is a feedback loop increasing its quality and its adoption.
There's two big exceptions. The first is Linux, which still manages to keep its technological dominance by having such a killer engineering team. That and because a high quality kernel is harder to write than most other software. There's also cloud services with high infrastructure costs like Google search and Facebook. I think its too early to know what'll happen for that category of software. Opensource implementations need to rely on efficient, secure distributed databases to replicate the features and I don't think we're there yet technologically.
So to sum up, we will have our user freedom eventually anyway. As a developer there's only two remaining questions:
- Do you want to write an implementation people are using in 15 years' time?
- Do you hate any corporations enough to want to forbid them from using the software you write? Windows used NetBSD's TCP/IP stack for awhile. Are you ok with that happening to your opensource codebase? Is this distasteful enough to hurt your own project?