Linux Is Fine, Nothing to See Here

___________________________________________________________________

Recently, Linux kernel developers were prompted to revoke licenses to their pieces of code to protest against the new Code of Conduct. Over the last week a whole lot of outlets shed light on this event and mused about the morality and potential ramifications of the whole controversy.

However, ethical and political aspects aside, there are at least two important things to understand: what are the developers opposing and whether they are really able to revoke the licenses for their code. We will try to figure out both as simply and briefly as possible.

Code of Conflict vs. Code of Conduct

The whole thing revolves around the new set of rules, or recommendations, for the developers community to follow.

The former rulebook was called Code of Conflict. Basically, it was one simple rule: you contribute the code — you get criticized because no one is perfect. Tolerate this. However, if you feel ‘personally abused, threatened, or otherwise uncomfortable due to this process, that is not acceptable,’ please, contact our Advisory Board.

Therefore, it was a post-factum remedy for anyone who felt attacked personally in any way, whether because of one’s sex, race, age, or whatever else.

The new Code of Conduct is more extensive. It is a typical code of good behavior which contains: positive and negative behavioral examples, a statement of maintainers’ responsibility to ensure the good standards by clarification and actions, the scope of applicability, and enforcement via contacting the Advisory Board with the possibility of “temporary or permanent repercussions.”

The Code of Conduct was derived from the Contributors Covenant, a set of rules widely adopted by the open-source community.

The reasoning behind the transition to the new rules is somewhat explained by the respective official statement from Linux:

“The Code of Conflict is not achieving its implicit goal of fostering civility and the spirit of ‘be excellent to each other’. Explicit guidelines have demonstrated success in other projects and other areas of the kernel.”

Therefore, the new Code of Conduct provides more explicit rules on how people should behave, rather than the measures one should take in case something bad already happened.

But it isn’t the actual introduction of the new rules, that caused all the hype.

Licence Rescission

The main question here is whether or not “contributors can, at any time, rescind the license grant regarding their property via written notice to those whom they are rescinding the grant from,” as it is put in the original email, urging kernel developers to protest against the Code of Conduct.

Let’s start with something simple. General Public License is a framework license created by Free Software Foundation for open source software developers. Whenever someone creates a piece of software, they can add certain lines in the end of the code text saying that it is licensed under the GPL. And so, the GPL will apply to anyone who uses this code. Licensees will also be forced to apply the same licensing rules if distributing the code afterwards.

Note, that GPL is a license in its essence. Hence, it is a legal construction that allows anyone to use a software developed by someone on a legitimate legal basis. It is also important that GPL license was iterated. In this case all the attention goes to GPL version 2.0 and version 3.0.

The difference in question between GPL v.2.0 and v.3.0 is the inclusion of the non-rescission clause. GPL v.3.0 in § 2 Basic Permission stipulates:

“All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.”

It means that whenever developers grant a right to use their code under GPL v.3.0, they do it for the whole term of the copyright for this object with no possibility to revoke the license, unless a violation of the conditions takes place. Simply put, the license is irrevocable in general.

GPL v.2.0. lacks this clause, which in certain interpretations means that developers can at any time revoke their licenses and potentially sue anyone who uses it without a proper legal basis. And since Linux kernel is licensed under GPL v.2.0, this whole rescission controversy arises.

There are a lot of debates about the terms of revocation and how it can be actually applied, so here are the main points for consideration:

1. Once license is granted, it cannot be withdrawn. Basically, an author as a creator of the work can do with the license whatever they want since technically a license is “I allow you” concept. Yet, what was licensed under specific terms, cannot be unlicensed retrospectively. Therefore, if an author would like to change the license for the software, that won’t work on its earlier versions. And so, from the “unlicense” moment, the software will begin to simply fork.
2. Once license is granted to a piece of code, it can be re-licensed. Simply put, no one can forbid the author to license a software under any different license again. A piece of software can be licensed under a number of licenses, it is called multi-licensing.

Linux kernel includes code written by hundreds of contributors who did not assign copyright to Linux. This means that they retain the copyright. Even if Linus Torvalds wanted to re-license the software, he would need to either buy the code, or ask for permission of every single one of the contributors. However, it is impossible for the contributors to revoke licenses at this particular stage completely. They can restrict the usage of the subsequent iterations, but the code that’s been already released will still be available for everybody to use, as the relicensing won’t apply retrospectively. The code will simply fork.

Conclusion

All in all, GPL 2.0 differs from the GPL 3.0 in the availability of the explicit non-rescission clause. Linux kernel is licensed under GPL 2.0 that doesn’t include said clause. Some people believe that developers have the right to “take away” the licensed code. At the same time, some think that it is not possible, since the code was granted under the GPL 2.0 which doesn’t contain any provisions that would explicitly allow for license revocation. Once the license is granted, it is granted for good.

If an author would like to change the license for the software, the new one won’t apply to its earlier versions retrospectively.

“Someone that acquires the copyright of a free program can of course stop distributing the free version, and if they hold the sole copyright they can go on to create a non-free fork and distribute that as binary-only. But they can’t “unlicense” the pre-fork copies that already exist. People will always be able to improve on, and continue to distribute, the free version,” reads the relevant discussion at Stackexchange.

To sum up, the apparent answer is: no, the developers won’t be able to revoke already granted licenses or relicense the code retrospectively. However, the question is mostly procedural and will depend on how the respective court would interpret the situation.

In fact, there is always another aspect to keep in mind: enforceability. Even if the court rules in favor of revoking the GPL, how would it be possible to enforce the ruling and make half of the internet stop using the code?