Between the advents of mobile computing and the Internet of Things (IoT), the API is rapidly becoming the most important leverage point in the history of computing. Few, if any, profoundly scalable innovations are able to fully deliver on their potential without the employment of APIs. A possible threat has emerged in the form of the court case Oracle America, Inc. v. Google, Inc. centered on Oracle’s claim that their Java APIs are copyrightable.
At an APIcon panel discussing the U.S. Appellate Court's ruling that APIs are copyrightable (video embedded below), PW editor in chief David Berlind captured one of the more likely consequences to the now-burgeoning API economy should the courts ultimately rule that APIs are copyrightable. He broached the question that if one pattern or best practice, like that of each of the 37 Java APIs in question, are subjected to copyrighting, then are all API patterns subjected to that same copyrighting? He pointed out that the API industry is working toward repeatable best practices, so the technology behind one API could then be used to create the next ones. Should this happen, Berlind contends that “If one pattern can be copyrighted and the copyright holder chooses to protect that pattern, well then, if we can’t repeat that pattern, if we can’t repeat our best practices, then what ends up happening is we design APIs to work around a copyright and we end up in a place of friction that inhibits the growth of the industry and inhibits developer’s frictionless access to APIs.”
To the extent that Oracle’s lawsuit against Google could set a precedent for API copyrightability, the potential of APIs as well as the fate of the API economy now lies in the hands of the U.S. Supreme Court who will decide this week whether to hear Oracle America, Inc. v. Google, Inc., or remand it back to a lower court.
Oracle v. Google: An Overview
It all started when Java was just a mere teenager back in November 2007 when Google released the beta version of its Android mobile platform, which included the use of application programming interfaces or APIs built with the standard edition Java Platform (J2SE).
Then in January 2010, Oracle Corporation acquired Sun Microsystems for more than $7 billion. The renamed Oracle America, Inc. officially became the owner of the Java programming language and its licensing.
In August 2010, Oracle first sued Google for copyright and patent infringement. The U.S. District Court for the Northern District of California split the case into three parts:
The crux of the case was (and still is) copyright, infringement, and fair use. Despite the fact that Sun open-sourced J2SE (among other Java assets) in 2006, Oracle alleged infringement of 37 Java APIs and API documentation. This first trial began in April 2012. The jury found that yes, the Java API had been infringed, but could not determine if Google had a reasonable claim that it was fair use.
Fair use is legally defined by these four factors:
- purpose and character of the use
- nature of the copyrighted work
- amount and substantiality of what is used
- effect on the potential market
Next, in May 2012, the same jury reviewed the patent portion of the dispute, which covered two parts:
- Patent #US6061520: “An improvement over conventional systems for initializing static arrays by reducing the amount of code executed by the virtual machine to statically initialize an array.” Google countered that they had been parsing to optimize static initialization, not simulating that execution, as Oracle contended.
- Patent #USRE38104: This covers the method and apparatus for resolving data references in code. Google countered that the code they used didn’t include the “symbolic reference” that is the basis of the patent.
The jury found that Google had copied nine sections of code called rangeCheck, but neither the documentation nor the literal code was infringed. In general, the U.S. District Court judge ruled that the Java APIs weren’t protected by copyright in this particular circumstance. This ruling was really narrow, meaning that it should only count for this particular case and the 37 Java APIs discussed, not to set policy or influence other rulings.
The U.S. District Court acknowledged that the overall structure of Oracle’s API packages is creative, original, and resembling a taxonomy, which could allow it to qualify for copyrightability. However, the court found that the Java API “is nevertheless a command structure, a system or method of operation — a long hierarchy of over six thousand commands to carry out pre-assigned functions,” deciding it was not entitled to copyright protection under Section 102(b) of the Copyright Act.
So Google was responsible for a small portion, but “Still, it will be seen as a victory by many in the software industry, who feared that a ruling in favor of Oracle would stifle innovation in the software industry,” wrote Network World in its assessment of this result.
But, it didn’t stop there. Oracle agreed to accept zero statutory damages — which would have been around a few hundred thousand dollars — because it was going to appeal the decision, as it was seeking up to $6.1 billion.
Oracle then appealed the majority of the U.S. District Court’s judgment, while Google cross-appealed regarding the rangeCheck code and eight decompiled files.
On May 9, 2014, three judges from the U.S. Federal Court of Appeals released their 69-page decision after hearing both sides:
“Because we conclude that the declaring code and the structure, sequence, and organization of the API packages are entitled to copyright protection, we reverse the district court’s copyrightability determination with instructions to reinstate the jury’s infringement finding as to the 37 Java packages. Because the jury deadlocked on fair use, we remand for further consideration of Google’s fair use defense in light of this decision. With respect to Google’s cross-appeal, we affirm the district court’s decisions: (1) granting Oracle’s motion for JMOL [Judgment as a Matter Of Law] as to the eight decompiled Java files that Google copied into Android; and (2) denying Google’s motion for JMOL with respect to the rangeCheck function. Accordingly, we affirm-in-part, reverse-in-part, and remand for further proceedings. “
To summarize, the Federal Appeals Court:
- Reversed the main decision, deciding that the 37 Java APIs could indeed be copyrighted and were infringed.
- Sent the “fair use” portion of the case back to a lower court for them to make a decision this time.
- Affirmed that Google was at fault regarding those nine pieces of rangeCheck code.
Not surprisingly, in October 2014, Google filed a petition to the U.S. Supreme Court on this basis:
“Congress specified that ‘original works of authorship’ are generally eligible for copyright protection, 17 U.S.C. § 102(a), but ‘[i]n no case does copyright protection for an original work of authorship extend to any idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described, explained, illustrated, or embodied in such work’.”
As the U.S. Supreme Court is winding down its season, offering its last opinions, and setting the docket for the 2015-2016 season, it should reveal by the end of June 2015 if it will take this case. If it does not, the Federal Appeals Court ruling on the Java APIs will stand; however the fair use case will still head back down to the lower courts for a clearer decision.
If the Supreme Court does take this case, about a year from now, they will be releasing a decision that will affect the future of the software industry.
Continue on page 2.