harmony-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Dalibor Topic <robi...@kaffe.org>
Subject Re: On Tainting/Residual Rights (Was: Re: [Legal] Requirements for Committers)
Date Thu, 09 Jun 2005 13:56:10 GMT
Bruno F. Souza wrote:
> Dalibor Topic wrote:
>> You can look at free software and work on other software as much as 
>> you want to, as free software licenses do not claim further rights 
>> beyound the rights granted to the author through copyright laws. I.e. 
>> if you copy or modify free software works, you are bound by their 
>> license terms, as the copyright laws grant the authors a say in 
>> derivative works. If you don't do that, then the author has no say in 
>> your own, original work. You are allowed to study free software 
>> (freedom 1 [1]). You can do what you want with that knowledge, modulo 
>> patents and creating derived works.[0]
> Well, the "tainting" (if that can be said that way) on open source 
> licenses only have any effect if the original license has some 
> reciprocity rules (like the GPL/LGPL for example) that prevents you to 
> use the code anyway you want. Under copyright, you cannot simply copy
> the code, and as such, Harmony's code should not bear any resemblance to 
> other free J2SE implementations to which the license is not Apache 
> compatible. As seen in the JBoss vs Geronimo legal discussion, we should 
> probably be careful here as well.

Yep, copying the code verbatim, or copying a derived work of the code is 
covered by Free Software licenses, and some of them have stricter rules 
than the Apache Software License v2, so that code can not be used in 
Harmony unless relicensed. Note that one would want to have copyright 
disclaimers on all the code going into Harmony, to avoid funny 
misunderstandings (cheers to everyone's friends in SCO) later.

Otoh, you are fine to look at Kaffe's source code (GPLd), for example, 
decide that it does some things not that well, and go on to implement 
your own, better runtime/jit/gc/verifier/whatever (just listen to Miguel 
for a while, to hear how many things Mono does better than Kaffe :), and 
license it as you wish (Mono is not GPLd), as it is your own original 
work, that does not share copyrightable portions with GPLd code.

Copyright protects an expression, patents protect ideas. Ideas expressed 
in Free Software can be learned and reused freely, modulo any weird 
software patents. The literal, tangible expressions of those ideas, 
though, can be copied and modified only according to the liberal, OSI 
certified rules set forth by the authors.

> And another can or worms is Sun's research license (JRL), that 
> specifically says:
>      B.  Residual Rights.  You may use any information in
>      intangible form that you remember after accessing the
>      Technology, except when such use violates Sun's copyrights
>      or patent rights.
> That pretty much spells out the same as what Dalibor said:
>  > You can do what you want with that knowledge, modulo
>  > patents [rights] and creating derived works [copyright rights].

Well, there is a major difference: the JRL claims copyright rights for 
any code implementing any part of the specifications, no matter whether 
that new code actually contains a copyrightable portion of the JRL code 
or not. As Harmony would be writing new code, it should avoid getting 
under such claims from the JRL. See 
http://www.mail-archive.com/classpath@gnu.org/msg09825.html for details.

quoting from it:

"As long as Sun says that anything that implements the specs for J2SE, 
without actually being derived from Sun's JRLd code, is nevertheless a 
modification of their work, the FAQ is pretty misleading, in my opinion, 
though it may be factually correct:

Yes, the JRL-bound developer probably can *create* your own independent 
implementation, but she can't distribute it without violating Sun's 
claimed rights, unless she distributes it under the JRL or an 
equivalent, which is very, very far from being open source. Yes, she 
probably can *work* on an open source implementation, but she can't 
distribute the results of her work under an open-source license.

That means the Residual Rights section, while well-meant, is not useful 
in real life. Most people writing open source software also happen to 
like to distribute their own, independant works to other people, under 
open source licenses, even. :)"

Copyright does not work the way the JRL-modification-clause works: for 
copyright claims to work, a work must somehow derive from another work, 
usually by incorporating a modified or verbatim copy of it. What the JRL 
gives the copyright holder is a 
'copyright-claim-through-wishful-thinking', i.e. a claim on works that 
do not contain any copyrightable portion of their original work. The JRL 
(and other 'Bride of SCSL' licenses) essentially tries to give the 
copyright holder an easy way to slap software patent-like protection of 
ideas embodied in an interface on their source code, without actually 
going through the cumbersome process of acquiring software patents.

That is extremely different from OSI-certified licenses: those must 
constrain themselves to just the works that are derived (in the sense of 
copyright law) from them, and can make no claims to unrelated works, 
that happen to implement the same interface. Which is why some software 
vendors can legally ship their Java(TM) desktop systems on both 
GNU/Linux and on non-free operating systems: Free Software does not 
claim their independent non-free software as covered by the free 
software licenses, just because it happens to do the same thing using 
the same ideas.

> So, if we're allowing (with the mentioned care to not infringe copyright 
> rights) anyone to work on Harmony that have worked on the open source 
> implementations, should we allow those that have read or worked on Sun's 
> code under the JRL the same treatment? Or for the sake of extra care, we 
> should avoid both or one of the situations? Maybe that would be going 
> too far? Geronimo did not avoid contributions from people that worked at 
> JBoss, and I understand that besides some trouble along the way, it all 
> turned out OK in the end.

The JRL, and other similar Java(TM) technology licenses, unfortunately 
try to make it very hard for someone who agrees to them to both work on 
*and* release a free software implementation of the specs without 
violating the license, afaict, despite well-meant comments from some 
executives and marketing staff to the contrary.

If the JRL did not make any claims to new, original code calling it a 
modification (see Modifications(b)), then the Residual Rights section 
*may* work as advertised, if the termination clause is fixed [1]. On the 
other hand, I'd be surprised if there were not too many legal mines 
buried in it to make fixing it a dull and pointless excercise. :(

dalibor topic

[1] Yeah, termination is broken, as well, as it does not preserve your 
Residual Rights, just section V, which covers Trademarks, Export Control 
and similarly useless things. Residual Rights, for your JRL-trapped 
inconvenience, are under section III, which does not survive 
termination, afaict.

Not that it is really easy to terminate the JRL anyway, as it does not 
tell you where to send your written notice of termination. And so on, 
and so on. Short story: don't touch non-free source code with licenses 
from the legal team that gave us such gems like the 'Read-only' license, 
without spending some serious time with your lawyers.

View raw message