GPL or BSD License: Confusion Galore

I have been working on a new project, Wikiply, for the past few weeks. Very little code has been written because I am still in the planning and designing phase. Things have been progressing smoothly except for one issue that sways me multiple times a day: licensing. Should I choose GPL or BSD license?

There are many, many posts online discussing the issue of GPL and BSD license. I have read a lot of them and they all make good points for and against GPL and BSD license. But the more I read, the more confused I become.

I started with the notion that GPL should always be used in open source software. I also thought that releasing software under BSD license was letting others take advantage of your hard work without giving anything in return; a highly unfair practice. My thoughts have changed a bit. You can read all about the regurgitated pros and cons all over the Internet. I’m looking to introduce a new perspective, if I can.

Let us first think of the developer, someone like me. He has to create a project that will utilize some code from other projects, be they libraries, embeddable code, or whatever. If he chooses code licensed under BSD, he has more freedom on what to do with the code. However, if he chooses code licensed under GPL, he now has an added responsibility: release his code under GPL as well. GPL seems to restrict his freedom on what to do with the code but it ensures that if he used someone else’s code, he has to let others use his code in the same manner.

Using code licensed under BSD license gives the developer lots of freedom to distribute the code under any license, provided he maintains the copyright notice and information. The developer now has to care less about his legal responsibilities and can focus on the code. He can take open source code and use it to make an even better code base. By reducing the burden of a developer, we increase the chance of him building better products.

For some projects GPL is the perfect license. Something like the Linux kernel needs to force others to give back after they take so that everyone can benefit and work doesn’t need to be duplicated. But that’s not to say Linux would not have been where it is without GPL (alright, maybe a little). The different BSD OS flavors (FreeBSD, OpenBSD, NetBSD, etc.) all exist, and have existed for close to 20 years, with the BSD license. They may not be as popular as Linux but in technical terms they are as good if not superior. Their using an “open source” license rather than a “free” license hasn’t resulted in a closed source OS that has taken the world by storm and left everyone else in the dust. Yes, parts of Mac OS X are from the BSD world but OS X is more than just its BSD lineage. It’s a perfect example of how “open source” helps millions with their computing. There’s no financial incentive or payback for the BSD developers in this case but it’s a matter of pride nonetheless.

Proprietary software developers have three options: (1) use GPL code and release their own code under GPL; (2) use BSD licensed code and release their code under any license; (3) create their own version of the code from scratch. In the best of situations, all code would be “free” but that is not always possible. In the worst of situations, all code would be proprietary and that is certainly possible, given the financial incentives it entails. But in the real world, some code is proprietary, some is “free”, and the rest is “open source”. “Open source” bridges the gap between proprietary and “free”. It gives an opportunity to a developer to choose his own path: does he want to be restrictive (against the benevolence shown by others) or does he want to be benevolent like others? So at each step in an “open source” license, we trust the judgement of the involved developer. Some will decide to be benevolent and others will not. That’s exactly how the world is anyways.

Not everyone who releases code under GPL can enforce its conditions. That includes small-time developers like me. We think that since we have released our code under a “free” license that others will respect the license. This is false security, pretty evident from the rampant software piracy in many parts of the world. If proprietary code can’t always be protected or licenses enforced, what chance does a “free” license have? On the other hand, as a developer, I sleep easy knowing that I did all I could to make sure I didn’t adversely affect a benevolent developer’s responsibilities and choice when I used BSD license. To me, BSD license is more of “do what you will” license because I want you to and also I can’t stop you from it.

Eventually, you have to decide how you want to approach code. Do you want to write something you are proud of or do you want to write something that gets you recognition? Are you writing code that you expect to be re-distributed multiple times or might be re-distributed a couple times and then stay in a data center somewhere? BSD is being benevolent to the next person who uses your code while GPL is being benevolent to the person after the next person who uses your code (while putting this next person in a licensing conundrum).

There’s the possibility of dual-licensing your code with GPL/BSD but I don’t like it because it might create even more confusion, hence legal burdens, on developers. Let’s try to keep things as simple as possible for us and for those who wish to use our code. You could even dual-license GPL/proprietary but if our goal is to provide “open source” or “free” code, why even go the proprietary route?

A good point comes from finite, who wrote “I am very glad that our code is MIT licensed. It doesn’t matter who ends up owning the copyright on my code in the future, because I have licensed it to myself and the world under a completely non-restrictive license.” So BSD gives you complete authority over the code even when you are not the copyright holder. Sure you can’t change the license of the written code but you are not artificially bound by any other means.

My take is this: don’t get stuck on one side of the fence. If your code will be used to create applications with mass distribution potential, use GPL so that more and more developers have access to the modifications and enhancements. If your code will be used in applications that are not distributed but function in a service-oriented role (web application, etc.), use BSD. So a kernel, with potential for mass distribution, ought to be GPL and a Wiki engine, most likely just installed and not modified before distribution, ought to be BSD.

Edit: I modified this post to address some points raised by cultic_raider.

Edit 2011-10-28: I have received some feedback from others on this issue, and as anyone would have guessed, both licenses have their supporters. I am leaning toward the BSD license for these reasons. I don’t expect my code to be used and then distributed under a restrictive license because it’ll probably not be so ground-breaking to warrant it. Even if others take my code, modify it, and release it under a restrictive license, my code is still open source so anyone (even I) could make similar modifications and release them under an open source license. BSD license allows other developers to include my code in their BSD code or GPL code so presumably my code can continue to live on in other products with non-restrictive licenses. I want other developers to have an easy time using and distributing my code because I have two users: end users and other developers. My code benefits end users directly but if other developers modify my code and the end product (with or without an open source or free license) also benefits end users, I win both ways. Any modifications others make are their own code and they should have the freedom, like I do right now, to release their code under conditions suitable to them. BSD lets me provide equal benefit to my end users and to developers consuming my code. If I release my code under GPL, my end users benefit and end users of other developers who modify my code benefit but the developers themselves are not free to make their own choices. This is good for the code but I want to be good to the developers as well.


8 Responses to GPL or BSD License: Confusion Galore

  1. Flimm says:

    The GPL and the BSD license are both “free”, and “open source”, as they are approved by both the FSF and the OSI…

    A license is free according to the FSF if it respects the four freedoms, which both the GPL and the BSD licenses do. A license is open source according to the OSI if it allows the recipient of the code to redistribute the code, which both the GPL and the BSD licenses do.

    The term you’re looking for is “copyleft”, which applies to the GPL but not to the BSD license.

  2. I applaud you on not taking a religious approach towards these licenses, and ultimately I think it’s up to the originator of the code and what their desires are. I also think you comment about to whom the license is benevolent provides an accurate spin on things without being overcritical of either.

    The conclusions you reach are somewhat interesting. Lots of end user distribution -> GPL, limited code/binary distribution -> BSD. I’m not sure I agree with this, I think it more has to simply do with what the originating author wants out of recipients and those who might modify their code and potentially redistribute those modifications. I can imagine situations where either license might seem appealing for small or large distribution situations however… Aside from expectations of users/modifiers of one’s code in picking a license, there’s also the effects that it will have on the types of audiences that might be interested. There are a lot of commercial companies that won’t touch GPL code for projects for both justifiable and unjustifiable reasons, and the choice of that license may limit code adoption depending on the target audience and their willingness to use GPL code. On the other side of the coin, people can use your BSD code and never give back modifications even if they distribute binaries. I also have some minor nagging suspicions that the license also tends to influence the type of community that grows up around the code (perhaps encouraging a more closely knit community around GPL projects.. but I suspect that there are a great deal more influential components in deciding this than the license).

    Personally, I would lean towards a “permissive” license since I think that the GPL, especially with v3, is showing more of a religious bent than I would be comfortable with. Also coming from a more academic background, I’m more interested in getting something useful out there and that being of utility than I am with forcing someone to use it in a particular way. All of these licenses (MIT included) ensure that if you had your name on a project or code and it’s redistributed that you get credited, so at least in a legal sense, as an author, you or the parent organization of the project should get credit for its contribution to something else (closed or open). As far as a wide distribution model is concerned, this is why you can find Lua in bucketloads of games (MIT), Ogg Vorbis (BSD-ish for libraries/SDKs) has been used in a lot of games for audio and for the format-of-choice for Spotify. Then there’s stuff like sqlite (public domain) which is in damned near everything.

  3. Pingback: Links 27/10/2011: Chrome 15 is Out, Mozilla Sells Out to Microsoft | Techrights

  4. Oli Warner says:

    When you understand the ramifications of both license, there isn’t too much to be confused about. You’re left with a choice that you’ll make based on two decisions

    1. Do I care about what happens with my code?

    2. Do I want my code to be able to be included in any project?

    If you care about the future of your code (an analogous question would perhaps be: “Would you mind if somebody took your code, made changes and released it under a restrictive license?”) you might want to steer away from non-restrictive licenses.

    If you just want your code as it is to be available to help as many people that can implement it, MIT, BSD, et al are options.

    The size and utility of a project will often be factored into the decision. If it’s just a library, lots of people don’t really care as long as their version is out there for people, chances are nobody will improve on it enough to warrant closing it down. If it’s a large application (eg Firefox, Linux, MySQL, etc) you might care a lot more that people could take it and pass it off as their own product, without feeding anything back into your code, and often more importantly, the code that the community also uses.

    GPL+commercial licensing is popular for bigger projects but it does complicate things because if you take contributions from users, you have to make sure you’re allowed to relicense their contrib under your commercial license. This typically means copyright assignment or some sort of agreement (see Canonical Contributor Agreement. Fedora, Oracle and others all have something similar too for certain projects)

    Again, it all boils down to personal preference; just note that once you’ve done it and somebody has downloaded it, there’s no revoking that license (assuming you don’t go for a license that has those caveats – which would probably make it technically non-free).

  5. Michael says:

    The GPL is a license/contract while BSD/ISC/MIT are emotionless copyright statements.

  6. twitter says:

    Your first thought were right. The rest is what you say it is, regurgitated confusion. If you care about your users, you will GPL the code to make sure they always stay free. You should care about your users because you are one for all the code you did not write. The GPL prohibits most of the nasty things people can do with your code otherwise and this promotes a stable community that often leads to commercial exploitation. Good luck with your code.

  7. Harley says:

    An online acquaintance reverse engineered an MMORPG server that is no longer supported by the developers and the official servers have been shut down. He was able to create a server so the game could still be played. He did so as an open source project released under the GPL. As the server neared feature completion with some people starting to use the server, a group took the GPL’d code, made some changes and ran the server. The original author requested for them to submit back the changes they’d made and they refused. The original author had no legal right to force them to release the code because they 1) downloaded the GPL’d code, made changes in private and 2) didn’t distribute the binary. Instead, they just ran the server themselves. Because they weren’t distributing the binary, they needn’t distribute the sources. The original author relicensed all available versions he had put out under the AGPL. This would require the sources to be made public even if the software was compiled and the server was run. This however would not prevent the other party from continuing to use their already obtained GPL version (or others for that matter) of doing something similar with the previously licensed code.

    In this case, the author very distinctly wanted a copyleft project because of the niche it filled. He wanted everyone working together and for the project to not be splintered off into many versions of varying quality. In this case, the GPL allowed another group to exploit the contract by not distributing the binary but still running the server.

    Really, I would say how you license your project really depends on the project, the desired community, if you care how people use it, your personal beliefs, etc. As some have said, some projects flourish because they use a MIT/BSD style license (Lua) and others flourish because they use a GPL/copyleft license (Linux kernel.)

    I personally tend to prefer AGPL/GPL/LGPL but always carefully consider the MIT/BSD as an option. Philosophically, I’d prefer my code to always be open, so anyone can use, update, read, etc it. I also consider the community. For instance, if I’m developing something in Lua, the MIT license is the norm for projects/libraries. I’d likely follow the trend in this case. As another example, I’ve developed a small C library for an out-dated game console that can be used as a base to create games for the system. The perspective developer community is very small (perhaps 50 at best developers world-wide, though probably closer to the 5-10 range for active devs.) In this case I felt it was better for the community to just have the code with as few strings attached as possible (without actually just making it public domain.) In this case I chose the 2-Clause BSD License.

    Just my 2¢ on the subject.

  8. gallery says:

    A fascinating discussion is worth comment. I think that you ought to publish
    moree on this subject, it might not be a tabopo matter but typically folks don’t talk about such subjects.To the next!

%d bloggers like this: