This is a subject I have been looking at for years, and for years when people start reading this type of information they either do not care, agree or mentally shut down and refuse to understand anything presented and ultimately throw a tantrum, often making threats because to them the GPL is a religion and not a mere software license. They do not care about the wording of that license if it goes against the Orwellian double speak the FSF puts forth. The double speak I am referencing is things like the GPL keeps software free. They are not talking about the cost of the software but rather the freedom to modify it, to distribute modified works and things of that nature.
I will present an alternate theory, that the GPL is restrictive, that those restrictions do not meet the stated goals, and that ultimately the GPL harms open source by creating islands of code that cannot be used together thus forcing developers to rewrite code just to change the license. This rewriting of code is time and effort spent on duplication rather than innovation, slowing the FOSS movement somewhat.
First lets look at what the GPL is supposed to do:
- ensure access to the source code for future modifications
- allow individuals to distribute the original or modified work
- makes software more accessible for future projects
Access to the Source Code
The GPLv2 states in part (emphasis added):
3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
- b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
There is nothing that limits what your costs may be other than it must be your cost of physically performing source distribution. You may include stamps, envelopes and the media itself in your charge. You may even go to a kinkos or internet cafe and have those costs added to the total. If you hired a friend, spouse, relative, etc to do the source distribution for you you may charge their fee, after all it is no different than hiring a company who mass produces the media and distributes it, such as many of the GPL licensed operating systems offer. There is also no wording in the GPL that requires these costs be sane, market rate, or even reasonable. As such your friend or family member could charge you $1,000,000,000 for the distribution and that is your cost of physically performing source distribution.
Because there is no clause that limits what the charge will be, because there is no requirement that the charge be reasonable you cannot be forced to be bound by those tacit terms introduced into the license. As such you could charge insane fees through careful structuring, thus effectively making the software closed source since few can afford such fees and of those that could I am sure most if not all would decline the offer. Linux is a good example of a GPLv2 licensed software title.
The GPLv3 has similar wording:
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:
b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.
This indicates that they realized this feature was in fact considered a problem. For software that is dual-version licensed, often with the wording
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.
The option is at the person who is going to distribute not the receiver. If I distribute software to you under the terms of v2 you cannot demand anything that exists under v3 of me. Many bits of software are licensed as v2 only or v2+ and so enable this particular feature. The only way to stop this is to get consent from each and every developer who has contributed to a v2 or v2+ project and change the license to v3 or v3+. If you cannot get consent from every developer you may not unilaterally change the license since you do not have permission to change the license on their contributions. You may distribute under v3 if you want, however someone who receives the program can invoke v2 and distribute under those terms.
Distribution of the work
The goal of the GPL is to allow people to distribute both the original and the modified versions of the software. This is generally a noble goal, however it is not always possible. While it is true that you may not distribute any software that includes components of non-GPL compatible (ie those software components that the GPL cannot parasitically take over the license of) as part of the same program, there are ways around this. You can create a RPC like service, basically a program that would load GPL code or GPL incompatible code and expose the functions and methods contained within via a network or other service to another program.
Lets say I wanted to use the FSF’s libreadline. This is GPL so my program must be GPL unless I write wrapper code around libreadline and expose the functions via the network. I would still be able to use the GPL code from libreadline in my program, however I am not bound by the terms of the GPL for my code since there is a “bridge” between my program and theirs. This exception is clearly allowed, and to some degree by necessity as few would have initially developed under the GPL if it meant that you had to totally close borders to GPL incompatible programs.
While the GPL would give you the ability to distribute the libreadline program it would not give you the ability to distribute the program that is calling it over the network, the license of that program would dictate this. This means that the GPL does not prevent, and to a point cannot prevent, the inclusion of GPL code in the totality of the end program whether that is licensed under an incompatible open source license or a commercially licensed program. This impairs the distribution of derived works and ultimately makes it no different than the 3-clause BSD license in this regard since the original code could always be obtained from its original distribution channels.
Were someone to employ this technique with the source sequestering technique above you could have a program that is 99% GPL with an external call to a closed source application that is required to exist and return valid data before the GPL program will continue. As the source would generally be unavailable it would be difficult for most users to remove this “lock” and in fact laws like the DMCA could be used to stop people from publishing anything on how to remove the lock.
In addition the GPL only comes into play on distribution. You could load a system full of GPL code and retain ownership of the system but allow customers to use that system. This is similar to what Google and many other companies do. Because you retain ownership it would not matter where the physical server is located. The server could be colocated at a customer facility instead of hosting it at yours. As a result of using this technique you would not be distributing the code and the GPL would not come into play, yet you are providing that code to others for their use as if it were distributed. This is yet another “GPL authorized” method of ensuring the code is not distributed.
Source more usable
A lofty goal in the open source movement is that the code written by one person is usable by another for a different purpose. This seems like a noble goal but in the real world it does not work out exactly that way when it comes to GPL software unless you only use GPL software. The reason is the parasitic nature of the GPL. I can freely mix BSD, MPL, LGPL and other licensed software together, but I cannot freely mix GPL licensed software short of the “bridge” example above. To this end the GPL creates islands of code, code that cannot touch other code without a bridge connecting the islands.
Ultimately this requires developers to reinvent the wheel, instead of innovating and providing better software functionality they have to rewrite entire sections of code, libraries, etc just to make them compatible. The FSF libreadline is a classic example. NetBSD has a 4 clause BSD license, this means that if you advertise any feature contained in their software you must state that it is from their software and cannot claim it as your own. This clause makes it incompatible with the GPL. To that end developers sat down and reimplemented the GNU readline for a functionally compatible library that is “clean code” and they can license it any way they choose. Those developers could have been working on new features, innovations that could have made someones life easier, instead, purely for a political point with respect to licenses they had to duplicate the effort of others. This is not the only example there are many more examples.
Another example is with the Zaptel suite of drivers for telephony cards used in Asterisk by Digium. Zaptel is derived from zapata a BSD licensed project. Zaptel became GPL because the person that first took zapata and made it work with Asterisk was told that it would make the code free for everyone. The person who made Zaptel GPL was upset that he was tricked into licensing it GPL making it incompatible for some users while at the same time the people that told him this, Digium, got a disclaimer allowing them to license it commercially and sell the software. Since the software had contributions by others you would not be able to reverse the license back to its BSD state. The code was not free for everyone to use, another open source telephony project ultimately had to write openzap a functionally equivalent interface library to talk to telephony boards. This was done rather than adding new features or fixing bugs, simply because of a license issue.
The duplication of code merely to deal with licensing issues does not make the code more usable by others, in fact it makes it less usable.
License exceptions are created which allow GPL software to link against non-GPL software. In many popular examples this is so they can use the OpenSSL library, although many other examples exist. These license exceptions actually create GPL incompatible code when distributed together as a working program. In some instances this is done without all of the contributors consent, which means that contributors who did not wish to agree to having their code become GPL incompatible when shipped as a whole had no say in their GPL rights being taken away. Many people do not see this as making GPL incompatible code, however the mere fact that you have to create an exception means that you are altering the terms of the license. This also complicates other issues with code usability in that I cannot take code from an excepted program and put it into another GPL program if it is going to cause the exception to cross over too – ie that functionality is off limits unless I can get consent of the new GPL program authors to modify their license. This further creates islands within the islands of code.
I have shown that you do not always get the opportunity to view and modify the source code, that you do not always get the opportunity to distribute working projects, that the code may not always be used in other distributed open source projects. There are features in the license that enable people to do all the things the GPL is supposed to prevent and you are left with restrictions on use, distribution and other aspects. The end result is that the FSF mantra about “the GPL keeps code free” is really just Orwellian double speak and the code is no more free than with the BSD or MPL license and probably a few others which what is published will always remain available and free to modify with the difference that the GPL places additional restrictions that do not exist with many other licenses.