[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: GPL traitor !

From: Hyman Rosen
Subject: Re: GPL traitor !
Date: Mon, 11 May 2009 10:50:54 -0400
User-agent: Thunderbird (Windows/20090302)

Alan Mackenzie wrote:
The issue is what is meant by "contains".

You have to take the allegedly infringing work and show that significant
parts of the infringed work are present in it. You have to do that well
enough to convince the people who will be trying the case.

The fact that it calls certain functions is likely to indicate that
> the code is derived from the program containing those functions

That's generally false - any program written to the specifications of
an API contains many function calls to that API, but is not bound by
the copyrights of the code underlying the API.

since it will be using the internal data structures of the original

"The only way to interoperate" is a defense against copyright violation.
If it is necessary to incorporate data structures in order to interact
with an API, then one may do so without needing permission from the rights
holders of the API.

The exception is if the functions are designed to be callable from
> independent source, such as standard library functions like sin, cos

This just isn't so. You are making up your own ideas of what is and is not
permitted, and there is no basis in copyright law for your claims.

unless, of course, it contains code derived from some other copyright

Again, there is no such concept as "derived from other work" in copyright

Whatever "physically" means.

It means that the infringing work has to contain recognizable pieces
of the infringed work. The claim of copyright violation has to be
brought against some specific copy - you cannot claim that someone is
infringing your work in the abstract.

If Bob uses a different compiler from Alice, his binary won't "contain",
> physically or otherwise, any significant part of hers, even if he fails
> to change a single line of her source code.

Binary and source code of a computer program share a single copyright.
If Bob is copying compiled binaries of Alice's source, he is infringing
on Alice's single copyright of her program.

Considering binaries isn't helpful, it just leads to confusion.

Considering source is very easy, but is unhelpful to you. It's very
easy to determine copyright infringement in source - you simply look
at it and see if it contains pieces of the allegedly infringed work,
except insofar as necessary to interoperate with it.

> You'll probably agree with me that Bob's binary is still derived
> from Alice's source.

Compiled binaries and other such mechanically transformed versions
all share a single copyright. There is no "derived from" here - they
are all the same work.

    321.03 Relationship between source code and object code.
    The Copyright Office considers source code and object code
    as two representations of the same computer program. For
    registration purposes, the claim is in the computer program
    rather than in any particular representation of the program.
    Thus separate registrations are not appropriate for the
    source code and object code representations of the same
    computer program.

Now suppose instead that Bob manually changes Alice's source, say by
changing the identifier names in the data structures, or by translating
it manually into Haskell, then modifying this source and compiling it.
This is the case where you've asserted (wrongly) that Bob's binary is
independent of Alice's copyright.  (Alice here has written GCC, and Bob
writes a code generator for a new chip).

You are conflating two separate things. The first is clear copyright
violation - Bob is preparing a derivative work of Alice's program, and
may not do so without Alice's permission. Given permission, both Bob
and Alice hold copyright to the resulting work. However, it is possible
to write a code generator for a new chip without needing to begin with
existing source code, and doing that requires no permission from the
rights holders of the compiler into which it will fit.

In none of the above scenarios does the form of the binary and the call
make any odds.  Whether Bob adds bob.c into the build process, creates
libbob.a or creates has no bearing on the copyright

When the compiled binary contains a copy of a foreign library, permission
to create and copy the compiled program requires permission from the
rights holder of the foreign library. Otherwise it does not. Copyright
deals with copies - there must be a copied work at issue, and there is no
copied work when there is no copy.

Even in literary works, there's no requirement for "physical" inclusion.
If Bob translates Alice's novel from English to Russion, renaming London
to Moscow, Bob to Ivan, and Alice to Natalia, not a single word of
Alice's original will survive the translation.  Yet the translated novel
is derived from the original and needs a copyright license.

You have described a derivative work. There is no question that this
requires permission from the original author. That's because the derivative
work is a significant auctorial transformation of the original work. Using
a library in a program is not a significant auctorial transformation of
that library. The resulting program is not a derivative work of the library.
The only copyright issue is if the resulting binary contains a physical
copy of the library.

reply via email to

[Prev in Thread] Current Thread [Next in Thread]