Combining GPL and non-GPL code

[Chris Travers]

On 8/17/07, John Cowan <cowan at ccil.org> wrote:
>
>
> So it does.  This, however, is about something like copying some functions
> from a BSDed coriginal into your GPL code, possibly modifying them in
> the process, in such a way that it isn't obvious how to reconstruct
> the original.


This is a problem not because the original code is not under the BSD license
but because the changes are under the GPL and this is permitted uner the
BSDL.

> I personally think it's abundantly clear that this is, actually, a
> > phoney issue, because copyright owners alone are entitled to decree
> > licence terms for their creations.  Period.
>
> Quite so.  But the copyright on a derivative work (as opposed to a mere
> collective work) belongs to the deriver, provided the derivation was
> lawfully made, which means obeying any licensing requirements attached
> to the original.  So this is not "relicensing" or "sublicensing", it's
> applying the license permissions to make a derivative work.



While I agree with your conclusions in a limited way, I think your statement
is overly broad, but IANAL.  Copyright applies to original expression (at
least in the US) only.  Therefore the copyright on a collective work may be
limited to the collection itself (the expression in terms of selection,
ordering, and organization of the work-- since a telephone directory has no
expressive elements in a basic white-pages list, there isn't much that is
copyrighted outside of advertising) and not the internal pieces (which could
be differently licensed, public domain, etc. provided that the person who
prepared the collective work has appropriate rights to do so).

I similar case occurs in relation to a derivative work.  The deriver only
owns copyrights to the original elements, not to every aspect of the work as
a whole.  The key problem here is that the original elements may not be
clearly separated from those that are not, and so permission may be a
problem.

The basic issue here is that you *don't* own the copyright to the original
BSD code unless you also wrote it or have had it assigned to you.  But you
do own the copyright to a) your changes to that code and b) the collective
work as a whole.  While b) may not be much of a problem, a) could be if you
cannot separate out the changes (but see below).

Another potential problem is that standards of derivation and what is
protectable may vary from one jurisdiction to another.  Simply using the
#include directives in a header file may not be enough under a Gates-type
test (used by the 9th Circuit, iirc) because the practical, interop elements
may not be protectable, but may be covered under other jurisdictions.  If
there is conflict among these within the US, one can imagine it getting far
worse as other nations' notions of copyright are added to the mix.  Hence it
may not be clear what is protectable under "work as a whole" and "derivative
work" terms until you get into court :-(.

Best Wishes,
Chris Travers
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.opensource.org/pipermail/license-discuss_lists.opensource.org/attachments/20070817/a8749a7a/attachment.html>