Re: Dynamic loading

["Stephen J. Turnbull" <stephen@xemacs.org>]

Stefan Monnier writes:

 > > module.  APIs apparently don't count because they're not "expressive",
 > > there's only one way to do it.)
 > 
 > IIUC the case for GMP was based on the fact that a user of the GMP API
 > wasn't just using the API but was necessarily using GMP (even if loaded
 > dynamically) because there was no other implementation (which forced
 > the offending company to write a substitute for GMP which implemented
 > the same API but with a more liberal license).

Sure, but if no GMP code is actually copied *by the distributor* then
it's very hard to argue that the distributor has violated the GPL (this
is something Richard referred to earlier).  That was the contention of
Aladdin in the Ghostscript + GNU readline case, but it didn't go to
court because it didn't matter to Aladdin's business plan, it only
hurt non-paying users.  So they weren't willing to spend USD 0.01, and
the FSF won by having more lawyers, not on the strength of the case.

Did a case for GMP actually go to court, or was it simply that it
seemed cheaper (in community reputation as well as legal fees) to cave
in and write a workalike?

That also happened with readline, of course.  The BSD community has
a similar library under BSD license (called libedit, I believe).

 > So similarly, an Elisp package can currently only be run by linking it
 > with GPL'd code (given the lack of non-GPL'd Emacs), which (I thought)
 > is the reason why it has to be GPL'd as well.

Well, there's also stuff like macros to worry about.

However, I think the distributor of the Lisp package could probably
argue that an Elisp package is data being processed, not part of
Emacs.  Since running Emacs is 100% unrestricted, IMO IANAL a claim
that an Elisp package must be distributed under GPL would be hard to
prove under copyright law.  For example, note that the special
exemption to the GPL for bison only applied to programs using the
"hairy" skeleton, because that was the code being copied.  Even though
yacc was available, copying the skeleton meant it was a derivative
work.  (Not directly relevant, since with elisp we have no copying --
assuming that no compiled code based on GPLed macros is distributed,
but it illustrates the way to think about these problems.)