Hot Take: Google v Oracle

[jducoeur]

Spreading the word for the other software-law geeks: the decision has come down on Oracle v Google, and it went the right way.

Summarizing very briefly (and possibly a little inaccurately -- IANAL, and I haven't read the ruling in detail yet): the Android phone operating system, like a large fraction of the software world, is more or less built on top of the Java Virtual Machine, which was invented by Sun decades ago and bought by Oracle. Google decided to reimplement the API for the JVM to suit their needs -- basically, providing a new implementation for the existing interface. This is totally normal (there are lots of reimplementations of parts of the JVM), but Oracle asserted that the API is their intellectual property, and sued.

(Note that pretty much everyone agrees that the implementation -- the code itself -- is copyrightable. The question was about the interface -- essentially, how you call that implementation from other code. If the interface is protected by copyright law, it becomes a legal minefield to try to write compatible, alternate implementations.)

Suffice it to say, the lower courts went with Oracle, and much of the industry has been on tenterhooks ever since. A lot was riding on this -- if Oracle had won, it would have tossed an enormous spanner into the software industry, and probably done a lot of damage to smaller companies. (Among other things, Querki's user interface is based on Scala.js, which necessarily reimplements a fair chunk of the JVM API. It's unclear whether Scala.js would have been able to survive if Oracle had won; in turn, that could have destroyed my company.)

The implication here, I believe, is that reimplementing APIs is now officially considered fair use, so the law matches the way the software industry has generally assumed things should work. So while on the one hand, this seems like an obscure technical point that most people don't care about, for those of us in the field it is extremely important, and really good news.

So yay for the Supreme Court for getting this one right...

Comments

[squirrelitude]

The thing that stands out from an *extremely* quick skim of the decision is that they've determined that this is a successful fair use defense. I think that means that they've determined that copyright holds for the API, but that a use of that API in implementing it can be defended under fair use.

This would be a middle ground sort of thing -- Oracle could still sue on the basis of copyright infringement, and the defendant would have to build a case around fair use, rather than just having the suit thrown out immediately or having Oracle bearing the burden of proof. So that kind of sucks, but it should cut down on a lot of potential cases, and this case should serve as a fairly straightforward template for any such defense.

...but I Am Not A Lawyer either, so I'm curious to see what the Actual Lawyers write about it. I follow Kyle Mitchell and Heather Meeker's blogs and I imagine they'll have something to say.

[hudebnik]

I just read most of the majority opinion, and a little bit of Thomas-and-Alito's dissent. The majority opinion says basically "we're going to assume for the sake of argument, without actually asserting, that an API is copyrightable, and concentrate on the fair-use question. [pages of argument omitted] Since we find there was fair use, we don't need to address the copyrightability question."

The dissent, rather oddly (to me; IANAL), criticizes the majority for skipping over the question of copyrightability, and spends some time asserting that an API is copyrightable. It then claims that Google's use was "anything but fair"; I haven't waded through their reasoning for the latter claim.

Anyway, yay! Not because I work at Google, but because I'm a software engineer who appreciates the idea that one interface can have many different implementations.

[squirrelitude]

Ahhh, OK! So they didn't really rule on copyrightability at all. That's very SCOTUS, isn't it. :-)

While I'd like them to say an API isn't copyrightable, I'll settle for this -- it's strictly an improvement, if only incremental.

[hudebnik]

I'm not sure about that. API design does require a significant creative effort, with a set of skills almost disjoint from those involved in implementation, so one could reasonably say it's a "form of expression" in its own right.

However, the whole purpose of API design is to allow people on one side to use it without worrying about implementation, and people on the other side to implement it without worrying about who's going to use it, so I would argue that anybody doing either of those things has a reasonable claim of "fair use".

What would not be "fair use" is copying it and representing it as your own work, or copying it with significant unauthorized changes and attributing the modified version to the original author.

[danabren]

or copying it with significant unauthorized changes and attributing the modified version to the original author.

The legal requirement for modification without violation of copyright is 10%. Which can be a modest visual amount in the clothing/prop/art world, but would likely be a larger effort in ratio for something like this.

Not 10%

[metageek]

There is no percentage below which copying is fair use, and it certainly isn't 10%—if it were, Oracle would have had no case, since the interface code Google copied was under 1% of the Java code.

Fair use depends on four factors. One of them is how much was copied, but there's no bright line; courts have to decide subjectively. The others are: the purpose and character of the new work (some purposes are special, like education; and, if the character of the new work is different enough from the original, it's considered transformative, which is a help); the nature of the original work (the more creative, the more protection); and whether the new work diminishes the market for the original.

In this case, the Court decided that the amount of copying was tiny, Android was substantially different from Java 2 Standard Edition, the API that was copied was more functional than creative, and Android didn't interfere with the market for Java. (This last seems odd: Sun did have a version of Java for cellphones, Java 2 Micro Edition, and it was possible to buy J2ME apps, until the rise of Android and the iPhone killed it off. I gather the Court decided that wasn't substantial, maybe because J2ME was never a large part of the Java market.)

[squirrelitude]

I would agree that creation of an API involves creative effort. I'd certainly agree that the original author should retain attribution rights, even if other parts of the bundle we call "copyright" are not reserved. There's also all the documentation of the API, which would of course be a separate matter—and a significant creative work of its own. (And an API means nothing without its documentation.)

However, I would argue that the bare listing of API endpoints/methods/names is like the numbers in a phone book -- a collection of facts, as in Feist Publications, Inc., v. Rural Telephone Service Co.. What are they facts about? The API documentation, of course. :-)

[dsrtao]

Most of the good stuff came up from William Alsup's opinions in the District Court. He spent a significant amount of time teaching himself programming in order to fully understand what an API is, came to a correct understanding, then wrote that into his opinions.

That gets quoted a lot in the SC decision, and then Breyer messed it up a bit but basically agreed with it.

All points to Alsup. https://en.wikipedia.org/wiki/William_Alsup#Notable_cases

[cellio]

That's an impressive investment from Alsup. Well done!