Copyleft is dying
Software licensing is the catalyst that drives the modern tech industry. This is because reusable software code released under an open source license (permitting its reuse) is the norm for nearly all software development today. After all, if we couldn’t reuse existing code in new software projects, it would take far longer to bring technologies to market, and the overall software industry wouldn’t be able to evolve as quickly. Moreover, there are two major types of open source licenses.
- Copyleft licenses vigorously defend the freedom of the software. If you reuse copyleft-licensed code, your software and its derivatives must make any modifications publicly available (among other restrictions). Copyleft is the oldest open source license type and was designed to prevent large corporations from ripping off code and modifying it for profit without giving back to the community. Linux uses a copyleft license for this reason, and probably always will.
- Permissive licenses place far less restrictions on how you can use the code in your software. While there are many different permissive licenses out there, they all encourage others to reuse the code first and foremost, and have few (if any) restrictions on derivative works. In other words, permissive licenses promote adoption in other projects over software freedom.
In other words,
- Copyleft = If you use this code, you must satisfy our license requirements to keep this code free, including derivative projects, forever and ever.
- Permissive = You can freely use this code in your projects (read the fine print for any minor restrictions, but there are probably few).
In the early days of open source software (1980s-1990s), the software development community rallied against the big proprietary software giants using copyleft licenses. This copyleft-focused community led to the proliferation of Linux and the ultimate success of the open source movement. In fact, the community was more important than the actual copyleft license, and this theme has persisted in the tech world since. If you can build a community, you’ll have the momentum to do anything. It’s the community that supports and drives the adoption of technology today.
Large software corporations still exist today of course, but they leverage the power of open source and focus on building communities that ultimately serve their purpose. Plus, the nature of software development today is very different than in the 1990s. Nowadays, complex cloud software backends interface with the frontend apps on your computer, phone or device, and both ends are often built using a tremendous amount of open source code.
But this open source code almost always uses a permissive license.
Why? Because it’s much easier to build a community when the software code you’re reusing has a permissive license that encourages both contribution and spinoffs. If you use a copyleft license, you’re going to turn away a lot of contributors, and others are far less likely to reuse your code, especially companies with deep pockets that can really build your community and thus accelerate the evolution of the technology. For example, the permissively-licensed LLVM compiler has more developers, users and features than its copyleft counterpart, GCC. It’s used by many of the largest tech companies, including Apple (who also spent considerable resources on its development).
Furthermore, technologies that have a restrictive license (e.g. proprietary or copyleft) encourage others to create a competing technology that uses a permissive license, such that it can be easily incorporated into future projects. For example, the KDE desktop’s restrictive Qt library license led to the development of GNOME, and the restrictive license of BitKeeper led to the creation of Git. Never heard of BitKeeper? Don’t worry, it’s nothing worth noting nowadays.
So, copyleft licenses don’t have a lot going for them in the software world today. They are still important, but not for smaller software components or frameworks, where adoption is necessary for continued use. Platforms where software freedom over a long period of time is valuable are more likely to adopt a copyleft license, but the developers face an uphill climb when it comes to building a community that allows the software to persist. I can’t see a copyleft operating system project today garnishing the same momentum that Linux saw in the 1990s. A copyleft license in the 1990s wasn’t as big a deterrent to collaboration as it is today.
Will copyleft ever die? I doubt it. After all, it does provide a necessary function for projects that must preserve software freedom. However, it’s becoming less and less common for software development projects, and I imagine that trend will continue until copyleft becomes some rarely-used exception to the permissive license norm.
NOTE: Many of the topics in this blog originated from a mailing list discussion I initiated a while ago in my local LUG. They’ve been on my mind occasionally since, and so I decided to get them down in this blog post. Furthermore, I wrote this blog post while at Starbucks in Markdown using vi on my SPARCbook running Solaris 2.5.1 in order to take my rightful place as King of the Hipsters.