Thursday, May 31, 2012

Judge Alsup Rules that Java APIs Are Not Copyrightable

In the well-publicized Oracle v. Google case, Judge Alsup has ruled that Java APIs are not copyrightable, at least to the extent of Google's limited use of the APIs in Android.  Judge Alsup relied on the Lotus v. Borland case I worked on many years ago, and other similar cases, to reject Oracle's copyright claim.  Since a jury ruled that Google didn't infringe the two Oracle patents being tried, that leaves Oracle with a minimal damages claim for a few lines of code (not related to the API claim).  Techdirt's writeup of this decision is here; EFF's post is here; Eric Goldman's post (by Tyler Ochoa) is here.

Some key points of Judge Alsup's ruling are as follows:

In view of the foregoing, this order concludes that our immediate case is controlled by these principles of copyright law:
• Under the merger doctrine, when there is only one (or only a few) ways to express something, then no one can claim ownership of such expression by copyright.
• Under the names doctrine, names and short phrases are not copyrightable.
• Under Section 102(b), copyright protection never extends to any idea, procedure, process, system, method of operation or concept regardless of its form. Functional elements essential for interoperability are not copyrightable.
• Under Feist, we should not yield to the temptation to find copyrightability merely to reward an investment made in a body of intellectual property.

As long as the specific code written to implement a method is different, anyone is free under the Copyright Act to write his or her own method to carry out exactly the same function or specification of any and all methods used in the Java API. Contrary to Oracle, copyright law does not confer ownership over any and all ways to implement a function or specification, no matter how creative the copyrighted implementation or specification may be.  The Act confers ownership only over the specific way in which the author wrote out his version.  Others are free to write their own implementation to accomplish the identical function, for, importantly, ideas, concepts and functions cannot be monopolized by copyright.

Much of Oracle’s evidence at trial went to show that the design of methods in an API was a creative endeavor. Of course, that is true. Inventing a new method to deliver a new output can be creative, even inventive, including the choices of inputs needed and outputs returned.  The same is true for classes. But such inventions — at the concept and functionality level — are protectable only under the Patent Act. The Patent and Trademark Office examines such inventions for validity and if the patent is allowed, it lasts for twenty years. Based on a single implementation, Oracle would bypass this entire patent scheme and claim ownership over any and all ways to carry out methods for 95 years — without any vetting by the Copyright Office of the type required for patents. This order holds that, under the Copyright Act, no matter how creative or imaginative a Java method specification may be, the entire world is entitled to use the same method specification (inputs, outputs, parameters) so long as the line-by-line implementations are different. To repeat the Second Circuit’s phrasing, “there might be a myriad of ways in which a programmer may . . . express the idea embodied in a given subroutine.” Computer Associates, 982 F.2d at 708. The method specification is the idea. The method implementation is the expression. No one may monopolize the idea.

To carry out any given function, the method specification as set forth in the declaration must be identical under the Java rules (save only for the choices of argument names). Any other declaration would carry out some other function. The declaration requires precision.  Significantly, when there is only one way to write something, the merger doctrine bars anyone from claiming exclusive copyright ownership of that expression. Therefore, there can be no copyright violation in using the identical declarations. Nor can there be any copyright violation due to the name given to the method (or to the arguments), for under the law, names and short phrases cannot be copyrighted.

In sum, Google and the public were and remain free to write their own implementations to carry out exactly the same functions of all methods in question, using exactly the same method specifications and names. Therefore, at the method level — the level where the heavy lifting is done — Google has violated no copyright, it being undisputed that Google’s implementations are different.

Interoperability sheds further light on the character of the command structure as a system or method of operation. Surely, millions of lines of code had been written in Java before Android arrived. These programs necessarily used the java.package.Class.method() command format. These programs called on all or some of the specific 37 packages at issue and necessarily used the command structure of names at issue. Such code was owned by the developers themselves, not by Oracle. In order for at least some of this code to run on Android, Google was required to provide the same java.package.Class.method() command system using the same names with the same “taxonomy” and with the same functional specifications. Google replicated what was necessary to achieve a degree of interoperability — but no more, taking care, as said before, to provide its own implementations.

In closing, it is important to step back and take in the breadth of Oracle’s claim. Of the 166 Java packages, 129 were not violated in any way. Of the 37 accused, 97 percent of the Android lines were new from Google and the remaining three percent were freely replicable under the merger and names doctrines. Oracle must resort, therefore, to claiming that it owns, by copyright, the exclusive right to any and all possible implementations of the taxonomy-like command structure for the 166 packages and/or any subpart thereof — even though it copyrighted only one implementation. To accept Oracle’s claim would be to allow anyone to copyright one version of code to carry out a system of commands and thereby bar all others from writing their own different versions to carry out all or part of the same commands.  No holding has ever endorsed such a sweeping proposition.

Monday, May 7, 2012

Darth Seder!

MAD Magazine Helpfully Explains Why "The Avengers" Made $200 Million Opening Weekend

Phase One Verdict in Oracle v. Google, and It's a Mess

The Oracle v. Google case is being tried in San Francisco federal court.  The jury came back this morning with a partial verdict on Oracle's copyright claim (phase one).  Oracle claimed that Google infringed the APIs (Application Program Interfaces) in the Java language.  The jury decided that Google infringed the "overall structure, sequence and organization" of the APIs, but did not reach a verdict of whether this is fair use or not.  It is highly debatable whether API's are copyrightable at all -- the Judge will have to decide that -- and the jury's failure to decide fair use creates a real mess.  Articles by Techdirt and Ars Technica describe the mess.  Update: Here's EFF's post on the verdict.