Linus Torvalds says GPL v3 violates everything that GPLv2 stood for (2014) | Hacker News Reader

Linus Torvalds says GPL v3 violates everything that GPLv2 stood for (2014)

youtube.com

120 pointsnaetius96 comments

Also Linus: GPL V3 is a fine license.

Overall Linus Torvalds did not like how V3 was forced onto 'unsuspecting' GPL v2 users due to the 'or later' license assignment.

Yeah, but this quote is out of context. With context it makes much more sense.

The number of persons who earnestly say that it is a good idea to license one's work under or later-licenses is quite boggling.

It is putting one's work into the hands of license that does not yet exist, it is irrevocable and once the F.S.F. brings a new version and one does not like provisions thereof, one cannot go back.

While I can see why some wouldn't want to use an "or later" license, I don't think it is near as big a deal as you make it out to be.

While you are granting the FSF the ability to relicense your code, they only have the ability to re-license your existing code. As it is already under the current version of the license, if you do not like the new version, you can simply stop using it for future additions. If I license something under "GPLv2 or later", and the FSF releases GPLv3 that is the SSPL, I can simply keep using my existing code under GPLv2. If the FSF releases GPLv3 and it is CC0, then I can once again keep using my code under GPLv2. In either of these cases, I don't have use the new version of the license on new versions of the software. While the existing software is always "GPLv2 or later", later additions can be "GPLv2 only".

An "or later" license allows for making my license compatible with future versions of the GPL. Personally, I see this as a good thing.

You can also dual license your work. If a new license version appears you can read it through and then decide if you want to distribute your work with that license _too_.

Only if you are the sole author.

If you have accepted third party contribution and don't have any copyright assignment agreement (which is... Most of the projects out there), you can't relicense easily.

Not official GNU projects. They can easily switch their/our projects to GPL-4 when the urge arises.

This is fundamentally wrong. I don't care if you like GPLv2 or not, but this is clearly showing you can't read or haven't read it.

Its not about the user keeping his code under GPL2, its about other parties being required to keep their changes under GPL2 and accessible.

> This is fundamentally wrong.

Would you provide a point-by-point rebuttal? If not, would you at least provide some evidence of your position that my post is "fundamentally wrong"?

> I don't care if you like GPLv2 or not, but this is clearly showing you can't read or haven't read it.

I have read GPLv1, GPLv2, GPLv3, aGPLv3, the X.ORG license, all forms of the BSD license, the appache license, several versions of the Mozilla License, amongst others. Please refrain from personal insults ("clearly showing you can't read") as well.

> Its not about the user keeping his code under GPL2,

My argument is that the FSF will probably not grant anybody privileges with the existing code that I don't like. Even once a new version of the GPL is released, other contributors will have to contribute under a version of the GPL. If the best versions are only under a later version of the GPL, maybe I will switch to GPLv4.

> its about other parties being required to keep their changes under GPL2 and accessible.

So it seems that you are worried that future contributors will release their contributioins only under the "later" version of the GPL and these new contributions will thus not be compatible with the older version of the GPL. This definitely could happen. However, many projects already dual license under GPLv2or3 so I don't see this as much of a concern. Sure we are adding GPLv2,3,orLater but these issues already exist and already don't cause too great an issue (in my opinion).

"fundamentally wrong" and "you cant read" are a poor choice of words in retrospect and i should have used "Fundamentally misrepresents the issue" and "you appear to not understand why GPLv2 exists".

> Please refrain from personal insults ("clearly showing you can't read") as well.

I think the issue stems from:

> "I don't think it is near as big a deal as you make it out to be."

It is ambiguous weather you are "not sure about your logic", or if you are "not sure about Blikkentrekker logic". I took it to mean the latter. This puts your comment in a very bad light and set me off because it fails to acknowledge the issue Blikkentrekker is raising.

> "While you are granting the FSF the ability to relicense your code, they only have the ability to re-license your existing code"

A developer chooses the GPLv2 in part to what it does to _future_ code. `I provide this for free and we are all required to contribute future improvements for free, no-take-backsies`.

>"If the FSF releases GPLv3 and it is CC0"

is among the worse case scenario's for a developer that chooses GPLv2. It invalidates their choice and leaves only `I provide this for free` and is the core of the issue at hand.

> My argument is that the FSF will probably not grant anybody privileges with the existing code that I don't like.

And this is a perfectly fine counter. Its a matter of if you think the risk is worth it.

Imagine I use software "X" which is licensed under GPLv2-or-later and put it inside locked-down hardware.

Then someone else comes along and chooses to use it under GPLv3, then proceeds to sue me because I can't lock down GPLv3 software.

Problem is... when you choose the GPL version in an "or later" scenario, you're choosing for yourself, not others.

Thus "or later" posed no problems by itself.

(The same exercise can be made regarding the patent clauses.)

you locked it down under v2, there's no problem there, and only the author can sue you for violating the old license or the new one, which you have not done.

The "or later" bit was meaningless until the first GPLv3 (or later) code change was introduced, and it wasn't forced by anyone since it wasn't even part of the license.

Users of GPLv2-or-later software cannot use GPLv3 clauses against other users (such as patent grants), as either party can always claim to be using the code under either license. GPLv2-or-later is thus fine.

The "unsuspecting part" comes from people relicensing under v3 without understanding how radioactive it is. And it is radioactive not because of any software-related concerns, but because of extraneous stuff (like Linus says).

Funny enough, the most radioactive bits come from trying to cover things that are better fought in other grounds, like software patents.

I read this comment then watched the video and this comment misled me. He did not come around to accepting v3 after just procedural complaints, he said it’s fine for other people, who actually want its new conditions, but it’s not an update to v2 and should have been a separate license.

Wait, we first need to know if the OR in "GPL v2 or later" is short-circuit or strict evaluation.

Deepest differences between GPLv3 and v2 are:

* Antitivoization clause: it bars its use in software that will only run if signatures are required. This guarantees freedom 0 (freedom to use the software) will not be circumvented and discourages vendors from shipping hardware that requires signed software.

* Antipatent clause: The license is revoked from an attacker if patents are used to attack users of the software.

These clauses maybe desired in some cases. Probably, a sensible direction could be to add flags to the GPLv2 to particularly enable these clauses. Somewhat similar to how it is done with CC licenses which may have BY, SA, or NC flags.

> it bars its use in software that will only run if signatures are required

It's a little bit more nuanced than this. It's okay to require signed code as long as the end user has control over which signing keys to trust (e.g., x86 Secure Boot, but not ARM Secure Boot). In particular, this means you don't have to choose between security and freedom - you can have both.

Also an IMO important point: if a copyright holder notifies you of a violation, you have an explicit 30 day grace period to "cure" that.

The GPLv2 instead terminates your license, requiring a reinstatement by the copyright holders.

The GPLv2 “death penalty” is most likely unenforceable.

The legal argument is that since the GPLv2 is a public offer that one can accept by complying with it's terms, regardless of the original holder's specific permissions, the offer is even extended to past violators, so all violators have to do to re-accept the offer is to simply come into terms with it again, but for the duration that they are out of terms, the offer is terminated.

but for the duration that they are out of terms, the offer is terminated.

Try telling the NFL that you're only violating their copyright during for duration of the super bowl. If you stop committing a crime, it's not like it never happened. Sure, most copyright holders of GPL licensed code won't sue you if you make an honest effort, but the 30 day clause just makes that official.

That has nothing to do with licence termination, however, which is an entirely separate part from violation.

Once the license is terminated you are in violation.

No, in reverse, once one violates, the licence is terminated.

That has nothing to do with copyright per sē, and is simply a provision of the GPL, and thus has nothing to do with the Superbowl.

The GPLv2 rightsholder can independent of that elect to sue and seek damages for the duration of the copyright violation, but once one come into compliance again, one can re-use it, and the GPLv2 rightsholder cannot stop that.

The GPLv2 rightsholder can independent of that elect to sue and seek damages for the duration of the copyright violation, but once one come into compliance again, one can re-use it, and the GPLv2 rightsholder cannot stop that.

We might be arguing semantics here. I am trying to convey the idea that the rights holder can sue for damages after the duration of the violation, even if they can only sue for damages that took place during the violation. That is, once you are in compliance with the license you don't retroactively have a license for the time it was revoked.

Yes, but that is not what the GPLv2 death penalty is.

The principle if true means that one can never obtain a new licence when coming in compliance except by gaining permission from every single rightsholder which for large projects can be thousands. — this is theoretically true by the letter of the GPLv2, but the common legal opinion is that this provision is not legally enforceable.

The GPLv3 fixed this unintentional problem, as the GPLv2 was never written with the idea of thousands of rightsholders in mind.

It appears to me that the complaints in the video seem to go more towards the problems of license compatibility (or lack of backwards compatibility) between GPLv2 vs GPLv3 creating tons of problems with outside contributions to the kernel if the typical "or later" clause was used.

Some of the other commenters here seem to stress the Tivoization clause, but it appears to me that that is not the real issue. Linus even says so, at one point when the guy asking the questions repeatedly tries to stress that point.

I am not familiar with the Tivoization issue, but v3 solves one showstopper problem with v2: v2 has no real patent release. To me this puts v2 in the same category as MIT/X11 and BSD: archaic licenses that no one should ever use except for the most trivial of projects.

Linux is chock full of potential patent release deathtraps: that it is still using v2 is kinda scary.

I wasn't familiar with "Tivoization" either but I found that there's a Wikipedia article about it: https://en.wikipedia.org/wiki/Tivoization

I just looked up the history of it. Interesting characterization.

The "medical devices" loophole in GPLv3 makes the whole thing kinda insane

http://gplv3.fsf.org/dd3-faq

Look at that table!

I don't understand how this table relates to medical devices? Could you explain?

The table is a second thing - Section 6 is the medical devices loophole; I was just amazed by seeing that (unrelated) table.

Certainly simple! /s

This is basically why apple stopped shipping GPL software when GPL3 came along.

Apple takes away the ability to run the software, then sells it back to you.

I like Linus's generalization of (in my words):

- If you like the idea of sharing code and want people to share code back. Use GPL

- If you like the idea of sharing code, and merely want credit for it. Use BSD.

Your point about patent is an import part of his generalization that is not addressed.

GPLv3 solves the first bucket WRT patents. Is there a license that falls under Linus's SECOND bucket, that solves the patent issue?

EDIT: formatting and clarifying words.

> Is there a license that falls under Linus's SECOND bucket, that solves the patent issue?

Apache 2.0 License.

Good to know. Thanks!

And BSD + Patents

I think this is a common misconception. The Apache 2.0 license isn't all that similar to simpler licenses BSD/MIT/X11.

Apache 2.0 has some clauses which (most people tend to ignore and which) make it somewhat incompatible with modern open-source fork and pull request workflows.

In particular 4.b)

> You must cause any modified files to carry prominent notices stating that You changed the files;

For the most part, people just throw their name in the file, in an attempt to "meet" this requirement without massacring the file header/notice.

However, if the Apache 2 license is taken at face value, when you fork and modify a file, you have to mark it as such. Then when you submit back, the project (in adherence with the Apache 2.0 license) has to retain this notice. Technically the project may even then need to add their own notice to indicate they modified the file since you did.

Clearly, that's not tenable, so most (small) projects just offer leeway. Larger projects instead have contributor agreements (AOSP and alike).

Yeah it's a bit troubling that such weird clauses exist in the Apache license, and that the Apache license has become this popular lately. The main motivator is that everyone else is doing it I think, and the patent license.

Large Apache licensed projects without contributor agreements exist (LLVM for example).

I would argue that git blame is prominent enough. And as long as you don't distribute sources in any other way than a git repo you are fine.

Assuming this is true (hopefully it never comes down to it, but I'll leave that for the courts), then the simple act of hosting on Github, with its download source functionality, would make you in violation.

You can argue all you want, ultimately it's for courts to decide, and in the meantime the Apache 2 license creates a ton of legal uncertainty for no good reason.

For example, GPL has language requiring you to make clear that you changed the software, but leaves open how you do it, and doesn't require you to mark individual files.

I guess I assumed you only need to be clear about the modifications if you are not also releasing them as Apache 2.0. is that not the case?

If not, is there any other similar standard license with a patent clause that I could use?

The "default" license for Java libraries being Apache 2.0 shouldn't be overlooked as a reason for the success of Java in the corporate world IMO. It's a perfect license to make corp lawyers comfortable.

I believe Apache solves the second bucket with respect to patents.

I actually really like the idea of a license that forces changes to the licensed code to be made available to be merged back upstream, at least in theory. The issue I have with the GPL is that it doesn't, in my opinion, do a good enough job of distinguishing between "changes to the licensed code" and "changes to unrelated code which happens to be integrated with the licensed code". I would prefer not to impose restrictions on the latter, because in my mind that effectively restricts what people are allowed to DO with my code by making it harder for them to use it with code that's available under a different license.

For example, if I were writing some kind of calendar application which contained a date parsing module within it and someone wanted to copy some code out of that date parsing module and paste it into their own application, I'd be perfectly fine with that. If they later make improvements to that code they copied, I'd prefer it if they'd contribute those changes back, but I absolutely don't want to try to force them to make their entire application open-source, or if it's already open source, to force them to re-license it under my license.

I recognize that the line between "unrelated code" and "improvements to my code" can get really blurry, which is why right now I prefer to err on the side of freedom by using permissive licenses like the MIT, but I wouldn't mind using a copyleft license that took greater pains to ensure it isn't "viral" like the GPL.

If you haven't already, you might take a look at the LGPL.

Linus is also against enforcing the GPLv2 against violators because it alienates companies and contributors.

Their preferred strategy apparently consists of using two properties of the Linux kernel as leverage: the massive scale of its development and the instability of its internal interfaces. Linux kernel hackers get about 20 patches every hour and that figure comes from a video I watched years ago. Those patches improve things all over the place and nobody cares about code that isn't in the kernel tree. As a result, out-of-tree code quickly becomes out of date and the companies must pay the constant maintenance costs or be left behind.

To me this puts v2 in the same category as MIT/X11 and BSD: archaic licenses that no one should ever use except for the most trivial of projects.

Isn't BSD widely accepted to have an implicit patent license? e.g.: https://github.com/facebook/zstd/issues/335

No, nor MIT/X11. There is debate as to whether its wording might provide some protection through accident of history, but that's not how the law should work: a proper license is unambiguous.

In common law countries, it's nearly impossible to write a legal document that's completely unambiguous. Even if it's unambiguous at the time the document is written, the underlying law could change at any time. Of course that could happen in civil law countries too, but it'd be from a statute being changed.

Whataboutism. There's a massive difference between "no license is 100% unambiguous" and "BSD is maximally ambiguous".

Tivoization is when a computer comes with GPL code, but refuses to run it if there have been any modifications to the code. Tivo used to ship GPL'd software, and provide the source, but they had some kind of lock that checked the authenticity of the code being run. So it defeated the entire purpose of the GPL, which is so the end users have control of their own computers.

...which was of largely academic interest when it was DVRs, but is now a pants-on-fire emergency with the "advent" of Linux-powered pocket spy devices masquerading as telephones - with huge consequences for ordinary, non-nerd people.

The stakes for software freedom have never been higher.

Giving end users control of their own computers is not a stated goal of GPL 2.

From the preamble:

  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

This jives well with Linus's intention of "I give you software to do whatever you want with, and if you make improvements you have to give them back"

isnt this why they made gplv3 then

It is. My point is that saying Tivoization went against "the entire purpose of the GPL" (which would include v2) isn't backed up by the text of v2 itself.

I agree. GPLv2 was about keeping the software free. The tivoization issue addresses a (relatively) newer issue, to protect full control over hardware and software. Which is, IMO, not within the scope of a software license -- it took many of us by surprise that the "or later" clause was used to change the fundamental meaning of the license in that manner.

Some of us were always suspicious before the change -- "what if RMS sells out and v(n+1) grants non-reciprocity to his employer" type of crap -- but we went with v2+ because it was popular at the time. I don't think I've seen "v3 or later", probably because we've been burned already.

Eh... it seems more like “the authors of GPLv2 didn’t even think of Tivoization when it was written”.... I think the assumption was that if you have access to the code and the rights to change it, that meant you could be in control of your software. They didn’t think of the possibility that hardware would restrict what could be run.

I don’t think it is that much of a stretch to say preventing people from running modified versions of the software went against the goals of GPLv2 to allow users the ability to “change the software or use pieces of it in new free programs”

Not being able to run the software you change certainly means you can’t use it.

It's very clearly backed up by the history of how the GPL came to be in the first place.

There was a printer driver that RMS wanted to change but couldn't. If the system he was working with had had code signing for printer drivers and refused to run with his modifications because of it, we'd have had the TiVo clause in the very first version of the GPL already.

It wasn't an explicitly stated goal, but thats exactly what those freedoms were meant to do. Atleast in regards to the software being provided under the license. They just didn't foresee a future where computers would refuse to run a modified version of the code they came with. Remember, the impetus for GNU was a closed source printer driver that rms wanted to modify, and was not allowed to.

This jives well with Linus's intention of "I give you software to do whatever you want with, and if you make improvements you have to give them back"

Except the GPL does not require you give any improvements back. It only requires that you give the same freedoms to whoever you give the improved software to. That is, the end users. There are plenty of enterprise "appliances" that come with modified GPL code that is only given to the companies that pay for these computers. That is perfectly within the spirit of the gpl, because it's goal is to give the end users freedom.

edit:

What else would be the point of "that you can change the software" without having a means to run it?

What else would be the point of "that you can change the software" without having a means to run it?

Porting the software to new hardware?

Of course it was, implicitly. Go back an read Stallman's writings from the time. It was all about giving end users control. The end users of the early GNU software were mostly programmers so providing them with source code was providing them with control.

Giving end users control of their own computers is not a stated goal of GPL 2.

But it is. Let's quote another paragraph of the preamble too, shall we?

  if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.

This surely says, in spirit, that if you as manufacturer have the right to deploy this software on certain hardware, that the recipient must have the same rights?

Linus's intention of "I give you software to do whatever you want with, and if you make improvements you have to give them back"

This, on the other hand, is not a stated goal of GPLv2. Your obligation, as a software distributor, is only downstream (your recipients/customers), not upstream (your suppliers).

> Giving end users control of their own computers is not a stated goal of GPL 2.

It is the goal of Stallman and the Free Software Foundation. Free software licenses are one of the means to that end.

Free software started in universities decades ago. The software was written for Unix computers, many years before things like trusted computing. The GPLv2 reflects this environment: it takes hardware freedom for granted and focuses entirely on software freedom. Tivoization was an unforeseen development.

Yes but:

- There is no legal viable way to upgrade to v3, even if the "or later" clause would be there it would have been a legal disaster.

- It's also makes it much more viable to upstream drivers in Linux

- Let's be honest the patent system is by now utter garbage failing the one fundamental thing it was invented for: Driving/Improving Innovation. The only reason it didn't fall on our head yet is because many companies simple don't enforce patents. Also you could argue it already fell on our head in some areas due to innovation having slowed to a crawl, while certain competitions (mostly in Asia) are not affected as they ignore patents. I mean sharing and cloning software (between companies!) is what enabled us to have massive innovations (through some maybe stupid) in software space. Non of this would have been possible with enforced software patents.

Because software patents should not be legal, and are not enforceable in many sane jurisdictions, e.g: Europe.

I'd much rather stick with "archaic" but understandable licenses like BSD, over verbose licenses that intertwine US Patent Law with Copyright law, such as Apache 2 or GPLv3.

Apache 2 is a terrible license for another reason anyway: it requires modified versions to carry notice of the modification on every modified source file. This means that tons of people who fork Apache 2 projects on GitHub are in violation of the license without even being aware of it.

"or (at your option) any later version" is probably the most insidious line in any license anywhere ever - as arguably the GPLv3 is incompatible with the GPLv2 without that.

And we're seeing that the GPLv3 didn't "solve" the problems it was meant to solve and now we have multiplications of "open source" licenses designed to protect business models.

Are you referring to AGPL? Or RSAL/SSPL?

The second - in theory GPLv3 "solves" the Tivoization problem but the "cloud service" problem now exists - and honestly I think BOTH the GPLv3 and SSPL and such licenses are bandaids on an underlying problem - GPLv3 trying to solve a hardware licensing issue, and SSPL trying to solve a business model problem.

The other side-effect of all this license proliferation is that companies clearly "know" where they stand with them - and are scared to move to new ones, especially if they have "patent side effects" that the lawyers don't want to investigate or stick their neck out on.

Apple stopped with the GPLv2 and hasn't moved forward in anything GPLv3; sure you can argue they never contributed much but the license should be about source code freedom - and it has morphed to be so much more.

>but the license should be about source code freedom

This is not true, GPL is about "user freedom", repeat it 3 times, "USER" freedom. This is why it gates hate from some developers or entrepreneurs here, it removes the freedom of the developer to abuse the user or in recent cases companies to profit from community work and not give anything back or even harming the original project with FUD or unfair competition.

The developer is a user; in fact the whole point of the GPLv2 is that it should be the case that users CAN be developers. GPLv3 puts restrictions on what a USER can do with the software; it's analogous to the "software cannot be used for evil" or "this software cannot be used in tanks" clauses on other licenses.

And as Linus is arguing, it's perhaps a perfectly FINE license, but it is NOT the GPLv2 and it has different aims and desires: and he gives examples where if the kernel had the "and any other version" the GPLv3 could be used to do exactly what the GPLv2 is supposed to prevent - someone taking the code and modifying it and distributing it in a way so that he can't use the modifications.

>GPLv3 puts restrictions on what a USER can do with the software

No it doesn't. You can do whatever you want with GPLv3 software, provided you don't distribute it. It's disingenuous to use the word "developer" to equate "person who edits their own software" with "person who distributes software to others".

Or if you disagree, can you articulate exactly what USER freedom you think is being infringed?

"Your freedom to swing your fist ends at my face."

>GPLv3 puts restrictions on what a USER can do with the software

GPLv3 puts requirements on what a DEVELOPER can do with the code

> The developer is a user

then he should not put restrictions on other users then himself. The point is that all users should have the freedoms not only the developers, the only limitation is that you can't abuse users.

A good example would be a quote I heard in a play of Uncle Tom's cabin (this was a translated and adapted so it might not be present exactly like this in the book). So in the play a french and some americans debate slavery and the salve owner says something like "America is the land of the free because we are free to own slaves" , like that slaver some companies and developers want to be more free to abuse others (put DRM to lock people, create proprietary formats, spy on users, nag them etc).

IMO we all are free to chose the license for our work, and if anyone wants to make his work BSD or proprietary it is his rights, but they should not complain when someone chose GPL because he decided that he is concerned about user abuse.

Affero GPL is for cloud stuff.

> the license should be about source code freedom

no, it is about USER freedom.

You can USE gpl software for any purpose whatsoever.

Do anything you like with it. modify it, run it, it is yours.

It's just that when you redistribute it, you have to pass on that freedom.

I don't know why people in business freak out about this. They have money. Pay people to write software. If they want to redistribute software, just get MIT stuff, fork and close it, make modifications that restrict the use/redistribution, then sell it.

The GPLv3 worked exactly as intended. The GPLv3 was primarily meant to solve Tivoization, and GPLv3ed works cannot be legally Tivoized. Business models are outside the scope of Free Software.

> "or (at your option) any later version" is probably the most insidious line in any license anywhere ever - as arguably the GPLv3 is incompatible with the GPLv2 without that.

And it introduces a gigantic single point of failure with the FSF. If someone legally takes over the FSF, and publishes GPL 4 which is a BSD style license, then copyleft goes away for a lot of GPL software.

The FSF being taken over in that way is actually quite likely, given long enough time frames. It'll be interesting to see.

There is even a precedent of the FSF doing this, without a takeover. The FSF published a new version (1.3) of the GFDL license specifically to allow Wikipedia to relicense its text (that was licensed as "GFDL version X or above") to a CreativeCommons license.

https://en.wikipedia.org/wiki/GNU_FDL#Compatibility_with_Cre...

While this is a scary, yet also somewhat possible scenario out there, the GPL license text itself goes to great extents to explain (in classic RMS speech style) the ideals of Free Software and the whole point of the license. It also says, that the FSF may publish modified versions of the license in the future which are "similar in spirit" to this one and alludes to the fact that the author of the software may have given you the "any later choice".

To the slight dismay of some in my immediate family, I chose to study CS instead of law, so IANAL, but in the scenario you describe, I would try to argue into the direction that the hypothetical GPLv4 without copyleft clause is very much not "similar in spirit" to the intent outlined in the older versions in great detail, and hence should not apply.

The problem is you could have a huge legal battle over it.

I'm frankly surprised that ANY lawyers signed off on the GPLv2 (as in, picking it for a company sponsored project) as the "any later version" and "similar in spirit" are quite open to interpretation.

And all we'd need to see in GPLv5 or v6 is some line like "nothing in this license shall be taken as being incompatible with the BSD/CDDL" to open a huge can of worms.

Honestly, if you want to do "or later" I'd instead just assign your code to the FSF to do with it what they will.

> The problem is you could have a huge legal battle over it.

Of course, and it would be a real PITA, but I don't see how it would be that much different from a GPL violation law suit right now. If you publish your source code, even under GPLv3, there is nothing that really stops anybody else from taking it and violating the crap out of the terms and conditions.

In pretty much all jurisdictions I'm aware of, the copyright holders are the only ones who can sue for copyright infringement (setting aside the whole "is the GPL a contract?" debate for the moment[1][2], which would also open up suing for breach of contract in some juristicions).

You can slap any license constraints you like on your source code and publish it, but if you really don't have the resources to pursue legal action for violations to begin with, that already isn't worth anything and the software is effectively in the public domain.

[1] https://perens.com/2017/05/28/understanding-the-gpl-is-a-con...

[2] https://en.wikipedia.org/wiki/GNU_General_Public_License#Lic...

To be fair, that text does not actually appear in the license; it appears in the suggested instructions for using the license (which you are free to ignore when licensing your project). In practice, though, most projects tend to use those suggestions as-is.

This distinction is actually important, because the GPL forbids adding more conditions on top of the license while still being GPL-compatible.

The FSF does agree[0] with you that code licensed "GPLv2-only" cannot be included in a GPLv3 project.

[0] See table at http://gplv3.fsf.org/dd3-faq

Honestly, the only way the GPLv3 could have succeeded was if everyone had been forced to use it. In order to succeed, it would have to literally become law.

People are always free to reinvent the entire free software ecosystem. They are also free to choose different licenses. I knew it was over when LLVM compilers started replacing GCC in a lot of systems.

Top comment on YT:

> I love Linus so much. He has opinions and doesn't hold back with them.

Yep, this is the steve jobs era people that were straightforward. Linus can be a lot better with his initial reaction "It's horrible" but you can see through the outer shell that he is a really reasonable person and doesn't come across as this evil lord archetype people push on him. His knee-jerk reactions are so outlandish that after a while you just dismiss them as comedy.

Our society is eradicating people with strong opinions. It's is a huge loss.

I wouldn't characterize a tendency for hyperbolic excess to be a good thing even if it's just rhetorical. You can see in any thread mentioning his opinions that nobody really digs for the deeper meaning, they just take him at face value.

His comments on AVX-512 are a great example. He later toned them down after his ridiculous excess was challenged, just like you say. But nobody ever brings that up when the topic is discussed, just "HAY GUYS DID U KNOW LINUS SAID AVX-512 IS JUST BENCHMARKETEERING AND NEEDS TO DIE A PAINFUL DEATH!?!?". And now apparently it's such a worthless waste of silicon that AMD is implementing it on Zen4 too... cause Lisa Su loves spending a bunch of silicon on a "few meaningless benchmark wins" too apparently.

It's like the old adage, "a lie gets halfway around the world before the truth has got its pants on". Well, the ridiculous hyperbole gets halfway around the world before the correction gets its pants on too. Nobody ever hears his retractions, just the initial hyperbole. First impressions matter.

How different is this from people spouting off their political party lines without really understanding the platform? It's human nature. We should not be required to let morons doing moronic things dissuade us from our natural reactions and feelings.

I personally enjoy the way Linus tends to lead with his emotional reaction and then explain the layers behind it. I get the impression he often backtracks from his initial position because he's just giving the topic more thought, which is a mature response. The fact that he's a well-known figure doesn't excuse him from the privilege of being a human who learns.

> The fact that he's a well-known figure doesn't excuse him from the privilege of being a human who learns

being a well-known leader does convey a certain expectation of emotional maturity and moderation. Hyperbolic and mercurial individuals are generally considered to be a poor fit for leadership positions.

Yes, it may be human nature to react emotionally, but this is something most people grow out of at a fairly young age, and we certainly expect our leaders to be reasoned and measured about their reactions.

I guess I don't really disagree with you. Still, there's value in knowing how people really feel about a topic, and with Linus that's rarely in doubt.

"The FSF is full of crazy bigoted people" (Linus Torvalds 2014)

10 seconds later: "I overstated that a bit. The FSF has a lot of nice people in it, but some of them are a bit too extreme."

Thank goodness the FSF basically failed.

Linus - FSF is "filled with crazy bigoted people"

Then the guy keeps on going on how "we" can get Linus to stop. Who is this "We" attacking linus?

My favorite quote from Linus in this talk:

"When somebody else wrote the code, you don't get that choice, right?"

this isn't really news -- it's a historical commentary now, his aversion/issues with GPL evolution are well documented from multiple articles/appearances. The whole discussion in here is all in past tense.

Reply on news.ycombinator.com