I was reading the Open Handset Alliance FAQ recently, and noticed that it mentioned the old source code licensing issue. That, along with a few emails I’ve received regarding my own code, made me decide to briefly state my own position on source code licensing.
I’m a developer, and I’ve released my fair share of code as open source. I get a kick out of it, and I’m going to continue to do it. The license I release my code under is a simple attribution license (similar to various other more widely-used licenses out there).
I generally do not release code under the GPL (though on rare occasions I’ve issued specific source packages under that license for certain people). The reason is simply that I’m not a big fan of the GPL. I understand the goal, but it’s not compatible with my own reasons for releasing source code, which are:
- To contribute to the developer community.
- To remain visible in that community.
- For my own vanity.
- For general good karma.
The essential part of releasing source code for me is to get it used by as many people as possible. I derive a lot of validation from downloading a demo of a new app, seeing something familiar, checking the About window and seeing my name in there. It’s a very pleasant feeling, and I’m genuinely pleased that others have found some of my code useful. You can see a list of a few of them here.
The GPL doesn’t really sit well with that, because idealism aside, most things just aren’t free (at this point in history, humans still used currency, Spock). The vast majority of software developers want to be able to charge for their software, or at least retain the option to do so in the future, and the easiest way to do that is to keep it closed-source. I want those developers (the majority) to be able to benefit from my code. I want my code to be in those apps – as well as the free and/or open source ones.
Now, don’t get me wrong: licenses like the GPL can be a powerful tool for affecting change, or for advancing a certain ideology. Open source operating systems, office suites and the like have had a significant impact on how our industry operates, and even on how people think about software in general. They have also undoubtedly promoted competition, and lowered (to some degree) the financial barriers against widespread computerisation. Releasing an entire application under the GPL can be a very effective way of ensuring that application’s utility for a long time. That’s all great, and I hope it continues, but there’s still this issue of time and money.
Development takes time, and by convention we all agree that a period of time spent applying skills has some kind of monetary value, presumably because of what else we could instead be doing during that time to increase our income and/or net worth. It’s not a particularly pleasant way to view things, but it’s the foundation of our economy, so there you have it. When I release my code as open source, I pretty much kiss goodbye to any chance of directly profiting from it – but I don’t see why I should have any right to force that same decision on those who use it.
Indeed, wouldn’t that be unbelievably arrogant? You can use the code, but you can’t use it in closed-source software… um, thanks but no thanks. For me, that’s hijacking the basic intent of releasing source code, and instead making it into a political platform at the expense of those who would use it.
I strongly disagree with the viral aspect of the GPL, but I acknowledge that it’s a philosophical issue. I’m interested in having my code used, whereas the GPL is interested in having code always available. The sad fact is, such an availability guarantee in many cases limits actual usage. As developers, we’ve all googled for some code which does something-or-other for use in our closed-source app, found a decent sample, then been forced to throw it away because it was released under the GPL. Releasing library code, or samples, or technology demonstrations or other fragments under the GPL is frankly perverse.
I write code which I then release for others to benefit from. I know that a large subset of those potential users will discard my code out of hand if it forces an entire philosophy and business model upon them, even if their users may one day theoretically appreciate being able to grab the source for the relevant app and modify it.
For the type of code I release (i.e. components for use within other, larger pieces of software), I’ll take widespread current use and utility over theoretical future availability any day. Because I’d like my code to do some good now, definitely, instead of later, maybe.