|Perl: the Markov chain saw|
OT: A Modest Proposal for a GNU infrastructure license RGPLby mdupont (Scribe)
|on Jun 20, 2002 at 11:05 UTC||Need Help??|
This is a bit off topic for perl, but since I have written the software in perl that I want to license under this.
This does affect perl and relates to the B::* modules
Also the perl core is GPled and is a target for this module.
You might find it an interesting proposal. I have a modest proposition :
To create a license for software that only takes GPLed sourcecode as input and produces GPLed code as output.
Basically, it is to create a licensed persistent memory model where all data and functions in whatever form are treated as if they are in the main memory of a statically linked executable, even if all types of neat tricks are used.
More to the point, that the inputs and outputs must be already be source code (in what ever form) and that must already be under the GPL (in whatever form). If documentation is produced, then it would be under the GPL documentation license.
It is a bit like a recusive function f(n>1) that does not solve the base case, and leave the n=1 and n=0 to a specific other function.
The GPL is used by many projects to maintain thier freedom.
The LGPL is a license that allows for the production of non-free software. This could be seen as a right-wing GPL, a RGPL that is a restrictive GPL. One that only allows for the production of more free software.
Because the GPL is so sucessful, there are many applications that use it. It is now possible to work only with free software.
I would like to give those who use free software an advantage over those who don't.
By making services and software that are only legally usable by those using free software.
This special type of license will only applies to software that works on other software, thus meta-software.
The inputs and outputs of this meta software of any form would be limited to free software only.
This of course does not affect the input and output of the free software once it is compiled, so the used software is not changed. Only the usage of the GNU Infrastructure License would be affected.
The GPL is carefully designed to allow users to do anything with the input and output of the files not to affected by the license.
Some authors decide to publish a version under GPL for non-profit usage. I want to go a step further.
My question is if I can publish a software that is for GNU usage only? That is only licensed for usage in conjunction with free software, down to the user.
This would then be usable to create an entire range of services for promoting the usage of the GPL and giving them and advantage and a incentive over non-free software.
This would overcome the issues non-free software using XML, File Systems, XML-RPC, SOAP, Dynamic Linking, and Web Services for interfacing with GNU software and going around the GPL.
This would give an explicit license to a limited set of powerful interfaces that are for use for only free software. This would give people who want to experiment with interfacing to the GCC via dynamic linkage a legal basic protection.
Now the protection of the data files are very tricky, because the data file are sourcecode.
The best would be to treat all data files as if they are persistent inside the memory of the GPLed program and that any usage of them is a derived work.
If a data file is produced derived from source code, this data file would also be under a special form of the GPL that prevents it from being used by any non GNU infrastructure licensed tool.
Of course you wont have the freedom to take away this protection offered.
This would allow the safe storage of internal data structures without their usage in non-free software.
No non-gpled program would not be allowed to use any of the internal data structures of this program. Not to read or write them or process them electronically. If it is offered as a web service, only users from free software projects would be allowed to use the software in conjunction with free software.
I have put together a summary of the licensing points for your review.
This license will help create a massive online database of program meta data and hope to protect it in any way at all.
Remember this only applies to a very small set of tools that process programming languages and covers the in-memory representations of the programming languages in a form that is very close to being executable, but still readable and editable. An enriched source code. All this does is try an protect the services rendered by the various compiler and interpreters so that they may be "PATCHED" to dump thier data into this meta-data repository without fear.
This will apply to programs like GCC,PERL, BASH, MAKE, YACC, LEX and any program that can parse language trees.
An entire new generation of visualization and editing tools can be created on this foundation.
The RGPL idea has crystallized into a very restrictive and recursive idea indeed.
It might have to be renamed into RPL (Restrictive/Recursive/Right-Wing Public License) if the GNU group rejects it, but for now, I will use the RGPL, because it is the opposite of the LGPL.
Get it Left-Wing, Liberal, Lesser / Right-Wing, Restrictive, Recursive ?
Also the adding of a level notation is needed RGPL(N) for specifying the recursion factor.
I think the issue is now of a special end user license that is completely outside of the GPL.
The restrictions imposed are simple : 1. You do not have the right to remove the restrictions.
2. You do not have the right to use the software in a way that is not explicitly given.
3. All output of the program is at a one higher level of the recursion, all input at the same or one level below.
4. You cannot use input from any other source but from what is specified.
All RGPL(N) input and output is source code mixed with mark-up in a declarative language.
Here is an overview of the license and linkage : 1. LGPL software can be linked to by other programs GPL and non GPL programs.
2. GPL software can only be used by users and linked to by other GPL programs, it can link to LGPL programs, but cannot link to RGPL programs, otherwise the RGPL program might be considered a derived work and fall under the GPL.
3. The GPL program can only use the output of the RGPL, the RGPL can only use the output of the PATCH to the GPL program.
4. This GPL PATCH is will be a intellectual property of a holding company and will not be distributed outside of it. Only the usage of it via a registered user via a web service with a restrictive EULA and Terms of Usage will give access to the ability to invoke the PATCH.
Under the GPL v2 there is no need to distribute the source code of this patch, and that will prevent third parties from abusing the PATCHED program, because non-one will ever get the source code. Anyone who does will have to either sign a NDA with the company or join the holding company.
Here are three examples : A. GPL software + PATCH = RGPL(1) output The RGPL(1) output can only be used by RGPL(1) and GPL programs.
B. RPL(1) + PATCH = RGPL(2) output The RGPL(2) output can only be used by RGPL(1) and RGPL(2) programs.
C. RPL(n) + PATCH = RGPL(n+1) output The RGPL(n+1) output can only be used by RGPL(n) and RGPL(n+1) programs.
The point is that the license gets recursively more and more restrictive.
Creating layers and layers of programs and licensing. All data and output is licensed only for usage by the programs at the same layer or higher.
There is no linking between the programs, only an File and network connection that have no copyright. The data will be only accessible via a site the imposes restrictions on copying, linking, quoting and usage of the copyrighted materials.
All of this to protect the GPLed programs from having such "patches" widely available and the programs that use them under the GPL.
If you look at putting the RGPL under the GPL, you will see that a profilation of such patches would just cause licensing chaos and just invite abuse by non-free software vendors.
This license being restrictive, does not mean it is not free. It gives you less freedom, but opens up a area of freedom that is not covered by the GPL, the freedom to exchange data safely between GPLed programs.
A function call might go between GPL --> RGPL (1) ->RGPL (2) ->RGPL (3) RET -> RGPL (2) RET -> RGPL (1) RET->GPL.
That will allow for GPLed programs to communicate over the RGPL safely without any non-free software to get between (other than the RGPL if you don't consider it free.)