Hi Paolo,

Sorry for the very belated reply...

I think the problem with this is idea that you end up with a lot of legalese 
and easy-to-accidentally-violate conditions, but don't actually provide any 
stronger protection than the X11 license.  Take Objective-C as an example:

I can take an Objective-C framework and, by means of categories and runtime 
introspection, replace any individual method in any class.  I can add or rename 
an instance variable in the original framework, breaking ABI compatibility with 
the original version, and release this.  I can then use categories and 
introspection to modify the classes in any arbitrary way, then I can distribute 
my code with an evil license, and the old framework under the LGPL.

Because I've broken the ABI, you can't just drop in another version of the 
LGPL'd framework, you have to back-port my changes.  Doing this, you still 
don't get to use any of my new methods in your own code.  The only thing you 
get from the LGPL is that I have to make available the source code for the 
LGPL'd code, but if this is already available upstream then that's not helpful. 
 

If the code had been X11 or BSD licensed, I'd have been able to do exactly the 
same thing, had less legalese to read.  GPLv3 + your exemption would not make 
me release any code that the MIT license would allow me to keep private, but 
would give me a massive blob of legalese that I'd need to read very carefully 
to make sure I wasn't infringing.  

The GPL, as a whole, is very easy to violate with impunity for a large 
corporation that wants to put a bit of effort into.  Here's the easiest 
strategy for doing so:

Company A spins out company B.
Company A ships product A, which uses a third-party GPL'd product and provides 
new interfaces.
Company B ships a proprietary product that uses these new interfaces.
Company A is complying with the GPL with respect to the upstream product.
Company B is violating the GPL, but only with respect to Company B's product.  
Their product is not a derived work of the original, and is not shipped with 
the original, so only Company A has standing to sue.
Company A decides not to sue, because they've signed a covenant not to do so 
when Company B was founded.
Company B continues to ship code that violates the GPL with impunity.  

Now, maybe GPLv4 will prevent this, but GPLv3 is already a barely 
comprehensible mess that requires lawyers to interpret it.  I did an internship 
with an IP law department before I went to university, and I find the GPL 
difficult to understand - I can't imagine how people without even my experience 
or any formal legal training manage it.  

While I agree with the FSF's objectives, I think the best strategy is to try to 
make writing Free Software easier, not to try to make writing proprietary 
software harder.  This means licenses that mere mortals can easily understand, 
not longwinded things that a competent lawyer for a large corporation can find 
loopholes in but an individual programmer may accidentally violate (I violated 
the GPL by mistake - I gave Quentin a copy of a custom build of Colloquy that 
didn't crash so much without giving him an offer in writing for the source 
code.  It was a build of an unmodified version of the upstream source, but it 
was still a technical violation.)

There is one thing that is much more important to promoting Free Software than 
legal issues, and that is making people actually care about the FSF's Four 
Freedoms.  Ask a typical person if those freedoms are important to them, and 
most of the time the only one they will care about is Freedom 0.  Now ask them 
this:

> When was the last time you used a piece of software that, out of the box, did 
> exactly what you wanted it to do?


Most of them won't be able to answer.  Software not working correctly is normal 
and expected.  The value of Free Software is that you can fix it, if you have 
the skill to do so.  The conditional clause here is the problem, but it's one 
that we're working on with Étoilé.  Modifying a program with LanguageKit / 
Pragmatic Smalltalk takes less skill than writing it in Objective-C.  

With Pragmatic Smalltalk, you can write categories on Objective-C classes in 
Smalltalk, or modify them in EScript, and have these modifications loaded 
automatically when the program starts.  

For us, access to the source code is actually not a precondition for Freedoms 1 
and 3.  We can introspect binary-only programs and replace methods using a 
high-level language.  With even better languages and tools, anyone will be able 
to modify any program to work as they want.  

The authors of the GPL seem to have forgotten that the objective is to promote 
the Four Freedoms, rather than to promote the GPL.  

On a completely unrelated note, have you adopted my SmallInt arithmetic 
algorithms in GNU Smalltalk?  Someone mentioned to me a while ago that your 
version was slower, although I haven't checked your code to see i they were 
correct.  And is there any progress on an ARM port of Lightning - I'd love to 
be able to use it for accelerating bits of GNUstep.

David

On 10 Mar 2010, at 11:41, Paolo Bonzini wrote:

> Hi all,
> 
> I am the maintainer of GNU Smalltalk.  A fellow GNU guy pointed me to 
> your web page at http://etoileos.com/dev/licensing/
> 
> I've started a discussion on $SUBJECT at 
> http://smalltalk.gnu.org/blog/bonzinip/towards-permissive-copyleft-license-dynamic-languages
>  
> -- Etoile developers are welcome to join.
> 
> Thanks,
> 
> Paolo
> 
> _______________________________________________
> Etoile-dev mailing list
> Etoile-dev@gna.org
> https://mail.gna.org/listinfo/etoile-dev


-- Sent from my STANTEC-ZEBRA


_______________________________________________
Etoile-dev mailing list
Etoile-dev@gna.org
https://mail.gna.org/listinfo/etoile-dev

Reply via email to