What is Copyleft?

[Rod Dixon, J.D., LL.M.]

> > > How can that create a derivative work?
> >
> > Well, the question is why wouldn't it?
>
> Because you're not modifying the original work.  You're not adding
anything
> to it.  The two parts (the Program and the Library) aren't ever combined
> into one work.  If you would argue that they are combined because they're
> both loaded into memory together, than you'd have to say that >everything<
> in the computer's memory formed a derivative work, so you could >never<
use
> a GPL'd program unless every byte of information in the computer's memory
> was also GPL'd.

If by "adding anything" you mean an adaptation of the pre-exsisting work
sufficient to make an original work, then, yes, I agree with you. If you are
referring to the fact that the work vanishes in seconds, then I disagree. I
was not sure which point you were really making, and the two are quite
distinct.


> > Try a better hypo or simply state what you are driving at.
>
> My above example is flawed.  It should have read "a database management
> program".
>
> I'm suggesting that the definition of a derivative work can't include data
> being passed between two independent pieces of code, via file, via a
> network, or via an internal process communication.  Making a function call
> is not the same thing as actually incorporating the code of that function
> into the body of the calling code.
>
> When you make a function call in compile-time linked code, you are
creating
> a derivative work, because the function code itself will be compiled into
> the Program and inextricably combined with your code.  When the two are
> separated by a run-time linking, there can be no derivative work.

> Imagine this example:
>
> I write a program which runs interactively.  It takes an input of the name
> of a DLL.
> The program loads the DLL, which will cause some of the code in that DLL
to
> excecute automatically when the library is loaded, even if the calling
> program does nothing.
>
> If the hypothosis that run-time linking created derivative works is true,
> the above program could never be covered by the GPL, because the person
who
> distributed it would not be able to provide permission to create the
> derivative work of the Program + DLL when run.
Interesting point. In the ordinary course of programming, I suspect there
would be no derivative work created, hence the GPL should provide no
obstacle for distributing the program as open source. As you mentioned,
there could be a counter-example such as the development of a text editor
for Windows that not only makes calls to print drivers that MS has thrown in
its OS, but also to DLLs written by printer manufacturers. Add to that fact
that the windows text editor reads into those drivers additional True Type
fonts (independently copyrightable) and you my have a genuine derivative
work question. Under copyright law, the adaptation of the print drivers may
be considered fair use.  (particularly those deemed part of the
OS...although I could think of a hypo that could produce instant lititgation
on both sides involving the copyright holders of the drivers developed by
the printer manufacturers). The GNU GPL, however, would seem to permit an
open source windows text editor to exist in this manner as well. You might
say that the derivative work is evanescent, and under such cases the GNU GPL
is silent. Indeed, as I stated before, I do not think the GPL should
preclude participation of the Program as an open source project under such
cases. Why should the GPL control the copyright interests in all of the
libraries that are used by open source software? I have not read RMS as
saying this, but perhaps he has done so. No question there is some risk or
tension in reliance on closed DLLs, but those issues should probably be
addressed as they arise (e.g., the use of the GNU LGPL).


>
> This is not such a far-fetched example.  This is how printer and video
> drivers work in Windows, for example; and many are not distributed with
the
> OS.  It would be impossible to write a GPL'd program that used the
standard
> device-driver model for printing using Windows if this run-time linking
> hypothesis were valid.
You are correct, but this point is not unique to the GPL. If common dynamic
liking to OS drivers created derivative works (which is not to say that this
can never be so...just that it is not the usual case), Microsoft may have
controlled the market for third party applications running on its OS to a
far greater extent than commonly understood.

Rod