[stared]

I am totally for Open Source (and Open Science), but I dislike copyleft licenses (cf. "2. Use a Share-Alike License").

And while Share Alike have their (good) use-cases, IMHO it is bad to recommend them as the default; the best standard is CC-BY or MIT/BSD.

Why? For me "open" means "open" - i.e. can be used by anyone, for anything (not "open, but only for the openness believers... and only of the same creed"). All share-alike clauses have issues:

- viriality (you have to get infec... I mean: accept another license instead of the one you are using),

- kosher rules (e.g. you can't combine GPL with CC-BY-SA).

So, with the openness, you can't beat the WTFPL (http://www.wtfpl.net/).

[agwa]

> So, with the openness, you can't beat the WTFPL (http://www.wtfpl.net/).

Please, please, please, do not use the WTFPL, especially if you say you care about "openness" and "kosher rules." The WTFPL is so poorly written no one knows what it really means. Consequentially, legally-sensitive people/organizations may actually have a harder time using a WTFPL-licensed project than a GPL-licensed project.

If you want a public domain-style license, use CC0 (https://creativecommons.org/about/cc0) instead.

[tomchristie]

> Please, please, please, do not use the WTFPL

I think it's a valid, personal choice.

If someone wants to make the point that they think licensing legalese sucks, and wants to license their work accordingly, then fair enough.

It's a little absurd that I shouldn't be able to, in plain words, express "This is my own work, and you can do whatever you want with it". Eg. I shouldn't need 'warranty disclaimer' to not be at risk of liability, unless I was explicitly providing some kind of guarantee in the first place. (It's just a bit of freely available software, hardly leaving a dangerous item out on the streets.)

Any legal system that leaves its citizens unable to be protected by simply using clear, plain and unambiguous language is failing in its duty to some extent, so I'm perfectly sympathetic to developers who choose "fuck that shit" as a personal preference. :)

[agwa]

> If someone wants to make the point that they think licensing legalese sucks, and wants to license their work accordingly, then fair enough.

As a protest license, it makes some sense, but I do not think that's what draws most people to it. People choose it because they want their code to be used by anyone, because they think it's the most "open." This is the motivation that the parent commenter gave for the WTFPL. But as a protest license, it's ideologically motivated just like the GPL and does a poor job at letting anyone use their code.

> It's a little absurd that I shouldn't be able to, in plain words, express "This is my own work, and you can do whatever you want with it". Eg. I shouldn't need 'warranty disclaimer' to not be at risk of liability, unless I was explicitly providing some kind of guarantee in the first place. (It's just a bit of freely available software, hardly leaving a dangerous item out on the streets.)

As much as you may wish this to be the case, it's not. It would be a pretty expensive way to make a point if you end up being sued because of the lack of a warranty disclaimer. This is a risk which I think is not adequately conveyed to people who choose the WTFPL.

So sure, it's a personal choice, but if you do choose it you're not doing yourself or anyone else any favors.

[tomchristie]

> It's ideologically motivated just like the GPL and does a poor job at letting anyone use their code.

Agree that it isn't a good choice if what you want is the most permissive, inclusive license.

(Completely with you there, and hadn't noticed the misjudged "with the openness, you can't beat the WTFPL" above.)

> Sure, it's a personal choice, but if you do choose it you're not doing yourself or anyone else any favors.

I wouldn't and don't use it for my projects, but I'd absolutely defend anyone else's choice to do so.

The choice to go with a license that actively eschews the standard reliance on legalese is a form of self expression. If someone chooses to use it and disregard the supposed legal risk, then I totally respect that.

[jordigh]

The WTFPL is approved both by OSI and the FSF, both of whom had lawyers look at it. It looks like they do know what it means.

I'm more of a GNU GPL guy myself, but the WTFPL isn't a bad license.

Edit: Ah oops, OSI did not approve WTFPL. Oh well.

[reubenmorais]

In addition, OSI does not recommend using CC0 for software: http://opensource.org/faq#cc-zero

[agwa]

They don't approve of WTFPL either...

[reubenmorais]

You're right, I was fooled by the GP comment who said they do.

[agwa]

This lawyer disagrees: https://news.ycombinator.com/item?id=8104407

He even points out that using it could get you sued due to the lack of a warranty disclaimer by default.

I've heard other stories of companies refusing to use WTFPL-licensed code, and that alone should discourage you from using it if you goal is really to let anyone use the code with no hassle.

Edit: the FSF doesn't recommend it (in contrast to CC0, which they do recommend if you want a public-domain license): http://www.gnu.org/licenses/license-list.html#WTFPL

[_puk]

Sounds like we need a "It's not my f-ing problem" licence.

[stared]

To be honest, I never used WTFPL, except for one April Fools' Day project.

As you say, CC0 is the way to go for transmitting things to the public domain (when it's applicable; many European countries do not have the concept of "public domain").

[amirouche]

not yet. It in the process of being worked out in France, at least.

[marcosdumay]

What's hard to understand in "do what the fuck you want to"?

[mtgx]

I'd like to see more open source software, but more importantly higher quality and much better designed open source software. To make that possible, open source software needs well paid developers. I'm tired of seeing open source software that has unreadable code from 20 years ago, and looks like it was designed 20 years ago, too. Such software from my point of view is unusable and therefore pointless.

That's why I think the best model is offering open source code that is freely available for other open source projects (to expand "freedom" and all that) OR free/gratis software (or perhaps only to non-profits), BUT if you get paid for it, you have to pay for a license. I think it's more than fair that if you make money off open source software you should give a cut back to the creators of that open source code.

Right now we're in the shameful situation where large companies making billions of dollars in profit every quarter don't even pay modest sums to projects such as OpenSSL (this changed a bit, but only after Heartbleed happened, and there are many more such projects that don't get the same benefit).

I know there are some disadvantages to this model, such as having hardware built with open source software cost more than it would otherwise, but let's face it the alternative would be hardware that comes with proprietary unverified code that may cost even more. So I think this "compromise" is well worth it, considering it can get the open source developers the money they need to keep working on it and expand the project.

[belorn]

Unreal Engine seems to have a fairly successful model of gratis for everyone except commercial products, and then it is 5% royalty on gross revenue per product. You don't have to mess around with non-profit status, or create a divide between people. A simple rule that state 5% royalty on revenue for each product, and if there is no revenue then its 5% of 0.

[ArneBab]

I agree that it’s important to have more paid developers of Free Software.

I disagree with your shism between open source projects and getting paid.

People should get paid for improving free software, because many others know that they benefit from that. Copyleft is a good tool to ensure that the improvements can flow back into the projects.

[tbrownaw]

That would get impractical very quickly.

The old-style BSD license is considered rather awful due to requiring a notice in your documentation somewhere.

Requiring money based on what you're doing with the software is more complicated, and dividing it up between all the included and depended-on projects is even worse.

[gsnedders]

I think it varies massively with what the open source project is and what the goals of the project are.

If you're implementing an open standard to try and encourage use of higher quality implementations of that standard, a permissive license is probably the right choice.

If you're creating an open-source clone of some software (be it the GNU OS or LibreOffice), a copyleft license makes far more sense—the fact it is open-source is the defining characteristic of your software.

[Sir_Substance]

>the fact it is open-source is the defining characteristic of your software.

That's a terrible thing to aim for with your project, because anyone else can duplicate your defining attribute with the mere choice of a license. Why not aim to make the defining attribute that it's the best?

[ArneBab]

You left out part of the sentence: “clone of some software”.

Freedom is a goal in itself, and “clone” defines how it’s the best: be directly usable to someone who knows the other software.

[jobvandervoort]

I don't understand the reason the author mentioned that you should use such a license. Why do you have to, in their reasoning?

We've been happily using MIT Expat for everything we open source and have not had any issues with it. Criticism, yes. Issues, no.

[mikekchar]

In my opinion, share-alike licenses are important when you want to establish a level playing field for competition. With a share-alike license nobody has more rights than anyone else. The exception is the copyright holder (if there is only one) who can re-license the work.

There are many situations where this level playing field is useful. For example, consider it like a consortium. If you have many groups in the consortium, you want each group to contribute equally. The only way they are likely to do that is if one group doesn't get an unfair advantage.

So the downside of permissive licenses (like MIT) is that it can (in some cases) discourage cooperation. Let's say you have a library that you license with a permissive license. Your competitor may not want to contribute (publicly) to that library because they fear that you will use their changes in your proprietary code to gain advantage over them. In fact, there is an advantage to consuming permissive code and keeping your changes to yourself as long as you don't mind paying the cost of merging upstream changes.

Conversely, there are times when a permissive license is more appropriate/beneficial. In some cases, there is no real risk that others will "horde changes". For example, if you are the author of a programming language, it is in everybody's best interest to continue to develop it. Nobody really gets any advantage by making their own proprietary Ruby implementation, for instance.

People should think very seriously about which free software license they choose, because it makes a difference. Permissive licenses lower the barrier to entry, but potentially create one-sided advantages for some players. Share-alike licenses ensure that everybody is working with from the same place, but makes the barrier to entry higher.

Generally speaking, if you look at the free software ecosystem, you will see natural divisions. Software that creates an entire application (like a word processor, or image editor, etc) tends to use a share-alike license. They do not want someone to take their work, add some proprietary icing to it and take mind-share from their project. On the other side are development tools and libraries which tend to use permissive licenses. Nobody benefits from making proprietary versions of these things. Even if some tries to do so, nobody will be interested in it.

There are people who feel that ensuring everybody has the same opportunities is morally a better choice. Obviously some people disagree, but I often find it surprising that the two sides can't at least understand the other's point of view.

[joesmo]

Very well thought out. Yes, recommending one type of license for all open source projects is naive. Frameworks and libraries need a different type of license than 'application' type projects. If it's not a MIT/BSD or something similarly permissive, these types of projects will generally not get used as much. I need to be able to modify these things at will, without ever having to think about licenses, especially in the case of bugs or problems that I cannot wait for the community to solve (if they're even going in the direction I am). If I'm going to distribute copies of my app, the license choice becomes one of the definitive criteria points in my choice of framework or library. For 'apps,' it's a much less critical choice and it makes sense to have a license that encourages collaboration.

[ArneBab]

why do you need anyone to agree with your changes with a copyleft library?

[joesmo]

I don't, but I also don't want to release all the code for my app upon distribution simply because it employs a copyleft library.

EDIT: copyleft library that I've modified.

[TuringTest]

The whole justification for share-alike (as opposed to permissive) licensing is traced back to the UNIX wars, where uncertain copyright attribution was a huge hindrance to developers and a source of commercial wars battled through litigation.

Share-alike protects against such fragmentation, allowing any developer to always take any improvements made to a different branch and merge it back to your version; with MIT licenses, that is often not an option.

A modern paradigmatic example is KHTML, the LGPL rendering engine that was the basis for Safari. Without the share-alike, it's uncertain that Apple would have released Webkit, and it would have been almost certainly impossible for Google to fork it as Blink - most improvements would have been unavailable to the public, with Apple using hidden changes as a competitive advantage.

[gsnedders]

> Without the share-alike, it's uncertain that Apple would have released Webkit, and it would have been almost certainly impossible for Google to fork it as Blink - most improvements would have been unavailable to the public, with Apple using hidden changes as a competitive advantage.

Hmm. They may well have eventually released it — WebKit did eventually get released (years after the code dumps of WebCore an JavaScriptCore).

[TuringTest]

Yes, maybe they would have released it, just like they released modified parts of FreeBSD. But the share-alike makes it less likely that they keep the best parts hidden, and more likely that there's a single reference implementation where improvements from competitors are kept close to one another.

[ArneBab]

WebKit did get released after the KDE developers attacked Apple for violating the license of KHTML.

[gsnedders]

Violating it? When did they ever do that, or get attacked for it?

They got complaints for just having code-dumps (or WebCore/JavaScriptCore) alongside releases, which made it hard to have any sort of individual patches. They were still in no way obliged to move to developing it in public, nor were they obliged to release WebKit.

[snarfy]

I used to believe in the BSD license. The GPL is better for the users, even if it restricts developers more than a BSD license would. There are far more users in the world than developers.

[quadrangle]

For that matter, concerns about compatibility are the only reason to use GPL over AGPL. If you want to protect user freedom, just close all the loopholes and go AGPL with everything.