For instance, company I work in develops software for a customer that later sells it to various corporations, big and small. Were I to include an GPL dependency in the code, and were it to pass unnoticed by my boss and our customer, it could quickly turn out into a legal clusterfuck with damages orders of magnitude larger than my salary. So we do have a list of open source licenses that are allowed for dependencies of projects for our customer, and GPL/AGPL are prominently not on that list.
Now if there was some critical piece of code we absolutely need and there's no non-GPL alternative, I could ask my boss to talk to his boss to talk to the lawyers to figure something out. But in 99% of cases, you'll be asked to "Google harder", and then you'll find something with a "better" OS license - so it's easiest for the management to ban GPL by default (or, in our case, create a whitelist of allowed licenses).
(I desperately tried to get WTFPL on the whitelist list, but failed :(.)
It sound to me that the only code allowed in the product is code you have written yourself, code you have hired someone to make so its yours, code you bought so its yours, or code which license make it indistinguishable from code you own.
It's a common occurrence in my experience in companies over 1k or so employees. Under 1k, getting hit with the GPL would probably just be a death knell.
Even if it was AGPL... and even if the customer modified the library, and even if they did get sued.... all three of which are vanishingly small probabilities... still all you'd have to do is release your modifications to the AGPL library. The notion that the AGPL will force you to open source your proprietary code is, as far as I can tell, completely spurious.
I really think that it's just a cultural "screw the hippies" kind of a thing, which you're buying into by making these sound like rational fears. There's nothing rational about it, it's just "oh my, we'd need just thousands of lawyers for that!" bogeymen.
Lots of permissively licensed software exists that is mainly corporate contributed code, or which is produced by projects which are primarily corporate funded (by corporations which use the code.)
You can't get free maintenance on your code by using permissively licensed open source if what you use diverges to far from what your free labor force has, after all.
Why is this weird? As the author of the software, surely I get to decide how I prefer to be compensated?
If I'd like patches and user freedom, then your only decision is whether the software is worth that for you. Not whether my license is "weird" or "not open source".
This way people still add features and upstream bugfixes, but a) it doesn't get forked to hell like the 200 Linux kernels that each Android manufacturer has to publish and b) you get much wider adoption faster, with more people being paid to fix bugs and add features to your code because it is being used alongside proprietary code.
Sure, it doesn't give you a nice stick-it-to-the-corporations dose of righteous satisfaction, but it feels to me far more pragmatic, and healthy for the project in the long run.
Is there a freeloader problem? How do we know if people just aren't that interested in the software?
If one puts something out there for "free" then one is not entitled to a return. It's the model which is broken, not the users!
Regarding your "peek and return" scenario, GPL actually lets you do that, and I wouldn't consider you an actual "user".
For example: the FSF's stance on certain provisions of the GPL, like the ones on linking, is as far as I know completely untested in court and at odds with what appear to be both established legal and common-sense/intuitive notions of what constitutes a derivative work. And I'm not speaking from inexperience there: the Django project had to go many rounds on this because the maintained MySQL driver modules for Python are all GPL. Does this end up GPL'ing Django since it supports MySQL as an option and, thanks to the nature of Python's import system, will share address space with a GPL'd module if you use MySQL as your database? Or does the fact that it's an end-user choice and Django is simply shipping code to normalize API access to any of multiple drivers on multiple DB engines (leaning heavily on PEP 249, which itself is a normalized API for Python DB drivers to expose) avoid that? Nobody seems to be able to give a clear answer, because there is no clear answer, legally, on when the GPL's derivative-works clause is invoked or even if the GPL's derivative-works clause is legally sensible.
In contrast to uncertainty, I think we can be quite certain that django works without mysql (I personally run several sites with postgresql). Modules for django would likely not work without django, so they are likely derivative of django and not the other way around. I also vaguely recall fsf stating that they don't consider the linking guidelines to be that relevant for software written in languages without linking, which would include python programs.
Is your problem with the license that FSF as an organization has an opinion on how derivate works can be identified for software?
My problem is that the FSF's opinion on what constitutes a derivative work is horribly broad, and has never to my knowledge been tested in court. So despite all the reasonable intuitive opinions in the world, who knows?
GPLv2 says very little directly about patents, only touching on the topic by saying that they're not an excuse for not complying. That implies some things for patent holders on relevant topics but isn't explicit about it.
GPLv3 basically makes those implications explicit, stating clearly that if you hold or license any relevant patents you must be able to freely license them downstream.
To me that stuff is implied with copyleft, because how else could it work? Since patents restrict my ability to legally redistribute the code, and the whole point of copyleft is to ensure my ability to legally redistribute the code, I don't see how they're separable as long as software patents remain being a thing.
I'm specifically thinking about sub-pixel font rendering, for which FreeType contains code which is disabled by default due to patents:
https://en.wikipedia.org/wiki/Subpixel_rendering#Patents
That would imply that it's the latter. Which, of course, is still an issue for the user. But it does point to the GPL not requiring the patent clause in order to meet its copyleft goals.
FreeType wasn't created by Microsoft, obviously. It has no license for M's patented tech so it can't include the code live, period. I presume that FreeType is trying to skirt the law by making it easy for users to break the law without, they hope, being seen as breaking the law themselves. I don't know what the court would decide if Microsoft sued. Presumably FreeType would say that the code was there just to help future programmers catch up when the patent expires. I'm guessing they wouldn't win that one.
So, I'm going to say it's not a sufficient example.
So you might ask, why does Google use the Linux kernel? Perhaps because they don't have to modify the kernel to accommodate inventions they wish to preserve, for public software such as Android; but more importantly the kernel is useless by itself and the license doesn't extend to libraries (Google spent billions recreating the GNU libraries to be sure of that), so the license for the kernel has no practical importance. The rights granted are "stranded", as it were. Clever on the part of Google. But in most cases, the GPL or MPL can't be gotten around in that manner.
The googleable rubric for GPL2 is "GPL's Implied Patent Grant." In sum, the GPL seizes all relevant patent rights from any contributor (regardless of whether those contributions related to their patents, IIRC) and any distributor. In some cases that doesn't matter - in other cases, it does. If you want to retain control of who gets to use your patents, and patented tech, that's a big problem. If your invention is a hardware invention, the GPL still scoops it up - their language doesn't exclude rights to hardware inventions - so you may actually have the right to build any such patented hardware as long as you put Linux in it: if the patent owner touched Linux. It would take a court case to be certain this wasn't a risk.
This also seems to mean (even for GPL2) that if you explicitly license one entity to use GPLed software with your patented tech (hardware or software), then you've just given a free license to every soul on earth to do the same, with no royalties. In some cases, that might not matter. In many other cases, it does.
"In contrast, a GPLv2 licensee, under the doctrine of implied patent license, is free to practice any patent claims held by the licensor that cover “reasonably contemplated uses” of the GPL’d code, which may very well include creation and distribution of modified works since the GPL’s terms, under which the patented code is distributed, expressly permits such activity.
Further supporting this result is the Federal Circuit’s pronouncement that the recipient of a patented article has, not only an implied license to make, use, and sell the article, but also an implied patent license to repair the article to enable it to function properly, Bottom Line Mgmt., Inc. v. Pan Man, Inc., 228 F.3d 1352 (Fed. Cir. 2000). Additionally, the Federal Circuit extended that rule to include any future recipients of the patented article, not just the direct recipient from the distributor. This theory comports well with the idea of Free Software, whereby software is distributed among many entities within the community for the purpose of constant evolution and improvement. In this way, the law of implied patent license used by the GPLv2 ensures that the community mutually benefits from the licensing of patents to any single community member."
The "copy" in Copyleft gives you your answer - it ought to be about sharing copyrights to code, not patents. You don't have to grab patents (which expire in twenty years.) Copypatentleft is what we really have, instead, with GPL, and that's a whole different beast.
So, it is of course logically possible to confer the copyright to code that exploits a patented idea without conferring the patent rights at the same time. That would mean that not everyone could use some shared code, without a license, even though they have a copyright license and can share and examine it. The patent holder would retain their patent rights. Why respect patent rights? Because the majority of value in American businesses is IP - trade secrets and patents being the bulk of that. GPL is therefore a non-starter in the corporate world, more often that not. You don't have to share patents. If you insist, then your code gets duplicated under another "more permissive" open software license at enormous expense, that's all.
If you want my work on your community code, great! If you want my ideas - my patented ideas, um, no.
It would be more convincing if you gave a clear example. (that wasn't functionally an attempted end-run around software freedom.)