[TazeTSchnitzel]

> 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!

[morganvachon]

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.

[lwf]

> 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)

[bzbarsky]

> 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).

[the_why_of_y]

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?"

https://wiki.mozilla.org/MPL_Upgrade

"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."

[bzbarsky]

Huh. I was pretty sure Gerv spent a while hunting down contributors, but maybe I'm misremembering something. Clearly I must be!

[jarfil]

> 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.

[antihero]

If it's GPL'd, what prevents the author/project owner simply changing the license though?

[bzbarsky]

Nothing, if they have copyright on all the code.

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).

[digi_owl]

> 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.

[gbog]

Ok but I would like to know if Mac os taking FreeBSD code did benefit to Free BSD. Edit: tried to add more but some js breaks everything on my phone

[toast0]

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.

[reitanqild]

> 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?

[Deejahll]

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.

[millstone]

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.

[click170]

> 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.

[elsjaako]

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.

[the_why_of_y]

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.

[fsloth]

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.

http://www.libpng.org/pub/png/src/libpng-LICENSE.txt

[alecco]

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.

[anonbanker]

Microsoft did exactly this in Windows 2000 with the BSD-licenced Kerberos. Embraced and Extended.

[throwawaykf05]

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.

[dummyfellow]

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).

[anonbanker]

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.

[throwawaykf05]

MS extended the protocol, not the implementation.

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).

[pjmlp]

If Apple hadn't made Swift open source now at WWDC, that would be a fine example.

Or the zillion of extensions being made by companies on top of LLVM.

[geon]

A very contrived example.

[Deejahll]

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.

https://en.wikipedia.org/wiki/Embrace,_extend_and_extinguish

[jahewson]

And what permissively licensed software did Microsoft apply this policy to, exactly? Or is it just an unfounded fear?

[fao_]

Read the link. It has a moderately-sized list of examples from Microsoft. https://en.wikipedia.org/wiki/Embrace,_extend_and_extinguish...

[anonbanker]

Kerberos. back in 2000.