3 ms·
One of the circuit court's stated reasons for ruling that the SSO holds for the Java API was because of the names: The evidence showed that Oracle had "unlim
by groovy2shoes 12y ago
One of the circuit court's stated reasons for ruling that the SSO holds for the Java API was because of the names:
The evidence showed that Oracle had "unlimited options as to the selection
and arrangement of the 7000 lines Google copied." Appellant Br. 50. Using
the district court's "java.lang.Math.max" example, Oracle explains that the
developers could have called it any number of things, including
"Math.maximum" or "Arith.larger." This was not a situation where Oracle was
selecting among preordained names and phrases to create its packages. As
the district court recognized, moreover, "the Android method and class names
could have been different from the names of their counterparts in Java and
still have worked." Copyrightability Decision, 872 F. Supp. 2d at 976.
Because "alternative experessions [we]re available," there is no merger.
See Atari, 975 F.2d at 840.
http://www.cafc.uscourts.gov/images/stories/opinions-orders/13-1021.Opinion.5-7-2014.1.PDF http://www.cafc.uscourts.gov/images/stories/opinions-orders/...
pp. 30-31.
- chc 12y agoThis is a broader point than "it was because of their names." As I understand it, the court is saying that Google copied the whole package structure of Java, including a whole tree of associated names. It's not just that some names happened to match up, but that the whole structure of the Java libraries was considered a creative work and Google copied that whole creative work. The names are a component of that, but you can't point at a name and say "That was the copyrighted thing," because it was the aggregate API that the court considered copyrightable. (Again, not a lawyer or legal advice. This is just my layman's understanding.)
- groovy2shoes 12y agoYeah, I think you're right. It's the wholesale copying of a large chunk of the Java API rather than just the name of one thing. Tangentially, I really disagree with the ruling. First, we have to figure out where to draw the line: if you can copyright a big API, can you copyright a small one (like, say, Iterable)? Second, there's legal precedent for allowing partial copies in cases where it's necessary for interoperability (Sega v. Accolade). Finally, the appeal for Lotus v. Borland allowed for wholesale copy of a command hierarchy for user interfaces, which has parallels to application programming interfaces that I think any programmer would find obvious. My favorite quote from that case: [51] That the Lotus menu command hierarchy is a "method of operation" becomes clearer when one considers program compatibility. Under Lotus's theory, if a user uses several different programs, he or she must learn how to perform the same operation in a different way for each program used. For example, if the user wanted the computer to print material, then the user would have to learn not just one method of operating the computer such that it prints, but many different methods. We find this absurd. The fact that there may be many different ways to operate a computer program, or even many different ways to operate a computer program using a set of hierarchically arranged command terms, does not make the actual method of operation chosen copyrightable; it still functions as a method for operating the computer and as such is uncopyrightable. http://www.law.cornell.edu/copyright/cases/49_F3d_807.htm http://www.law.cornell.edu/copyright/cases/49_F3d_807.htm Anyway, I know you didn't ask for my opinion on the ruling but I just wanted to rant a little :) The circuit's ruling really pissed me off. Programming is hard enough without having to worry about whether or not our APIs are covered by an existing copyright.