@Angus Glashier: While you are correct that capitalism is about making money (that’s why it’s called capital-ism: see http://en.wiktionary.org/wiki/capital#Noun), you are incorrect in saying that serious money cannot be made in selling free software (e.g.: software released under the GPL). How do you explain Red Hat’s success? Yes, it is less common for a successful company to be successful due to free software due to the freedom to redistribute the software. However, that doesn’t mean it’s not possible.
Here’s a hypothetical for you: Let’s say Internet Explorer wasn’t freely available from Microsoft (pre-installed, whatnot). You’re walking through your local computer shop, and you see IE CDs. Right next to those, you see Firefox CDs. (Yes, they exist: http://store.mozilla.org/product.php?code=MZ9008) Which would you pick? Sure, you could just opt to download Firefox at no cost online, but what if Mozilla didn’t offer it for download at no cost? Most people don’t know how to compile source code, and I’d venture to say that most people would trust an official release directly from Mozilla over a binary on a P2P site.
Of course, this assumes you’re using Microsoft Windows, because if you were using a free operating system, then you could just install Firefox (or a derivative) via a built-in package manager from a remote repository. I never claimed hypotheticals were perfect.
john, you can actually legally relicense your own works. Been done many times for many reasons, sometimes to a more restrictive or proprietary and sometimes to a more open license. The conditions as far as I know are that you have to have the consent of everyone who non-trivially contributed; if anyone doesn’t consent, you must remove and rewrite in your own way their contributions. (Some will bypass this step, figuring that getting a little flak and grousing if discovered beats recreating half your code. They’re usually right, far more care whether it works than what license you have.) This goes for dual-licensing as well. Or just add a clause to the end of the GPL, “John Collins and any software developed by him is exempt from this license.” The JGPL! =p
Starting out on the right foot is always the way to go, but I thought you’d like to know.
Jeff’s main point here seems to be that there are too many licenses, and having to read them all and figure out what exactly they all mean is a major PITA.
I came to that same conclusion a few years ago. That’s why I don’t think anyone should be writing new licenses. Just stick to the least-bad well-known license.
For the last 5 years, I have stuck to the following three licenses for all my needs:
GPL - For stand-alone apps only.
GPL with blanket linking permissions (GMGPL)- For libraries, APIs, and the like.
Public Domain - For sources that I want to be usable (perhaps by me when working on company time!) even when pasted into another source file.
I know the WTFPL-dude thinks there are problems with Public Domain assignments outside of North America. Frankly, if Romania or Botswana have their laws that screwed up, they can fix them or suck eggs as far as I’m concerned.
You may not find any of these licenses perfect, but you won’t have to spend half an hour reading and parsing them figuring out what they allow you to do. They cover every development need I ever have. They also have the advantage of all being officially GPL - Compatible Free Software licenses (see http://www.gnu.org/licenses/license-list.html#SoftwareLicenses )
I don’t use downloaded software without reading and understanding the license first, so anyone who uses some new license I’m not familiar with, when one of the old ones would have done, is wasting my time.
My own software license (yes, I have actually used some version of this in software I produced long ago). I call this the DBML (Don’t Blame Me License). It’s VERY muck akin to “Works On My Machine”:
This software is released as-is for the general good. It may be used without permission for any reason as long as my name is contained in the documentation somewhere. I don’t care if it’s highly visible or not. I claim no responsibility for damages that may occur to any person, place, thing, idea or noun through the direct or indirect use, misuse or disuse of this product. Caveat lector.
– Yes, I’m aware “Caveat lector” means “Let the reader beware” and that Caveat emptor is “Let the buyer beware”.
Good article, but your description of the LGPL is far more onerous than it ends up being, and it’s quite practical to use the LGPL in a commercial project (Apple uses KDE’s WebKit for Safari, for example). The rules are:
Use the library in .dll/.so/.whatever-apple-uses; don’t statically link it
If you make your own tweaks to the library itself, send those tweaks back to the original author, preferably in Unified diff format. That’s not so hard/capitalism-hating, and it’ll get your company street cred.
GPL is actually probably the best license for capitalism. With the GPL, you can release your software for free use by the free software world, and charge people who want to license it for commercial use. This is the most viable free software business model I’ve seen (closely followed by charging for support), and it’s used by a large number of companies.
It also forms a least-common denominator for license compatibility. If you use a GPL-compatible license, and Bob uses a GPL-compatible license, and Sue uses a GPL-compatible license, I can take the code written by all three of you, and combine it into a single project under the GPL. GPL-compatibility is essential for any free software license.
It’s also a safe license to use early on, before you’ve evaluated other licenses – it is by far the strongest license, legally (it’s been evaluated by massive numbers of lawyers), and it doesn’t give too many rights. If you want to use a more permissive license later, you can. If you release under a more permissive license, and find that you don’t like it that someone is proprietizing your code without paying you, you can’t take back the rights already released (you can for future code releases, but the anyone who downloaded the original once can use it under the earlier license).
The only licenses really worth considering are: Proprietary, GPL, LGPL, MIT/X (or the new/rewritten BSD), public domain. These go in increasing order of permissiveness. This gives maximal compatibility with existing free software code, makes for a well-tested license, and lets people know how you’re licensing your code without having to read a bunch of legal fine print.
Jeff didn’t even scratch the surface on how many licenses there are. Sign up at Sourceforge and create a new project. Look at the drop down of license types. And that’s not even counting the different versions of each license. God forbid you work for a company and decide to release a library or application to the public. Then you get the “technology transfer” people involved.
Most developers will spend more time deciding on which license to use and figuring out the difference between all of the licenses than they will developing the app they want to license.
Eh, I just use a very simple approach for things I make on my own time or am allowed to release: If I use Qt/KDE, it’s GPLed out of necessity. If not, I just put it under MIT/X11. Problem solved.
By not choosing a license, you have what Mr. K mentioned above. Whatever license you choose, you, as the author, still have copyright. The license only specifies what others can and cannot do with the software. If the license doesn’t mention if you can do something, then you can’t do it.
Personally, I’d choose GPL because it gives me the best chance to get some money out of Microsoft should they want to use my code. Anybody else, I just wouldn’t charge as much. After all, I am a capitalist.
To add to the confusion, there are multiple versions of GPL.
GPL can be used in proprietary software. Just add Google. It only requires you open up your changes to the code if you distribute your product. So if you use GPL for a webservice, you’re covered.
Well that is if you use GPL v1 or v2.
Early drafts of GPL v3 attempt to revert this by requiring give back when code is “released” as a web service. This is controversial and I don’t know if they’ll keep it or not.
I use the zlib license ( http://www.gzip.org/zlib/zlib_license.html ) for all my libraries, since it’s simple, to the point, and permissive. The GPL is used for programs, because it’s the de-facto standard Free Software license.
I’ve never understood the whole argument about “leave my name in the source code” - heck, I’ve written quite a few lines of code that I’d rather someone else took the blame…errr…credit for.
@David H.: FWIW, in DBML I leave the “leave my name in the documentation” because at the time I wanted to see where my code wound up as it wandered this wide wild world. Sort of akin to wheresgeorge.com or that one company that encourages you to put a tag in a book and leave it somewhere it can be picked up for free and registered online to see where it has been.
Creative Commons licenses are not intended to apply to software. They should not be used for software. We strongly encourage you to use one of the very good software licenses available today. The licenses made available by the Free Software Foundation or listed at the Open Source Initiative should be considered by you if you are licensing software or software documentation. Unlike our licenses – which do not make mention of source or object code – these existing licenses were designed specifically for use with software.
Creative Commons has “wrapped” some free software/open source licenses with its Commons Deed and metadata if you wish to use these licenses and still take advantage of the Creative Commons human-readable code and Creative Commons customized search engine technology. You can find more details here.
For example, you may want to reserve all rights to your writing, but release code snippets as public Domain or under a more permissive license such as a Creative Commons or Open Source license.
the next time you release code into the wild, do your fellow developers a favor and pick a license-- any license.
I would slightly amend this statement: do your fellow developers a favor and pick a COHEARANT license. I see a lot of people just rattling off something official sounding at the top of their code, often resulting in unclear, vague licenses that are actually worse than having no license at all.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE. IT CAN BE DISTRIBUTED FREE OF CHARGE AS LONG AS THIS HEADER
// REMAINS UNCHANGED.
//
// Email: yetiicb@hotmail.com
//
// Copyright (C) 2002-2004 Idael Cardoso.
At first glance, this license seems unrestrictive, but the clause “IT CAN BE DISTRIBUTED FREE OF CHARGE AS LONG AS THIS HEADER REMAINS UNCHANGED.” is actually extremely restrictive. The license says nothing about modification, derivative works, and is actually incompatible with a number of other licenses.
In any event, the author’s mistake here is not going with a standard, known license. I suspect he was going for something sort of like an MIT license, but ended up with something that makes almost no sense at all.
For what it’s worth, I agree with the tone of this blog posting: licenses suck terribly, but nothing sucks more than people who vomit some official sounding rubbish at the top of their source files and expect other people to bother trying to parse cryptic clauses.
“Speaking of which, I mentioned in my blog post today that it is a good idea to license code snippets in a blog differently from the main blog content.”
Now I gotta license my code snippets in my blog posts?
