Google v. Oracle Perspective: Google’s Android ‘Cheat Code’ was to Copy Oracle’s Code

In two months, the Supreme Court will hear the oral argument in the long-running Google v. Oracle software copyright case. At issue is the availability of copyright protection for computer programs and in particular the copyright protection of code in Oracle’s Java platform, which Google admits it copied for its Android operating system without obtaining a license. Google also claims its commercial use of that code in competition with Oracle is protected under copyright law’s fair use doctrine, but that is a subject for another day.

If adopted by the Supreme Court, Google’s arguments would undermine the Constitutional purposes and specific Congressional intent in enacting the Copyright Act, and along with them the fundamental incentives for new creative expression in software, a building block of so many consumer and industrial products. To better understand how, it helps to start at the beginning: Apple’s groundbreaking release of the iPhone.

Apple Innovated and Google Copied

In January 2007, Apple CEO Steve Jobs announced the first iPhone. It was a revolutionary product that combined cellular calling, email, touch-screen web browsing, music, and other apps that either didn’t exist on the then-dominant Blackberry handheld, or which required the combined capabilities of several different devices.

Until then, the Android operating system under development at Google was a Blackberry clone with a few more features. After Apple unveiled the iPhone, Google scrapped previous plans because it knew it was in trouble, shrewdly perceiving two realities:

• Google’s data-scraping, advertising-based business model depended on massive numbers of people using its services on the web, yet users would increasingly tap the internet via mobile devices.
• Competition among mobile devices would pivot on functionality, including the availability of third-party apps.

Google and its business partners, such as Samsung and Motorola Mobility, which it later acquired, copied many operational aspects of the iPhone. That led to extensive patent litigation. But copying Apple’s product didn’t solve all of Google’s problems. Today we take for granted that there’s an app for everything. That wasn’t so in the early days of smartphones. Apple had the early lead in apps available for its platform. Copying Apple’s code would leave Google in second place in the app market. It needed an artificial boost to catch up with Apple – a “cheat code” like the ones that give players an artificial and unearned advantage in video games. Except this was in real life and billions of dollars were at stake.

The Java code developed by Silicon Valley server and software pioneer Sun Microsystems, which Oracle acquired in 2010, was the answer Google needed.

Java, unveiled in the mid-1990s, became widely used thanks to its “write once, run anywhere” functionality that let programs run across computers based on various operating system and chip platforms. Java was easy to use and well known to programmers, who could quickly write new apps for a Java-based environment. Making Android into such a computing environment would let Google offer new apps —and thus make its platform more competitive — much faster than it otherwise could.

But Google didn’t license the code it needed from Sun, whose terms would have preserved “write once, run anywhere” and prevented Google from keeping Android proprietary. Google’s business couldn’t succeed under those strictures. It’s important to remember that Google doesn’t make and sell hardware as Apple does. It relies on its platform to collect data from users and show them commercially valuable targeted ads. If other companies could offer devices that ran apps written for Android, Google would have lost control, users, and money.

To catch up with the iPhone then, Google needed to copy key elements of Java — namely, its declaring code that programmers use to allow their apps to access pre-written code, a key efficiency shortcut. Google needed to play catch-up without taking a Java license — as some of its own technicians concluded it needed to — so it could keep Android proprietary. Every argument Google has made in the ensuing litigation has been a post-hoc rationalization of those business decisions.

The Supreme Court has seen this type of behavior before and had little patience for it. The Grokster and Aereo cases both involved companies that tried to gain a competitive advantage by infringing copyright. While the particulars of the copyright law that were at issue varied, they both involved companies that tried to engineer their systems in a way they hoped would allow them to use others’ copyrighted works without a license, in competition with the copyright owner, for their commercial advantage. In the present case, Google is trying to engineer the law to fit its copying. On the business side, its strategy already worked. The Android platform outsells Apple and Microsoft combined. And with annual revenue over $160 billion, any damage award in this case will be no more than a one-time hiccup on Google’s balance sheet. It is for the Court to decide whether to apply some measure of accountability for Google’s copying or to excuse it and weaken copyright law even more.

Copyrightability of Java’s ‘Declaring Code’

Google copied more than 11,000 lines of Oracle’s Java code to build Android. Specifically, it copied the “declaring code,” instructions that describe pre-written programs in Java. There is no dispute as to whether the copying occurred, or that it was infringing—the first jury found that it was—instead, the question is whether it was otherwise excused.

The U.S. Copyright Act protects original works of authorship. Computer code qualifies as a “work of authorship,” since the statute defines a computer program as a “set of statements or instructions” that are used “to bring about a certain result.” As the Solicitor General reminded the Court, “petitioner [Google] conceded below that both the 11,330 lines of declaring code that it copied and the SSO of the Java Standard Library satisfy the originality requirement for copyright protection.” (See page 16). That did not stop Google from later contradicting itself, trying to contest that point before the Supreme Court. (See page 10).

But Google doesn’t want to talk about that. Rather, its briefing reveals a strategy of conflating the copyrightability of the original code at issue with that code’s function. Those familiar with copyright principles will immediately recognize the error in that reasoning. Copyright protects creative expression in original works of authorship, including computer code. Copyright does not protect functions, which are the domain of patent law. This is the idea/expression dichotomy, a foundational doctrine that articulates the boundary between what copyright is designed to protect — expression — and what it does not — ideas, systems, and methods of operation. By trying to characterize code as the function it performs Google misapplies the law to reach the incorrect result it desires.

Google hinges its argument on a novel interpretation of the Copyright Act—specifically, Section 102(b), the provision that codifies the idea-expression dichotomy. Section 102(b) provides:

In 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.

Google now zooms in on the phrase “or embodied in such work,” claiming that because Oracle’s otherwise-copyrightable code embodies a method of operation, 102(b) denies copyright to the expressive code.

To understand why this is wrong, we need only look at the plain language of 102(b).

The construction of Section 102 is well-established. Subsection (a) sets the requirements for copyrightable works: they must be (1) original (2) works of authorship, and (3) “fixed in any tangible medium of expression.” Subsection (b) is the flip side, stating that copyright protection established in 102(a) doesn’t extend to ideas, procedures, or methods of operation.

Google seizes on the last five words of the section: “or embodied in such work.” It argues that expressive works that embody an idea can never be protected. This flips the text on its head: under Google’s reading, 102(b) does not just limit the reach of 102(a) to preclude ideas from protection, but undoes 102(a) to deny protection to the expression itself. Google’s approach would change Section 102, the foundation of the Copyright Act, from a pair of complementary provisions into a section at war with itself. This is the core of Google’s cheat code.

Of course, virtually all copyrightable expression embodies some idea. And computer programs are by their nature designed to produce a functional outcome when the code is processed and run. Congress even defined computer programs as works that “bring about a certain result” — copyrightable expression with an uncopyrightable functional aftermath. If function alone were enough to render the expression unprotectable, copyright for computer programs, indeed all of copyright would be swallowed up.

As Nimmer on Copyright, a widely cited treatise on copyright law, confirms, it “would, then, be a misreading of Section 102(b) to interpret it to deny copyright protection to ‘the expression’ of a work, even if that work happens to consist of an ‘idea, procedure, process etc.’” (1 Nimmer on Copyright §2.03).

Analogies in the Semiconductor Chip Protection Act

If that were not enough, the structure of the Copyright Act and legislative history further dispel Google’s claim. The Copyright Act speaks of embodiment repeatedly and in a variety of contexts:

• Architectural works can be embodied in buildings, plans, and drawings.
• Audiovisual works can be embodied in films or tapes.
• Musical works can be embodied in sound recordings and “phonorecords” — such as LPs, tapes, CDs, DVDs, and digital files.
• Works can be embodied in transmissions and material objects.

In none of those cases is the copyrightability of a work extinguished by the characteristics of “embodiment.”

Perhaps most tellingly, the Semiconductor Chip Protection Act of 1984 included a faithful recitation of the text of Section 102(b) as it applies to “mask works,” the series of images that together describe layers of a semiconductor chip (codified at 17 U.S.C. §902(c)).

Given that this enactment came just four years after the statutory changes that provided federal copyright protection to computer programs, it is particularly instructive. At least as much as computer programs, mask works have inherently functional purposes. As with computer programs, Congress saw no contradiction in providing copyright protection for their creative elements: code in the case of programs and design in the case of microchips.

House Judiciary Committee Report 98-781 on the SCPA is a conclusive rejection of the novel and unsupported position Google has put forward. On page 19, it specifically addresses the meaning of section 902(c), stating:

Section 902(c) distinguishes the subject matter of the Semiconductor Chip Protecting Act from the subject matter of the patent laws. In this regard, section 902(c) parallels section 102(b) of the Copyright Act.

It’s that simple. Section 102(b) does not create any new standards by which creative expression should be denied copyright protection. It merely says that copyright for the expression doesn’t extend to the ideas, methods of operation, procedures, and processes that may be embodied in the protected expression. Those are the purview of patent law.

And that’s why Google insists on trying to conflate the expression at issue in this case — Oracle’s declaring code — with the function that code performs when it’s run. A ruling for Google would undermine the protection for all computer programs, because they all ultimately perform a function.

Conversely, the Court can affirm that the code is copyrightable without disturbing precedent and, despite the usual apocalyptic predictions by some of Google’s amici, without broadening the scope of copyright.

Google Crossed the Line

Google, like Apple before it and Microsoft after it, is free to write its own declaring code for its mobile platform. That code can even achieve the same function as Java’s code, so long as Google writes its code independently. But Google’s business decision to copy the code as a shortcut to close ground with the innovative iPhone crossed the line into infringement.

Image Source: Deposit Photos
Copyright: AndrewLozovyi
Image ID: 236462792