From the comments on Codinghorror’s blog post on Discourse:
The way it looks now, you’re not engaging in open-source in the same
way as WordPress does. The GPL is enough, you don’t need a contributor
license agreement. What it actually means is that you are keeping an
exit door if you ever want to close the source again in the future:
contributors agree to license you their copyright for whatever future
Probably lots of open-source projects use this method, but it sure is
not reassuring. Please don’t compare yourself again to WordPress,
though. Nuance matters
Is there something to this? Is the CLA somehow “keeping an exit door”?
This CLA is actually rather non-restrictive, as CLA’s go – you’re merely licensing the code to the company. I believe the FSF insists on copyright assignment, meaning that they have ownership of the code.
The problem that a CLA tries to solve is this: Ten years from now it’ll be impossible to track down the dozens or hundreds of different contributors (some of whom may be completely unreachable or even dead). Ownership might need to be proven for legal reasons (see SCO’s attempted claims to Linux a few years ago), or maybe there’s a strong desire in the community for a change in license. The CLA makes these things possible.
If Discourse ever decides to stop licensing under GPLv2, or goes in another direction the community doesn’t like, it’ll be impossible for them to stuff the genie back into the bottle. (Look at Netscape’s rebirth as Firefox, the multiplicity of MySQL forks, or LibreOffice’s displacement of OpenOffice.) The last GPLv2 version that exists just prior to the time of the license change could be used as the basis for a fork.
Alternatively, because under the CLA contributors still own their patches, at some point in the future it might be the case that most of the code consists of third-party material. (Think about the Linux kernel; probably only a tiny fraction of today’s master branch is code that was personally written by Linus Torvalds.) So the most prolific contributors might be able to band together and write replacements for the pieces of code that are owned by Discourse (or uncooperative contributors), ending up with an “independent” implementation which is very similar to the last “official” version.
It is true that Discourse is taking a different route than Wordpress and some other classically GPL software, and requiring a contributors license for code submitted for inclusion into the main core. This isn’t an uncommon arrangement though:
And all FSF projects require a CLA so that the FSF can choose a “better” license should one come up later. This has dogged some projects in the past, especially where GPL and BSD style licenses meet and interact.
For instance, some of the code which will come out of Discourse is likely to be licensed with a BSD-like license, where it makes sense to do so. If they receive a contribution that is only GPL, they cannot release that code back into the world as BSD.
Further, it complicates the code base. Now they have to start tracking which code is theirs, which is under GPL, and which is under BSD or similar, and who originated the code so they have a clear right to the code.
In a sense, yes. They can take a bunch of contributions, and reverse their stance and stop distributing later versions as GPL. It’s a possibility.
They could also choose to go with BSD or AGPL in the future.
The point is - they have the freedom to choose without tracking down contributors and asking permission later, or trying to excise contributed code so they can release it under the desired license.
What you find with projects like this is that contributors, rather than believing in just the project, also have to believe in the people running the project. That can be difficult with the fact that they have outside investors that will want to see a return on investment in short order, but that is again tempered by the fact that they have an open git repository and are making regular commits to it:
If you’re worried, don’t contribute - instead make a plugin and release it as GPL only, or make a patch and release it as GPL only.
We, as authoritative representatives of “The Company” (Civilized Discourse Construction Kit, Inc.) do solemnly swear and commit back to You that the “The Project” remains freely accessible under these terms. As “The Project” continues to remain under the control of co-founders Jeff Atwood, Sam Saffron and Robin Ward, “The Work” (Discourse/Discourse) will always and forever remain publicly free and available in its entirety under the same terms as are described in the GNU General Public License (GPL) v2.0. If, at which time, Jeff Atwood, Sam Saffron and Robin Ward no longer retain control as co-founders of “The Company”, and the licensing model for “The Project” (Discourse/Discourse) changes to another scheme other than the GNU General Public License (GPL) v2.0, then an effort will be made, if possible, to hand “The Project” off to a third-party under the guidance of the Free Software Foundation.
Is there a possibility of altering the way the CLA is signed? Google Docs might work for most, but our proxy blocks us from accessing it. Many organizations actually do this, in order to keep employees from unintentionally storing data or other forms of documentation you may be required to legally keep in-house.
These days, there are lots of entirely-on-github ways of signing CLA’s.
I’m concerned with the first point of the agreement (emphasis mine):
You grant to “The Company” (Civilized Discourse Construction Kit, Inc.) a non-exclusive, irrevocable, worldwide, royalty-free, sublicenseable, relicenseable, transferable license under all of Your relevant intellectual property rights, to use, copy, prepare derivative works of, distribute and publicly perform and display “The Contributions” on any licensing terms, including without limitation: (a) open source licenses like the GNU General Public (v2.0) license; and (b) binary, proprietary, or commercial licenses. Except for the licenses granted herein, You reserve all right, title, and interest in and to “The Contributions”.
I see two problems with this (b) point:
it seems to suggest that the GPL is not a commercial license. But the GPL doesn’t prevent commerce at all. This is a common misconception.
it seems to tell that the code is GPL (which forbids proprietary license) AND can be used to produce proprietary software. That is, it’s saying that the code should be licensed under the Apache 2.0 license (if you want to prevent patent treachery), or a lax license such as BSD-3 (which authorizes free software to be closed, as we’ve seen with Apple OS X, etc.), not the GPL.
This latter point makes me uncomfortable because it definitely contradicts the general discourse of Discourse and free software: e.g., section 6 of the CLA, or the famous “there’s only one version of Discourse, the awesome version.”
I’m ready to give my assent for GPLv2, which practically authorizes employing GPL code with proprietary modifications. What I’m not ready to do is sign a document that pretends I’m writing free software, while the code is aimed to be used in non-GPL-compliant ways as suggested by point ‘(b)’. I’d like to understand the logic behind this point.
My understanding is that this CLA gives an exit opportunity (in startup jargon) for the founders to sell the company to corporate sharks who would then be able to do whatever they want, including killing the product by making it proprietary, in which case the burden would fall on this community to keep a fork free.
This sounds like wishful thinking. I still don’t get why is this (b) necessary.
As soon as the developer shares copyright with the company, and grants the company full control over what they can do with the code, I see no reason why the developer should have anything to say about the next owner’s rights, and certainly no reason why the developer should explicitly disavow the purpose of the GPL by signing the CLA.
IANAL, but it seems entirely sufficient to grant copyright to the company and accept to release under the GPL, since the license grants these permissions irrevocably downstream. That means a non-cooperative buyer may still relicense the code to some proprietary license, because they own the copyright: as explained before, the existing GPL’d code base would be maintained by the community, while the new proprietary code, well, who cares. But I as an individual have nothing to do with this, and I’d prefer not having anything to do with this, especially if that enthuses saying it’s OK to “proprietarize” public code: from my perspective it’s not, and it would be a moral issue to say the opposite. Ultimately what the copyright holder does is their problem, not mine.