Introduction
The Free Software Foundation [FSF1] touts the GPL[GNU1] as an all singing, all dancing defender of your freedoms. We are told that the GPL is at the heart of defending four freedoms:
- The freedom to run the program, for any purpose (freedom 0).
- The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this.
- The freedom to redistribute copies so you can help your neighbor (freedom 2).
- The freedom to improve the program, and release your improvements (and modified versions in general) to the public, so that the whole community benefits (freedom 3). Access to the source code is a precondition for this.
[GNU2]
I assert though that the GPL does not give us freedom, merely different restrictions. I even assert that it does not give us all of the freedoms listed above. In this post, I will argue that the GPL is inherently flawed when it comes to freeing software.
What did I write?
Allow me to take a detour before we begin. I would like to investigate a related topic that is at the core of my argument, and that is the question of exactly what code you wrote. Let us imagine a typical scenario – you are the author of a free, open source library. The purpose of your library does not particularly matter, so lets say it encrypts widgets. You pour your heart and soul into your library, and it becomes stable and fully featured. This diagram represents the project as it stands:
You are proud of your project
So lets now suppose that a third party takes your code, and builds upon it. We might represent this as such:
A large, and a small addition to your project
What’s important to realise here is that the amount of code you have written has not changed. Even if the addition that the 3rd party writes simply wraps your library with a pretty GUI, the amount of code you have written has neither grown, nor shrunk.
What you license
Okay, so now let’s ask the question. What relevance did that have? Well, it helped clarify exactly what you are licensing when you attach the GPL to your code. You are licensing your code, and only your code. And yet, the GPL makes a restriction on the license for the derivative work. Noting here, that the derivative work is wholy someone else’s work.
The most common argument I hear pushing the GPL is that with a weaker license (say, BSD[BSD1]), a third party can take your code, extend it, and close it. So let’s think about what that means. In order to close your code, they would have to have taken it, removed all open sources for it, and then rereleased it in a closed form. But that doesn’t make any sense. You’re still distributing your source code under a free and open source license, so how have they closed it? They haven’t – your code has remained open source. So then, what have they closed? Well the answer is, their code, and only their code is closed source, and that’s fine – it’s their right to license their code in any way they like.
So the conclusion then, is that a company can come along, and take libWidgetCrypt and produce a thin wrapper around it, and start making an enormous profit by selling the result at $10,000. Yes, that’s possible, but it’s also a rather unlikely scenario. If all they’ve done is write a thin wrapper, then you, or someone else in the open source community is perfectly capable of making such a thin wrapper in no time at all. Then all you need do is undercut them by $10,000, and a good chunk of freedom.
The more likely scenario though, is that a company may come along and take libWidgetCrypt and produce a large amount of other code that just happens to use your library at its core. Then said company will sell their code, and their extensions for a large sum of money, and they are perfectly entitled to do so. It is after all, their code.
Believe it or not, this scenario is even one which is beneficial to you. Said company, is likely to find bugs in libWidgetCrypt, and fix them. From my experience of such things happening, they more often than not, contribute their changes back to you when they make such fixes to your library, even though they’re not required to! Yes it happens that they patch it and run with the patch, but again – they wrote the patch, they’re entitled to do that!
Where the GPL fails
I’ve now gone into detail a lot on exactly what you are licensing when you apply a GPL license to your code, but I haven’t looked at what I claimed I would show at the start of the blog. I haven’t told you why the GPL is not a free license. To do that, I’m going to concentrate on the last freedom that it claims to offer – “The freedom to improve the program, and release your improvements (and modified versions in general) to the public, so that the whole community benefits (freedom 3).” Suppose that I am a company, and I am building a product to release. I would like to use your library in my program, I would even like to improve your library, and release the improvements to the public so that the whole community benefits. Unfortunately, at the end of the day, I need to ship a product, so I’d like to keep the core of my project closed source. Unfortunately, the GPL outlaws this kind of interaction.
So, we have a good citizen, a company that wants to release their patches to your library back to the community, and yet, the GPL is banning them from doing so! It is not giving them freedom at all! Instead, the GPL is a different set of restrictions.
It may be that you personally find the set of restrictions that the GPL offers more morally palatable than traditional closed source licenses, but it is not a free license. It does not grant freedom, it grants different restrictions.
Conclusions
The GPL is not a free license, in that it restricts freedoms to only people it deems to be morally acceptable. Often, there are people who do not fall inside this morally acceptable box, yet do really have good intentions. Thus, the GPL is too restrictive for many projects. Instead, it’s often a good idea to use a truly FOSS license, like for example the BSD license. Doing so, will not make you vulnerable to companies magically making your code closed source, as you will continue to distribute it. It may be that they will close a small addition to your code and attempt to sell it for vast amounts of money. However, in that situation, you can just release the same minor change, and give it away totally freely too.
References:
[BSD1] http://www.opensource.org/licenses/bsd-license.php
[FSF1] http://www.fsf.org
[GNU1] http://www.gnu.org/copyleft/gpl.html
[GNU2] http://www.gnu.org/philosophy/free-sw.html
No Ordering 
“Noting here, that the derivative work is wholy someone else’s work.”
This sentence is confusing, becuase in terms of copyright law, a derivative work is precisely one that is not wholly the work of the “somebody else”. Perhaps you’re arguing that the new work should not be considered derivative?
I find it strange that you don’t mention the LGPL.
Perhaps I phrased that badly. The point I’m trying to make is that we’ve already established that your code is unaffected by someone making a derivative work, as is the licensing, and openness of your work. So the only thing that’s changed here is that someone else has written a whole bunch of code – thus it’s only really logical to say that the derivative work is the work they did, and only that work.
You’re right, I probably should have mentioned the LGPL, I think my argument mostly still stands up against the LGPL, with the addition that it’s a rather arbitrary choice that the LGPL makes to allow for dynamic linking, but not for static linking. Such a restriction seems rather pointless when we establish that you don’t really give away any protections of your code by using something more free like BSD.
[…] I Beelsebob’d him this time!* Anyway, he’s made a better start than I have by writing a nice article on why the GPL is in fact not free, but just restricting you in a different way. So go ahead and […]
“[…] I’d like to keep the core of my project closed source.”
In other words, you’d like to take away the freedom from users whom you distribute the software to? Or do you mean you’d like to keep your code private? The GPL doesn’t insist you release any improvements you make if you keep them private. You are only required to release the source if you are distributing the software (changed or not).
“Unfortunately, the GPL outlaws this kind of interaction.”
Of course, but I don’t see why this is “unfortunate”. The GPL is designed to give all users of the software (and its derivatives) the freedoms you’ve outlined in your post. The word “interaction” here is a euphemism.
“[…] a company that wants to release their patches to your library back to the community, and yet, the GPL is banning them from doing so!”
The GPL doesn’t prevent anyone from releasing patches to GPL code so I’m not sure what you mean.
“[The GPL] does not grant freedom, it grants different restrictions.”
You mean to say, it enforces different restrictions. Yes, and those restrictions are there to make the software free for all users. Naturally, we have the freedom to distribute binary-only software just as we naturally have the freedom to knock each other to the ground. The GPL puts restrictions on us to prevent us from taking away another’s freedom just as the law puts restrictions on us to prevent us from assaulting others.
If using the GPL makes you upset that you can’t make a buck by taking away user freedom, then realize this and state it as so. But to claim that the GPL isn’t a free license because it restricts you from restricting others is doublethink.
The GPL doesn’t insist you release any improvements you make if you keep them private.
The key to this sentence being you make – you made the improvements, you should be free to decide how they are distributed. The original code will stay as free as it ever would, but I, having written some code, should be allowed to decide how to license it.
Yes, and those restrictions are there to make the software free for all users.
No, as I outlined in the blog, they are there to make the software free if and only if you also like the GPL, that’s not freedom, that’s restrictions.
The GPL puts restrictions on us to prevent us from taking away another’s freedom
No it doesn’t – as I outlined in the article, it’s totally impossible to take away others freedom in this respect. You can not magically make a project closed source – the original code is still out there! The only thing you can do is make your code closed source – that’s not taking away freedom, that’s just choosing not to grant it in the first place.
But to claim that the GPL isn’t a free license because it restricts you from restricting others is doublethink.
Not at all – freedom comes with no strings attached. Take for example new terror laws – they’re brought in based on “preserving freedom”, and yet what they really do is introduce additional restrictions and erode our freedom. The GPL does the same thing. It erodes my freedom to release my code under whatever license I choose. Second to that, it gives no benefit while doing so as I outlined in the article. People can’t in reality “take your code and run with it” and start making enormous profits from your hard work, because if they really do just bundle it up and sell it, then there’s a free alternative sat there, and they’ll die in the market. If they really do make major modifications, then good on them – they should be entirely free to sell their code – they were the ones that did the modifications, not you.
“you should be free to decide how they are distributed.”
I disagree because when you distribute, you affect others. However, in practice you do have this freedom so the best we can do to counteract this is through copyleft.
“[the restrictions] are there to make the software free if and only if you also like the GPL”
This is a common misunderstanding regarding the GPL. If you have a copy of software under the GPL, you do not have to agree to the license (i.e. “like”) in order to *use* it. You only have to agree if you affect others by *distributing* it. As a *user*, you have complete freedom. As a *user*, you are free to hate the GPL and ignore it. Again, the restrictions are there to make the software free for all *users*.
“it’s totally impossible to take away others freedom in this respect.”
I don’t understand. Make some changes, distribute the software and don’t give the recipient the source. There, you’ve just taken away their freedom. In fact, this occasionally happens and the FSF is pursuing companies with lawsuits to address this.
“freedom comes with no strings attached”
As it has been said, “the freedom to swing your fists ends at the tip of my nose”. You can go ahead and argue that you don’t have freedom until you are allowed to punch me in the face without consequence, but you’re not going to win over many minds with such rhetoric.
The GPL says, users go ahead and do whatever you want to do with the software. You users don’t even have to agree to the license to use it in any way you want. But the second you affect others by *distributing* the software, we’re going to make sure you’re shaking hands instead of swinging your fists. That’s entirely reasonable and perfectly aligned with freedom.
I disagree because when you distribute, you affect others.
Do you? How?
As a *user*, you have complete freedom.
No, I don’t, as a user, I would like to go “hmm, this program doesn’t do what I want quite, I’m going to extend it with my code”, and then chose to distribute *my* code any which way I like.
Make some changes, distribute the software and don’t give the recipient the source. There, you’ve just taken away their freedom.
Have I? Which freedoms did they have before? The freedom to look at the source code of your work. What freedoms do they have now? The freedom to look at the source code of your work. Which freedom has disapeared? None.
But the second you affect others by *distributing* the software, we’re going to make sure you’re shaking hands instead of swinging your fists.
No. It enforces this not only for distributing the GPLed software, but also for distributing *my* software, software that may be totally and utterly useless without the GPL software, software that may be tiny compared to the GPLed software, and software that may be my life time work of genius (unlikely as that is). The GPL is making restrictions on something *I* made, because of *your* philosophical values. That’s unacceptable.
Of note, I find your argument deeply hypocritical – you are arguing that how I chose to distribute my code affects others, while also claiming that a license that affects how *I* distribute my source code because of *your* philosophy is a good thing.
“Do you? How?”
Through the license that falls under the law of course!
“as a user, I would like to go ‘hmm, this program doesn’t do what I want quite, I’m going to extend it with my code’”
And you are free to do that under the GPL. As I said, you don’t even have to like or agree with the GPL to do this.
“and then chose to distribute *my* code any which way I like.”
Then you are a distributor, not a user. But go ahead, distribute *your* code any way you want. Just don’t mix it with GPL code unless you agree to the license.
“The GPL is making restrictions on something *I* made”
How so? You are free to distribute *your* code any way you like. You often emphasize the difference between *your* code and *others* code. So, since you think this division to be so very important then there is no problem. Take *your* code and distribute how you like but don’t take *another’s* code (which is under the GPL) and expect to re-distribute it as you like. If you so strongly believe that when another person receives a copy of *your* code that it is still *your* code then the only “hypocrisy” here is complaining when *you* are told that software under the GPL is not *your* code.
But here is the icing on the hypocritical cake:
“That’s unacceptable”
Oh, so you say you should have the “freedom” to distribute *your* code any way you like but it is “unacceptable” for someone else to control how *their* code is distributed? Come again?
I think this article shows the posters failure to understand the difference between free as in no cost and freedom of information.
GPL software DOES carry a cost, just not a $ value one. The cost is that if you make use of GPL code you have to release your code as GPL code.
“The GPL is making restrictions on something *I* made”
The thing is when you make use of GPL software what you release is NOT something you have made. It is something built on the work someone else has done. That person has every right to put restriction on how their work is used.
It is up to you to decide if the “cost” of using GPL code is something you can live with, if not look somewhere else.
Had it not been for GPL Linux would not be the OS we see today. People would have tried to create proprietary versions that cost to use. There would not have been the contribution so everything would have been a poor shadow of what we see today.
I think either I failed to accurately explain my position, or you failed to read the article.
GPL software DOES carry a cost, just not a $ value one. The cost is that if you make use of GPL code you have to release your code as GPL code.
Indeed, that’s exactly the point I’m making in fact! The GPL advertises itself as a free license meaning freedom, while at the same time not giving freedom, instead giving a pretty hefty set of restrictions. Note that I’m not arguing in this that the GPL is not a useful license, merely that it doesn’t do what a lot of people seem to think it does.
The point I’m making is that whether you’re building on something someone else wrote or not, the thing you wrote was written by you. The original author is welcome to put restrictions on the part they wrote, but not the part that you wrote.
Peter Rock makes a good comment above, that of course, the GPL does in some way allow for this – you could in theory, release your work under the BSD license (or any other in fact) as a patch for the GPLed software – just don’t distribute the original software with it. Personally though I see this as a major hack though. If you can license this way anyway, why make it awkward for your users and require them to patch the software and build it themselves. Why not instead, preserve freedom properly, and just let people license their work how they want.
Had it not been for GPL Linux would not be the OS we see today. People would have tried to create proprietary versions that cost to use. There would not have been the contribution so everything would have been a poor shadow of what we see today.
I don’t think that’s true at all. FreeBSD demonstrates this fact – FreeBSD is much more advanced than linux in many respects, and indeed does have some closed source variants out there, but that hasn’t held it back. If anything, they have benefited hugely from having huge companies like Apple and Sun contributing patches to them.
“The point I’m making is that whether you’re building on something someone else wrote or not, the thing you wrote was written by you. The original author is welcome to put restrictions on the part they wrote, but not the part that you wrote.”
Actually the whole point of GPL is the original author CAN control how you release your changes. If you make use of GPL code you HAVE to accept this. So YES the original author CAN control the parts you write/modify.
GPL is about free. Just not free cost. It makes sure that someone does not come along, use your code then close it to make a proffit. The source remains free and in speech.
“I don’t think that’s true at all. FreeBSD demonstrates this fact”
The BSD distros I have looked at have been a shallow version of most Linux distibutions. They lack the depth of hardward compatibility etc.
The difference you talk about though are normally based on Berkley vs System 5 *nix core. Which has nothing to do with GPL vs BSD liccence.
The Mac highlights the issue with the BSD licence. Apple take a BSD disto, wrap it in some sparkle and a crap load of DRM and lock it down so tight so they can screw every last penny from it. Then you look at iPhone which is OSx hence a BSD distro.
Apple take “free” software and wrap it in DRM so they can use it as a weapon. How is that free? “)
This is why the app I have just released was released under GPL.
Actually the whole point of GPL is the original author CAN control how you release your changes. If you make use of GPL code you HAVE to accept this. So YES the original author CAN control the parts you write/modify.
Exactly the point I’m making – this is *not* freedom – this is restrictions. You are not licensing your code freely (as in freedom, not beer), you are licensing your code under a very heavily restricted license.
GPL is about free. Just not free cost.
No it isn’t – the GPL, as you yourself pointed out above is about restricting people to not do something you happen not to like.
It makes sure that someone does not come along, use your code then close it to make a proffit. The source remains free and in speech.
And if you will read the article, you’ll see that the original source code does indeed remain free – a company can not take my BSD code, and magically make it disappear and impossible to download.
The Mac highlights the issue with the BSD licence. Apple take a BSD disto, wrap it in some sparkle and a crap load of DRM and lock it down so tight so they can screw every last penny from it. Then you look at iPhone which is OSx hence a BSD distro.
And that’s why you can download the source code to kernel and userland of OS X?
Not only that – but this is the perfect example of what I’m talking about. Apple by your reports took the code and closed sourced it. Yet somehow, I can still download all of the code to BSD. How did Apple close it if I can still download all the code under BSD license?
The answer: They didn’t – they closed sourced a GUI layer, which is entirely their code, and which they put an awful lot of effort into.
Apple take “free” software and wrap it in DRM so they can use it as a weapon. How is that free? “)
Because I can still download the source code and use it.
1) The BSD foundations are still BSD licensed.
2) Even apples kernel and userland is BSD licensed.
3) Apple wrote all of the GUI and are within their rights to license it any way they like – it’s entirely their code.
This is why the app I have just released was released under GPL.
Fair enough, if the GPL agreed with your idiology that’s fine. If you would like to restrict people to only using GPL licenses for their code or tighter, again, that’s fine. But what you are not doing is licensing your code freely, you are licensing it in a very restricted state.
I agree with you. I’m sure that’s a surprise!
An interesting read, and a few good comments as well. This discussion has however been going on for a long time, you haven’t added anything new to it, you’ve only let us know where on the spectrum of opinions about the GPL you come down.
What I thik is missing from your thoughts is the realisation that freedom isn’t an either-or, it isn’t absolute.
As the author of libWidgetCrypt Joe Blogs have copyright on his work. He then decides to grant some freedoms to others by licensing it under GPL. Fred Jones takes advantage of Joe’s hard work, but in doing so is furced by the license to release the derivative code under GPL as well. Sure, one could focus on the restriction that GPL puts on Fred, but doing so misses the point of the GPL (as I see it). The point is that GPL is a “tit for tat” license. Fred takes advantage of Joe’s work, and in doing so enables Joe to take advantage of Fred’s work. Furthermore, a 3rd party (Alice) is now able to take advantage of both Joe’s and Fred’s work. Most importantly, as a user who finds a bug, Alice is able to correct the code (the original use-case for the GPL, as I understand it from reading about RMS’s motivation for creating the license).
If Joe had released his code under a BSD-like license then the chain could have been broken at any time and Alice would not benefit from the freedoms that the GPL guarantee.
What I thik is missing from your thoughts is the realisation that freedom isn’t an either-or, it isn’t absolute.
Odd, that was actually exactly what I was trying to point out – you can’t claim to be granting freedom when taking it away from a certain group. You have to give absolute freedom, or you’re not giving freedom at all.
Fred Jones takes advantage of Joe’s hard work, but in doing so is furced by the license to release the derivative code under GPL as well.
That’s exactly what I’m trying to point out – Joe’s hard work is always available, and thus *can not* be taken advantage of. The only thing that Fred can abuse is his own work, because Joe’s will still be as free as ever.
Furthermore, a 3rd party (Alice) is now able to take advantage of both Joe’s and Fred’s work.
No, she isn’t, because if this third party really is hell bent on closed sourcing their code, then they will not use the GPLed code in the first place. Alice is in the exact same position as she would be with BSD’d code – able to modify Joe’s and fix the bugs, and not able to modify Fred’s and fix the bugs. Poor fred, his game plan hasn’t paid off very well for him, maybe he’ll think about open sourcing next time.
If Joe had released his code under a BSD-like license then the chain could have been broken at any time and Alice would not benefit from the freedoms that the GPL guarantee.
No, if Joe had released his code under a BSD-like license, then Alice would have got access to exactly the code that Joe has the right to dictate how it’s released – Joe’s code. She may have gotten access to Fred’s too if Fred happened to feel like licensing *his* work that way.
Conclusion: Alice would be no better off under the GPL, Fred would not have built anything making us poorer over all, and Joe would have had an overly restrictive license. In the BSD case, Alice would still have access to Joe’s code, Joe would have bug fixes from Alice, and possibly Fred, and Fred would have made something, and possibly learnt a lesson about opening his code up.
I completely agree with the original poster here. Those who are commenting that the OP does not understand the GPL do not understand the post.
A BSD-style license grants more freedom than the GPL for one reason: the GPL *forces* any changes to also be released under the GPL. With a BSD-style license, you can if you want to. That’s freedom!
So, where the people arguing against the OP come in is *after* that. The GPL *guarantees* that the software will remain free to the *users* (not the developers). The BSD license guarantees freedom to the *developer*. At that point, it would be up to the developer to decide whether or not to make his or her changes available under the BSD license. And, as a developer, I think that would depend on whether or not I just invested 5 man-years worth of time into my changes or not. I do have to pay for my house, you know.
BSD-style licenses won’t force a world full of free software. If we get there, it will be by choice.
I totally agree. But consider the GPL protects code, not its users. In a way you could say it’s also protecting users by protecting the code, but which users? Well, only GPL respecting users. It is a noble idea which has demonstrated to be very efective to keep companies contributing back their changes to GPL software. But we can also look at high quality/important BSD projects, like FreeBSD, Postgres, LLVM (if I’m not mistaken), xorg (MIT), and much more; and they are still successful.
I think if you develop some software that may be useful for someone else (be it closed source or open source), you could benefict more with a BSD style license because more companies are going to pick your project only because it’s “enterprise friendly”; if those companies improve your project (and their sole product isn’t entirely based on your project), then you are almost guaranteed to receive patches, as they most certainly want to also benefit from your project not dieing and being constantly supported for them. With the GPL license, you’re stuck with GPL loving community only, but you are missing the whole industry. Granted, not all companies will contribute back, but some will. And those that will do it willfully, without any GPL pressure, are the ones you want to keep closer.
I don’t disagree with your general argument, but ultimately it is a philosophical debate about freedom and people will disagree.
The only problem I see with your explanation is in your examples. What if someone writes a large and very useful program, releases their code under BSD. A huge company comes around, takes this program and markets it with its unlimited funds while changing almost nothing from the program itself accept adding a simple user interface. They spend millions on marketing and place it at a high but reasonable price. Millions of people buy the program, the company becomes huge. The original author attempts to add a simple interface for the program, the company sues him for copyright infringement.
Well, copyright infringement doesn’t apply in that situation. He has the copyright on his original code, and *he* is writing a GUI for it, so he has the copyright on that too. There is no infringement going on… done and dusted.
For reference – the company being able to make millions off the product (as well as some other guy being able to make something cool out of it, etc) is *exactly* what being “open” and having “freedom” is about – if you’re not allowed to take the source and make millions out of it, you’re not free to do what you like. If you aren’t allowed to take the source and make something cool, you’re again, not free. This is the impact of open sourcing your code – you don’t necessarily get anything much for your time, other than a warm fuzzy feeling inside.
Obviously this is just a fabricated situation, but if you allow companies to have complete control of your work then there is a possibility that you will get screwed by them.
In the real world, a company with enough money will take someone’s completely free code, re-release it and then sue the original author if he tries to undermine them buy extending the features of his original work to compete with a commercial product.
Your view of the real world is rather unfortunately jaded. There are plenty of examples of companies taking large BSDed projects, adding GUIs on top, and being very happy, and contributing back to the BSDed projects. The one that immediately springs to mind is Mac OS X. Apple’s made huge contributions to the BSD code base that the OS is based off, and they’ve not sued FreeBSD or OpenBSD for doing something vaguely similar either.
I agree that by opening your work up for free use there is a small risk that someone will do work (notably, it’s them doing the work), and will make money off that work that they added (even if that work is just marketing expertise). It’s even possible that if you copy their work they will sue you for copying them, and quite rightly too if you actually did copy their work – it is after all *their* work.
However, in reality, this situation rarely crops up. Can you think of *any* BSDed projects that have been sued by a company that took on their code?
GPL provides safeguards for commercial code. BSD license is targeted at hobbyists.
If a company releases GPL code, they can rest assured that their competitor won’t take their work, develop a killer modification for it and release it, taking advantage of the company’s hard work.
The BSD license provides no such assurance.
BSD is for hobbyists who don’t care about cash. GPL is for commercial entities that care about competition and profits.
Companies steal code. Your competitor may even reverse-engineer or decompile your proprietary app and steal your code.
The GPL is not a magic wand that prevents theft from occurring.
What it does is, it provides a legal recourse when the need arises.
You may not worry about legal rights, but corporations do. That’s why you will never see any company release code under a truly free license like the BSD or the MIT licenses. Corporations also release much more code than hobbyists do, so the GPL is far more important than aforementioned truly free licenses.
Ultimately, there are companies based around the GPL (RedHat). You’ll never see a company based around BSD license because your competitors will walk all over you.
From a hobbyist perspective, the BSD license may be great, but if you depend on your code for a living the BSD license is suicide.
This is roughly the point I’m trying to make in the entire article…
The GPL is for offering you recourse when people “steal” your code. That is, you want to maintain control over your code, i.e. people receiving your code are not free, because you keep control over them.
Note that I’m not saying that the GPL isn’t a valid license choice. Instead, I’m saying it’s not a free license, because as you rightly point out, it gives the original author a set of shackles to control you by.
You have a good point on how people cannot take away control over your own code, no matter what license it’s under, and it’s worth to take under consideration when choosing a license.
Your notion of freedom is a bit confused I think. Isn’t this about two different kinds of freedom? GPL maximizes the freedom of *all users* (at the cost of individual freedom) while BSD, MIT, etc. maximizes *individual freedom* (at the cost of freedom of *all users*).
Among all the significant FLOSS projects, all the FLOSS licenses enjoy commercial success, so clearly companies and commercial projects have different needs, which is not much of a surprise really.
GPL is mandatory freedom. Is mandatory freedom still freedom? Or, reversely, is optional freedom still freedom? This essential philosophical question is exactly the core of the Soviet vs. Liberal opposition.
Actually, it’s pretty funny that the GPL vs. BSD licence war involves the exact same arguments that the USSR and USA used to throw each at the other’s face, claiming they are the homeland of true freedom, while the other is the homeland of corruption.
For the Soviets / the GPL, true freedom is freedom that is mandatory: “you have been given freely, give freely”. Whatever work one does, they have to let everybody enjoy it freely, otherwise it’s not a free system.
For the Liberals / the BSD, true freedom is freedom that is voluntary: “you are free because you are given the choice”. Whatever resources one might have enjoyed freely to make their own work, they must remain free to release it non-free, otherwise it’s not a free system.
I can see the truth in each of those two ways of thinking. Heck, they are even both in the Bible! But if each one is equally true, then they are also equally false: the first kind of freedom might lead to collectivism and negation of free will, which is bad (and has led to totalitarianism and the collapse of the Soviet Union), and the second kind of freedom might lead to individualism and negation of social duties, which is equally bad (and has led to exploitation and the current crisis).
Truth, and thus true freedom, is probably actually elsewere. Somewhere outside the domain of the law…
Thanks for that, a really great reply!
Thanks! 🙂
Saying “mandatory freedom” is sort of like saying “hot coldness” or “loud silence.” Sure, people are free to make up abstract philosophies explaining why silence may be loud, but all the fluff around it does not change the core meaning of the words which go against each other. (Even thesauruses will list “free” as an antonym to mandatory).
Well, that’s exactly why I said that this ‘mandatory freedom’ is not true freedom.
🙂
Isn’t that statement, “mandatory freedom is not true freedom”, nonsensical?
Any license or right is mandatory, otherwise any purpose of the license is lost.
There is no such thing as absolute freedom (without consequences), even without any law there isn’t, but I suppose one could always kill one self to be absolutely and truly free in some sense.
Both GPL and BSD licenses are free software licenses with different purposes as far as freedom goes, and they are both mandatory by law on any user, who accepts them. Any argument saying that this is not freedom, basically just repeats the basic notion that any law is not about true freedom, but that’s silly, because of course they are not.
@Dennis: Mandatory freedom makes sense if by mandatory freedom you mean freedom that can be legally enforced. Nevertheless, the is not how it was used above. Above it meant “freedom that imposes mandatory obligations.” That is not true freedom.
Freedom means the ability to do as one wishes without restraints. True, they are always restraints, the physical ones at the very least. But if we forget the restraints forced upon us by the laws of physics, we can consider ourselves free if there are no other restraints.
As for the software licenses, the BSD license may be considered relatively free. Relatively because there are tiny restrictions such as the one saying that you have to retain the disclaimer. Otherwise, the license does not restrict you in any noticable way and thus it may be considered free. Moreover it gives you the right to use it in any way you see fit, and this is not implied by law unless explicitly stated (!). This is freedom. There are no social obligations that bind you if you decide to use the code. It’s almost as if you found the code magically written on a piece of rock in nature. Your’re free to use it in any way you naturally can. (When I say “no obligations” I consider the obligation to retain the disclaimer as a negligible one).
On the other hand, using code licensed under the GPL gives you obligations that you would not normally expect if you used a piece of code you’d had found laying around in nature not attributed to anyone. That’s not freedom. You are restricted, and you are restricted by something more than physical laws. What restricts you here is the copyright law. The author does not waive his copyright freely but in exchange for an obligation.
As for “any right is mandatory”, I beg to differ. Rights are never mandatory* (*never mandatory towards the holder of the right– they are mandatory from the point of view of a judicial authority–a court has to respect somebody’s right ) You can always choose to exercise your right, but you never have to. 🙂 Licences do not have to be mandatory either. Licences that grant rights to someone (it is implied by the law that copyright remain with the author) are not mandatory toward the person they grant rights to. Such person is always free to ignore the existence of such a right without having to face consequences.