Supreme Court Sides With Google on API Copyright

No Comments

It should also be noted that the Supreme Court also slapped down the United States Court of Appeals for the Federal Circuit (CAFC, AKA, the “Patent Court”) once again.

This time, the Patent Court big-footed the normal appellate process, it does not normally handle copyright claims, and made an egregiously bad decision, which it pretty much always does, to boot.

Once the Supreme Court noticed, it was over but for the fat lady singing.

The purpose of patents is two fold:  To encourage innovation, and to make the information contained in patents available to the public.

The patent troll friendly CAFC is doing exactly the opposite.

This time the Supreme Court ruled that using the application programming interface (API) is fair use.

An API is a series of rules which describe how a computer program is programmed, or how it interfaces with hardware, and for program compatibility, programs running on the same hardware, or the same operating system, or on a similar language.

It’s not a creative expression (copyright) but a functional description of the system, like the manual for a toaster.  The specific words in the manual are covered by copyright, but the idea that you slide a lever from left to right to set the doneness of your toast is not.

For example, we can look at a “Hello World” program in Java, where Oracle was asserting infringement: (This is also an example of why I don’t want to program in Java, it’s way to obscure and verbose)

import javax.swing.JFrame;  //Importing class JFrame
import javax.swing.JLabel;  //Importing class JLabel
public class HelloWorld {
    public static void main(String[] args) {
        JFrame frame = new JFrame();           //Creating frame
        frame.setTitle("Hi!");                 //Setting title frame
        frame.add(new JLabel("Hello, world!"));//Adding text to frame
        frame.pack();                          //Setting size to smallest
        frame.setLocationRelativeTo(null);     //Centering frame
        frame.setVisible(true);                //Showing frame
    }
}

If you want to create an application, or an operating system, which is what Google did, and allow for Java programmers to work in this without learning a completely new way of doing the same thing, then you have to use the same code words, things like “Jlabel”, “Jframe”, “setTitle”, etc. 

That’s what Google did, and what the makers of IBM clones did in the 1980s, and what third party spare parts manufacturers do when they make cheaper parts for your (increasingly computerized) car.

The Supreme Court said that it’s fair use, which is nice, but not as nice as if they had said that it was not subject to copyright:

It’s taken over a decade, but the Supreme Court has finally said that Google’s copying of the Sun Java API for Android was clearly fair use in a 6-2 ruling (Barrett did not take part since she was not on the Court when the case was heard). The background of this case is actually kind of important to understanding what just happened, so here’s a quick(ish) recap.

As you’ll probably know, this case began in 2010 when Oracle, which had just taken over Sun, sued Google for patent infringement. The patent parts were quickly tossed out and what remained was what referred to as a “sideshow” to the main event: a question about whether APIs could be covered by copyright. Pretty much all historical evidence, including an important Supreme Court ruling from the 1990s, said no, interfaces are not covered by copyright.

Oracle and friends then spent the next decade deliberately gaslighting basically everyone who doesn’t understand what an API is, and insisting that it’s the same as executable code. The district court, under Judge William Alsup, who somewhat famously taught himself Java to better understand the issues in the case (he already knew how to code and was a hobbyist programmer), correctly found that APIs are not subject to copyright as they represent a “system or method of operation” which is explicitly not covered by copyright, as per Section 102(b) of the Copyright Act.

Rather than go to the 9th Circuit (as it should have) the case went to the Federal Circuit, which hears all patent appeals. That was because the case began as a patent case, even though it no longer was. CAFC judges are somewhat infamous for never finding a patent issue they couldn’t screw up, and decided to extend that to copyright. In the ruling overturning the lower court, they made it clear that because they were code illiterate they could not understand the difference between executing code and an API, even though it’s like the difference between a novel and a dictionary.

The CAFC bigfooted the case, which is not surprising.  They also do things like change determinations of fact by the lower courts, something that is not supposed to be done by appellate courts, which are only supposed to adjudicate matters of law.

The case went back to the district court, where the jury this time sided with Google, this time saying that the use of the code was covered under fair use. That whole trial was a little weird, because reading between the lines, you could see that nearly all the arguments for why copying an API was fair use were really about why an API shouldn’t be covered by copyright at all (as per Alsup’s original ruling) and then squeezing that square peg into the round hole of fair use to make it work. Once again, however, CAFC got flummoxed by an API looking like code and overturned — which is quite crazy because CAFC had, in its first ruling, insisted that the jury should decide this issue (as a matter of fact) and then when the jury said “fair use” CAFC suddenly decided that it was a matter of law that it could overrule.

It’s taken over a decade, but the Supreme Court has finally said that Google’s copying of the Sun Java API for Android was clearly fair use in a 6-2 ruling (Barrett did not take part since she was not on the Court when the case was heard). The background of this case is actually kind of important to understanding what just happened, so here’s a quick(ish) recap.

So, basically, we have another set of incoherent, and weird rulings from the CAFC, and once it gets on the SCOTUS radar, they shoot it down.

The patent court needs to be abolished.  The argument for it, that there needs to be a court with a specialized focus on patents is simply not justified by the results.

Instead, we have an institution that is completely captured by the patent bar, and has literally allowed for the patenting of a rainy day (Bilski v. Kappos,).

Just shut them down, and reassign the current judges to traffic court.

 

Leave a Reply