Open Source Licences Wars - Revision 2

When Joel Spolsky (“Joel on Software”) wrote his notorious blog post “Language Wars”, many people asked whether he has “jumped the shark” and that his blog will go downhill from there. After reading the post, I agreed, that while it had a few good points, it was based on “feeling rather than knowing” too much. Joel later on posted many good articles and shorter entries on his blog, but many people still recalled it as a very low-point in the blog.

Like Joel, I have a home-site and several blogs, where I post articles and essays about my thoughts, and this time I’ve decided to risk something similar to what Joel has done on an equally flamatory topic: licences of open-source software. I’m going to introduce the various options, explain a little about their motivation and then give some advice according to my own personal opinion.

I should note that I am not a lawyer, and only write this according to my best knowledge, understanding and experience. ^[IANAL] I think what I’m writing here is correct, but would still appreciate any correction for future versions. If you’re unsure about my advice, then you should consult a legal expert (if you can afford one) or your local or global Free and Open Source Software organisation. I cannot guarantee my advice is valid.

The first thing I’d like to note is that it is not entirely agreed upon which licences are free/open-source and which are not.

The original Artistic License (authored by Larry Wall for dual-licensing perl) is:

(Who are you going to believe?)

The Artistic License was later clarified into the Clarified Artistic License which incorporated the minimum changes to make it “free” and GPL-compatible, and now has a new and improved version - Artistic 2.0, which is considered free and GPL-compatible by everybody, and is generally preferable for newer projects.

Moreover, the Apache 2.0 License was specifically phrased to be GPL-compatible, and is considered GPL compatible by the Apache Software Foundation, but the FSF concluded that, while it was a free-software licence, it was not compatible with the GPLv2 (although it is with the GPLv3 that was published afterwards). Their legal teams still disagree on that matter.

The Creative Commons Attribution (CC-by) and Attribution-ShareAlike licences (CC-by-sa) are considered free (but not GPL-compatible) by the FSF (see their licences page), while the Debian legal team concluded that they were not free up to version 3.0, which was. ^{[DFSG-for-non-software]}

Another curious licence is the Affero GPL - - which aims to close the “Application Service Provider Loophole”. What it means is that if I install an AGPLed program on a public web-server and modify it then I must make my modifications public. However, the Free Software Definition , says that one must have “The freedom to study how the program works, and adapt it to his needs.”. As a result, I personally don’t consider the AGPL as free (because I may wish to run it on my publicly accessible web-server and modify it), but the FSF thinks otherwise. We have enough problems with the suitability of the GPL for embedded systems, that we don’t need to undermine the prospering web-apps market too.

The so-called “GPL vs. BSD” war probably started from as early as the time when the GPL was phrased in stark contrast to the BSD or generic permissive licences used up to that point by the free software community. Here are some links that I can recall:

Of course, this is just the tip of the iceberg. Searching the web for “gpl bsd” and similar searches will yield many other resources. So let’s move on to my recommendations.

Now that we covered the controversy of whether some licences are open-source/free software or not, let’s move on to which licence you should choose. I’ll start with some bad ideas of what not to do.

I personally accept the fact that some developers would like to use weak copyleft or strong copyleft licences for their works. However, I still prefer to use the MIT/Expat License for works that I originate and now I’d like to explain why:

When I posted an early draft of this essay to the Hackers-IL mailing list, I received a comment about the fact that GPL (or other strong copyleft licences) prevent threats to free and open source software. I’d like to reply to it here.

Quoting from the comment:

My response is that this was indeed a problem and inconvenienced the users of Exceed. However, if X-Windows were GPLed, then the people who made Exceed and wanted to sell it, might not have made it in the first place, because they had to make it GPLed and keep it as FOSS. So either they would have implemented it from scratch or not at all. It is possible that a different group would have created a free X server for Windows, but it is possible that no free X server would have been available at all. And if a different group could have created a free X server for Windows without Exceed, they could have certainly created it with it.

Furthermore, If X11 had been initiated under a non-BSD-style-licence, then it is possible it would not have become as ubiquitous as it is in the UNIX world, thus making it irrelevant to port it to Windows in the first place. We can’t tell that for sure, but I think it is a possibility.

Quoting again:

Well, first of all I should note that that is a lot of “if”’s. When I started working on Freecell Solver, there were already plenty of graphical Freecell games, possibly with support for other variants of Solitaire. And there were also several open-source ones, including some very polished ones.

As a result, I could have easily integrated my solver into one of them. So his thought experiment is not very realistic, although it may be valid in the general case.

Back to the thought experiment, a person who would be interested in creating a commercial Freecell UI and still integrate a solving mechanism to it could:

In all of these cases, we won’t have a graphical game as FOSS.

Finally I’d rather have a proprietary derived work than no derived program at all, or that instead someone will duplicate my effort in creating a BSD-style or a proprietary replacement for my work.

In my coverage of the reasons of why I prefer permissive licences instead of weak copyleft or strong copyleft licences, I probably missed the one that was the most important for me.

I’ll start with a little history. Back when I got my first computer - an 8088 PC XT with two 5.25" 360 KB diskette drives, and no hard disk, I started programming in BASIC - first the one that came on the BIOS and then BASIC.COM or GWBASIC. (BASICA wouldn’t run on my computer, for some reason). Back then, I programmed mostly games and my friends and I shared tips and programs between ourselves.

I took a long break from programming, and then started programming BASIC again - this time QBasic. Then I got my father to buy a C compiler and he bought me Borland Turbo C++, which I used for somewhat more “serious” stuff than BASIC (though I still used QBasic). Back then I wrote two libraries-of-sorts - called CCalc (for various mathematical routines) and CSee (for graphics) which I intended to distribute as shareware. I don’t recall if I planned to include the source.

I’ve now made them, and some other C code from that era, available as free and open source software under the Expat Licence.

In any case, back then we were used to the fact that we have to pay for our software, so I probably thought that making these libraries public-domain was not worth it.

After I started getting into the world of UNIX, Linux, GNU, and open-source, I realised there was a lot of software out there distributed with the source, which I could download and compile. I used to think of prep.ai.mit.edu (the old primary FTP host for gnu.org’s software) as a cool collection of source code, which I could download, read the INSTALL file, build and install (sometimes after fixing the source). I wasn’t interested in the implications of its open source nature or the GPL licence. I also downloaded other software. I did know the software was gratis, as opposed to MiniSQL/mSQL which was sourceware and shareware. That was good enough for me.

After I became more involved and started playing with Linux for developing software on it, I learned even more and understood what “free (as in speech) software” (or as it was later called “open-source software”) was all about. One thing I understood back then, was that it took me a long time to fully get to the bottom of all the GPL’s nuances, and that I thought the public domain was preferable, because I didn’t care too much about people changing the licence to something else, or using it in their own non-free/non-GPL-compatible software. A lot of people I have talked with since have exhibited many misunderstandings of the GPL.

In any case, I had initiated some FOSS projects under the public-domain which didn’t amount to a lot. I also wrote a patch for GIMP, which I have made available, but which has since then required some other iterations and incarnations to be incorporated into the mainline GIMP source code. And then I released Freecell Solver (originally licensed under the Public Domain - now under the MIT/Expat licence) and did a lot of extensive work on it. After that, I started some other moderately successful MIT/Expat projects, or contributed to or adopted FOSS projects under various licences.

So why am I still sticking with the MIT/Expat licence? The main reason I think is that as an open-source programmer, I’m not interested in worrying about how people abuse my code. I don’t like Apple Inc., and am not fond of many Microsoft products. But I’m not interested to prevent Apple or Microsoft or any other developer of commercial and/or proprietary software for Windows or Mac OS X or the iPhone or whatever from using my code in their projects. In fact, I would prefer them to use my code than to create a proprietary replacement. Not to mention that making my code GPLed may also make it inappropriate for reuse by some developers of BSD software, for inclusion into the core BSD distributions, for some developers of non-GPL-compatible-but-still-open-source software, etc. I don’t want that - I want my code to be of the maximal use possible.

I should note that I’m more worried about my code being used for malicious purposes by evil governments, as I think no big corporation in history has been as abusive as some past and present governments that come to mind. But preventing internal use or “defence use” or government use or whatever will make it non-FOSS, (and non-GPL-compatible), not to mention that adding random restrictions (e.g: “cannot be used by Neonazis”, “cannot be used by terrorists”, “cannot be used by ‘Zionists’”, etc.) will fragment the software licensing world as a whole, and I would prefer not to open that Pandora Box.

Back to the topic: I don’t want to be bothered about legal issues with my software. If you want to use my code - use it. “Drive safely, the keys are inside.”. If you encounter any technical problems with the code (bugs, documentation issues, etc.) then I’d be interested to hear about them, because that will improve the quality of the product, which will hopefully make it even more successful. But I didn’t become a FOSS developer so I can sue people for violating the licences of my works. I have better things to do with my time, that bring me much more benefit.

Now, on to the issue of whether developing BSD-style code makes me a “sucker”. I covered it earlier in “The GPL, the BSD, and being a Sucker” mini-essay.

To sum it up here, I don’t see why contributing to one’s neighbour (or the public at large), willingly and on one’s free time (which may be called “donation”, “philanthropy” or even “altruism”) and for a non-harmful cause can be considered as being a “sucker”. Everybody is able to use GPLed software of various originators free-of-charge or put it into good use in many legal and legitimate ways, too. Yet you don’t hear that often that people who develop GPLed software are “suckers”.

I don’t see myself as a sucker just by allowing third-parties (whether individuals, corporations, governments or any other organisations) to use my software in non-free contexts, and don’t think anyone should say that the GPL is the “don’t-be-a-sucker” licence because BSD-style licences are by implications “be-a-sucker” licence. I hate selfishness. (And I don’t mean “rational self-growth” or acting-out-of-one’s-own-best-self-interest, which is what Ayn Rand meant in the book The Virtue of Selfishness - I discuss it in the link briefly).

Another argument that you can often hear against the BSDL was that the Linux kernel was more successful than the BSDs due to its GPLed licence. However, this is:

While I’m still using GNU/Linux (Mandriva Linux Cooker in my case) because that’s what I’ve grown accustomed to using, I would still like to play with some BSD derivatives and OpenSolaris. I’m also not planning on switching to gNewSense or one of the Free Software Foundation’s endorsed “100% Free Distributions”, because Mandriva is free enough for me.

To sum up, I’m not trying to dissuade you from licensing your software under weak copyleft or strong copyleft licences, but I’m still happy with my code being BSD-style. I’m glad to learn of any use someone has been making of it, and in the few times it has been used in commercial or proprietary contexts, it did not make me regret that I released it as FOSS. I hadn’t wanted it to be an issue in the first place, and so it wasn’t. Hakuna Matata.