On Tue, Jan 29, 2008 at 09:08:18AM +0100, IOhannes m zmoelnig wrote:
Roman Haefeli wrote:
ask a lawyer to check in detail, if this is true. however, if licenses could cross 'levels of abstractions' in the sense of pd patches being affected by the license of pd,
afaik, licenses do not cross "levels of abstractions".
In this particular case, Hans is wrong and you guys are right, but it's quite complicated, depending on the type of work which is created and the license of the software. Let me try to explain (IANAL and I am also sleep deprived :) ).
Hans wrote: "I think that if you write a patch that uses a Pd library that is covered by the GPL, technically, your patch is covered by the GPL."
This would only be true if you were: a) Distributing the GPL library/external with your patch. b) 'Linking' your patch with the original software.
On count (a) you generally don't distribute externals with your patch - you expect people to download and install them themselves. Distributing the patch on it's own is fine even if it used a commercially licensed external - it's up to other users to procure a license for that commercially licensed external in order to run your patch. Infact, if you are not distributing the result, you can do whatever you want (including linking commercial code or whatever) in the comfort of your own home and nobody can stop you.
On count (b), I don't think anybody would 'link' a Pd patch with Pd since that would require the patch to be turned into a data segment and linked into the Pd binary and a special hook would be required to load the linked binary segment directly into Pd at runtime instead of reading it from a .pd text file. In other words, if someone made a stand-alone application with the Pd file compiled into the binary and then distributed that, then they would probably be required to adhere to the GPL license of the externals used (e.g. if they used the linker program to link the patch into the application). This area is quite fuzzy because some people even contend whether dynamically linking things is covered by the GPL - this has probably changed with GPL 3.0 which probably makes it more explicit (but would still allow an interpereted .pd file no problems at all). If the developer/distributor used pure Pd then they wouldn't have to worry about that because it's BSD (except they would have to flash the Pd license to the user at some point).
It's conceivable that someone would write some software that had an EULA which specified that works created with that software were covered by the same license as that software (crossing "levels of abstraction"). Microsoft's Hotmail service does something like this - when you create a hotmail account you agree that all data and emails that pass through their server are owned by them. As for whether this would stand up in court or not is a different matter. Especially interesting in this regard is whether code is speech or not because as I said, the type of work created matters a lot as different works are considered in different ways under the law.
however, if i have a collection of abstractions published under the GPL, then i think i don't cross this magical border.
There is no "magical border". There is just different software with different licenses and different types of works (which are treated differently under the law) created with those bits of software. 99% of the time you are going to be fine and you are going to be able to license your work in whatever way you want, independently of the software. When the work is itself a computer program it seems more complicated but actually really isn't.
next comes the question, what is the difference between an abstraction and an external non-abstraction object. afaik, GPL does not dissolve just because of languages used. (that is: porting of code from one language to another is (to my knowledge) not really affected by the GPL (e.g.: you can chose the license again) as it usually involves re-coding an algorithm rather than re-using pieces of code.; but this is unrelated to the language a library is written in)
Yep. The copyright covers the text of the source code. So if you re-write the source code in a different language you have created a new and different text. This is akin to re-writing a novel with different words and characters and place names, but with the same basic plot. It's completely legal. In the case of algorithms though, watch out because under certain jurisdictions they may be covered by software patents which will bite you in the ass.
The principal difference between and abstraction and an external is that an external is 'linked' with the Pd binary (dynamically at runtime usually) whilst an abstraction is interpereted. Interpereted works are not covered by the GPL, but linked code is.
finally, i am still unsure about the "static linking" clause, and how it affects an interpreted language.
It doesn't in the case of the GPL.
i guess, if you have a patch that depends on a GPL'ed pdlib, and you are distributing your patch with this library (e.g. for convencience reasons), then you are kind of _statically linking_ and thus your patch is automatically GPL'ed too.
I really don't think so, unless you are actually using a linker program to link the .pd file with the Pd binary, which is very unlikely. If I am wrong then ALL YOUR BASE BELONG TO MILLER and I am switching to supercollider. :)
Best,
Chris.