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.

[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