Subject: Re: GPL & interfaces
From: Stephen Turnbull <>
Date: Mon, 18 Oct 1999 02:52:59 +0900 (JST)

Although I agree with Peter that we really need a lawyer to speak up,
I would like to add another question:  "what is a work?"

Here's what I think it is:

>>>>> "craig" == craig  <> writes:

    craig> Yet that's clearly allowed, since that's the whole point of
    craig> GPL'ing the source and distributing it, so people can write
    craig> code to interface to it.

    >> Correction: so that people can write **GPL'ed** code that
    >> interfaces to it.

    craig> But not a correction to how *I* view the situation!

    craig> In my view, distributing the routine as source code, with
    craig> headers, as a distinct work, *implicitly* grants the right
    craig> to "copy" names and such out of it, in order to invoke it,
    craig> along basically the same principle that putting
    craig> "foobaz-1.0.tar.gz" up for public FTP *implicitly* grants
    craig> the right to "copy" the name "foobaz" into:

You're misinterpreting the whole concept of a "work".  The point of
applying the GNU GPL to "works" rather than some other unit is that
the fact that your code invokes a procedure "foobaz" from "bar.o"
derived from a GPLed program shows your intent to integrate your code
with the GPLed code, and thus requires you to put your code under GPL
in that application, because it is a single work derived from (ie,
incorporating) GPLed code.

"Distributing the routine ... as a distinct work" is simply not
envisioned in the GPL; the work is not distinct, rather its GPLness
will be transferred to any routine it is combined with; from the point
of the GPL the derivative work is a seamless whole.  It's like a
yogurt starter: the yeast (bacteria?) in the teaspoon of yogurt enters
and curdles the whole gallon of milk, which becomes a single work of

    craig> That latter item is most pertinent: it does not matter one
    craig> whit whether foobaz is GPL'ed vis-a-vis whether your shell
    craig> *script* needs to be GPL'ed to be distributed.

That depends on what the script does.  If, for example, its sole
function is to munge the Makefile of Glorp in order to add foobaz
capabilities, I suspect the script must be GPL'ed, because it is part
of a single work.  That is, it is part of the build process for the
single work, although it will not be present in the executable object.

BTW, its mere existence is strong evidence that Glorp is intended to
be combined with foobaz.  Even if the script itself needn't be GPL'd,
it's existence implies that Glorp must be GPL'd according to my
interpretation of "work."

    craig> (Has your use of the phrase "readline" in your email forced
    craig> it to be under the GPL?  I find that hard to believe, yet
    craig> that would be the logical result if what you say about what
    craig> the FSF says were true:

Not at all.  It is quite obvious that our posts are not works based on 
GNU readline; in fact, they are not programs at all.  The word
"readline" is not being used to invoke any functionality, it is

    craig> Still, I think that a library published *as* a "work" is
    craig> therefore one that implicitly grants copying privileges
    craig> vis-a-vis its interface

Once again, you misunderstand the concept of "work"; "derivative work"
is intended to be as inclusive as RMS thought he could get away with.
As I understand it, "derivative work" as used in the GPL is not
defined by copyright law, but rather by the GPL itself; RMS's
intentions are highly relevant here as they will help determine the
interpretation of the GPL, in particular that term, in court.

Literally, your statement is probably true; I suspect that Peter has
misinterpreted RMS's words vis-a-vis copyrighting the interface qua
interface.  In particular, I suspect that RMS is confining his answers
to the narrow situation that Peter has proposed (GNU readline), and is
not considering a hypothetical alternative non-GPL implementation of
the library providing the interface.  (If he is denying the right to
use the interface in that case, then as has already been pointed out
the whole GNU Project is in deep trouble, because there's no such
thing as an "open interface.")

But if that interface is used to invoke GPLed functions, your work is
clearly derived because it incorporates those functions, and you must
GPL it to distribute it.  If a public domain implementation using the
same interface were available, you could invoke that using the interface
without being forced to GPL your program AFAIK, but I would appreciate
a real lawyer's opinion.

    craig> Your rights are what *copyright law* grants you *plus*
    craig> whatever it says you've been automatically granted by
    craig> virtue of someone distributing a "work" (such as readline)

No.  All rights not explicitly granted are implicitly reserved AFAIK.
Anyway the GPL explicitly reserves all rights not explicitly granted;
see clauses 4 and 5.  True, publishing a work means others are allowed
to "read" it.  But under what conditions?  As Peter points out, a
license is a private contract, whose terms are in principle subject
entirely to negotiation between the parties.  (The law does provide
some exceptions (such as non-disclaimable implicit warranties and
"fair use" specifically for copyright) but these are carefully

In particular, the contract defines the parties who are allowed to
"read" that work.  In the LGPL, any party (ie, other code), may "read"
the work, but the GPL explicitly restricts readers to be other GPL
code.  The human owner of a particular copy of the code may of course
invoke it directly if she is equipped with "bus-master" hardware, but
few of us are.  If she does it through new code, this involves
"copying the original work into a derivative work," and the GPL must
be applied to the _entire_ derivative work as a precondition for

University of Tsukuba                Tennodai 1-1-1 Tsukuba 305-8573 JAPAN
Institute of Policy and Planning Sciences       Tel/fax: +81 (298) 53-5091
What are those two straight lines for?  "Free software rules."