The "Do I Look Like I Give A Shit" Public Licence
blog.samuellevy.com
blog.samuellevy.com
https://news.ycombinator.com/item?id=5733477
Long story short, no matter how hilarious and concise your license is, you probably want to disclaim warranty, and in the form everyone else uses.
To put it all into perspective, the origin is as old as 1854, and was from a legal case around a delayed mill shaft. That leading English contract law case was many years later written into the Uniform Commercial Code. It specifies the need for disclaimer, and specifies that any disclaimers must be "conspicuous", which in turn is defined as: A term of clause is conspicuous when it is so written that a reasonable person against whom it is to operate ought to have noticed it. [...] Whether a term or clause is “conspicuous” or not is for decision by the court. The document gives as an example that a printed heading in capitals is conspicuous, though any text that is larger or in a contrasting type or color will work.
So what it boils down to is this: If you sell something and thus perform a commercial transactions, you can become liable, except if the contract between the customer and seller conspicuously says otherwise.
A software license is not a contract, and most people don't sell the software if they put it under a permissive license. I'm not a lawyer, but the liability of giving away software should be minimal, if any at all.
There's plenty of untested FUD, well exemplified by your linked comment, about how someday somehow someone might screw you, if you don't follow all the right lawyerly-approved licensing incantations. If someone wants to minimize risk and fuss, they should surely follow the lawyer-recommended course.
But if they've got other goals, such as testing whether the FUD is true, and maybe eventually getting the legal precedents established that such lawyerly boilerplate isn't necessary for free uncompensated sharing of code, then they might follow another course. That other course might sometimes infuriate potential code-reusers, and appear reckless to experts about the traditional order. But once aware of the risks, it's the licensor's own chance to take.
Of course, YMMV, IANAL, etc.
(If there is any case of an open-source author being sued in a manner where simply having attached the right license boilerplate would have saved them, that would make an excellent front-page HN story.)
You've extrapolated DannyBee's mention of some risk of implied-warranty lawsuit all the way up to "lose your house many years later because you chose a whimsical license".
But, there are no examples of something like that happening in the open source domain. It's worst-case speculation, without precedent.
That's spreading "Fear, Uncertainty, and Doubt" to deter a particular course of action. Now perhaps, fear is justified, and the uncertainty will be resolved in some future case that confirms it was wise to be afraid. (Literal "FUD" isn't necessarily false!) Or maybe there's a prior case that hasn't yet been mentioned – that's why I've asked for an example.
But for now, the idea of someday losing your house over a insufficient disclaimer-of-warranties on freely-published, unmarketed, uncompensated source code is just a scary bedtime story.
A few years ago there was legalistic FUD about how releasing code as public domain was dangerous; without a license you'd be at risk, and no amount of disclaimerizing could save you, because without either a license or contract, the disclaimers had no force.
Thankfully, that FUD has receded, so that now even legalistic worrywarts can recommend the CC0 or unlicense.org dedication as a safe and reasonable approach.
I predict such common-sense progress will continue, driven by irreverent young programmers with no patience for obsolete complexity. But that's a socioeconomic prediction, not a legal opinion. If being airtight-alright by all the lawyers and judges is someone's top priority, they should take your circumspect advice.
So this "you-could-lose-your-house-by-using-WTFPL" FUD indeed originates with DannyBee.
"This software is safe for use in a nuclear reactor". Not "this software, that I made in highschool for the lulz, is not safe to be used in a nuclear reactor".
Software should come with guarantees if guarantees are needed. It should not come with an exhaustive list of non-guarantees.
And to your example regarding cars, such a guarantee could be "this car is safe to drive on [roads]". Replace "roads" with the legal name for surfaces where cars can be driven.
The underlying problem though is that there are such a large number of people that refuse to take responsibility for their own actions. "But, your honour, the guarantee said I could drive on roads. It didn't mention anything about being blind folded while doing so. It wasn't my fault I'm now paralysed".
A pretty ridiculous example; and probably a naive one as well. But the law systems we live with are way too complicated. And I feel the people, whose job is to "interpret" the law (judges) are doing a terrible job upholding the spirit of law.
Legally a lot of software (& things) comes with default guarantees. You have to opt out of some guarantees.
In my experience the the worst licenses to deal with are the ones that lawyers have not had a hand in specifying the language used (With the exception of anything that's been written by someone on retainer at Oracle).
It's not hard to copy a MIT or Apache license file into your repositories and push it.
$ cat mit.txt | wc
19 167 1065
$ cat bsd.txt | wc
10 219 1479
$ cat CC0.txt | wc
29 978 6384As an unfortunate side note, none of the licences you listed have any terms relating to patents, (unlike the apache licence, which is considerably larger) which is one more tangled-web that a dev has to think about.
You're essentially suggesting they should just shut up and maximize others' convenience. OK, that's a valid opinion, and if their only goal is maximal reuse, CC0 is great.
But their choice of crazy-ass license is an expressive act, like the coding itself, and you haven't established why your convenience trumps their other expressive goals.
As far as I remember, all of the major free software licenses disclaim any obligation to maintain the software, disclaim that the software is fit for any specific task and state that the user uses it at their own risk.
If you use a known licence at least there's a chance that those companies will at some point contribute back instead of sitting on their internal patches.
I'm in that situation now with a couple of projects, but I have to patch them locally only. I will not spend days with legal to approve a licence, sign a contributor agreement, or some other form of ownership transfer. Both the project and its users lose that way.
Without the licenses free software doesn't get more free. It just dies. Everybody runs away from it. Copyright law is clear: It belongs to the original author, and without a clear transfer of rights, nobody dares to reuse it except in secret. It's technically risky even to read it, lest you establish evidence that will later be used against you in a copyright suit. And it's risky to offer the original author a patch without an explicit disclaimer of warranty - after all, the author owns and controls the code, and the fact that the codebase looked like comedy on Tuesday doesn't mean it won't be part of a nuclear power plant by Friday night.
(Of course, when the lawsuit happens you'll probably be able to argue that the use of your patch in a nuclear power plant wasn't authorized. But that argument may have to be made to a jury, by a lawyer that is costing you a lot of money.)
So, it'd be nice, I think, if we could create a mapping between these sort of "intention-based licenses" and the more legally-strict "implementation-rule-based licenses." Like, to say, "code under the Do I Look Like I Give A Shit License is, in practice, MIT-licensed" or something like that. And then people can pick a license based on intent (instead of reading legalese), and have it map to a license with full legal power.
--or, cut out a step, and just give all the current legally-enforcable licenses nice, human-friendly abstracts, for things like the GitHub LICENSE chooser to display.
We were required to audit every line of code used in the project, and state whether we owned the code, or if the code was open source, what license was used. (The bottom line is that IBM's lawyers were afraid we might be using GPL code)
I would love to see how the lawyers respond to code under the "Do I Look Like I Give A Shit" license.
Anyway, for people in this thread pleading to take these things more seriously, it's because of real-life scenarios like I just described.
This is the kind of thing that could hold up a Multi-Million Dollar business deal for weeks while the lawyers figure out what to do about using code with this license.
More likely is that experienced management will prohibit developers from using the code in the first place.