Software that can be freely shared and modified, including in source code form. The term was first coined by Richard Stallman, who codified it in the GNU General Public License (GPL), and who founded the Free Software Foundation (http://www.fsf.org/) to promote the concept.

Free software under another name. But the different name reflects an important philosophical difference: « Open Source » was coined by the Open Source Initiative (http://www.opensource.org/) as a deliberate alternative to « free software, » in order to make such software a more palatable choice for corporations, by presenting it as a development methodology rather than a political movement. They may also have wanted to overcome another stigma: that anything « free » must be low quality.

While any license that is free is also Open Source, and vice versa (with a few minor exceptions), people tend to pick one term and stick with it. In general, those who prefer « free software » are more likely to have a philosophical or moral stance on the issue, while those who prefer « Open Source » either don't view it as a matter of freedom, or are not interested in advertising the fact that they do. See the section called « Free » Versus « Open Source » in Chapter 1, Introduction for a more detailed history of this schism.

Where there are two of anything, there will soon be three, and that is exactly what is happening with terms for free software. The academic world, perhaps wanting precision and inclusiveness over elegance, seems to have settled on FOSS, or sometimes F/OSS, standing for « Free / Open Source Software ». Another variant gaining momentum is FLOSS, which stands for « Free / Libre Open Source Software » (libre is familiar in many languages and does not suffer from the ambiguities of « free »; see http://en.wikipedia.org/wiki/FLOSS for more).

Approved by the Open Source Initiative. This is another widely-used test of whether a license permits all the necessary freedoms. The OSI's definition of Open Source software is based on the Debian Free Software Guidelines, and any license that meets one definition almost always meets the other. There have been a few exceptions over the years, but only involving niche licenses and none of any relevance here. Unlike the Debian Project, the OSI maintains a list of all licenses it has ever approved, at http://www.opensource.org/licenses/, so that being « OSI-approved » is an unambiguous state: a license either is or isn't on the list.

The opposite of « free » or « Open Source. » It means software distributed under traditional, royalty-based licensing terms, where users pay per copy, or under any other terms sufficiently restrictive to prevent Open Source dynamics from operating. Even software distributed at no charge can still be proprietary, if its license does not permit free redistribution and modification.

Generally « proprietary » and « closed-source » are synonyms. However, « closed-source » additionally implies that the source code cannot even be seen. Since the source code cannot be seen with most proprietary software, this is normally a distinction without a difference. However, occasionally someone releases proprietary software under a license that allows others to view the source code. Confusingly, they sometimes call this « Open Source » or « nearly Open Source, » etc., but that's misleading. The visibility of the source code is not the issue; the important question is what you're allowed to do with it. Thus, the difference between proprietary and closed-source is mostly irrelevant, and the two can be treated as synonyms.

Having no copyright holder, meaning that there is no one who has the right to restrict copying of the work. Being in the public domain is not the same as having no author. Everything has an author, and even if a work's author or authors choose to put it in the public domain, that doesn't change the fact that they wrote it.

A license that uses copyright law to achieve a result opposite to traditional copyright. Depending on whom you ask, this means either licenses that permit the freedoms under discussion here, or, more narrowly, licenses that not only permit those freedoms but enforce them, by stipulating that the freedoms must travel with the work. The Free Software Foundation uses the second definition exclusively; elsewhere, it's a toss-up: a lot of people use the term the same way the FSF does, but others—including some who write for mainstream media—tend to use the first definition. It's not clear that everyone using the term is aware that there's a distinction to be made.

Although there are many different free software licenses available, in the important respects they all say the same things: that anyone can modify the code, that anyone can redistribute it both in original and modified form, and that the copyright holders and authors provide no warranties whatsoever (avoiding liability is especially important given that people might run modified versions without even knowing it).

The differences between licences boil down to a few oft-recurring issues:

compatibility with proprietary licenses

Some free licenses allow the covered code to be used in proprietary programs. This does not affect the licensing terms of the proprietary program: it is still as proprietary as ever, it just happens to contain some code from a non-proprietary source. The Apache License, X Consortium License, BSD-style license, and the MIT-style license are all examples of proprietary-compatible licenses.

compatibility with other free licenses

Most free licenses are compatible with each other, meaning that code under one license can be combined with code under another, and the result distributed under either license without violating the terms of the other. The major exception to this is the GNU General Public License, which requires that any work using GPLed code be itself distributed under the GPL, and without adding any further restrictions beyond what the GPL requires. The GPL is compatible with some free licenses, but not with others. This is discussed in more detail in the section called “The GPL and License Compatibility” later in this chapter.

enforcement of crediting

Some free licenses stipulate that any use of the covered code be accompanied by a notice, whose placement and display is usually specified, giving credit to the authors or copyright holders of the code. These licenses are often still proprietary-compatible: they do not necessarily demand that the derivative work be free, merely that credit be given to the free code.

protection of trademark

A variant of credit enforcement. Trademark-protecting licenses specify that the name of the original software (or its copyright holders, or their institution, etc.) may not be used by derivative works without prior written permission. Although credit enforcement insists that a certain name be used, and trademark protection insists that it not be used, they are both expressions of the same desire: that the original code's reputation be preserved and transmitted, but not tarnished by association.

protection of "artistic integrity"

Some licenses (the Artistic License, used for the most popular implementation of the Perl programming language, and Donald Knuth's TeX license, for example) require that modification and redistribution be done in a manner that distinguishes clearly between the pristine original version of the code and any modifications. They permit essentially the same freedoms as other free license, but impose certain requirements that make the integrity of the original code easy to verify. These licenses have not caught on much beyond the specific programs they were made for, and will not be discussed in this chapter; they are mentioned here only for the sake of completeness.

By far the sharpest dividing line in licensing is that between proprietary-incompatible and proprietary-compatible licenses, that is, between the GNU General Public License and everything else. Because the primary goal of the GPL's authors is the promotion of free software, they deliberately crafted the license to make it impossible to mix GPLed code into proprietary programs. Specifically, among the GPL's requirements (see http://www.fsf.org/licensing/licenses/gpl.html for its full text) are these two:

1. Any derivative work—that is, any work containing a nontrivial amount of GPLed code—must itself be distributed under the GPL.

2. No additional restrictions may be placed on the redistribution of either the original work or a derivative work. (The exact language is: "You may not impose any further restrictions on the recipients' exercise of the rights granted herein.")

With these conditions, the GPL succeeds in making freedom contagious. Once a program is copyrighted under the GPL, its terms of redistribution are viral—they are passed on to anything else the code gets incorporated into, making it effectively impossible to use GPLed code in closed-source programs.

However, these same clauses also make the GPL incompatible with certain other free licenses. The usual way this happens is that the other license imposes a requirement—for example, a credit clause requiring the original authors to be mentioned in some way—that is incompatible with the GPL's "You may not impose any further restrictions..." language. From the point of view of the Free Software Foundation, these second-order consequences are desirable, or at least not regrettable. The GPL not only keeps your software free, but effectively makes your software an agent in pushing other software to enforce freedom as well.

The question of whether or not this is a good way to promote free software is one of the most persistent holy wars on the Internet (see the section called “Avoid Holy Wars” in Chapter 6, Communications), and we won't investigate it here. What's important for our purposes is that GPL compatibility is an important issue when choosing a license. The GPL is by far the most popular open source license; at http://freshmeat.net/stats/#license, it is at 68%, and the next highest license is at 6%. If you want your code to be able to be mixed freely with GPLed code—and there's a lot of GPLed code out there—then you should pick a GPL-compatible license. Most of the GPL-compatible open source licenses are also proprietary-compatible: that is, code under such a license can be used in a GPLed program, and it can be used in a proprietary program. Of course, the results of these mixings would not be compatible with each other, since one would be under the GPL and the other would be under a closed-source license. But that concern applies only to the derivative works, not to the code you distribute in the first place.

When choosing a license to apply to your project, if at all possible use an existing license instead of making up a new one. There are two reasons why existing licenses are better:

    •   Familiarity. If you use one of the three or four most popular licenses, people won't feel they have to
        read the legalese in order to use your code, because they'll have already done so for that license a
        long time ago.
    •   Quality. Unless you have a team of lawyers at your disposal, you are unlikely to come up with a leg-
        ally solid license. The licenses mentioned here are the products of much thought and experience; un-
        less your project has truly unusual needs, it is unlikely you would do better.
   

If your goal is that your code be accessible by the greatest possible number of developers and derivative works, and you do not mind the code being used in proprietary programs, choose the MIT / X Window System license (so named because it is the license under which the Massachusetts Institute of Technology released the original X Window System code). This license's basic message is "You are free to use this code however you want." It is compatible with the GNU GPL, and it is short, simple, and easy to understand:

One consequence of choosing the GPL is the possibility—small, but not infinitely small—of finding yourself or your project embroiled in a dispute about whether or not the GPL is truly "free", given that it places some restrictions on what you can do with the code—namely, the restriction that the code cannot be distributed under any other license. For some people, the existence of this restriction means the GPL is "less free" than more permissive licenses such as the MIT/X license. Where this argument usually goes, of course, is that since "more free" must be better than "less free" (after all, who's not in favor of freedom?), it follows that those licenses are better than the GPL. This debate is another popular holy war (see the section called “Avoid Holy Wars” in Chapter 6, Communications). Avoid participating in it, at least in project forums. Don't attempt to prove that the GPL is less free, as free, or more free than other licenses. Instead, emphasize the specific reasons your project chose the GPL. If the recognizability of license was a reason, say that. If the enforcement of a free license on derivative works was also a reason, say that too, but refuse to be drawn into discussion about whether this makes the code more or less "free". Freedom is a complex topic, and there is little point talking about it if terminology is going to be used as a stalking horse for substance. Since this is a book and not a mailing list thread, however, I will admit that I've never understood the "GPL is not free" argument. The only restriction the GPL imposes is that it prevents people from imposing further restrictions. To say that this results in less freedom has always seemed to me like saying that outlawing slavery reduces freedom, because it prevents some people from owning slaves.

A fair amount of Open Source software is distributed under a BSD license (or sometimes a BSD-style license). The original BSD license was used for the Berkeley Software Distribution, in which the University of California released important portions of a Unix implementation. This license (the exact text may be seen in section 2.2.2 of http://www.xfree86.org/3.3.6/COPYRIGHT2.html#6) was similar in spirit to the MIT/X license, except for one clause:

              All advertising materials mentioning features or use of this software must display the
              following acknowledgement: This product includes software developed by the Uni-
              versity of California, Lawrence Berkeley Laboratory.

The presence of that clause not only made the original BSD license GPL-incompatible, it also set a dangerous precedent: as other organizations put similar advertising clauses into their free software—substituting their own organization's name in place of "the University of California, Lawrence Berkeley Laboratory"—software redistributors faced an ever-increasing burden in what they were required to display. Fortunately, many of the projects that used this license became aware of the problem, and simply dropped the advertising clause. In 1999, even the University of California did so. The result is the revised BSD license, which is simply the original BSD license with the advertising clause removed. However, this history makes the phrase "BSD license" a bit ambiguous: does it refer to the original, or the revised version? This is why I prefer the MIT/X license, which is essentially equivalent, and which does not suffer from any ambiguity. However, there is perhaps one reason to prefer the revised BSD license to the MIT/X license, which is that the BSD includes this clause:

              Neither the name of the <ORGANIZATION> nor the names of its contributors may be
              used to endorse or promote products derived from this software without specific prior
              written permission.

It's not clear that without such a clause, a recipient of the software would have had the right to use the licensor's name anyway, but the clause removes any possible doubt. For organizations worried about trademark control, therefore, the revised BSD license may be slightly preferable to MIT/X. In general,however, a liberal copyright license does not imply that recipients have any right to use or dilute your trademarks — copyright law and trademark law are two different beasts.

There are three ways to handle copyright ownership of free code contributed to by many people. The first is to ignore the issue of copyright entirely (I don't recommend this). The second is to collect a contributor license agreement (CLA) from each person who works on the project, explicitly granting the project the right to use that person's code. This is usually enough for most projects, and the nice thing is that in some jurisdictions, CLAs can be sent in by email. The third way is to get actual copyright assignments from contributors, so that the project (i.e., some legal entity, usually a nonprofit) is the copyright owner for everything. This is the most legally airtight way, but it's also the most burdensome for contributors; only a few projects insist on it.

This is a license agreement only; it does not transfer copyright ownership and does not change your rights to use your own Contributions for any other purpose. Here are some examples:

    • Individual contributor CLAs:
       • http://apache.org/licenses/icla.txt
       • http://code.google.com/legal/individual-cla-v1.0.html
    • Corporate contributor CLAs:
       • http://apache.org/licenses/cla-corporate.txt
       • http://code.google.com/legal/corporate-cla-v1.0.html

Copyright transfer means that the contributor assigns to the project copyright ownership on her contributions. Ideally, this is done on paper and either faxed or snail-mailed to the project. Some projects insist on full assignment because having a single legal entity own the copyright on the entire code base can be useful if the terms of the Open Source license ever need to be enforced in court. If no single entity has the right to do it, all the contributors might have to cooperate, but some might not have time or even be reachable when the issue arises. Different organizations apply different amounts of rigor to the task of collecting assignments. Some simply get an informal statement from a contributor on a public list mailing list—something to the effect

   Most projects have a single legal entity own the copyright on the entire code base. This is done for vari-
   ous reasons. If the terms of the copyright ever need to be defended or enforced in court, it's much easier
   if a single entity has the right to do so; otherwise, all of the contributors would have to cooperate, and
   some might not have time or even be reachable when the issue arises. Also, if the code is the target of a
   copyright infringement suit, you wouldn't want the individual developers to be personally exposed to li-
   ability.
   Remember that centralized ownership of the copyright does not make the code any less free. Open
   source licenses do not give the copyright holder the right to retroactively proprietize all copies of the
   code. Even if the copyright-holding entity suddenly turned around and started distributing all the code
   under a restrictive license, it wouldn't cause a problem for the public project. The other developers
   would simply start a fork based on the latest free copy of the code, and continue as if nothing had
   happened. Because they know they can do this, most developers do not object when asked to assign
   copyright to some sponsoring organization.
   Different organizations apply different amounts of rigor to the task of collecting copyright assignments.
   For most, simply getting an informal statement from a contributor on the public list is
   enough—something to the effect of "I hereby assign copyright in this code to the project, to be licensed
   under the same terms as the rest of the code." At least one lawyer I've talked to says that's really enough,
   presumably because it happens in a context where copyright assignment is normal and expected anyway,
   and because it represents a bona fide effort on the project's part to ascertain the developer's true inten-
   tions. On the other hand, the Free Software Foundation goes to the opposite extreme: they require con-
   tributors to physically sign and mail in a piece of paper containing a formal statement of copyright assignment, 
   sometimes for just one contribution, sometimes for current and future contributions. If the developer is employed,
   the FSF asks that the employer sign it too.The FSF's paranoia is understandable. If someone violates the terms of 
   the GPL by incorporating some of their software into a proprietary program, the FSF will need to fight that in court, and they want their
    copyrights to be as airtight as possible when that happens. Since the FSF is copyright holder for a lot of
    popular software, they view this as a real possibility. Whether your organization needs to be similarly

    Some projects try to fund themselves by using a dual licensing scheme, in which proprietary derivative
    works may pay the copyright holder for the right to use the code, but the code still remains free for use
    by Open Source projects. This tends to work better with code libraries than with standalone applications,
    naturally. The exact terms differ from case to case. Often the license for the free side is the GNU GPL,
    since it already bars others from incorporating the covered code into their proprietary product without
    permission from the copyright holder, but sometimes it is a custom license that has the same effect. An
    example of the former is the MySQL license, described at ht-
    tp://www.mysql.com/company/legal/licensing/; an example of the latter is Sleepycat Software's licens-
    ing strategy, described at http://www.sleepycat.com/download/licensinginfo.shtml.
    You might be wondering: how can the copyright holder offer proprietary licensing for a mandatory fee if
    the terms of the GNU GPL stipulate that the code must be available under less restrictive terms? The an-
    swer is that the GPL's terms are something the copyright holder imposes on everyone else; the owner is
    therefore free to decide not to apply those terms to itself. A good way to think of it is to imagine that the
    copyright owner has an infinite number of copies of the software stored in a bucket. Each time it takes
    one out of the bucket to send into the world, it can decide what license to put on it: GPL, proprietary, or
    something else. Its right to do this is not tied to the GPL or any other Open Source license; it is simply a
    power granted by copyright law.
    The attractiveness of dual licensing is that, at its best, it provides a way for a free software project to get
    a reliable income stream. Unfortunately, it can also interfere with the normal dynamics of Open Source
    projects. The problem is that any volunteer who makes a code contribution is now contributing to two
    distinct entities: the free version of the code and the proprietary version. While the contributor will be
    comfortable contributing to the free version, since that's the norm in Open Source projects, she may feel
    funny about contributing to someone else's semi-proprietary revenue stream. The awkwardness is ex-
    acerbated by the fact that in dual licensing, the copyright owner really needs to gather formal, signed
    copyright assignments from all contributors, in order to protect itself from a disgruntled contributor later
    claiming a percentage of royalties from the proprietary stream. The process of collecting these assign-
    ment papers means that contributors are starkly confronted with the fact that they are doing work that
    makes money for someone else.
    Not all volunteers will be bothered by this; after all, their contributions go into the Open Source edition
    as well, and that may be where their main interest lies. Nevertheless, dual licensing is an instance of the
    copyright holder assigning itself a special right that others in the project do not have, and is thus bound
    to raise tensions at some point, at least with some volunteers.
    What seems to happen in practice is that companies based on dual licensed software do not have truly
    egalitarian development communities. They get small-scale bug fixes and cleanup patches from external
    sources, but end up doing most of the hard work with internal resources. For example, Zack Urlocker,
    vice president of marketing at MySQL, told me that the company generally ends up hiring the most act-
    ive volunteers anyway. Thus, although the product itself is Open Source, licensed under the GPL, its de-
    velopment is more or less controlled by the company, albeit with the (extremely unlikely) possibility
    that someone truly dissatisfied with the company's handling of the software could fork the project. To
    what degree this threat preëmptively shapes the company's policies I don't know, but at any rate,

   Software patents are the lightning rod issue of the moment in free software, because they pose the only
   real threat against which the free software community cannot defend itself. Copyright and trademark
   problems can always be gotten around. If part of your code looks like it may infringe on someone else's
   copyright, you can just rewrite that part. If it turns out someone has a trademark on your project's name,
   at the very worst you can just rename the project. Although changing names would be a temporary in-
   convenience, it wouldn't matter in the long run, since the code itself would still do what it always did.
   But a patent is a blanket injunction against implementing a certain idea. It doesn't matter who writes the
   code, nor even what programming language is used. Once someone has accused a free software project
   of infringing a patent, the project must either stop implementing that particular feature, or face an ex-
   pensive and time-consuming lawsuit. Since the instigators of such lawsuits are usually corporations with
   deep pockets—that's who has the resources and inclination to acquire patents in the first place�