In its brief filed on May 26, 2015, the US Solicitor General (SG) advised the US Supreme Court to not hear Google’s appeal of a decision, from the Court of Appeals for the Federal Circuit, holding that copyright protection extends to declaring code. Should the Supreme Court agree with the SG, it will once again refuse to add clarity to a confusing area of the law…confusion the Supreme Court helped create, by affirming (without opinion) the First Circuit’s Lotus v Borland decision almost 20 years ago.
When Android was being created, Google anticipated that software developers writing applications for Android would be familiar with the preexisting Java programming system. The Java “system” includes the Java programming language; a large set of “subroutines” of pre-written code modules enabling basic functions written in Java (such as determining if x>y); and associated “declaring code” that specifies the hierarchy of subroutines, as well as the subroutine names and requirements for inputting data to be processed by them. Java programmers were used to invoking Java subroutines by simply copying and populating (with data, such as x and y) the Java declaring code associated with the subroutines. Google copied the declaring code for a subset of Java subroutines. To be clear, Google completely re-wrote the subroutines themselves; they copied the associated declaring code to make it easier for programmers familiar with Java to invoke these subroutines.
Since 2011 courts have grappled with the question of whether or not Google’s copying of 7000+ lines of Java declaring code infringed Oracle copyrights. The law is very clear that as a general rule, computer code is copyrightable; the dispute has centered in whether or not the specific declaring code copied is eligible for protection under copyright. A lower court held the declaring code was not copyrightable, primarily because it constitutes a “method of operation” of the associated subroutines that is not protectable under US law (17 U.S.C. 102(b)). The US Court of Appeals for the Federal Circuit reversed, holding the declaring code is original and creative, and therefore entitled to copyright protection just like any other computer code, notwithstanding 102(b). It remanded the case to the lower court to consider whether or not Google’s use of the declaring code was nonetheless permissible under the “fair use” doctrine.
Google asked for the US Supreme Court to hear its appeal on declaring code copyrightability, and earlier this year the Court requested an advisory input from the SG on whether or not it should hear the case. In its brief, the SG argues that since (i) computer code is clearly copyrightable, and (ii) there is no difference in substance between the declaring code and the subroutines (both “instruct a computer to work”), the declaring code must therefore be copyrightable so long as it meets the other requirements for copyrightability, such as originality. The SG further argues that (iii) the intent of 102(b) is to limit how broadly copyright protection extends, not whether or not code is protectable in the first place, and (iv) the question of whether Google’s use of the declaring code is nonetheless permissible is best determined by proceeding with the “fair use” adjudication in the lower court.
Finally, the SG argues there is no contrary precedent of substance amongst the lower courts, and this case is so uniquely fact specific that a decision on it would be of limited value as a precedent. In 1995 the First Circuit Court of Appeals held (in Lotus v Borland) that Borland’s copying of the menu of commands of Lotus’ 1-2-3 spreadsheet program was permissible because the menu of commands constituted a “method of operation” of the underlying spreadsheet program, and thus was not copyrightable. As such, the Lotus ruling distinguished copyrightability of invoking commands, from copyrightability of the invoked code (the code that carried out the functions specified by the commands; similarly to the facts here, this code was rewritten by Borland). Lotus appealed to the US Supreme Court, which voted 4-4 to simply affirm the First Circuit decision, with no analysis or guidance.
So here we are, almost 20 years later, and the Supreme Court is being urged to once again provide no analysis or guidance regarding the scope and effect of the “method of operation” language of 17 U.S.C. 102(b). Simply put:
- the Lotus decision says that commands used to invoke subroutines (Lotus’ menu of commands) are different from the associated subroutines in terms of copyrightability, and are not eligible for copyright protection under 102(b) primarily because 102(b) says “methods of operation” are not copyrightable;
- the SG says that commands used to invoke subroutines (Java’s declaratory code) are no different from the associated subroutines in terms of copyrightability, and are eligible for copyright protection primarily because 102(b) does not define what is and is not copyrightable (rather, copyright rights cannot prevent others from practicing general “methods of operation” enabled by copyrightable code).
Which is it? The scope and effect of 102(b) has been a muddle since the Supreme Court’s affirmance (without opinion) of the Lotus decision. Refusing to hear Google’s appeal would perpetuate, rather than resolve, confusion regarding the scope and effect of 102(b)….confusion the Supreme Court helped cause.