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.
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. :)
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.
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.
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.
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
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").
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.
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.
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.
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.
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?
Freedom is a goal in itself, and “clone” defines how it’s the best: be directly usable to someone who knows the other software.
We've been happily using MIT Expat for everything we open source and have not had any issues with it. Criticism, yes. Issues, no.
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.
EDIT: copyleft library that I've modified.
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.
Hmm. They may well have eventually released it — WebKit did eventually get released (years after the code dumps of WebCore an JavaScriptCore).
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.
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/).