I think this is an important distinction to be aware of.
Licenses like the GPL exist for a reason. And that reason is an attempt to maximize the amount of software that is free.
Licenses like the MIT and BSD license exist for a different reason. And that reason is to give people who want to share what they did on generous terms a way to do so. And historically this was done in the belief that enlightened users would see it as being in their interest to contribute back.
The result was that people who used generous licenses got frustrated that others would come along, use their software, criticize the original author for "not protecting freedom", then create a modified version that the original author was not free to use as they wish!
Historically the free software movement was very clearly described with long essays by Stallman. With the open source marketing campaign, there were essays that people who liked more generous licenses could get behind. And indeed lots of people began producing free software with no encounter with the ideas that started the free software movement. The link above was Stallman's response to this.
If you understand the conflict, then you can form your own opinion. Here is mine.
When you choose a license, you should choose correctly for what you want to have happen. Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing? Well then, you shouldn't use a BSD license. By contrast you shouldn't use the GPL if your response would be, "Bully for them, I had fun and they made the world better."
Conversely if someone else used an open source license, DO NOT assume that their motivations are yours. It is their code with their choice of license chosen for their reasons. Respect that.
> Would it outrage you for someone else to take your code ... and make millions while you make nothing? ... You shouldn't use the GPL if your response would be, "Bully for them, I had fun and they made the world better."
This is wrong. Copyleft licenses are concerned with freedom, not price.
I don't care if somebody gets rich off my software while I don't.
I don't want somebody to take the work I have done and turn it into proprietary software that other users may no longer have the freedom to inspect, modify, and share. THAT is why all my work is GPL or AGPL. It has nothing to do with whether you make money or those users spend money or I get a cut of some money.
Now that we have so many SaaS startups, "turn it into proprietary software" includes "use it to build a service and never distribute the sources."
GPL and AGPL protects my code from this happening, while licenses like MIT and BSD ("permissive" licenses) do not.
Permissive licensing, in the context of SaaS, is functionally equivalent to proprietary licensing. Somebody benefits (not necessarily monetarily) from the use of my software without paying its price: improvements must be shared.
> This is wrong. Copyleft licenses are concerned with freedom, not price.
Precisely. The thought that someone might take the code I wrote and make it into a proprietary product, removing the freedoms I had, is horrible. But if someone made an free software product based on it and made millions, all the better for them!
BSD doesn't remove any freedoms from the original software author, and in fact it unshackles them from having to publish all future development, allowing them to go proprietary in the future if they wish to.
To put it another way, once you license something under GPL, it is forever GPL. That's a strength of that license in the sense that it has allowed so much excellent and important software to grow and flourish. On the other hand, when you license something under BSD, at any point you have the power to take it to another license or make it proprietary. That's the "permissive" part that many people (including GPL advocates) don't get. The source code itself is still open as long as the original author wishes it to be. Under the GPL, the source code is open for all eternity, even if the original author changes her mind later.
Another aspect of this (and it was mentioned elsewhere in this discussion) is that, even if a company comes along and turns your BSD licensed code into their own proprietary product, you still get to keep your code and continue to improve it. All they've really done is forked it; if they are a good citizen they will even contribute improvements back to you. I think the classic example of this is Mac OS X, which is based in part on FreeBSD. When Apple forked FreeBSD into the base of their new commercial OS, the FreeBSD project didn't magically disappear. Here we are 15 years later and both the commercial OS X and the open source FreeBSD are flourishing. Development of FreeBSD didn't die the day OS X was born.
> BSD doesn't remove any freedoms from the original software author
Neither does the GPL. The GPL does not place restrictions on the author. In fact, as the author of a project, you can declare your project GPL and totally fail to comply with the GPL yourself, because the license is a copyright license, not a contract.
> To put it another way, once you license something under GPL, it is forever GPL. That's a strength of that license in the sense that it has allowed so much excellent and important software to grow and flourish.
Both the GNU GPL and BSD licenses are non-revocable (except, in the case of the GPL, if a reuser violates the license)
> On the other hand, when you license something under BSD, at any point you have the power to take it to another license or make it proprietary.
Assuming "you" refers to the author of a project, they can change the license they use for the project in the future regardless of whether they initially chose BSD or the GPL.
(I'm on the Debian ftpmaster team, which checks all new binary packages submitted to Debian; I review licenses for fun)
> To put it another way, once you license something under
> GPL, it is forever GPL.
It's forever GPL for people who use it under the GPL license. If you're the copyright holder, not a licensee, you can change the license if you want to. Of course that doesn't stop people from using existing GPL copies, and you do have to be the actual copyright holder (e.g. if you accepted patches from other parties, you have to get permission from their authors to make such a change). But given such permission, a change can totally be made.
An example is the Mozilla code, which used to be licensed under a tri-license that included the GPL and was relicensed to a different license (MPL2). This process required finding everyone who had copyright on the codebase (several companies and a number of individuals) and getting their permission for the license change.
Now it's true that using the BSD license means you don't have to hunt down those other contributors and get their permission to relicense, so the bar for the author taking the code proprietary is lower (and in fact identical to the bar for anyone else doing so).
I don't understand why Mozilla would need extra permissions to upgrade from the old tri-license to MPLv2?
The MPLv1 already had an auto-upgrade clause that allowed any downstream to use and distribute the code under a later version published by the license steward; the MPLv2 also is implicitly a triple-license with LGPL/GPL.
MPL v1.1 "6.2. Effect of New Versions" does mention the new version of the license has to be published by Netscape instead of the Mozilla Foundation; was that the issue perhaps?
This page seems to agree with my reasoning in "Does Mozilla need permission from anyone to change the MPL?"
"No permission is needed from any contributor to upgrade the codebase from MPL 1.1 to MPL 2 because the MPL 1.1 contains within itself a provision which allows software under 1.1 to be redistributed under a later version of the licence."
> when you license something under BSD, at any point you have the power to take it to another license or make it proprietary
And that's why I would NEVER contribute code to any of your projects. You want people to work for you for free, then when you're ready just close the code and run with it? Yeah, right, try again.
The GPL is a "you can't screw me, I can't screw you" license. The BSD is a "whatever" license, much like the MIT or a CC0/Public Domain. If I don't care about the code, if it took me no effort to create, I may consider the BSD... or just the CC0, whatever. Otherwise, you're either looking at a real contract or the GPL, and you better don't try to screw me either way.
Oh, and you can re-license YOUR code under any license you wish. If you published it once under the GPL, it only affects whoever may get it from that publication; you can still re-publish it in the future under any other license you wish, since it's YOUR code, to do as you please.
If they accepted changes from someone else, that someone else has copyright on those changes and the license can't be changed without them agreeing to it (or possibly their changes being removed from the codebase; I am not an IP lawyer and you should consult one if you want to be sure on this score).
> BSD doesn't remove any freedoms from the original software author, and in fact it unshackles them from having to publish all future development, allowing them to go proprietary in the future if they wish to.
IANAL but as best i can tell, neither apply for GPL.
The changes do not have to go back to the original developer. All that is required is that the code changes are published if ever binaries based on those changes are made public.
And going proprietary is possible if everyone involved agrees. Note the number of multi-license projects out there, including some fairly substantial ones like Qt.
OS X uses the FreeBSD userland, but it was more or less a one time pull, the kernel is radically different, so it would be hard to keep things synced; as a result, I doubt there has been a lot of contributions of patches backwards. However, Apple and FreeBSD both had license problems with gcc, and Apple sponsored LLVM, which benefits FreeBSD as well. Maybe there's a cultural benefit for FreeBSD as a result of OS X exposing people to the FreeBSD userland, although running into limitations that have been fixed upstream more than ten years ago may give people the wrong ideas.
> The thought that someone might take the code I wrote and make it into a proprietary product, removing the freedoms I had, is horrible.
I feel this argument is weak: even if I license my works under BSD, no one can make my BSD licensed code that has already been distributed into to a proprietary product, even not myself.
To make that software that I licensed under BSD a proprietary product they would need to somehow convince all users of my software to get rid of all copies as well as convincing me to stop distributing it under a free licence.
Building a proprietary product that includes my code does NOT remove anyones freedom to use my code, no?
This presumes that any modifications to "your" code that someone else makes should be none of your business. Seems fine on the surface.
But what if your code writes files or communicates over the network? And what if, say, Microsoft takes your permissively-licensed code that is just beginning to gain popularity, changes one piece of it to make it incompatible with yours, and doesn't release their change? They use their massive marketing department or pre-bundling to get lots of Windows users to use it. Everyone is still free to use "your" version of the code, but nobody wants to, since it is incompatible with the more popular Microsoft version, now on its way to becoming "the standard."
If you are okay with that, no rabid copyleft zealot like me has any place to criticize you. Release your code with a permissive license. That's fine. (Permissive licenses are considered "Free Software" by FSF and rms as well, after all.)
But to me, that seems grossly unfair for code I spent my valuable time designing and developing, so I don't release my code under a permissive license. If Microsoft wants to build a product with the work I have done, it needs to convey the same freedoms to its users that I did. That's the cost.
This is hypocritical, because the GPL does exactly what you describe through its "or any later version" clause. Remember when gcc switched to GPLv3? Did you contribute to gcc? If so, your contribution got re-licensed under whatever the FSF decided, and thereby acquired a bunch of new restrictions that you never agreed to.
And sure, everyone is free to use the v2 version of the code (i.e. gcc 4.2), but nobody wants to, since all new development is happening with the v3 version, which is now the standard.
Linux is a famous exception: it omits the "or any later version" clause, and so avoids getting steamrolled in the way you describe.
> Remember when gcc switched to GPLv3? Did you contribute to gcc? If so, your contribution got re-licensed under whatever the FSF decided, and thereby acquired a bunch of new restrictions that you never agreed to.
How can they relicense the code unless every contributor signed a Contributor License Agreement granting them that right?
A quick search seems to indicate that GCC has no such CLA.
The standard GPL includes a clause that let's you published a modified version of the software under a later version of the GPL.
So if you write something under the GPLv2, and I change it and publish it, then the GPL says I need to release the source under the GPLv2 or later. This means that I can publish it under the GPLv3, and you can't take back my changes unless you upgrade your software to the GPLv3.
Linux removed the "or later" text from their version of the GPLv2, meaning that I can't change the Linux kernel and publish the result under the GPLv3.
This is incorrect, no version of the GPL has such a clause. The FSF merely recommends that authors give downstreams the option to use GPL version N "or later".
However, you can "upgrade" LGPL code to GPL, see LGPLv3
"2. Conveying Modified Versions".
There is a FLOSS license that has an implicit upgrade to new version clause: the Mozilla Public License, see "6.2. Effect of New Versions" in MPLv1.1.
It looks like the "or later clause" is a built in option, but not a built in default, of the GPLv2. With that I mean that the meaning of that phrase is explained in the 9th clause.
Can you provide examples of software that were released by their original author using BSD/Mit style licence and got steamrolled by a third party who took their code and mangled it?
At least to my knowledge the opposite seems to be more common. Experts release a library under a very permissive licence, and everybody wins. One such example is libPNG.
I got an example, you are likely using it right now.
KHTML (LGPL, not GPL) taken by Apple to make WebKit (LGPL), later "rewritten" and licensed BSD for 2.0.
Apple did also the dirty trick of giving a single huge patch against the previous release of KHTML making it almost impossible to integrate back to the main codebase. Even LGPL can be abused. Lesson learned the hard way by the community.
And you now have everyone parroting how great WebKit is, nobody remembers the original team at KDE. It was brutal.
Microsoft used their own implementation of Kerberos. From the Kerberos Wikipedia entry:
> While Microsoft uses the Kerberos protocol, it does not use the MIT software.
The license of the original implementation is thus irrelevant. Pretty much the only thing that would have prevented MS would have been if there were patents on Kerberos.
Did MS use kerberos implementation or the protocol, wiki page isn't very clear on it. If it is 2nd then it would be an entirely different issue, which even GPL/copyleft wouldn't have helped (though oracle java lawsuit may do so).
How would the Oracle lawsuit change anything? Protocols are almost explicitly the things that are not protected by copyright. The problem is, people here are confusing interfaces in human-readable code (copyright-eligible) with interfaces for binary interoperability between systems (not eligible).
no dude, not only did they take the code and extend the protocol[1], while attempting to relicense it[2], but then they tried to sue /. to remove posts of people that talked about it[3].
Yes, they used the code itself (which was legal due to the 3-clause license), but didn't credit until publicly shamed. There was a huge stink back in the day because of it.
Oh yeah I just pulled that from a fever dream I had, that sort of thing never happens in real life.
> "Embrace, extend, and extinguish", is a phrase that was used internally by Microsoft to describe its strategy for entering product categories involving widely used standards, extending those standards with proprietary capabilities, and then using those differences to disadvantage its competitors.
I could not find a single example of "permissively licensed software" in there. Nor do in think one exists. Remember, this is the Microsoft that would not touch open source with a 10-foot pole.
MS did embrace and extend standards, but that is a very different thing from code.
> This is wrong. Copyleft licenses are concerned with freedom, not price.
I have long been annoyed by this canard. Yes, someone can create a piece of code, slap a GPL license on it, and charge $10,000 a copy. In the real world, that developer will make exactly $10,000, because their first user is free to share the code with the rest of the world at zero cost.
"Free as in free speech and beer, not just free beer."
FTFY
In that case, the parent could have asked, "Would it outrage you if someone slapped a GUI on your code and released it as freeware?" I think they didn't because even fewer readers would see the harm in that.
> I don't care if somebody gets rich off my software while I don't.
This is either incredibly naive or incredibly stupid. I'll give you the benefit of the doubt and assume the former. To spend your time like most of us do, getting paid to make someone else wealthy, is one thing. Getting paid nothing to make someone else wealthy is little more than voluntary slavery. Don't want/need the money? Fine, then give it to a worthwhile charity and make the world a better place. But at least make your time and effort count for something.
> This is either incredibly naive or incredibly stupid.
In order to interpret that one sentence the way you did, you had to:
- divorce it from the context where the software was released as copyleft
- ignore that person getting wealthy must share their source code
- willfully misinterpret "don't get rich" as "get paid nothing"
- presume that money given to some charity is more of a societal good than software
- presume that that the creation of free software "counts for nothing"
But please do continue to abuse me as "incredibly" naive and/or stupid, and make comparisons to "slavery!" It might not feel like a genuine Hacker News discussion if you didn't.
This is the naive comment. It takes a lot of effort to start a company and make money off of something, even if you didn't make the original version. If people are willing to pay millions of dollars for software, and someone comes along and builds something that fits that demand, then why shouldn't they?
Some people make software for fun, or to help others. If my software helps someone make millions, then cool, good for them. Personally, I would certainly monetize free software I made if I saw the opportunity. However, some people might already be wealthy and want to play with their kids or something instead of chasing a new startup opportunity, so they shouldn't care if someone else makes millions off of their software. You are acting very arrogant when you assume everyone's values line up with yours.
While the style of your comment was acidic, it still remains a psychological fact that people do not value things that are free.
One can be afraid of a perception that since "everybody can code" and "opensource is free as in ... beer? Speech? I don't care, it's free so it's basically worthless" that the intrinsic value of people who code is not that high. This is not a risk in large corps and dedicated software houses but it can create crappy management-employee dynamics in smaller orgs where code is just the enabler for the main product.
That said, it is up to the authors to decide how they feel about the fruits of their labour being used. There is nothing wrong with being generous and embracing all positive externalities - or blocking them or attempting to extract value from them for that matter.
I use the BSD license for all the GPL reasons, plus one more: I am not bothered by the existence of other uses, and do not wish to eradicate them. I don't see them as a threat. The free version of the code is there, and gives users all the same rights as the GPL, and more.
I like all the freedom and sharing as does Stallman. I just don't see proprietary software as evil, and I don't think that if I prevent some code of mine from being proprietized, that I'm striking some blow against proprietary software. If anything, it might backfire: instead of using my quality, debugged code, they will have to choose something else that is perhaps not as good (or worse: whip something up from scratch). Somehow, in some way, that will come back and bite me.
I agree with you. I also feel kindness breeds kindness. I don't give out charity and expect something back. I don't look at it as "hey, I just gave you $100. If you ever do anything you must do the same". I just give the money and walk away. Similarly with my open source, it's all MITed.
Would I feel miffed if someone stole my biggest open source project?Maybe. Would that make me wish I had GPLed it? No.
I also have no idea what the percentages are on influence but my personally belief is MIT/BSD breed more open source than GPL. GPL attempts to breed open source by force. MIT/BSD by kindness. I'd like to think MIT/BSD does better because of that. It makes it easy for people to contribute and or fork and share and not worry their contributions can't be used in their own non open projects. You might see that as less open but I see it as more because their contributions wouldn't exist otherwise.
I think LLVM and all the zillions of things that are being spawned from it are a good example. If it was GPLed I doubt most of those projects would exist.
Speaking of kindness, I work on free code simply to express my creativity to the world, not out of kindness. If I wanted to be kind, I'd go volunteer with kids who have cancer.
I believe copyright is complete rubbish; it's just a legal extension of a sense of entitlement.
Since I believe copyright is rubbish, I must believe that all that is based on it is rubbish, including the GPL. Therefore, I won't use it.
The MIT and BSD licenses are good "interface adapters" between creators who believe copyright is rubbish, and the practical world with its legal framework which insists that there must be copyright.
Stallman also basically believes copyright is rubbish, but he used it to forge the "copyleft" which exploits it for an agenda.
My view is that if you disagree with it, don't wield it.
In my experience, its more like "get your $100, then offer you another $500". I've been offered several jobs to continue working on open source software I've written at companies where that software is being used. In all of those cases I've been allowed to continue opensourcing the changes I've made. For small projects, nobody wants to maintain their own fork.
While I believe there are those who is genuine when saying that, I am a bit burned by all those people who would quickly complain if someone made a patched version of their code and put it under GPL.
Snippets of BSD code have ended up in all kinds of GPLed projects. It would be kind of "rude" to just take a BSD-licensed project in its entirety and re-license it. It's legally questionable too. As someone who isn't the copyright holder, you can't really dictate the license.
In fact, incidentally, I believe that if you integrate BSD-licensed code into a proprietary product (where, say, it is manifested as a translation to machine code), you don't actually own those sections of machine code. They are derived works, governed by the BSD license: anyone can rip that out and use it accordingly. The code has not been turned proprietary at all---it just appears in a form that is difficult to modify and tightly coupled to proprietary code.
Yes, that's just silly. If you allow proprietary use of your code (Microsoft can compile it into a binary and ship it with Windows without source) how can you possibly have a fit over it being used in GPL-ed code.
What I would do is help myself to their patch, if it's worthwhile and backport it to the BSD-licensed version.
The code is my copyright, and the patch is a derived work of something of mine; therefore I own it and it falls under my license.
Not to mention that if you take someone's BSD program, and just slap a GPL on it, it doesn't actually hold. Once the users are aware that it's actually a re-labeled BSD program from another author, they can just go with that license.
>> What I would do is help myself to their patch, if it's worthwhile and backport it to the BSD-licensed version.
>> The code is my copyright, and the patch is a derived work of something of mine; therefore I own it and it falls under my license.
That is completely incorrect. You have no rights to the patch just because it is a derivative work. You have the right to prevent distribution of derivative works (not to own or distribute), but you gave that up with the BSD license which expressly allows it.
You're also wrong about the license of the patch. The author of the patch gets to chose it. For GPL licensed software the condition of redistribution is that all derived works be distributed under the GPL as well. If you don't GPL it, you lose your permission to redistribute the original code and derived works.
BSD and MIT licenses don't include this restriction, so you're shit out of luck with making any claim on that patch.
Are you sure that's correct, from a legal perspective?
If I release an MIT project, someone makes a GPL fork with a significant new feature, wouldn't pulling that feature back into my project make my project GPL?
Someone can't make a "GPL fork" of your MIT-licensed project. The new code they add can be GPL-licensed, but they cannot simply change the licensing of the existing code from MIT to GPL.
You are correct that pulling their GPL-licensed feature/additions into your code would require you to adhere to the GPL and re-license the code. The best you could do would be to ask the author of the changes to release them under the same license (MIT) as your original project so the changes could be incorporated without modifying the license.
>they cannot simply change the licensing of the existing code from MIT to GPL.
That is an issue of contention. GPL advocates believe that they are permitted to do that, and have done so in the past. The Software Freedom Law Centre (the legal arm of the FSF) advices developers that they are permitted to do it[1], as do GPL advocates on HN[2].
The only one who is talking about changing existing code from MIT to GPL is Theo de Raadt, and he has never provided any evidence to support that anyone did it or suggested it.
People can create derivative work from BSD licensed software and have any license they want to added with it. Theo has argued that some peoples bug fixing patches did not qualify for copyright, and he is perfectly free to think so. I doubt however that he would ever put money where his mouth is and test it in court. When silence can qualify for copyright, it is a hard argument to make.
> Permission is hereby granted... to deal in the Software without restriction, including without limitation the rights to... sublicense
Because you have the right to "sublicense", you can take MIT code and license it under another license (GPL) even though you are not the copyright holder.
The BSD license is less clear on this point (in fact this is one of the important differences) and whether the BSD's grant includes the right of sublicense is more debatable, but in my view the answer is "probably".
I am not a lawyer; I am not your lawyer; this is not legal advice.
The BSD license does not grant any sublicensing rights. It clearly says that the notice and disclaimers must be preserved.
The original license required copyright notices in binary code. A newer form does not, but this is for pragmatic reasons. The binary code is still copyrighted. If you decompile it into a source language, then you probably have to restore the copyright notice and disclaimers.
When a proprietary, binary-only program with a highly restrictive EULA contains BSD code, those sections of the machine language which correspond to the BSD code are not actually under the EULA. They are not sublicensed, but only used with permission, as granted by the original license.
> he has never provided any evidence to support that anyone did it or suggested it.
Which part of the patch[0] that removed the BSD license and made the file GPLv2 isn't evidence?
You'll note that the patch removed the lines that say "Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies."
In other words they removed the notice that specifically says you're not allowed to remove the notice.
Okey, someone apparently thought they could do it, but then realized better and fixed it. The source today includes the original copyright notice. That they fixed it afterward should point towards what their current believes are, and if they thought their past patch was correct.
Was that version ever distributed to anyone?
I also notice in that thread that the author of Ath5K .c code give explicit permission to "Alternatively, this software may be distributed under the terms of the GNU General Public License". Removing the old license text of the header file and replacing it with GPL might be incorrect, and people are free to argue what a judge would say about it. It just seems very far from an actually issue, any proof of current believes, or what advices FSF gives.
They only fixed it after Theo posted angry messages on the OpenBSD mailing lists about it, the story got posted to Slashdot, it became a huge controversy and the SFLC got involved.
If it was, any proprietary work which are also derivative of the BSD work could then be "pulled" back BSD. People would get really upset if that happened.
Your first sentence is right, the rest is advocating copyright infringement. You have violated the GPL if you take someone else's GPL code and publish it in a BSD program — it's irrelevant that their patch was built on your software, their work is still their copyright exclusively under the law.
> how can you possibly have a fit over it being used in GPL-ed code
Because it's tasteless. Legal, of course, but tasteless. The person doing that is exhibiting a degree of hypocrisy in their refusal to pay it back to the original developer, while demanding that those who use their code pay it back to them. It's a "rules for thee but not for me" type of thing.
> The code is my copyright, and the patch is a derived work of something of mine; therefore I own it and it falls under my license.
This is a misapprehension of how software licensing works.
Not a lawyer, but I think the standard way to do this would be to "clean room" it. You notice that the GPL'd fork made this change, and instead of changing it you write to a co-developer "Our `name` variable is too short; it should be one byte longer. Could you fix this?"
The idea that `name` is short by a byte isn't protected, just the literal code.
(It's quite likely that this particular change is too trivial to be covered by copyright, but the chilling effects reach wide enough here that it might not be worth risking it.)
No you can't. Well, due to fair use you probably could without losing a legal battle over it, but for more substantial improvements you couldn't do that. Presumably you thought about this when choosing the BSD license (or when choosing to contribute to a BSD licensed project).
I believe that any improvements which are such that a source file still has only my name and copyright notice on it fall under the original license.
The original license forbids changing the license:
"Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer."
If you want to appropriate the code as GPL, you better do most of the work in new source files, or else change the file so significantly that (according to your lawyer) you're justified in replacing or altering the original copyright notice.
Anything that has only my name and my copyright notice on it is mine, even if it was modified. Whoever modified it acknowledged that it's mine by preserving the notices. It smells a lot like copyright assignment, and I suspect that very argument would easily succeed in court. I don't see how you can argue with a straight face that A. U. Thor is making an infringing use of your work, by taking an excerpt from a file which is "Copyright 2013 A. U. Thor".
There's nothing stopping a contributor from keeping your copyright notice, and adding his own license that only covers his own modifications. The contributor does not technically need to change the license of _your_ work, but he is free to chose whatever license he likes for his own changes to your code.
You should read phkahler's comment very carefully, because I think it's especially important that people with such strong ties to non-GPL licenses as yourself fully understand these licenses.
I think the point of the GPL is to make a political statement about changing the state of affairs, and it's done remarkably well in that regard.
When you choose GPL you're saying "I believe software should be free"[1]. When you choose BSD you're saying, "here's something I've made; use it as you like". Those are two very different kinds of statements, operating at entirely different levels.
[1]: Of course, not everyone chooses GPL for that reason.
You may want to consider Apache instead of BSD simply because it includes a patent grant where BSD does not. (Which will cause some people to treat your code with suspicion because we live in a world with patent trolls)
The licenses are functionally equivalent in every other way.
I really don't get why people don't just declare their work public domain.
I hate having to dig through and grok licenses to figure out what using some random library does to the precarious legal framework of my project. Developers often engineer software dependencies badly, but we don't bother engineering legal dependencies at all, we just slap them in like new coders copy-pasting from stack overflow.
I see people saying this:
>Licenses like the GPL exist for a reason. And that reason is an attempt to maximize the amount of software that is free.
But mostly I think they are really concerned about this:
>Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing?
It's just another means of jealous control. We bag commercial licenses for stealing developer freedom, and then willfully use licences that deliberately obstruct people from using our work as a foundation for successful entrepreneurial efforts, because we can't handle the idea, even the /mere possibility/, that someone might be more successful with our own project then we are. We even have the nerve to pretend that we're being generous when we do this!
I think it takes guts and trust to really let your work go, but I'd like to see more of it. I also truly believe that making our works public domain will foster innovation now we have tools like github that allow living public domain works. People won't stop contributing just because you aren't forcing them, BSD is proof of that, and I'd be using way more open source libraries and doing way less Not Invented Here if I didn't have to wade through legalese to do so.
I really don't get why people don't just declare their work public domain.
Well there's one very good objective reason not to: it's not clear if you legally can in all jurisdictions. It's not clear that you can just relinquish all IP rights to something. This means that the user of the IP can't be completely sure what they are and are not allowed to do with it, and they may be less inclined to use it than they would a BSD style license where they know what they can't do.
Some public domain desgnations, like CC0, partially get around this problem by including a clause that says that if they can't relinquish all rights, then they'll relinquish as much as is legally possible. This helps, but doesn't completely get around the uncertainty.
But mostly I think they are really concerned about this
Please don't be so quick to pass judgement. First, there are plenty of people who use the GPL to maximize the amount of software that is free, for whom "jealous control" is a secondary objective or completely irrelevant.
Second, there's nothing wrong with what you label "jealous control". If someone is made uneasy by the idea of someone taking their code and "stealing" from them, but they still want to embrace their users' freedoms, and they use the GPL, more power to them.
The only way that the GPL restricts my licensees is by requiring them to not use the fruits of my labor to restrict other people's freedoms. I don't want to be involved in infringing on people's rights like that.
> I really don't get why people don't just declare their work public domain.
Because in many jurisdictions, this is not a thing that can be done. It is not in the author's power. If you want people in those jurisdictions to be able to use your software, you need to provide some sort of license even if you consider the work to be public domain.
Even in jurisdictions when it is possible to do this, it's understandable that hobbyists would still want the protections of the "Don't use my name" and "Don't sue me" parts of 3-clause BSD at the least.
As for GPL, people choose that because they have different priorities than you. For an obvious and topical example, see Richard Stallman. He believes that nonfree software is actively harmful, and therefore takes measures to avoid accidentally supporting its development. You may not agree with this viewpoint, but he is clearly sincere in holding it, and it is his right.
That claim works both ways. If I write a GPL library that you want to use, you could accuse me of wanting to control the library and not letting you use it however you want, but I could just as easily accuse you of wanting to control your resultant application by not wanting to release it under the GPL. If you GPLed your application, there's no licencing headaches.
You could and I bet you would, because you seem like that kind of person, but I wouldn't do that to you so I wish you wouldn't do it to me. That's the jealous control part. Please stop trying to shove your license down my throat with a plunger.
>If you GPLed your application, there's no licencing headaches.
There'd be way less special snowflake implementations of security protocols, login mechanisms and account systems if this wasn't the prevailing attitude in the open source community.
> deliberately obstruct people from using our work as a foundation for successful entrepreneurial efforts
No, the GPL does not do this.
Obeying the requirement to share source code does not necessitate that your profits must evaporate. If your competitor picks up your (A)GPL'd source code? They too then must release their changes.
> because we can't handle the idea, even the /mere possibility/, that someone might be more successful with our own project then we are.
If by "success" you mean "rich," then no. GPL is not concerned with money, it is concerned with the user's freedom to inspect and modify the source code of the software they use.
Go ahead, get rich. Be more popular than me. But if you base your work on mine, I want to see what your software is doing in my computer, or with my information. I want to fix a bug long after you have stopped supporting your software. I want to make the software run on devices that you will never care about. I want all the value and data and time I've spent on your SaaS service to not simply evaporate when your crappy VC-funded startup gets bought and shut down by Facebook.
> People won't stop contributing just because you aren't forcing them, BSD is proof of that,
Yes, some people would still be ethical and contribute back. Many won't. Companies are notoriously sociopathic, especially companies who are legally required to maximize profit for their shareholders, especially companies whose primary goal is return on investment for the VC that funded them.
I don't trust companies to be nice. You want to avoid paying a developer to build a poor NIH mimic of my awesome work? The price is that you must give your users the source code of your changes. I don't care if you get rich in the process. But I reject the implied assertion that you're "obstructed" from doing so.
I really don't get why people don't just declare their work public domain.
It's simple to understand. If it is in the public domain, people can just strip your name from your work. I have always seen the BSD, MIT, and comparable licenses as 'this is effectively in the public domain, but please keep my name on what I wrote, and don't sue me if it causes damage'.
That's why I specifically wrote "credit" rather than copyright notice. If you distribute modified binaries without code (as you can do with BSD/MIT), there's no copyright notice on code to see.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
I would be perfectly fine if everyone declare their work public domain. Free software licenses was an reaction to people who stopped putting their work in public domain and started to deliberately obstruct people from doing changes, running them, and distributing. Some people think you have to restrict those things in order to make a
successful company, and until that changes, I doubt we will return to the time where everyone declared the work public domain.
>Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing?
If he does it with the same license as mine (i.e. GPL), then no, it wouldn't outrage me (I would even be interested in applying to his company, so he teaches me how she did it). What I care about is the freedom of the users of my software (so I want to seal it to not be proprietary, ever), not about how other developers benefit from my creation.
> I really don't get why people don't just declare their work public domain.
Firstly, people do. Secondly, those who do are uninformed. Declaring your work to be "public domain" does not actually place it in the public domain. It in fact remains copyrighted.
Passage into public domain occurs when a copyright expires.
People who declare their work to be in the public domain are doing that because of the simplicity. If you include an all-permissive license and the public domain declaration, it's no longer simple and it's not as simple as an all-permissive license only.
By the way, I completely forgot to mention another reason for avoiding a public domain declaration, and going with a license: namely, liability!
The liability disclaimers in, for instance, the BSD license are important.
In fact, I have come up with a slightly modified BSD license.
My version makes it clear that retaining the license is a condition of redistribution, and that use of the software is subject to agreeing with the disclaimers.
The original BSD license lumps redistribution and use together, and only stipulates that the license not be removed.
All proprietary software EULA's I've ever seen make it clear that you accept the liability disclaimers as a condition of using the software. (E.g. by clicking on some Agree button, or opening a shrinkwrap or whatever.)
The disclaimer part of a freeware license is in fact a use license; they are not strictly redistribution licenses.
(By the way, I don't think it's a good idea to go around customizing de facto standard licenses willy nilly; I thought long and hard before making the decision to fix the BSD license for myself.)
For what it's worth, as someone who currently favours the public domain over copyright for his work, I will say that it's not especially because I think that it's simpler to choose the public domain; it's because I've tried to understand what copyright means and what public domain means and I think that public domain makes more sense and better serves my interests.
In particular, it reflects the fact that I don't think readers of my work should be obliged to follow any rules I might set (license) when they turn to the creation of derived works. They should go and do as they like and, where appropriate, acknowledge prior art (as a matter of professionalism).
I also feel that the problem of associating each "expression" with it's legal creator is a nasty problem fraught with difficulties; certainly, in this regard, you can say that I choose public domain because of its simplicity.
By the way, djb has argued in defence of the public domain here:
Anyway, I'm interested to read other developers views on this topic but I'm no authority and don't want to give the impression that I think it's unreasonable to choose differently. And anyway, most do! GPL, BSD and the rest seem much more popular than public domain.
Even though SQLite is in the public domain and does not require a license, some users want to obtain a license anyway. Possible reasons for obtaining a license include:
* You are using SQLite in a jurisdiction that does not recognize the public domain.
* You are using SQLite in a jurisdiction that does not recognize the right of an author to dedicate their work to the public domain.
* You want to hold a tangible legal document as evidence that you have the legal right to use and distribute SQLite.
* Your legal department tells you that you have to purchase a license.
> We bag commercial licenses for stealing developer freedom,
You have completely missed the point of the F in FOSS. It is not just about developer freedom but user freedom as in all users to modify (or pay to have modified for non-developers) code as they need.
>It's just another means of jealous control. We bag commercial licenses for stealing developer freedom, and then willfully use licences that deliberately obstruct people from using our work as a foundation for successful entrepreneurial efforts, because we can't handle the idea, even the /mere possibility/, that someone might be more successful with our own project then we are. We even have the nerve to pretend that we're being generous when we do this!
The GPL is not strictly about developer freedom, and it doesn't pretend to be. It's about guaranteeing user freedom.
From the GPL's Preamble:
"The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users."
> I hate having to dig through and grok licenses to figure out what using some random library does to the precarious legal framework of my project
For 99% of open source libraries, there is only one yes/no question: Does the whole thing have to be under this licence? i.e. is it a GPL licence or not? I don't think that's too hard.
>> Developers often engineer software dependencies badly, but we don't bother engineering legal dependencies at all, we just slap them in like new coders copy-pasting from stack overflow.
You sound like a legal liability waiting to happen.
Developers absolutely must take licenses into account or just don't use third party software.
Your comment is focused about how terrible the GPL is for you as a developer. But the GPL was not created to make life easy for you as a developer, it was made to increase the freedoms of the end users.
And even the GPL was too short sighted. The "ASP/PHP" loophole exploited by Google and others had a dismal impact in the free software community. They used the code, extended but never shared it. Some sociopathic corporations made BILLIONS on top of it buy contributed back almost nothing. Yes, the glorious Google being the prime example, but there are many others.
And let's not forget the patent trick Oracle pulled on Apache and Google.
I used to be a BSD fan, but from my own experience and some close firends's experience I learned the lesson. I would only release via Affero-GPL from now on. I hope the FSF will eventually bring out a revised version with a more aggressive stance against software patents (e.g. not valid to use if you ever sued anybody with a software patent or something like that).
> I would only release via Affero-GPL from now on.
Fine with me. Do as you please.
Everyone else keep in mind that your potential userbase drops dramatically if you only offer your software under AGPL. Even adding a commercial option in addition makes AGPL more usable.
I always avoid AGPL altogether. The idea that if I change 1 line of code I now have to setup a public repository is just crazy to me. Unless my reading of the AGPL is entirely wrong?
What Oracle patent trick are you talking about? If you're referring to the Java suit (Oracle v. Google), the Federal Circuit didn't issue a decision that found Google in violation of any patents. Google is currently awaiting a response from the Supreme Court to Google's petition to hear the case so that it may find Google's actions to be noninfringing under copyright, not patent law.
FSF and others were safe because they used a GPL-derived IcedTea codebase (earlier Sun code). That license protected from patent abuse and many other things. Apache and Google didn't take that path and it came back to haunt them. There were many threats. If I were Stallman, I would've died of a stroke lauging (ASF was very harsh on FSF/Stallman and anti-GPL).
> FSF and others were safe because they used a GPL-derived IcedTea codebase (earlier Sun code). That license protected from patent abuse
There very definitely isn't any patent indemnification provided by the GPLv2—which is the (only) version in effect for OpenJDK. That fact is a big reason why GPLv3 exists.
> Apache and Google didn't take that path and it came back to haunt them
In what way? This question was the entire point of my last comment, but it remains unanswered.
let's not forget the current systemd loophole, by allowing proprietary applications to bypass GPL restrictions via RPC.
The legally-gifted amongst the free software movement should probably fork GPLv3 to insert a clause about good faith efforts to ensure the application doesn't circumvent the license.
When I choose MIT over GPL I'm usually trying to make my work as easy for others to adopt as possible. I want some of the software I wrote to become a commodity. The MIT seems a clearer path to commoditized software than the GPL.
I think this is for one hyper-specific case that he in fact "okayed" the switch to BSD.
In response to the change of license, Richard Stallman of the Free
Software Foundation says, "I agree. It is wise to make some of the
Ogg Vorbis code available for use in proprietary software, so that
commercial companies doing proprietary software will use it, and help
Vorbis succeed in competition with other formats that would be
restricted against our use.
The problem with the GPL is that it presupposes its own supremacy and refuses to work with other free licenses. Two prime examples are MPL and CDDL (which was based on the MPL). Both of which GNU regards as free software licenses, but says to not use them because they don't bow to the FSF.
The binary in memory linking clause is the most harmful thing to ever happen to free software. It destroys collaboration and restricts user freedom. It causes partisanship and infighting within our communities and prevents good ideas, the best ideas, from being freely shared (breaking both freedoms 2 & 3!). GNU has declared war on other licenses for far less than that.
Can we all admit that the in memory linking clause makes GPL non-free software? We'd all be better off to realize it.
License incompatibility happens when two licenses has different conditions which both need to be happen in order stay in compliance.
Its very easy for a license to fix this. They can either use common conditions, or they do like GPLv3 and have a list of additional conditions which may be added in order to be compatible with other licenses. MPL do not have that, nor does CDDL, and thus we have the situation where they are incompatible with most other copyleft licenses.
I don't see why it's on the CDDL to fix. CDDL is a file based source license, the resulting binaries can be freely linked against binaries with different licenses. Section 3.6 explicitly says so!
The primary difference between MPL 1.1 and CDDL 1.0 with MPL 2.0 is that sections 1.7 and 3.3 of MPLv2 explicitly bow to GPL, a concession made by Mozilla to attempt to end this nonsense. Section 3.7 of MPL 1.0 and 1.1 (3.6 of CDDL) are clauses that imply GPL compatibility, without explicitly naming GPL. That wasn't good enough for the FSF, thus, MPLv2.
MPL was chosen as a template for CDDL because sections 3.7 (CDDL 3.6) gives it a quality like BSD, that the binaries can be larger works with different license terms while the rest of the license retains the copyleft qualities of the source code. Thus, CDDL would have "all the advantages of BSD, all the advantages of GPL".
Any supposed incompatibility is in the legal opinion of the FSF, who never stated their reasons, only the final conclusion, preventing healthy discussion on the matter.
Since the FSF and GNU identify all versions of MPL and CDDL to be "free" and "copyleft", why is the burden on CDDL or MPL? The FSF could have solved this by explicitly naming MPL/CDDL in GPLv3 (as they did with AGPL).
The MPLv2 was specifically designed to be compatible with as many FOSS licenses as possible. It was not possible to make it compatible with GPLv2 however, because the GPLv2 is incompatible with any license that has explicit patent clauses (which I would consider to be a historic accident and a serious issue with GPLv2).
That issue was resolved with a specific section in the MPLv2 that allows licensing the code under (L)GPLv2+/AGPLv3+.
1.12. “Secondary License”
means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses.
The MPLv1.0/v1.1 allows automatically upgrading to any later version of the MPL, in section "6.2. Effect of New Versions. ". Therefore (IANAL etc.) any code published under MPL is compatible with GPLv2+.
>Both of which GNU regards as free software licenses, but says to not use them because they don't bow to the FSF.
CDDL is and was created with the purpose of being GPL incompatible, because Sun did not want Linux to be able to use ZFS and DTRACE which were technical crown-jewels of Solaris.
>The binary in memory linking clause is the most harmful thing to ever happen to free software.
(usual disclaimer, not a lawyer, etc.). CDDL is file based - basically saying "if you modify this file, and distribute the software, you must provide the source code to the modified files".
Sun's intent (as far as I understand) was to appease OEMs by allowing them add additional files to Solaris (think device drivers, etc.) without requiring them to give away the source to their IP.
Yes that was indeed the case, Sun Solaris was losing hard to Linux and they were trying to go the open source route to get back on track (OpenSolaris), however since they (rather obviously) did not want to hand over their key technology advantages like ZFS and DTrace to Linux (their main competitor to which they were losing), they needed to release them under a non-GPLv2 compatible license to prevent Linux inclusion.
They were initially waiting for GPLv3 to be finalized (which would have been fine since Linux is GPLv2 ONLY) but it took too much time so they created CDDL which was, of course GPL incompatible.
License proliferation was a problem largely supported by the OSI. IMHO there are really only 3 free/open licenses necessary - GPL, LGPL and BSD (or MIT). Anyone else is trying to be open or free while also supporting some other agenda.
If you want it both ways, go dual lincense with GPL and a commercial license. Just be up front and honest about it.
There are a few other variants. Affero, as noted, also the Mozilla Public License, which applies on a file-by-file basis and allows for proprietary code to be integrated into a MozPL licensed work as a whole and distributed.
But otherwise, yes: GPL, LGPL, BSD/MIT are the principle cases.
You're missing a _technical_ reason for using a BSD/MIT license, and one that's been relied on to great effect: to promote use of a standard.
Apache was licensed under the BSD license in part due to philosophical preferences of its creators, but with the effect of promoting HTTP as a standard transport for online documents. Nobody had to ask for permission to use Apache, or to incorporate it into their own products (as IBM did).
Arguably the orginal use of the BSD license, to spread use of Berkeley Unix, achieved similar aims.
From the ideological standpoint:
* If your goal is to promote Free Software, use the GPL (or a variant with stronger ties to distribution for Web or online services).
* If your goal is to promote use of Free Software Libraries, in an environment where there are numerous non-free alternatives, the LGPL has benefits.
* If your goal is to promote use of an open standard, the BSD/MIT licenses are more effective because they allow for proprietary use.
> Licenses like the MIT and BSD license exist for a different reason. And that reason is to give people who want to share what they did on generous terms a way to do so. And historically this was done in the belief that enlightened users would see it as being in their interest to contribute back.
I think the thing that people ignore is that there's a huge incentive to contribute back with licenses like MIT/BSD. The incentive is not having to maintain a set of patches and an in-house fork. Proprietary forks can be expensive (an engineer will have to apply those patches every release -- and engineers are expensive. Not to mention the good ones won't want this kind of work.)
The notion of a company taking a BSD-licensed product and taking it to market while leaving the creator out in the cold seems rare. I won't say it never happens, but for most companies it makes economic sense to contribute back.
It makes economic sense... if you plan to ever update the software (especially more than a small handful of times). For most software, that's a pretty sane assumption, but there's a fairly important niche where it's not: embedded firmware, all the way from the GUI of some random thing-with-a-cheap-LCD to device drivers for flagship Android phones (which are more likely to be in the "small handful" category than "never", but still). In the latter case, even though Linux is under the GPL, at the rate the hardware changes there is often little incentive to contribute back to mainline. Or fulfill GPL obligations at all, for that matter - but at least most big Western manufacturers have some place to get a source dump. If Linux were BSD-licensed, things would be even worse.
On the contrary, out of all the free OSes out there, it was Linux with GPL the most successful, because companies could contribute back knowing that their competitors would not take the code and run away and produce proprietary forks backed by large marketings budgets.
See FreeBSD and Mac OS. If I contribute to Darwin, Apple will take my changes to improve their product. I get nothing in return. This may be fine for an individual, but for a company who depends on a product, it's a bad scenario.
I write open source application security software (e.g. https://github.com/paragonie/easydb) and use a very permissive license to encourage the wider adoption of better practices.
I don't care if I make some schmuck billions of dollars off my work while I suffer through poverty (which won't happen from a simple DB library), I care about making the Internet more secure, even if only a little.
> However, for everything else, I'm inclined to use GPLv3 / AGPL and offer commercial licensing under MIT for companies
Do you actually use MIT, or something similarly permissive but without permission to redistribute in source form? Because offering a true MIT license to paying customers means they could then redistribute that version to everyone. (Of course, doing so might mean they don't get any future versions from you under that license, but still...)
For example with libogg he was primarily concerned that the world would get locked into proprietary video code that was patent encumbered. (An issue which has happened a number of times. For example at various points free software had trouble with patents on things like the compression algorithm used by the gif format, and the RSA algorithm used in encryption. Both are thankfully long expired now. But video encodings in particular have a ton of patent issues.)
For instance, the Gnu Public License serves the needs of Oracle very well and quite possibly helped MySQL AB be salable to Sun and thus to Oracle.
Most of us who use MySQL are limited by the GPL, whereas Oracle has the right to use it in other ways, license it to specific customers on different terms, etc.
That's why Stallman prefers distributed code copyright: if contributors own their contributions, then dual-licensing won't work. On the other hand, this prevented a project like the linux kernel from moving to gplv3 since the distributed corpus of contributors could not all agree to switch.
Historically the FSF required copyright assignment for FSF works. This was to avoid having any potential problems where a contributor thought they were OK to contribute, but the employer potentially had a "work for hire" claim. (The ease with which such claims can exist varies by local law, and many are not aware of the fact that they have such a liability.)
Historically the FSF required copyright assignment for FSF works. This was to avoid having any potential problems where a contributor thought they were OK to contribute, but the employer potentially had a "work for hire" claim.
How would that work? If you don't have the legal standing to contribute to the project, you certainly can't reassign the copyright to another party.
The copyright assignment is so that the FSF can sue if someone break the project's license. They also require a disclaimer that the work isn't for-hire, but that's a different issue.
The process of getting the employer disclaimer mentioned in your link exists exactly to catch cases where the contributor was mistaken about their ability to legally contribute.
There is a third path, like that of the OpenStreetMap project. Originally it was released under a CC-BY-SA licence, but in 2012 was changed. As many users as possible were contacted and asked to agree or decline the new licence (ODbL). Eventually some data had to be deleted.
In response there is a Contributor Terms for all people wishing to add to OSM, which allows the OSM Foundation the right to relicence to a new free and open licence that 2/3 of active contributors agree to.
This means the copyright is owned by many people, not one organisation/company, but that there is a way to relicence without requring 100% acceptance.
> On the other hand, this prevented a project like the linux kernel from moving to gplv3 since the distributed corpus of contributors could not all agree to switch.
That's not enitrely true.
If I remember correctly Linus himself does not like the GPLv3 and opposes its use for the Linux kernel.
Basically his argument is that the changes and new restrictions imposed by GPLv3 in practice makes it a new kind of license, but that the naming seems designed to "lure" people who think it's a regular license upgrade into adopting a license they would otherwise not consider using.
I'm not sure if this is in writing anywhere, but I recall him talking about this on the same Debconf where he admitted that he had never managed to install Debian Linux.
So moving the Linux kernel to GPLv3 may not be entirely trivial, but that's not the reason it hasn't been done. Linus simply didn't want to.
Yes, the GPL comes in two flavors. If copyright is assigned to one holder, than that holder has special rights. Linux does things differently, so much that Linux can't possibly be dual licensed.
MySQL and Linux have both been big successes as well as Apache Hadoop, which is under an Apache license. There are a lot of choices that can work out fine for open source.
>Licenses like the GPL exist for a reason. And that reason is an attempt to maximize the amount of software that is free.
Does that work well out in practice though?
I think companies are much more likely to work with and contribute to open source programs if they are MIT/BSD/Apache.
>The result was that people who used generous licenses got frustrated that others would come along, use their software, criticize the original author for "not protecting freedom", then create a modified version that the original author was not free to use as they wish!
In 2015 most of the internet is running on free applications running on top of free operating systems and commercial companies are spending billions to maintain this situation. If you had predicted that circa 1990, you would have been dismissed as a lunatic. So something resembling success has happened for the free software movement. And no matter how you ascribe credit, it is hard to say that it would have happened without RMS.
How many cases has that happened?
A lot, but you don't hear about it if you're not swimming upstream trying to maintain code under a generous license. For a random example where it boiled out in public, see http://lwn.net/Articles/247872/.
So, OpenWRT (https://openwrt.org/) exists only because of the FSF enforcing the GPL. A non-complient company tried to unlawfully withhold it, and only because the GPL has some teeth did it actually end up with the source available.
I'd rephrase parent's statement to "that reason is an attempt to maximize the relative amount of software that is free."
So, if with BSD/MIT you'd end up with a few more contributions, but you'd also help a few companies build proprietary software that restricts their users, it's better to use GPL since fewer users end up being restricted by proprietary software.
And yes, I know that the users have the choice to not use proprietary software, but regardless of that discussion, that still doesn't mean you should help that happen.
> * Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing? Well then, you shouldn't use a BSD license.*
Pedantically, with the GPL, that could happen. However it'll be a GPLed GUI programme. That sort of business, selling units of software, doesn't like when customers can just copy the software and sell it themselves (so GPL would kill that business models), however many non-technical consumers would not know that they could do that, or have the business acumen to pull it off. We often say execution is important for a business, so does the GPL matter much for that?
It is entirely possible to use AGPL code commerically. You just have to give a copy of the source code to your user. This is no different from RMS selling copies of Emacs and giving the customers the code afterwards.
I could be wrong, but I think if you communicate with the GPL application using the command line under the hood, the application doesn't fall under the GPL either; which I think is how the closed source applications that provide a Git frontend work
I hate it when people repeat gossip without actually knowing what they're talking about, but here I go doing that very thing!
My ignorant understanding of this issue is that it has not been tested in court, and there are differing opinions about whether or not the strategy you describe is open to legal action.
In the GPL v2.0, there's some language in section 2 that suggests that if you ship your closed-source app with the open-source app, then you're licensing both under the GPL. GPL2 isn't super clear on the issue.
In GPL 3.0, there's a lot of language in section 1 about "Corresponding Source" which I believe was believed by the authors to specifically close the loophole you describe.
So, if I were trying to obey the letter of the law religiously, I wouldn't do what you describe. And if I was trying to obey the _spirit_ of the law, I'd do what a previous employer of mine did: personally contact the authors of the GPL code in question and verbally ask for permission.
> In the GPL v2.0, there's some language in section 2 that suggests that if you ship your closed-source app with the open-source app, then you're licensing both under the GPL. GPL2 isn't super clear on the issue.
That's unequivocally false.
It's not even a matter of GPLv2 making vague suggestions or being unclear. It's explicit and says the exact opposite of what you've written.
You can ship closed source apps and free software together. If that wasn't the case, then none of the Linux-based consumer devices that ship with proprietary userland would be able to exist.
You certainly can ship non-free software and free software together, in the general case. I was, of course, talking about the context of the parent comment, which was about (non-free) software that, as a fundamental part of its operation, use free software via a well-defined non-link-time interface. Such as, for example, a GUI text-search tool that, to do its fundamental work, shells out to gnu grep.
My understanding is that the relevant part of the GPLv2 is (with emphasis mine):
"If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it."
I honestly agree it's pretty explicit, but disagree with you about what it says.
IANAL, but I have heard the analysis I gave from two independent sources, one of whom is a lawyer specializing in IP law, and the other of whom used to work with the FSF on policy issues.
As I say, my understanding (given to me by the aforementioned lawyer) is that this has not been tested in court.
> When you choose a license, you should choose correctly for what you want to have happen. Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing? Well then, you shouldn't use a BSD license. By contrast you shouldn't use the GPL if your response would be, "Bully for them, I had fun and they made the world better."
BSD or GPL equally won't get you a dime, this example is flawed. The difference is that with GPL they must redistribute whatever modification they did (unless they are providing a "service", then you had to protect the code with AGPL).
> It is their code with their choice of license chosen for their reasons. Respect that.
If I may offer one addition to this: if you intend for your software to be open source, please use a recognized open source license, rather than rolling your own. Doing so makes it much easier for outside parties to understand how you would like them to interact with your software.
>Licenses like the MIT and BSD license exist for a different reason. And that reason is to give people who want to share what they did on generous terms a way to do so. And historically this was done in the belief that enlightened users would see it as being in their interest to contribute back.
And this works on an individual level, but once corporate bureaucracy gets involved it tends to turn into "why would we give away proprietary code?". GPL has its flaws, but it helps to fight short-sightedness.
> When you choose a license, you should choose correctly for what you want to have happen. Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing? Well then, you shouldn't use a BSD license.
Which license you should use? I thought licenses does not discriminate wether you use it for personal use or commercial use. Sorry, newb here.
Licenses like the GPL exist for a reason. And that reason is an attempt to maximize the amount of software that is free.
Licenses like the MIT and BSD license exist for a different reason. And that reason is to give people who want to share what they did on generous terms a way to do so. And historically this was done in the belief that enlightened users would see it as being in their interest to contribute back.
The result was that people who used generous licenses got frustrated that others would come along, use their software, criticize the original author for "not protecting freedom", then create a modified version that the original author was not free to use as they wish!
Historically the free software movement was very clearly described with long essays by Stallman. With the open source marketing campaign, there were essays that people who liked more generous licenses could get behind. And indeed lots of people began producing free software with no encounter with the ideas that started the free software movement. The link above was Stallman's response to this.
If you understand the conflict, then you can form your own opinion. Here is mine.
When you choose a license, you should choose correctly for what you want to have happen. Would it outrage you for someone else to take your code, put a pretty GUI on top, sell it, and make millions while you make nothing? Well then, you shouldn't use a BSD license. By contrast you shouldn't use the GPL if your response would be, "Bully for them, I had fun and they made the world better."
Conversely if someone else used an open source license, DO NOT assume that their motivations are yours. It is their code with their choice of license chosen for their reasons. Respect that.