Unless you’ve completely unplugged from the news, you probably are aware that the long-running feud between Oracle and Google had a new court decision this week. An appeal court found that Google’s excuse of fair use wasn’t acceptable and that they did infringe on Oracle’s copyrights to Java. Oracle has asked for about $9 billion in damages, although the actual amount is yet to be decided. In addition, it is pretty likely Google will take it up to the Supreme Court before any actual judgment is levied.
The news is aimed at normal people, so it is pretty glossy about what exactly happened. We set out to try to make sense of it all. We found a pretty good article from [Michaela Barry] about what the courts previous found. There were three main parts:
- There were 37 API (Application Programming Interface) declarations taken verbatim from Java. This would be like a C header file if you aren’t familiar with Java.
- Google decompiled 8 security files and used them.
- The rangeCheck function — 9 lines of Java code — were exactly the same in Oracle’s Java and Android.
Google’s argument was that this is fair use, which has a specific legal definition. Here at Hackaday, we aren’t lawyers, so we’ll let you look up that definition yourself. However, paraphrasing [Judge Potter Stewart], “we may not be able to define fair use, but we know it when we see it.”
Decompiling the security files does seem to be a bit much. There might be some case to be made there. However, the idea that creating an API that conforms to another API is an infringement is pretty scary. Linux, for example, offers a similar API to Unix (or POSIX). There is a long history of APIs per se not being intellectual property.
As for the rangeCheck function, it is true that it appears to be a copy. However, if you look at the code, it is pretty laughable to think it is stealing anyone’s secrets:
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);
}
We could think of other names for arrayLen, fromIndex, and toIndex, but the implementation is pretty obvious, don’t you think?
This hasn’t been a simple case. One court finds for Google then the next finds for Oracle. We suppose you could take the opposite tack. If you spent years building a super API for some purpose, why can’t you protect it? Somehow, though, that just doesn’t seem right. Maybe it is like the [Potter Stewart] quote. If you copyright your API to take an array and multiply it by 10, that seems like you shouldn’t be able to protect it. But we could imagine some intricate and logical API that we might feel could be intellectual property. We can’t think of any off hand, but we could imagine it.
In a further twist, the original case had a patent component that was successfully refuted. However, the court that made this week’s ruling normally would not hear a copyright case and only heard this one because of the patent component that was no longer under contention.
Incidentally, at least some of the Java code was covered by the GNU Public License. However, Google’s code — at least parts of it — fell under an Apache Open License which is apparently more permissive and incompatible. The $9 billion figure stems from Oracle’s assertion that Google killed demand for their Java mobile product.
We expect a lot of comments on this. Are your APIs your intellectual property? Or are they like mathematical formulae or algorithms and inherently not subject to copyright? If they are, how do you stop big companies (or small companies with legal resources) from gobbling up the software landscape with endless trivial APIs and killing everyone with lawsuits?
No comments:
Post a Comment