CopyLefting

Copylefting is an ingenious scheme promulgated by the GNU Project under the aegis of the Free Software Foundation which uses the Copyright law to ensure that copylefted code remains freely available. The concept seeks to utilize the licensing mechanism to ensure that all subsequent users of a copylefted program will have access to the source code of the software, and that any improvements or modifications that they may make to the software will likewise be made available to all subsequent users.

“Free software'' refers to the users' freedom to run, copy, distribute, study, change and improve the software. More precisely, it refers to three levels of freedom:

  • The freedom to study how the program works and adapt it to your needs.
  • The freedom to redistribute copies so you can share with your neighbor.
  • The freedom to improve the program, and release your improvements to the public, so that the whole community benefits.

The analogy that I like to use for copylefted software is that of a Rocky Mountain stream. Code bubbles up from a clear creative and pristine spring (or caffeine addled hacker) and flows down through the rocky banks of the software development community. The author of the software is free to copyright the software and license it under any terms he wants.

In the case of traditional commercial software, the software company puts up a fence around the spring and sells bottles of the water to customers. If the author gave his code to the public domain, there would nothing to prevent an interloper from coming in and putting up his own fence around the spring. You can take public domain code, add proprietary changes, and then protect the entire program. Although the simplest way to make a program free is to put it in the public domain, uncopyrighted, it is a plunderable resource. Public domain allows people to share the program and their improvements, if they are so minded. But it also allows uncooperative people to convert the program into proprietary software. They can make changes, many or few, and distribute the result as a proprietary product. People who receive the program in that modified form do not have the freedom that the original author gave them; the middleman has stripped it away.

The Free Software Foundation claims that by using the same distribution terms (the “GPL” and “LGPL”) for many different programs, it is easy to copy code between various different programs. This ensures compatibility of terms.

Ratting out GNU

Given the high moral road taken by the GNU License, one of the most popular questions is: "How do I get around it?" The reasons for wanting to do so may range from outright avarice to mere convenience . There are many different types of software licensed under GNU. Some are standalone applications, some are libraries, and many are in between. To see an example of what issues can arise, lets take the example of some code that performs a traditional library function that is licensed under the GNU General Public License. This code is used to perform a relatively minor task in an otherwise Proprietary program. Once done, the inevitable question is whether or not use of such a utility imbues the benefits of GNU to the entire application; or put another way, can this use of the GNU code that is relatively minor to the application as whole serve to virally infect the entire application and require that the entire application be distributed under the GNU License?

The GNU General Public License is necessarily ambiguous considering its scope. As a general license, it is not designed for any specific type of software, for any particular platform, or for any particular use or circumstances. Therefore, by necessity, application of the GNU General Public License requires a fair amount of interpretation.

The ability to replace GNU code with non-GNU code without modification to the other code is the traditional acid test for compliance with the GNU License. Regarding the impact of using the GNU code in a Proprietary application, the operative paragraph in the GNU General Public License is this portion of Paragraph 2(c):

“These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can reasonably be considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.”

Generally, the Proprietary application will be an executable file that contains compiled object code. The object code will be compiled from the original GNU source code, along with the addition of any modifications. The modifications made to the GNU source code clearly constitute a derivative work under copyright law. These changes and modifications are covered by the GNU License and must be located in the same directory as the GNU copyright/disclaimer file.

Consequently, you could comply with the terms of the license by compiling the object code into a separate file and directory, along with the GNU copyright/disclaimer file. In this case, the functionality of the GNU code is clearly separated out and the code provides incidental functionality to the overall program. The source code of the GNU code and any modifications thereto can be made available without exposing any other Proprietary code. The GNU code is not compiled into Proprietary code, thus is not considered “incorporated” into a Proprietary program. The file containing the GNU code is readily identifiable and separate. The Proprietary code is clearly identifiable as a separate section of the program that is not derived from the GNU code.

However, it should be noted here that there may be a difference between how the GNU code is accessed on different platforms. For example, there was a time when the Sun platform supported dynamic linking of libraries, but the HP platform did not. Consequently, the Sun code would accesses the GNU code dynamically at run-time, whereas the HP code would have to link (not compile) the GNU code statically. While it is clear that mechanically the Sun code is in compliance with the License, the HP code does functionally what the Sun code does. However, the static linking could arguably create an ambiguity.

The fact that the GNU code is compiled separately, located in library directory, and used as a functional utility, indicate that the GNU code is being used in the manner one would use any third-party utility. This functionality can be replaced by other programs, the functionality is incidental to the overall program, and the overall design of the Proprietary program is not predicated on the GNU code.

However, the license itself does not explicitly define “incorporation” or “works”. This raises a possible ambiguity. To resolve this possibility, you have to resort to traditional contract interpretation methods and look to the intention of the drafters of the License for resolution. The stated purpose of the License is to ensure that anyone who redistributes the software, with or without changes, passes along the freedom to further copy and change it. Further on in paragraph 2(c), the license states:

“Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.”

The GNU License grants to the user a free license to copy, distribute and/or modify the GNU code. The intent of the license is to protect free flow of this software. Compiling the GNU code into Proprietary software and refusing subsequent users access violates the intent of the License. This would be the case if you compiled the GNU code into the Proprietary code, and did not make that combined code available to downstream users. However, if you have kept the GNU code freely available, as well as added incremental improvements, and made such improvements freely available to whomever receives the code downstream, then you have adhered to the intent, and arguably to the letter, of the license .

Consequently, on the issue of ratting out the GNU License, there is an argument that you may use the GNU freely without concern of copyright violation, of breach of the GNU General Public License, or of exposing proprietary code to the terms of the GNU License, as long as the following is true:

  1. The library directory contains the copyright/disclaimer file;
  2. The GNU code is not compiled (as opposed to linked) into Proprietary code; and
  3. The library directory contains the GNU source code.