RIPEM also needed a big integer math library. The two main free software libraries for this were the GNU one and the the BSD one, which had different interfaces. RIPEM could be built to use either. This was an option you could set when you ran the build script.
The FSF said that distributing the RIPEM source code was a GPL violation, even though they did not claim copyright on any code in the RIPEM distribution. In particular, they were adamant that they were not claiming a copyright on the GNU mp library interface.
Their claim was that since RIPEM contained code (the conditional code that used the GNU mp interface) that was only useful with GNU mp, distributing that source code would lead to some people downloading GNU mp, which they would then link with RIPEM and the non-free RSA library, and that this meant that the RIPEM people had effectively distributed GNU mp with non-free software. See note [1].
The RIPEM people finally put an end to this nonsense by making a "new" mp library that had the same interface as the GNU mp library and was either (memory is hazy) just a thin wrapper for the BSD mp library, or was just a quick and dirty implementation of the simple, classical mp algorithms that any decent programmer can knock out from Knuth fairly quickly.
This meant that people receiving the RIPEM source and choosing to build using the GNU mp interface might not actually build with GNU mp. They might instead build with this new library. Now induced distribution can no longer be inferred. This satisfied FSF.
This was pretty astounding. If X is written first, and Y is written second, the answer to the question of whether or not Y infringes the copyright of X does not change if a third thing, Z, comes along AFTER X and Y. Copyright law obeys the arrow of time. :-)
[1] I may not be remembering their theory exactly correctly. The general outline (RIPEM not distributing any GPL code, but FSF thought they were liable anyway if someone downloaded RIPEM source, downloaded GNU mp source, and linked them together) is right.
http://clisp.cvs.sourceforge.net/viewvc/clisp/clisp/doc/Why-...
It was never actually resolved, because the CLISP author decided that making his program free software would be a good idea for other reasons anyway. In the past, I would have disagreed with RMS's insinuation that a GPL violation would occur, because, as stated:
> So the only reason why you may object is that my lisp.a has an INTERFACE that allows it to be linked to libreadline.a . As far as I know, only the readline CODE is copyrighted, not its INTERFACE. (Would you object because my libnoreadline.a has a similar interface?)
Only... we just got a US court decision that APIs are copyrightable. Although readline's API is much simpler than large parts of Java, it's substantial enough that I'd argue the decision nevertheless implies that libedit is a copyright violation. Which I find ironic, since most of the programs affected by the decision are free software clones of proprietary software, not the other way around.
But I think your example still doesn't quite capture what I mean ... even though, well, maybe it does, but let me explain ;-): What I had in mind is in particular that getting familiar with an API requires effort, so it's kindof an investment on the part of the developer. After all, an API is as much a human/machine interface as it is a machine/machine interface. As such, it is problematic to allow anyone to have a monopoly on that investment, essentially a monopoly on the use of those developers' knowledge. And protection of investments is one of the arguments (the argument?) for interoperability exceptions--so, why only for machine/machine interoperability and not also for human/machine interoperability?
I guess the "investment" aspect doesn't work that well for your example, but I still can see some value in the argument, in particular if you apply it to DRM (type) systems and culture in general.
To explain some more with my photograph comment: the photograph might have taken time and context and thought on behalf of an entire population of viewers to come to some "meaning"; maybe this is more obvious if we take a storyline from a popular television show: before the show people didn't care about the topic of the show, but after the investment, quality, and success of the show now people really like that topics and in particular the story progression that went along with it.
People are familiar with that story: to really allow those people to feel good about the new story, maybe it has to be similar to the old one? If you go down this path for a while, you start reading about idea/expression differences as they apply to literary and visual works: high-level plots and themes are not protected, but specific details and timelines are. The idea of organizing code into packages and classes is not, but the specific choice of what classes to put in what packages and what they are named are.
FWIW, I personally feel like a lot of the benefit of trying to be "interoperable" with someone's perception of how to program is sufficient to be at that higher "idea" level: when I use C# or Objective-C (which in many ways feel similar to Java and in the case of C# was pretty much designed as a direct replacement for Java) I am highly familiar with them despite not feeling like they are the same: I gain a lot of the benefit of C# and Java having similar ideas, despite the fact that they clearly have different expressions.
Now, that said? I continue to appreciate the idea that this is all a stupid distinction: but if you erase this distinction I am not certain where you still draw the line for claiming copyright on anything. Given the idea "investment in expression should be protected" (an admittedly-oversimplified version of "copyright"), I don't think you still have "investment by consumers in content should be inherently reusable by other creators". I could be wrong, however, and would love to hear more ideas.
http://www.fosspatents.com/2012/05/oracle-v-google-fair-use-...
http://www.fosspatents.com/2014/01/why-google-books-is-proba...
While I'm not a lawyer, it would make sense to me for API reimplementation not to be fair use when viewed from the perspective of copying "declaring code", even if interoperability is stronger or argued stronger. Incorporating part of a copyrighted work in a new work intended for exactly the same use, which competes with the original, is not "transformative", and certainly has an "effect of the [] value of the copyrighted work"; it doesn't look much at all like normal examples of fair use, such as thumbnails and quotations.
Also, I did read the decision itself, and the part about fair use didn't seem particularly friendly to Google's argument, even if the issue was remanded. In particular,
"We find this particularly true with respect to those core packages which it seems may be necessary for anyone to copy if they are to write programs in the Java language."
where "this" is relevance to fair use, reflects badly on the majority of packages which are not necessary to write programs in the Java language. (I think this definition of "language" is nonsense, as even though it's what a programmer would call the Java language, I think the analogy is to human languages, which were found to not be copyrightable; yet human languages include a large amount of vocabulary, which I find analogous to API declarations. However, it's what the court used.)
We will have to see what happens in the Android case, including appeals, as well as any future cases (though I'd say the former has a good chance of producing a chilling effect that will greatly decrease the probability of potential subjects of the latter from even being created), but I don't agree with your relatively positive assessment of the power of fair use.
Also, fair use determinations can, like in this case, be decided by the jury rather than the judge, and I trust juries far less than judges to weigh how the facts actually apply to the law rather than whether it feels like some company ripped off some other company.
More importantly, though: nor am I even certain I wish/hope that Google does win, as I have great sympathy for the argument that they were never intending to build an interoperable system. I tried very hard to not put a strong opinion in my comment on the other thread (as I really and truly can appreciate a number of other consistent positions, including ones as strong as "copyright is inherently wrong"), so I'm guessing you just assumed me to be arguing for the thing you wanted (which sounds like "Google should win"): I maintain my "relatively positive assessment" even in the situation where Google loses, as I think this case is materially different than ones I care about.
Finally, I will point out that you are preaching to the choir on "chilling effects": that is what my entire final paragraph both admits and (in the nod to the comment from grellas with respect to "uncertainty") laments. The only positive thing is that "interoperability" does have some status in the world of copyright, if nothing else in the DMCA's reverse engineering restrictions, and there is a wide pool of precedent for the legality of building systems based on the knowledge from said reverse engineering (so it isn't just that you get to reverse engineer things and then feel satisfied with the knowledge: you get to release production systems that embody that learned knowledge).
"Readline is free software, distributed under the terms of the GNU General Public License, version 3. This means that if you want to use Readline in a program that you release or distribute to anyone, the program must be free software and have a GPL-compatible license."
That's interesting, it does not say it must use GPL (which is what I expected, it seems a direct contradiction to the article we just read) and so libss being MIT seems fine. Nothing in libss source seems to include anything from readline, no header file, no copying portions of header file even, just some very small words in the dl loader like"readline", "add_history", "rl_forced_update_display", and so forth. I would hope that is fair use. I would say that Oracle though might have a problem though if can't study the source freely for their client. But it seems wrong in someway that they should have such a problem since they copied so little and so indirectly. To be safe, they should modify libss and distribute a version where DEFAULT_LIBPATH in their private source includes no traces to readline. It's sort of ironic though regarding the recent Oracle v. Google ruling, to be sure theyu really should also modify most editline function names to something like oracle_foo_0, oracle_foo_1, ... shouldn't they ;) Seriously, this is a very interesting question, it's a good one for a lawyer in fact.
The only change of substance since at least 2001 (when they started using CVS) is the rename of "Library GPL" to "Lesser GPL" (the 2001 version had a notice that the rename had occurred, but the article had not been updated).
Most of the changes are adding additional translations, and minor markup changes (the most recent is "Remove empty <p> element.")
On the other hand I could see the claim there was a violation with the proprietary app being at fault. They should have verified all of their dependencies not just the direct ones.
This is the problem of whether the GPL infects across dynamic linking. Yes, it is possible for GPL and proprietary code to be in the same process address space, without any knowledge of the owner of the proprietary address space. It was the user who decided to use a particular version of libss, not Solaris.
That is exactly why I don't think there is a violation. Sun didn't ship code that linked(dynamically or otherwise) to GPL code. The end user did something to make that happen. It would be a violation by the end user if they shipped their combined product.
The problem with this "GPL infects across dynamic linking" argument is that you are therefore trying to make the claim that whether or not kadmin is infected by GPL code is dependent on whether there exists another library which is not licensed under the GPL. This gets perilously close to claiming copyright infringement, with the added wrinkle that the simplest way for someone to take code that was previously claimed to be GPL infringing is to create and ship a new library which is ABI compatible. So something could be a GPL violation, and then when a new library ships, et voila!, it's not no longer a violation. And something could orignally clearly not be a GPL violation, but when a new library ships which has a dependency (implied or explicit or even conditional in the case of an optional dlopen) on GPL code, now that proprietary binary can now run with GPL'ed code in its address space.
https://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/tree/lib/s... https://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/tree/lib/s...
So riddle me this. The ss library is under an MIT-style copyright license. Suppose you have a proprietary program (Say, the Solaris kerberos v5 administration daemon client, to take a not-so-hypothetical example). Now suppose it dynamic links against a version of libss that might dlopen readline, or might dlopen editline, and if neither is available, libss will fall back to fgets. Now suppose Solaris distributes their kadmin program independent of the version of libss distributed as part of e2fsprogs. Quick! Is there a copyright violation, and if so, who committed it?