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/[email protected]/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. :(
cheers,
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.
