[sldev] Proprietary dependencies

[Dzonatas]

Argent Stonecutter wrote:
> On 2008-01-26, at 17:40, Dzonatas wrote:
>
>> The GPL has nothing written in it to allow or not allow such linkage. 
>> Certainly, the GPL doesn't say "hey.. you can't take out that library 
>> because it would be a violation!"
>
> The GPL covers creating derivative works. If you link against a shared 
> library, you are creating a derivative work of that shared library.

The act to link against the shared library is not an absolute factor to 
determine if a derived work exists.

>
>> The compile-time linkage or run-time linkage is not the determining 
>> factor under the GPL.
>
> I believe I made that point already.

Your point is not clear because it appears here you agree that a link 
with a shared library does not always denote a derived work is being 
made, but...


>
>> It could be perfectly fine to link a proprietary library with a GPL 
>> program of vice-versa if both of those packages are separate works.
>
> They're only separate works if there is a way to create a working 
> executable without linking it against a library that is compatible 
> with the GPL.

As long as they don't share execution context then they can be linked 
and still be considered separate works. The GPL, however, does not set 
an absolute, or cookie-cuter case, for kinds of contexts and how they 
can or can not work with other contexts. It provides a guideline and 
uses a 'take-it-to-court' explanation for all other diversions.

Take for example Quicktime.  It is a library of code being included in 
headers and object could. It is pretty obvious if one uses any 
definition from its headers or object code that there will be a derived 
work. This is true by the sense that actual code from the quicktime 
header got included into the compiled product.

What if one doesn't include Quicktime headers at all. The obvious is 
then removed. One could say well there is still a compile-time link 
being shown to the library, but what if it doesn't use any object code 
from the QuickTime library. This time that "what if" quickly starts to 
look like "it is not a derived work."

Another example, take two programs, one proprietary and one GPL. Let's 
say the GPL used a socket() to transfer a part of its binary code over 
to the proprietary program to execute.  In effect, it just shared its 
execution context with the other. There would be a violation here -- but 
the GPL also has a few intrinsic exceptions, like the system context.

Please do explain if a barebone SL client told another module (by http 
or more directly) to go fetch a sound from the sim and play it, how is 
the barebones SL client playing that sound? The only API between the 
barebones SL client and the sound system would be a directive to play a 
station.  If the other module listens for the directive and then plays 
the tune with fmod, gstreamer, quicktime, or whatever else... how does 
the barebones client violate the GPL?

I think you got the gist of this and understand it but wasn't sure about 
my point or even question if I understood my own gist. lol