|< Free Open Study >|| |
So far, we've seen how open source software works, and how it benefits the parties involved. But what, exactly, makes it tick? How does open source work its magic? The answer is in the license. Open source software takes advantage of existing copyright laws to enact a licensing framework in which users of the software are essentially required to play fair. Because everyone is on a level playing field, there is no risk that one contributor can poison the pot and usurp everyone else's hard work; this makes open source software safe for everyone involved, and encourages people to contribute. This section will discuss open source licensing, and describe some of the most common examples.
Contrary to an all-too-common belief, open source software is not the same as being in the public domain. Some people use the terms "public domain" and "open source" (or "free software") interchangeably, but they are not. Public domain software is exactly that: owned by the public. The person or group that wrote the software has chosen to abdicate ownership, and released it to the public domain. Any other person or group may take a piece of public domain software and do whatever they choose with it. That is, nothing protects public domain software from being reused in proprietary software.
Free software, in contrast, does not relinquish ownership. The prevalent model in software sales today is licensing. When you purchase (or are given) a piece of software, what you actually own is permission to use the software, not the software itself. The entity that provided you with the software still owns it, and what you can and cannot do with the software is determined by the terms of the license you agreed to when you received the software.
Typically, companies sell software to users, and the license is used to prevent the user from giving the copy to anyone else. (In this way, other users who wish to use the software must themselves purchase it from the company that owns it.) Free software, however, simply makes use of the license to ensure that the software and its source code are unencumbered by restrictions on use or modification. This essentially boils down to one key fact: any time someone modifies the software and distributes the modified version, they must also distribute the source code to their modifications, without additional licensing restrictions.
Of course, sometimes it's not quite as simple as that. For instance, some licenses do not require that users submitting modifications to the software assign their copyright on their contributions to the owner of the original license. This means that if Joe releases software under a free license and Jane submits a change, Jane still owns the copyright on her submission. Even though it falls under the same license as the original software, Joe cannot choose to license the software to Mike under a different license without Jane's approval, because now Jane owns part of it, and Joe can't ignore that. Joe can, of course, choose to not include Jane's contribution in the version he licenses to Mike, but then Jane can always simply redistribute her own derived version of Joe's software to Mike, too. To avoid this problem, some projects and licenses take steps to ensure that such mixed copyright issues are avoided.
The upshot is that free software and open source software have real, legitimate copyrights and licenses, which can be as simple and as complex as copyright law allows them to be. As of this writing, none of the common open source or free software licenses have been challenged in a court of law, so no one really knows for certain whether they'll hold up.
Generally, free software and open source software describe the same thing. However, they vary slightly in their definitions, and sometimes a license that qualifies as open source by the definition specified by the Open Source Initiative (OSI) doesn't quite qualify as free software by the definition specified by the Free Software Foundation. Such licenses, however, are relatively uncommon.
The Open Source Initiative (OSI) at http://www.opensource.org is a non-profit organization that promotes open source software and also provides certification services for open source licenses.
Here are a few examples of actual open source licenses, with quick comparisons and summaries. These examples will illustrate some of the major variances among open source licenses; most licenses can be compared to one of these examples, or will pick and choose features from them.
The General Public License (GPL) is the license that most of the GNU project is released under. Sometimes referred to as a "copyleft" (to emphasize its distinction from copyright), the GPL was really the first free software license, and, true to its heritage, is still one of the strongest licenses around.
The full text of the GPL can be found at http://www.gnu.org/copyleft/gpl.html, but in brief it says this:
There are no restrictions on the use or redistribution of the software (though a fee may be charged for distribution costs and handling).
If the user redistributes the software, the source code must be available.
The user may modify the software for private use.
If the user modifies the software and distributes the changed version, the source code must be available.
If the user modifies the software and distributes the changed version, it must be available under the same terms.
If the user incorporates the software into a larger work, the larger work must also be under the license or a stronger license.
You should, of course, read the GPL yourself rather than taking this book's word for it before making any important decisions.
The last point about larger works means that if Jane incorporates Joe's Software into her own SuperSoftware—even if she doesn't change Joe's Software at all but is merely using it—her own SuperSoftware must also be available under the GPL or a stronger license. This is sometimes referred to as a "viral" license, since it "infects" Jane's software, requiring that she also use the GPL.
On the one hand, this encourages developers who are building on free software to make their software free. However, this restricts the range of use; for example, a business may wish to use GPL software as part of their product, but can't because they wish to sell their product. This makes the GPL probably the strongest (that is, most free) license around, but its hostility to commercial use is a large part of why other licenses were created.
The Berkeley Software Distribution (BSD) license is a stark contrast to the GPL. Where the GPL requires free use, demands that the source code be distributed with the software, and "infects" derived works, the BSD license does not.
The BSD license is very simple: it simply says that if the software is redistributed in source form, or if a modified or derived version is distributed in source form, then the original authors' names and their copyright notice must be displayed in the redistributed code. If the software (or a modified or derived version) is distributed in binary form, then the authors must be given due credit either in the documentation or software itself.
The BSD license is extremely and deliberately friendly to commercial use. It permits a developer to incorporate the software into another larger work, with the sole requirement being that the original authors be given due credit. The philosophy of the BSD license is a bit more academically pure than the GPL; BSD developers are simply interested in producing the best possible code that can be produced, without regard to where it is used.
Since it allows licensees to incorporate the software into proprietary works (even though due credit must be given), the BSD license is much farther away from the free software ideal than the GPL. However, it is still an open source license, and it's friendlier to businesses.
The GNU Lesser General Public License (LGPL) is a slightly relaxed version of the GPL and lies somewhere in between the two extremes just presented. The LGPL was created in response to the issues involved with statically linking libraries released under the GPL. A statically linked library is one whose code is physically embedded in a program. The other possibility is a dynamically linked library, in which a given program only refers to the library, of which there is only one copy shared among all programs that use it. There are plusses and minuses for each approach.
Since a statically linked library (such as the system C libraries or a graphics API) is physically copied into the binary object code and is required for programs to run, any program making use of these libraries is implicitly merging with the library and becoming a "larger work." Since the GPL is a viral license, as mentioned earlier in this chapter, any program statically linking against a GPL-covered library must also be released under the GPL (or a stronger license)—even if the library was used completely unchanged!
This effect was judged too extreme, so a new license, called the Lesser or Library General Public License was created. This license is identical to the GPL, except that it is not viral; it relaxes the clause requiring that larger works including the software also be licensed under the same terms.
Since it's not viral, the LGPL has a little bit more in common with the BSD license than the GPL. However, since this is a slight weakening of the free software ideal, the Free Software Foundation generally advocates the use of the GPL over the LGPL, except where the LGPL is strictly required.
When Netscape Communications Corporation decided to release their Communicator product as open source, they looked at the existing open source licenses. However, the GPL was too strong (since they wanted their code to be usable in larger works), and the BSD License was too weak (since they wanted to preserve the requirement that derived and modified versions include the source code).The license that Netscape produced was named the Mozilla Public License (MPL), and is a lot like the LGPL, except that it's a bit more liberal in what constitutes a larger work. The MPL includes additional clauses establishing further protections against rogue contributors; for example, one clause prevents anyone from contributing patented code, and then attempting to enforce the patent against users of the software or other contributors or licensees. (The GPL has similar clauses protecting against rogue contributors, but is less explicit in the details.)
Most other licenses are more or less similar to at least one of these licenses. The Apache license, for example, is much like the BSD license, except that it also restricts any licensees from using the name "Apache" in the name of their product. (The BSD license only restricts the use of the name in promotions or endorsements.) There are numerous licenses out there—too many to keep track of. Generally, though, most are either variants of or fairly similar to one of the licenses discussed here. If the OSI has certified a given license as "open source", then that's a good benchmark; otherwise, you'll have to read the license yourself and decide whether you like it.
|< Free Open Study >|| |