
Licensing in a Post Copyright World - llambda
http://lucumr.pocoo.org/2013/7/23/licensing/
======
MikeTaylor
This post is in most respects excellent, but it suffers from a fundamental
problem. It starts from the assumption that the goal of free software is to be
as widely used as possible, and that anything that prevents this is therefore
Bad. But widest possible use was _never_ the goal of the Free Software
Foundation. They have always been about freedom first and software second, and
Stallman has many times stated that he'd rather a program be used less if it
results in more freedom, than vice versa.

So the goal of the various restrictions imposed by the GPL (in either of the
main versions) is to increase freedom. We can usefully have a debate about how
well they achieve that goal, and whether the increase in freedom is worth what
has to be spent in order to achieve it. But if we do that, let's do it from a
position of first having understood why the GPL says the things it does.

I saw this summed up an admirably concise way some years ago, but stupidly
forgot to note whose soundbite this is: "Saying that the GPL is less free
because it forbids proprietary derivatives is like saying the USA is less free
because it forbids slavery". Yes, of course it's hyperbole to hold up freedom
of software alongside the freedom of people; but this quote shows by example
that more freedom doesn't always get achieved by less regulation but by more.

~~~
baddox
> They have always been about freedom first and software second, and Stallman
> has many times stated that he'd rather a program be used less if it results
> in more freedom, than vice versa.

I think I disagree with your interpretation, but I think my disagreement
hinges on a semantic disagreement about the word "freedom." To me, the GPL is
a legal limitation on freedom. It prohibits certain use cases, like
distributing that software without its source code. To me, a piece of software
is "more free" if its source code is available, but people are still able to
do literally anything they want with the source code, including distributing
binaries without providing access to the source code. I think the point of the
GPL is to utilize the copyright system to ensure access to source code for
everyone, _not_ to simply increase freedom.

The slavery quip doesn't really make sense, because in that analogy the
_source code_ is the slave. So unless we're talking about increasing freedom
for source code (which is a strange notion, since most source code is not
conscious) rather than increasing freedom for _people_ , my disagreement still
applies. The reason forbidding slavery is not generally considered a decrease
in freedom is that both slave owners and slaves are people.

~~~
spacelizard
The GPL does not limit freedom, it only limits power. Distributing a binary to
a user while denying them the source code, while not strictly a malicious act,
is an attack on the user's freedom because it puts the user at a position
where the author hold power over him/her. The author allows himself/herself to
freely study and modify the program in its preferred format (the source code),
but he/she has intentionally made it impossible for the user to do this.
Copyleft is about authors willingly removing the powers granted to them by
copyright and "redistributing" them so that all users are granted freedom.

It's worth noting that the GPL does not say you have to give out source code
all the time, you just have to give it out when people ask for it, and you
have to make the offer to give it out clear. So the actual issue that you
believe is "a limitation on freedom" is the lack of the ability to say no when
someone asks for the source code, despite that they have already been
distributed a binary. However, there are no practical reasons to do this that
don't involve intentionally keeping secrets from people, or intentionally
making studying and modification of the program difficult.

~~~
pbsdp
I'm a user, and I want to use your library in my product. The GPL limits my
freedom.

~~~
spacelizard
Your choice of not wanting to accept the GPL doesn't limit your freedom, you
had the choice to accept it and you declined. The fact that the software is
copyrighted in the first place is the only thing that could be potentially
limiting your freedom, and the GPL cannot do anything about that.

~~~
pbsdp
Users of proprietary software have the choice and can decline, too. Since
users dont need it to protect their freedom, why is the GPL necessary if not
to restrict freedom?

~~~
gillianseed
Because what it actually protects is rights, rights of the end user.

You of course know this, but you instead choose to endlessly harp on the
meaning of the word 'freedom'.

Licencing your code under GPL grants the recipient of any binary in which your
code is included a specific set of rights.

These rights include the right to the source code should the recipient want
it.

This particular right makes GPL very interesting for many developers as they
can release code, and then as recipients of modifications of that code, get
access to those modifications in source code form and thus gain improvements
to their original code.

~~~
pbsdp
If those users don't want to use code that isn't released liberally, they
don't have to. So what are you actually securing for them? It's not freedom,
they already have the freedom to not use proprietary software.

~~~
gillianseed
What you secure is the end user right to the source code of the _actual_
binary they recieve, which gives them the further rights to _examine_ and
_modify_ said code and generate and _run_ a binary with their own
modifications.

You know, those end user rights which GPL was created to preserve.

~~~
pbsdp
You don't need the GPL for that; just provide the source code for your
software. If users actually care about having the code, they can use your
binary for which code exists.

If they don't care, they can use proprietary software, or proprietary
extensions that make your software better.

Either way, the user has full control over their choice of software, and
nobody's actions can make your original open source code disappear.

The GPL is _really_ about enforcing your ideals onto _other people 's code_ if
it happens to be reliant on yours. That's a legit quid pro quo for a license,
but it has jackall to do with freedom or user rights.

~~~
gillianseed
>The GPL is really about enforcing your ideals onto other people's code if it
happens to be reliant on yours.

Oh please, enough with the bs, your code won't just 'happen' to be relient on
GPL licenced code. It's just as much of a choice as that of end users choosing
not to use proprietary code which you keep repeating.

And of course it has to do with user rights, that is what GPL preserves.

The right to the source code of a binary containing GPL licenced code, the
right to modify and build binaries from that said source code.

It legally binds anyone who uses GPL licenced code to grant those _rights_ to
their end users.

Being able to examine the code for the ACTUAL binary you recieve, rather than
some original source code which may very well have gone through numerous
changes before being compiled into the ACTUAL binary you recieve are very
different things.

And I've already described how from a developer standpoint this is of
importance as they are likely interested in recieving enhancements to their
code in 'source code form' if they choose to licence under GPL, but it's also
of importance in other aspects aswell since you as an end user may want to
examine the source code to make sure it doesn't do something you don't want,
or change it's behaviour to do something _you_ do want.

Those are definitely 'user' rights.

~~~
pbsdp
Your entire argument depends on the fiction that users can't make their own
choices, or that somehow your code can be made non-OSS once released.

Neither is true, and this hokey 'user rights' notion is just a thinly veiled
justification for a paternalistic communist view of open source collaboration,
in which you want to control not only your own code, but the code that other
people write, too.

It wouldn't be so insidious if it was presented honestly, as a set of
limitations on freedom for your own benefit as the author of the GPL software,
rather than in terms of the moral high ground of _granting_ freedoms.

~~~
gillianseed
No my entire argument depends on the FACT that GPL preserves end user rights
which end users are not entitled to with permissive code and are not given
with proprietary code. All your attempts to evade this point shows that you
have no interest in any honest conversation.

This is not about end user choice, this is about end user rights. With GPL
licenced code end users have the _right_ to the source code which created the
_actual_ binary they recieve. They don't have to demand the source code, but
it is their right, they don't have to examine, modify, run a resulting binary
of their own, but it is their right.

These rights are NOT preserved with permissive licencing, and they are NOT
granted by proprietary code.

You try to muddy the waters by saying that 'users' don't have to use
proprietary code unless they want to, but again developers doesn't have to use
GPL licenced code so that doesn't have anything to do with this at all.

Whenever you want to use someone else's code you are subject to their
conditions, you sure see nothing wrong with setting conditions for using
proprietary code (users can always say no), so by what logic do you think
developers should not be allowed to set GPL conditions for their code?

Your communist rant makes you sound like some crazy right-wing extremist, you
want to have the right to use other people's code in your proprietary
projects, but the notion of other developers instead wanting access to code
used in conjunction with theirs in return somehow strikes you as some
oppressive communist scheme??? Seriously???

You seem to think open source developers somehow owe you code to use in a
proprietary fashion, and if they don't provide it under such conditions they
are 'communists who wants to control other people's code'. I can't quite
understand people like you.

~~~
pbsdp
> _I can 't quite understand people like you._

That's because you've pretty substantially misinterpreted what I said.

I don't think "developers somehow owe you code to use in a proprietary
fashion" \-- developers are free to place any licensing restrictions they want
on their work.

What I do think is that the GPL is paternalistic, communistic, and
intellectually dishonest.

Here's why:

\- Once open sourced, your code stays open sourced forever. There's no way to
"un-opensource" code, and users can make use of it, forever.

\- If users want the source code to the tools they use, they are absolutely
free to only use binaries from people that provide the source code. If they
don't want the code, they don't have to.

Ergo, users already have the "rights" and/or "freedoms" you're pretending to
gift to them. QED.

What the GPL _actually_ does is create a quid-pro-quo communist common
ownership of the means of production (code) between developers. This has
nothing to do with "rights" of end-users, and everything to do with
restricting the rights of developers should they choose to participate in the
GPL ecosystem.

There's nothing wrong with that system (other than it being unworkable and
viral and restrictive, but there's no law against being obtuse), but it is
intellectually dishonest to claim some sort of moral or ethical high ground.

The GPL is a simple mechanism to restrict what other people do with the code
_they_ write in exchange for using _your_ code, not about "four freedoms" or
"user rights". The parallel's to Marxist Philosophy ought to be pretty obvious
in the aptly titled "Why Software Should Not Have Owners" essay from RMS:
[http://www.gnu.org/philosophy/why-
free.html](http://www.gnu.org/philosophy/why-free.html)

------
pessimizer
>People that license software under the BSD or MIT license probably would not
mind that much if copyrights would be abolished or greatly restricted. Richard
Stallman's world on the other hand would would fall apart.

I'm pretty sure that Stallman would love a post-copyright world, unless it led
to a world of rented locked down single-purpose appliances run on gifted code
- an outcome that MIT/BSD would be totally fine with.

AGPL and GPLv3 was a line in the sand to separate OSI types from people who
feel that it is a problem that people are legally and physically alienated
from their own tools.

IMO, releasing the source code that operates people's property is equivalent
to putting a list of ingredients on a packaged food product.

~~~
npongratz
> IMO, releasing the source code that operates people's property is equivalent
> to putting a list of ingredients on a packaged food product.

pessimizer, I really like your metaphor, and I expect that using it is an easy
way to introduce the subject to non-techies/non-law-geeks. Thank you!

As I reflected on your metaphor, my first thought was that releasing source
code is actually more closely similar to releasing the ingredients _as well
as_ the recipe for the packaged food. But my thinking is probably not always
correct: An author can release their source code that operates on my property
(the ingredients), but they have no obligation to release the process to
build/compile said source code (the recipe). (Hopefully I'm correct, I'm
certainly open to constructive criticism).

That said, I truly appreciate it when developers offer easy-to-follow build
instructions. However, for me at least, releasing the source almost always
meets my needs for sufficient disclosure.

~~~
drv
IANAL, but by my reading, the GPL does include build scripts as part of the
source code, e.g. from GPLv3:

"all the source code needed to generate [...] the object code and to modify
the work, _including scripts to control those activities_ "

Presumably this includes things like Makefiles.

------
__david__
One license I think gets overlooked is the Mozilla Public License (MPL). I
think it's particularly good for libraries and I've published some of my
simple javascript code under it.

The interesting part about it is that it says modifications must be published,
but that they are _file_ based and not project or linker based. This omits
many of the "onerous" (from the library user's perspective) restrictions of
the LGPL, while still keeping the spirit of "this is free software, please
give your enhancements to others to make the world better" which is sort of
the whole point of GNU.

~~~
JoshTriplett
Note, though, that older versions of the MPL (before version 2.0) are
incompatible with the GPL, so you end up with things like MPL/GPL dual-
licensing. MPL 2.0 is OK in that regard, though I still prefer LGPL or GPL.

~~~
synchronise
You can use someone else's proprietary modules in MPL code to better your
program or library, you can't do the same with (L)GPL.

~~~
JoshTriplett
In many cases you can with LGPL, and you can with GPL if you explicitly add a
licensing exception.

Also, regarding "use ... proprietary modules ... to better your program or
library": depends on your definition of "better", but if that's one of your
goals, then I agree that you don't want the GPL.

~~~
synchronise
To add onto it in a beneficial way to the user. Also, MPL allows static
linking, the LGPL doesn't unless you explicitly state it.

For the record, would 'GPL + Linking exception' be incompatible with the GPL
and LGPL?

~~~
JoshTriplett
> Also, MPL allows static linking, the LGPL doesn't unless you explicitly
> state it.

The LGPL allows static linking, as long as you provide the means to relink
with a modified version.

> For the record, would 'GPL + Linking exception' be incompatible with the GPL
> and LGPL?

Only in one direction. You can take code under the GPL plus a linking
exception and merge it into a GPLed project, but the result will not have the
exception, so you can't add proprietary code to the result.

------
egh
If you want to misunderstand licensing, this article is here to help.

To pick out just one of the many errors of fact and interpretation: linux has
historically been GPL v2 only; this decision was not made after the release of
GPL v3.

It's great that his "generation sees copyrights [as] a concept that should be
much more restricted and have a smaller lifetime": I'm glad that he's so
surrounded by the FOSS that makes this possible. But this possibility came
about because of the work of free software advocates and developers. Reveling
in your ignorance and disinterest really isn't going helping.

And if you think that it's a problem that Apple and the FSF (among others!)
are clashing on issues like restricted bootloaders, tivoization, etc. -- well,
I don't really know what to say. There's a reason that Apple and advocates
like the FSF are on different sides here. I know which side I'm on: do you?

~~~
nkurz
_There 's a reason that Apple and advocates like the FSF are on different
sides here. I know which side I'm on: do you?_

In the US the Democrats and Republicans clash on many issues. There are
reasons for this as well, which have mostly to do with self-interest. Does
this mean that I have to choose one of them, even if my interests align with
neither? Might there be a better choice beyond those two?

I'm pretty certain I'm not on either side.

~~~
mcguire
Not making a choice is still a choice.

------
nkurz
This is a wonderful article, and a great summary of the current open-source
software licensing issues, but I feel uneasy about the apparent conclusion.
After dozens of paragraphs about the intricacies and uncertainties of
licensing, it seems to suggest that if instead of asking people to choose from
a drop-down list of licenses, things would be greatly improved if they were
given a 10 minute overview before being forced to choose.

Any overview, even if vetted by vast teams of international copyright lawyers,
can only brush the surface of the issues. At best, you could end up with a
list of reasons to eliminate certain licenses based on your personal goals,
with the wordings chosen by the ideologies of the lawyers involved. Would this
be any better than GitHub deciding internally which license(s) they want to
promote, and putting these at the top of the list?

 _I think we should start to seriously consider simplifying our software
licensing environment_

This I can agree with. Having seen the amount of time wasted by open-source
projects on licensing issues, copyright worries, and patent fears (and the
resulting reinvention of the wheel) I think simplification is the way to go.
Personally, I don't think this simplification can be achieved by piling more
layers of abstraction on top of copyright and contracts.

Most books and papers seem to get along alright without licenses. I'd love to
see "fair use" defined more broadly, but I don't think that adding additional
licensing would be an improvement. Most electronic parts can be used as
building blocks for whatever project you want without worrying whether one
part will "contaminate" the others or "infect" the project. Music is licensed
more frequently, but I don't think amateur musicians would benefit if they had
to agree to terms of service before attending a concert.

Please tell me again why we want every project on GitHub to choose and stick
to a license? And who is this "we", and what do "we" stand to gain?

~~~
tjaerv
Yes, the conclusion feels like a letdown. With the title of his post ("post
copyright") you might think he'd have something to say about releasing code
into the public domain, yet there's no mention at all of this. How is
licensing your code under the copyright monopoly supposed to be "post
copyright"?

The introduction at [http://unlicense.org](http://unlicense.org) seems spot on
for the topic of the blog post:

    
    
      Why use the Unlicense? Because you have more important things to do
      than enriching lawyers or imposing petty restrictions on users of your
      code. How often have you passed up on utilizing and contributing to a
      great software library just because its open source license was not  
      compatible with your own preferred flavor of open source? How many   
      precious hours of your life have you spent deliberating how to license
      your software or worrying about licensing compatibility with other   
      software? You will never get those hours back, but here's your chance 
      to start cutting your losses. Life's too short, let's get back to
      coding.

~~~
the_mitsuhiko
> you might think he'd have something to say about releasing code into the
> public domain

Author of the post here. I'm Austrian - the whole concept of public domain
does not even exist in my legislation. I cannot legally waive copyright
currently. The closest to putting code into the public domain is probably
something like the WTFPL but I am perfectly fine with my stuff having a few
more restrictions through the MIT/BSD to avoid license confusion.

> How is licensing your code under the copyright monopoly supposed to be "post
> copyright"?

It is not. However there is a certain trend ongoing that people wish the whole
copyright system would be reformed and that would have more impact on Copyleft
licenses than MIT/BSD.

Aside from all of that I don't want to make license decisions for other
people. :-)

------
jtome
Did anyone notice the line:

What if it will become illegal to sell consumer devices without signature
checks for all software running on it.

I find it pretty weird that he's complaining that any country foolish enough
to enact such a draconian law would also criminalize all gplv3 software. I
personally think the gplv3 would be wonderful in this case since it would
create a high cost for enacting such an evil law.

------
lifeisstillgood
Most people are ignoring licenses, because most developers think they have
won.

There is a generation of developers for whom software freedom is in the bones.

Why bother putting a license on code, or releasing code under compatible
licenses -its all free and open.

This attitude may seem naive - but i see it as wondrous - any attempts to put
the genie back in the box will not be met by court cases led by Lessig, but
simple mass global disobedience - software is free when everyone simply thinks
it is free.

~~~
icebraining
Most developers think software is free for them to use, while completely
proprietary if anyone tries to use theirs.

It's not software freedom in their bones, it's self-interest running in their
veins.

~~~
lifeisstillgood
Well logically that still means everyone thinks all software is free. :-)

Excellent metaphor aikido there though.

------
drewcrawford
This is a great article.

One thing I would add to this is that nobody really knows what licenses like
the GPL actually do. Jacob Kaplan-Moss published a fantastic piece called "20
questions about the GPL"[0] , and my attempts to clarify a few of them with
the FSF and SFLC have so far revealed that not even two developer advocate
organizations can agree on even fundamentally basic concepts about the most
popular license, so isn't that a problem?

The reason that I contribute to the "projects on GitHub with no license"
problem is that I cannot find a license that unambiguously does what I want,
after spending many, many weekends on the problem. I could write one, or get
my lawyer to, but license proliferation is grounds for expulsion from the cool
kids club. Since I have no good options, I take no action.

Fundamentally, I believe we need a new license steward that isn't afraid to
update regularly to address 1990s questions like dynamic linking and optional
dependencies, and 2010s questions like app stores. Something like Creative
Commons for code, where you have some options to choose from.

[0] [http://jacobian.org/writing/gpl-
questions/](http://jacobian.org/writing/gpl-questions/)

~~~
tjaerv
Creative Commons for code would be CC0:
[http://creativecommons.org/weblog/entry/27081](http://creativecommons.org/weblog/entry/27081)

------
yk
The post ignores, why there are so many different FOSS licenses, the thing is
people have interests and sometimes these interests are not compatible. So
there is a place for MIT licenses, namely if you want as much adoption as
possible, and there is a place for copy left licenses, if you want to protect
the associated rights of copyleft. This is probably most visible in the “anti-
tivoization” section, which concludes

    
    
         The license restrictions of the AppStore, Google's Play Store
         and similar distribution systems and the GPLv3 are just not 
         compatible.
    

The reason for this is Apple, Google and others have their interests, namely
controlling a platform and enforcing whichever restrictions are mandated by
their interests.[1] On the other hand, the GPL[v3] tries to protect the
freedom to tinker for the owner of the device, the ability not only to see the
source code, but also to modify and run it. So the absence of GPLv3 licensed
software on iOS is actually proof, that the license is working as intended.

[1] Some examples of these interests are: Enforcement of DRM, trying to create
a 'more secure' environment, having a consistent UX, etc.

------
null_ptr
_" What if it will become illegal to sell consumer devices without signature
checks for all software running on it."_

Well that would be a tragedy. As if computing isn't moving towards closed
systems fast enough. I really hope general-purpose computing devices will not
become something only found in museums. Few movements in humanity's history
were as revolutionary.

------
binarycrusader

      Sun liked the whole concept of not being compatible with GPL...
    

This old chestnut again? I'm assuming this is based on Danese Cooper's
comments. Well, Danese was wrong:

    
    
      She is speaking this way because she lost an argument
      inside Sun, not because her view is representative of the
      views of Sun or its staff in the way she claims. She,
      along with many actual engineers, was an advocate of
      using GPL or OpenSolaris but the need to release rather
      than wait for one of {GPL v3, Mozilla license revision,
      encumbrance removal} meant that this was not possible. I
      am still furious with her for the statement she made at
      DebConf, which was spiteful and an obstacle to a united
      FOSS movement.
    

[http://web.archive.org/web/20110716130648/http://www.opensol...](http://web.archive.org/web/20110716130648/http://www.opensolaris.org/jive/message.jspa?messageID=55013)

------
zeckalpha
This is a must read for anyone licensing software.

I wish there would have been a discussion of the ISC license, as I find it
even clearer than the MIT/BSD licenses.

~~~
jtome
I agree about the ISC, that's why OpenBSD, the most free OS (as in you can do
whatever you want with a larger percentage of it than any other OS), prefers
using the ISC over the BSD license now.

~~~
graue
The FSF's site[1] points out what looks like a serious problem with this
license:

> _This license does have an unfortunate wording choice: it provides
> recipients with "Permission to use, copy, modify, and/or distribute this
> software…" This is roughly the same language from the license of Pine that
> the University of Washington later claimed prohibited people from
> distributing modified versions of the software._

To me, it sounds like "modify and/or distribute" means it _should_ be okay to
both modify and then distribute the modified version. But I'm not a lawyer,
and if the same language has been used to argue you can't distribute modified
versions, that's pretty scary. Enough reason to prefer the slightly longer MIT
license.

[1] [https://www.gnu.org/licenses/license-
list.html#ISC](https://www.gnu.org/licenses/license-list.html#ISC)

~~~
zeckalpha
I was under the impression that that website is outdated. The ISC used to just
say "and distribute", which is similar to older versions of the Pine license,
and had problems. However, the new language is more similar to the MIT license
("and/or ..."), but the FSF does not have an issue with the MIT license.

[https://en.wikipedia.org/wiki/ISC_license](https://en.wikipedia.org/wiki/ISC_license)
[https://www.washington.edu/pine/faq/legal.html](https://www.washington.edu/pine/faq/legal.html)
[https://www.gnu.org/licenses/license-
list.html#X11License](https://www.gnu.org/licenses/license-
list.html#X11License)

~~~
graue
The FSF quotes the new version with "and/or" in the blurb claiming problems
with wording, but that may just be an editing mistake; maybe someone went
through and corrected the quotation without realizing it resolved the concern.

Either way, though, the OpenBSD folks didn't change "and" to "and/or" in their
template, which ranks high for a search for "ISC license". Someone could
easily copy the older, problematic version. Given the MIT license works fine,
why take even a small risk?

------
jdmitch
Very informative - here is a license comparison tool I've found useful:

[http://www.tldrlegal.com/compare](http://www.tldrlegal.com/compare)

------
stormbrew
An interesting thing, to me, about the GPL is that it's possible for companies
to use it as an anti-competitive weapon against each other. A company who owns
or has been assigned the copyright to an entire codebase is able to hold the
exclusive right to profit from hidden modifications of it. Oracle is in this
position right now with mysql, for example. GNU itself, were it so inclined
(though it obviously isn't), would be as well.

This becomes even more significant when talking about the AGPL and its
limitations on using it as a service. 10gen is the only company that could run
a proprietary uber-version of MongoDB, and that right persists effectively
forever.

When it comes to more open licenses like BSD no one holds this as an exclusive
right.

~~~
spacelizard
Arguably that problem is _worse_ with permissively licensed software. In that
case you don't just have the original copyright holder peddling a proprietary
uber-version, you have every company and his dog doing it and every version is
expensive and/or incompatible with each other.

~~~
stormbrew
I don't see how it can be considered worse. I could see even, but not worse.
Does it matter if it's one or ten organizations that are taking advantage of
the ability to make proprietary software out of open source code? At least
with ten there might actually be competition.

But realistically, it's not like permissive licenses are a new thing and this
apocalypse doesn't seem to be a very common occurrence in practice.

------
danbmil99
Great article. My favorite example of these Talmudic complexities is opensim
(opensimulator.org), an MIT-licensed Second Life-compatible server that has a
twisted, Black Widow-like relationship with Linden's GPL-licensed client code.
Before 2011, there was a nutty "6 month cool-off period" before any SL client
contributor could contribute to Opensim:
[http://justincc.org/blog/2011/06/30/announcing-the-overte-
fo...](http://justincc.org/blog/2011/06/30/announcing-the-overte-foundation-
for-opensimulator/)

------
er0k
This is why I use the WTFPL (DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE)
[http://www.wtfpl.net/txt/copying/](http://www.wtfpl.net/txt/copying/)

~~~
LeafStorm
I'm pretty sure suing you if it causes damage counts as "what the f--k they
want to."

~~~
droithomme
Can you post a list of all lawsuits filed against WTFPL licensed software?

~~~
LeafStorm
Yes: []

But that's only because it hasn't been used for anything worth suing over.

~~~
droithomme
Are you aware that disclaimers of liability are not considered valid contract
terms in most scenarios and legal jurisdictions in western countries where
software is likely to be used?

Do you believe that you can disclaim liability for negligence such as
carelessness or a failure to thoroughly test? How about for intentional
malicious acts? Courts in the US and commonwealth nations at least don't allow
such disclaimers. What about other sorts of liability? Do you know the
differences between direct, consequential, special, incidental and indirect
damages?

The reality is that in enough jurisdictions to matter, authors can be held
legally liable for bad code they create no matter whether they have a
liability clause as a condition of licensing or not. Forming an LLC or
corporation won't shield them either if someone wants to sue. The only
protection in these cases is maintaining E&O insurance.

If I use GPL, BSD, or any other licensed code that disclaims liability, and
the code is flawed because the author was negligent, I can sue the author for
damages and I can win. The disclaimer does absolutely nothing.

What purpose then is there in cluttering up licenses with useless clauses?

------
qznc
My try of a licence wizard:
[http://beza1e1.tuxen.de/licences/](http://beza1e1.tuxen.de/licences/)

~~~
Tobu
Thoughts on LGPL vs MPL vs GPL with linking exception?

~~~
qznc
I opted for MPL, because it is the most liberal licence that I could find,
which is still "copyleft". The spectrum between MPL and GPL (covering LGPL
etc) is complex.

------
desmondrd
This is awesome.

------
azeemk
great post.

