GNU License warning:

[Ignacious via Digitalmars-d]

https://www.gnu.org/licenses/gpl-3.0.en.html
https://www.gnu.org/licenses/gpl-faq.html


http://z505.com/cgi-bin/qkcont/qkcont.cgi?p=Please%20Stop%20Using%20GNU%20Licenses
http://gng.z505.com/cult.htm


And, I should point out:


"If I write a plug-in to use with a GPL-covered program, what 
requirements does that impose on the licenses I can use for 
distributing my plug-in? (#GPLAndPlugins)

     It depends on how the program invokes its plug-ins. If the 
program uses fork and exec to invoke plug-ins, then the plug-ins 
are separate programs, so the license for the main program makes 
no requirements for them.

     If the program dynamically links plug-ins, and they make 
function calls to each other and share data structures, we 
believe they form a single program, which must be treated as an 
extension of both the main program and the plug-ins. This means 
you must license the plug-in under the GPL or a GPL-compatible 
free software license and distribute it with source code in a 
GPL-compliant way.

     If the program dynamically links plug-ins, but the 
communication between them is limited to invoking the ‘main’ 
function of the plug-in with some options and waiting for it to 
return, that is a borderline case.
Can I apply the GPL when writing a plug-in for a non-free 
program? (#GPLPluginsInNF)

     If the program uses fork and exec to invoke plug-ins, then 
the plug-ins are separate programs, so the license for the main 
program makes no requirements for them. So you can use the GPL 
for a plug-in, and there are no special requirements.

     If the program dynamically links plug-ins, and they make 
function calls to each other and share data structures, we 
believe they form a single program, which must be treated as an 
extension of both the main program and the plug-ins. This means 
that combination of the GPL-covered plug-in with the non-free 
main program would violate the GPL. However, you can resolve that 
legal problem by adding an exception to your plug-in's license, 
giving permission to link it with the non-free main program.

     See also the question I am writing free software that uses a 
non-free library.
Can I release a non-free program that's designed to load a 
GPL-covered plug-in? (#NFUseGPLPlugins)

     It depends on how the program invokes its plug-ins. For 
instance, if the program uses only simple fork and exec to invoke 
and communicate with plug-ins, then the plug-ins are separate 
programs, so the license of the plug-in makes no requirements 
about the main program.

     If the program dynamically links plug-ins, and they make 
function calls to each other and share data structures, we 
believe they form a single program, which must be treated as an 
extension of both the main program and the plug-ins. In order to 
use the GPL-covered plug-ins, the main program must be released 
under the GPL or a GPL-compatible free software license, and that 
the terms of the GPL must be followed when the main program is 
distributed for use with these plug-ins.

     If the program dynamically links plug-ins, but the 
communication between them is limited to invoking the ‘main’ 
function of the plug-in with some options and waiting for it to 
return, that is a borderline case.

     Using shared memory to communicate with complex data 
structures is pretty much equivalent to dynamic linking.

     See also the question I am writing free software that uses a 
non-free library."

Essentially they draw an imaginary line between using "fork and 
exec" vs linking.


"If the program dynamically links plug-ins, and they make 
function calls to each other and share data structures, we 
believe they form a single program, which must be treated as an 
extension of both the main program and the plug-ins"

And so we are in the realm of belief.

As we all know here that every computer program ran on a computer 
is connected by nested "data structures"... so fork and exec are 
just dereferencing linking
by an extra step.

What happens, when in the future, OS's use some other mechanism 
for execution? Is there really any difference between 
exec("app.exe") and LoadLibrary("app.dll")? (I don't mean an 
imginary difference created in the mind by obfuscated data 
structures. I'm talking about a fundamental difference(besides 
performance))


There is a lot of arbitrary language in the GNU license and the 
fact that it was created by lawyers for lawyers(see 
http://gng.z505.com/cult.htm. I realize the link looks a bit 
crackpotish but it has a lot of relevant points and if the 
numbers are right, shows more than enough proof).


As usual, it comes down to who has the biggest bank roll and 
smartest lawyers to obfuscate the issues. The push for free 
software is becoming a nonsensical pursuit like most other human 
behaviors.

I think a license should exist that EXPLICITLY states what one 
can do with the source code and binary and what they are.