Dynamic linking, was: Re: Dispelling BSD License Misconceptions
bastin at iro.umontreal.ca
Sun Jan 28 07:30:00 UTC 2007
The question of derivative work sounds really tricky to me, and I am a
bit surprised that you seem to be so sure that just linking is making a
derivative work. By the way, the question arises often, and until now, I
have never read a satisfying answer. And if such an answer was easy to
produce, why the term "derivative" has been replaced by the "whole
work"? My feeling is that the question will not be solved until a
judgement, following a trial, would have been made. But still the answer
would then be country-specific, and probably quite artificial. And what
if a library linking produce a derivative work in a country and not in
another country. Would it not be a discrimation between users, so a
violation of the open-source definiton?
We can also consider a different situation. Often, GPLd library are
created as replacements to non-GPLd libraries (to my best knowledge, it
is for instance the case of TLS, whose goal is to replace SSL), so
programs designed to work with these libraries are only using in
practice previously designed functionalities, so if we later just
consider the function definitions to recreate equivalent
functionalities, why should we still have to consider the work as a
derivative of the GPLd library? And by the way, how can we now with
certainty that the original author has written is code in order to only
allow the use of the GPLd library? It could be only a transitional
development phase, a "better-than-nothing" solution.
I become more and more uncomfortable with the "all-GPL" (GNU project)
vision behind this licence, and I cannot accept to see for instance the
GPL copyright notice in the beginning of the BLAS header in the GSL
library. How can I think that using the GSL blas is producing a GPL
derivative, while I could compile with ATLAS without changing a single
line of code? The rationale of GPL 3 is well designed on this point,
since the "whole work" do not include such standardized API... if you
can define what is standard and what is not... The licence GPL 3 becomes
less and less clear, and it could produce a lot of law problems,
especially in Europe where trials are not as expensive as in North
America, and law is different. For instance, GPL is a contract in view
of European law, even if Moglen does not agree. But first of all, remind
that United Stated is not the only country on earth, so you should try
to avoid and location-specific consideration...
P.S.: while I am writing, I would like to make an off-topic, and gently
ask all to stop discussion about "delete me"? Even if Russ Nelson's
words could have been better, I can understand him because it becomes
really frustrating to receive such emails, especially the spam one. I do
not subscribe to list to get reminders, but to learn and discuss about
the topic, which is not what it is done on this other thread.
Arnoud Engelfriet a écrit :
> Russ Nelson wrote:
>> Arnoud Engelfriet writes:
>> > If, as Matthew writes, part of the code is _specifically_ written to
>> > work only with GNU readline and no other library, then the code is
>> > a derivative work of GNU readline at the moment of creation.
>> And if I later write a library compatible with GNU readline, that
>> makes the code NOT a derivative work? How can that be? It's either
>> derived in the sense that I incoporated parts of GNU readline into my
>> code, or else it's NOT derivative because no part of GNU readline was
> Your library would probably only copy the functional elements, i.e.
> the function calls that GNU readline supports. If you don't copy
> implementation, your library is not derivative of GNU readline.
> A program originally written to work only with GNU readline is and
> remains a derivative of GNU readline. A later compatible alternative
> does not change that.
>> The dynamic linking argument has no legs unless you can claim
>> copyright on a list of names. If somebody else produces a similar but
>> different list, does that infringe your copyright? Not obvious.
> I am not relying on the static/dynamic linking situation at all.
> What I'm saying is that if you write something that needs GNU
> readline to work, you have a derivative of GNU readline. That's
> (in my eyes) a useful criterion. If you don't need GNU readline
> but just any library that implements a char *readline() function,
> you are not creating a derivative of GNU readline.
> I still am unsure as to whether a Windows or Linux program would
> be seen as a derivative work of Windows/Linux. Those programs are
> written according to a more-or-less standard API, but there is only
> one implementation of that API available. Fortunately this isn't
> a problem in practice.
More information about the License-discuss