These infamous lines are certain to get copied quite a bit more. In case you haven't seen them:
private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex+")");
if (fromIndex < 0)
throw new ArrayIndexOutOfBoundsException(fromIndex);
if (toIndex > arrayLen)
throw new ArrayIndexOutOfBoundsException(toIndex);
}
Those lines of code are from OpenJDK's TimSort implementation. It was written by Joshua Bloch, who was actually working for Google at the time, and contributed to OpenJDK. He later re-used the same code for Android's implementation of this same function.
In order for this to be a copyright violation, Bloch would have had to assign exclusive ownership over the code to Oracle.
Quoting from the relevant section of the Oracle Contributor Agreement:
"You hereby assign to us joint ownership", and "grant to us a perpetual, irrevocable, non-exclusive, worldwide, no-charge, royalty-free, unrestricted license to exercise all rights under those copyrights". However, "each of us can do all things in relation to your contribution as if each of us were the sole owners".
So, Bloch still owns this the copyright in this code, and is free to do whatever he wants with it. All he did was grant Oracle the same rights to that code that he has, so that Oracle can do whatever they want with it as well.
So, not copyright infringement. Oracle's own contributor agreement makes that very clear.
Edit: Added references
List of signatories of the Oracle Contributor Agreement (Google cache, because the main site is down at the moment):
I don't think you have the facts right (and your citations only back up your logic, not your premises). If it were true, you don't think the lawyers would have maybe mentioned this in court?
Bloch used the function in the course of implementing TimSort, but copied it directly from Sun's version of the Arrays class (it existed long before Bloch worked for Google). And the reason he did that was because he thought TimSort was going to be contributed and added to Arrays, where it would have direct access (and the copying would at that point be removed). That never happened, which lead to this count of infringement.
It's absolutely ridiculous though. Even though they infringed the damages for that infringement should be about $100, which is the maximum amount you'd have to spend to reproduce that in a clean room. Reimplementations of that method would look pretty much byte-code identical so Oracle really has no basis for seeking anything more than trivial damages.
I just went and did some more digging around. Looks like you're right - the method in question was present in OpenJDK's java.util.Arrays first, and seems to have been copied into the TimSort implementation.
Are you talking actual measurable real world damages, or damages as assessed by a court? The latter has nothing to do with reality, like the recent RIAA cases and the obnoxiously high damages per track.
And one of the python sources [0], where Timsort originates, for the later two conditions -- index (i) is checked to be in range of the list's (a) indices (size):
if (i < 0 || i >= Py_SIZE(a)) {
if (indexerr == NULL) {
indexerr = PyString_FromString(
"list index out of range");
if (indexerr == NULL)
return NULL;
}
PyErr_SetObject(PyExc_IndexError, indexerr);
return NULL;
}
Can we really expect prose of such simple (more-or-less obvious?) functions to be patented? Tasked to write as many obvious variations of either of the above, I'd certainly expect to find something both functionally and grammatically the same.
> Can we really expect prose of such simple (more-or-less obvious?) functions to be patented?
We're still talking about Copyright, not Patents. However, I agree entirely. I don't think I could come up with a function that verifies if a given index is valid in a given array that is substantially different than that.
Seriously? I've written code that's semantically identical to that, as have thousands of other developers. It's the obvious way to do a range check against an array of a given size. There's nothing copyrightable about it because it contains no unique expression and the algorithm certainly precedes the development of Java.
It's kind of crazy that these are the only lines Oracle could find. While it does appear that these were copied, they're so trivial that it hardly seems to matter.
I think that de minimus was only part of question 1 B, which they hung on. But I don't have the jury instructions or form in front of me, so I could be mistaken about that.
Personally, I agree that it ought to be considered de minimus by any sensible definition. It's not so large as to be identifiable as part of the Java language. It's a tiny part of the entire work. It offers no identifiable contribution to the work's value. It is one of only a few sensible ways to express that concept. It has no literary or artistic merit and offers minimal creativity. And it was copied by the very person who wrote it in the first place.
In short, this is a trivial piece of code that was mistakenly included and which caused no identifiable harm to Oracle, as further evidenced by the fact that they're not sending DMCA notices to HN to take it down. But that might just be a bad idea. I mean, what if they got that judge who ruled against a copyright troll saying that even quoting an entire news article could be fair use?
EDIT: Found the SV form. I was wrong about the questions. Question 3 is the only one to mention de minimus, but it's pretty confusingly worded, though it sounds like they did not believe it was de minimus, something I strongly disagree with.
truly a marvel of engineering. that this stupid piece of code can be sitting at the center of a legal argument speaks volumes about how dysfunctional things have really gotten.
What the fucking fuck, seriously, that is just a straight-up implementation of the pseudocode "Ranges can't be backward, can't start at impossible negative indexes, and can't end beyond the last element of the array".
Wait, for someone who hasn't been following this ordeal very closely, can you elaborate on the significance of the 'infamous lines'? Because this just seems like some crap you'd have to do as a freshman on the first day of learning C. Java. Whatever.
This is code that Oracle has claimed that Google illegally "copied" from OpenJDK without proper license.
Whether you could write this code yourself is irrelevant - this is Copyright, not Patent law. What matters is whether it was copied, and whether that copy falls under the Fair Use doctrine.
I do. I think it'd be hilarious if a Copyright case like this went forward and the defendant said, essentially, that they "threw away and rewrote" the copied code because it had too many bugs.
"[Judge Alsup] has yet to decide on the overall copyrightability of the structure, sequence, and organization of the 37 Java APIs themselves. Ruling that the APIs are not covered would render today's decision entirely meaningless, essentially throwing away the jury's earlier finding of infringement on the SSO issue."
The judge instructed the jury to assume the API is copyrightable when they determined whether Google violated that (assumed) copyright. The actual ruling whether the API is copyrightable will be decided by the judge as a matter of law.
I disagree with that analysis. The Judge asked the jury to decide fair use assuming API copyrightability because he had them at hand, and it was an opportunity to make his eventual ruling more appeal-proof. Finding APIs copyrightable rather than purely functional would create new barriers to interoperability, which would be a little more important than having part of a jury's verdict moot.
I hope that Judge Alsup rules that APIs are not subject to copyright, as the EU has already ruled.
It certainly would be in the public interest to do so!!
But supposing that the Judge rules that APIs are subject to copyright, I expect that a developer boycott of Oracle would soon follow, together with a push to get the US Congress to change copyright law.
Note that this a blog post by a very respected IP law expert (cited by the Supreme Court in recent decisions). One detail I find particularly interesting is that, unlike most common summaries which focus on the UI issues, he points out that there was also an API issue at stake in Lotus v Borland: the menu structure was effectively part of the macro programming API.
Oracle didn't lose on fair use for all time, but they've effectively lost for now. They didn't defeat Google's fair use defense as a matter of fact (because the jury hung) and the judge refused to rule as a matter of law. Beyond a new trial or an appeal, what else could Oracle do?
Alternatively, the judge can rule that APIs are not copyrightable, making the issue of fair use moot. I personally believe that this is what will happen, but it remains to be seen.
> Google has filed a motion [PDF] for a new trial on both question 1a and 1b, arguing that they are indivisible and that Google has rights under the Seventh Amendment for a new trial on both sides of that same coin:
>> "Under settled Supreme Court and Ninth Circuit law, the jury's failure to reach a verdict concerning both halves of this indivisible question requires a new trial concerning both questions. To accept the infringement verdict as binding on the parties and retry only fair use would violate both the unanimity requirement and the Reexamination Clause of the Seventh Amendment."
Good point. We know that a retrial is necessary to find any infringement beyond rangeCheck. We don't know what the parameters of that possible retrial would be.
