So, this was a big win for Google, especially given the damages Oracle was seeking. But it was a costly win. It was expensive to have a trial, and it was particularly expensive to have this trial. But it is also costly because it leaves so little answered: what happens the next time someone wants to do what Google did? I don't know. Quite frankly, I don't know how often people make compatible programs already, how many were holding back, or how many will be deterred.
Google did this a long time ago thinking it was legal. How many others have done similar work that haven't been sued? Given how long has it been since Lotus v. Borland quieted things, has the status quo changed at all? My thoughts after the jump.
Some of my colleagues think the status quo changed because the Federal Circuit got the law of copyrightability wrong. For them, merger should play a much bigger role in copyrightability and it's really important to them that API's be considered uncopyrightable because function merges with expression.
I'm not so sure merger is to be so broadly interpreted. Sure, for an API called "Open" you'll have merger - there are few choices for that expression. But for a large, complex set of APIs, there are surely lots of ways to express the function. For me, the question is copyrightability - is there de minimus creativity that allows someone to own the expression without owning the function? The answer is an obvious yes. You could make a program with APIs like Java using expression different than Java. I am as sure today as I was two years ago that the Federal Circuit got that question right, certainly under prevailing 9th Circuit law.
(Yes, I know there's a method of operation argument as well, but for similar reasons, I think you can practice the method of operation without copying the expression. This isn't a play button or even a simple menu structure. In any event, the 9th Circuit hasn't adopted Lotus v. Borland so clearly anyway).
But that doesn't end the analysis - and here some of my colleagues are reluctantly (some less reluctantly) embracing something I've been saying for at least two years, and more like fifteen. It's not the copyrightability question that matters, it is whether or not we allow reuse. And that's an infringement question (or, as some of my colleagues put it in different theoretical terms, a scope question). As I quote below, the Sega case in the 9th Circuit makes clear that this is an infringement question, and not a copyrightability question. If you listened to oral argument (and read the opinion), you'll hear both the advocates and the court get this point wrong. Google argued that Sega was about 102(b) and non-copyrightability. The court basically ruled that Sega was about fair use (it was, of course, but not the operative quote).
So, my final thought on the jury verdict remains the same as it was two years ago: there never should have been a jury verdict. The court should have ruled that as a matter of law, on these facts, this type of use of an API does not constitute infringement. Whether you get there through abstraction/filtration, thin copyright, privilege, or even presumptive fair use, this should have been an easy question. My regret for the posture that this case was decided and went up on appeal is that it was so focused on copyrightability. That was the wrong question to look at, and it wound up doing a disservice to software developers everywhere, because even though Google won this time, you don't know what will happen next time.
[Edited to add this link to an op-ed at Ars Technica by counsel for Oracle arguing that this ruling will somehow kill open source and the GPL. The comments do a fine job of debunking this specious claim, such as pointing out that the APIs may be copied even if the underlying implementation cannot, that Oracle winning would have been way worse for free and open software, and that the Free Software Foundation came out in favor of a fair use finding once the copyrightability battle was lost.]
And now, my thoughts from the last time around, which I think are as pertinent today as they were then:
Two years to the day since my last blog post on this subject, the Federal Circuit has reversed Judge Alsup’s ruling that the Java API (the list of function and variable -a/k/a parameter- names) is uncopyrightable. The Federal Circuit held that the structure, sequence, and organization of the APIs renders them sufficiently original and non-functional to be copyrightable. As such, the case is remanded to determine whether there is fair use by Google in using them wholesale to make Android.
For more background, see my prior post.
The problem with this ruling is twofold. First, it is surely correct. Second, it is surely wrong. Why is it correct? Because structure, sequence, and organization can be creative. This has long been true, and well should be. I won’t relitigate that here, but holding that these APIs were simply not copyrightable was a stretch in the 9th Circuit, and the Federal Circuit is correct to say so.
Why is it wrong? Because Google should surely be privileged to do what it did without having to resort to fair use. The court says: “We disagree with Google’s suggestion that Sony and Sega created an ‘interoperability exception’ to copyrightability.”
It is here that framing is important. The court’s statement is accurate; we don’t get rid of copyrightability just to allow interoperability. But Sega is crystal clear that we do allow interoperability reuse: “To the extent that a work is functional or factual, it may be copied,Baker v. Selden, as may those expressive elements of the work that ‘must necessarily be used as incident to’ expression of the underlying ideas, functional concepts, or facts….” This is not the merger doctrine that the court applied, but rather a defense to infringement.
In short, this should have been an abstraction-filtration-comparison case, and the Federal Circuit makes clear that Judge Alsup did not perform that analysis. The appeals court also makes clear that if the APIs are directly taken, you can jump directly to filtration, but this does not mean you need to hold the APIs uncopyrightable in order to filter them out in the infringement analysis. Instead, Oracle gets its copyright, and Google gets interoperability. It is here that the appellate decision misses the boat.
I hate to be critical after the fact, but this case should never have gone to the jury. It should have been decided as a non-infringement summary judgment case pre-trial where Oracle kept its copyright but infringement was denied as a matter of law due to functional reuse. Maybe that would have been reversed, too, but at least the framing would have been right to better support affirmance.
May 12, 2014 update: Two commenters have gone opposite ways on Sega, so I thought I would expand that discussion a bit:
Sega is about intermediate copying fair use, yes. But that intermediate copying was to get to the underlying interoperability. And I quote the key sentence from Sega above – even if that functionality is bound up with expression (as it is in this case), we still consider that a privileged use (and thus a worthy end to intermediate copying, which is not a privileged use).
Now, in this case, we don’t need to get to the intermediate copying part because the interoperability information was published. But the privileged use that allowed the intermediate copying didn’t suddenly go away simply because Google didn’t have to reverse engineer to expose it. So, so say Sega doesn’t apply because it is a fair use case completely misunderstands Sega. The fair use there was not about fair use of the APIs. That use was allowed with a simple hand wave. The fair use was about copying the whole program to get to those APIs, something that is not relevant here. So sending this case back for a fair use determination is odd.
That said, Sega pretty clearly makes the use a defense to infringement, rather than a 102(b) ruling that there can be no copyright.