News for hackers. Stuff that matters.
Re:Why you shouldn't use the Lesser GPL for your next library by tytso on Friday May 16, 2014 @04:19PM (#7757684)
The problem with the readline library example is that there are BSD versions of the library. So you can do something like this:

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?

Re:Why you shouldn't use the Lesser GPL for your next library by tzs on Friday May 16, 2014 @06:43PM (#7758339)
This is reminiscent of the RIPEM situation ~20 years ago. This was a program that did email encryption using RSA. RSA was implemented using a library from RSA (the company) that was freely distributable but not free software, and because RSA (the encryption method) was patented, there was no way in the US to replace this library with free software.

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.

Re:Why you shouldn't use the Lesser GPL for your next library by comex on Friday May 16, 2014 @05:10PM (#7757925)
As it happens, this exact argument was put forth by the "at least one application program" that converted to free software:

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.

Re:Why you shouldn't use the Lesser GPL for your next library by saurik on Friday May 16, 2014 @06:00PM (#7758178)
The court opinion stressed pretty strongly that Google's usage of the Java API was never actually intended to build an interoperable implementation (stating that Google was unable to point to any specific examples of code that would even be interoperable ;P) but instead to build a non-interoperable platform that was heavily inspired by the work that was put into Java. I think Google could have made a better case for attempting to be interoperable in certain ways (such as with libraries as opposed to "apps"), but apparently they didn't, and in fact came off quite strongly as trying to build their own unrelated-to-Java platform for various technical and business reasons. It still seems to be the case that if you are building a system whose goal is truly to be interoperable (such as libedit is to libreadline) you would not run into problems. For much more detailed commentary and argument (as well as quotes from the opinion), I encourage you to read my comment from that thread:

https://news.ycombinator.com/item?id=7723853

Re:Why you shouldn't use the Lesser GPL for your next library by zAy0LfpBZLC8mAC on Friday May 16, 2014 @07:51PM (#7758604)
I don't have a clue what Google's specific goals were, but couldn't an argument be made that compatibility with existing knowledge of developers is also a form of interoperability, and in particular one that needs to be protected from monopolization?
Re:Why you shouldn't use the Lesser GPL for your next library by saurik on Friday May 16, 2014 @09:17PM (#7758873)
At that point copyright becomes meaningless (though if you are willing to go that far that's great: I don't see anything inherently incorrect about the position "copyright is meaningless"): "I needed my photograph to look like yours because everyone was familiar with yours and I wanted them to feel the same way as they did when they saw yours".
Re:Why you shouldn't use the Lesser GPL for your next library by zAy0LfpBZLC8mAC on Friday May 16, 2014 @09:48PM (#7758947)
Well, yeah, I don't see much inherently meaningful in copyright either, in particular because drawing boundaries is ... difficult, to say the least.

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.

Re:Why you shouldn't use the Lesser GPL for your next library by saurik on Friday May 16, 2014 @10:07PM (#7758996)
For me, part of the difference is whether the interoperability is complete or fuzzy: I don't feel like you can be "only sort of interoperable", and that seems to be the big difference between the human/machine and machine/machine examples (it isn't that the interoperability is a different kind of interoperability, it is that it is a different level of precision in the kind of interoperability). A developer of will notice important differences in Java vs. Android.

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.

Re:Why you shouldn't use the Lesser GPL for your next library by comex on Friday May 16, 2014 @08:06PM (#7758673)
Interoperability is relevant to fair use, but it's not the only factor. For instance, when Florian Mueller looks at the fair use argument, he cites a number of factors that weigh against it, of which the supposed lack of interoperability is only one:

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.

Re:Why you shouldn't use the Lesser GPL for your next library by saurik on Friday May 16, 2014 @09:44PM (#7758933)
None of this responds to my point in context that the analogy "libedit is to readline as Android is to Java SE" does not hold due to arguments that were levied against Android not being applicable to libedit. I also am confused by some of your comments here regarding my stance on fair use: I think that there is a core misconception people have in this case with relation to the separation of "infringement" from "fair use", but to be clear: I would not personally bet much on Google winning fair use (though I would also not bet much against: the jury was hung before, I doubt Google will manage a more intelligent argument, and so maybe it will go either way).

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).

Re:Why you shouldn't use the Lesser GPL for your next library by comex on Friday May 16, 2014 @10:44PM (#7759078)
I'm sorry if my argument was unclear, but I was attempting to say my best guess is that fair use in this case is untenable regardless of the interoperability argument, and thus also in cases where interoperability was more strongly attempted. Of course, there would be many individual factors involved in any other court case, and it's not like a jury in the Android case could set a precedent one way or another (although an appeal could), but even so.
Re:Why you shouldn't use the Lesser GPL for your next library by mzs on Friday May 16, 2014 @05:04PM (#7757900)
There is this interesting claim in the readline homepage: http://cnswww.cns.cwru.edu/php/chet/readline/rltop.html

"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.

Re:Why you shouldn't use the Lesser GPL for your next library by dllthomas on Friday May 16, 2014 @04:37PM (#7757766)
There are now BSD versions of the library. This was not true for several years, after the license was picked.
Re:Why you shouldn't use the Lesser GPL for your next library by yuhong on Friday May 16, 2014 @04:39PM (#7757786)
Yea, this is an old article.
Re:Why you shouldn't use the Lesser GPL for your next library by mzs on Friday May 16, 2014 @05:05PM (#7757908)
I wonder what changed? "Updated: $Date: 2014/04/12 12:39:52 $" Maybe someone could look in archive.org, it's blocked for me.
Re:Why you shouldn't use the Lesser GPL for your next library by LukeShu on Friday May 16, 2014 @05:33PM (#7758047)
The CVS log of the page: http://web.cvs.savannah.gnu.org/viewvc/www/licenses/why-not-...

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.")

Re:Why you shouldn't use the Lesser GPL for your next library by stonemetal on Friday May 16, 2014 @05:20PM (#7757982)
There was no distribution of GPLd code so I don't think there was a violation of the GPL.

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.

Re:Why you shouldn't use the Lesser GPL for your next library by tytso on Saturday May 17, 2014 @11:36PM (#7762068)
The proprietary app in this example, has no idea whether they are dynamic linking with a version of libss that has the dlopen functionality (which is the case in the version of libss distributed with e2fsprogs), but there is also the version of libss distributed with Solaris SEAM and the MIT Kerberos v5 distribution which does not dlopen readline.

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.

Re:Why you shouldn't use the Lesser GPL for your next library by stonemetal on Tuesday May 20, 2014 @04:13PM (#7774891)
* 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.

Re:Why you shouldn't use the Lesser GPL for your next library by tytso on Thursday May 22, 2014 @12:14PM (#7784556)
Sun shipped could which _could_ link dynamically to GPL code.

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.