Re: Using a script licensed under GPL in an application licensed under a license that's not compatible with GPL

[Stefaan A Eeckels]

On Fri, 15 Dec 2006 22:29:36 -0500
Barry Margolin <barmar@alum.mit.edu> wrote:

> When he originally wrote "scripts", I was archaically thinking just
> of shell scripts.  Programming in Perl, Python, and Ruby is much more
> like C programming, and the things you do by linking with libraries
> in C are done with "use", "require", and "import" in these
> languages.  These are comparable to dynamic linking in compiled
> languages, so it would make sense to treat them equivalently for
> purposes of license application.

Do you really think that the way in which source code is transformed
into something that the machine can execute is relevant for its
copyright status?

After all, there are 'C' interpreters, and Perl claims to have a
compiler. 

When the FSF says that dynamic linking makes the executable a
derivative work of the libraries it dynamically links to, they do not
imply that the source code of the program is a derivative work of the
library. 

In the case of an interpreted language, there is no identifiable
intermediate step between the source code and the executable (even
though none of the common "script" languages interpret the actual
source code). 

Thus, equating the use of "require" or "import" with the dynamic
linking for copyright purposes would mean that the source code itself
becomes a derivative work. 

But languages need not be compiled or interpreted - it's merely the
choice of the implementer. 

I believe that whatever a programmer writes only becomes a derivative
work if it is a modification of existing source code, or contains
substantial amounts of existing source code. How the source code is
transformed into executable code is irrelevant. After all, there is no
semantic difference between:

#include <gpled_lib.h> (C)

and

require gpled_lib (Ruby)

even though the mechanisms to enable the executing programs to use the
facilities of the "code-libraries" are quite different. If the
"executable" Ruby program is a derivative work of the library (as you
seem to argue here), is the 'C' source a derivative work when executed
with an interpreter, but not when compiled?

Of course, if the _source_ code is a derivative work of libraries that
are merely referenced through an "#include" or "require", and some
function or method names, it would mean that almost no source code is
an original work, and it would become possible to crush fledgling
competitors by the simple threat of a lawsuit (of course we now have
software patents for that purpose :).

<aside>
I know that in all human creative efforts, there is not much truly
original work, and source code would be useless without compilers,
interpreters, microcode, processors etc. But mutatis mutandis, this
applies to novels and poetry and music as well. In the latter case
there seems to be no argument that many people can write about wizards
and dragons without their work necessarily being a derivative of LOTR,
for example. 
</aside>

-- 
Stefaan A Eeckels
-- 
"A ship in the harbor is safe. But that's not what ships are built for."
                                -- Rear Admiral Dr. Grace Murray Hopper.