Oracle's Java Case Takes Another Battering With API Ruling
A judge has ruled against Oracle in the matter of whether application programming interfaces are copyrightable, laying to rest a question the jury couldn't answer. The company's case against Google over Java failed to prove patent violation allegations and has won what appears to be only a small victory in the arena of copyrights. Oracle says it will appeal.
With a ruling from United States District Judge William Alsup that application programming interfaces (APIs) cannot be copyrighted, it appears Oracle's lost yet another battle against Google over Java.
However, the war is not over. Oracle has indicated it will appeal, and the judge has indicated that Oracle should turn to patent laws in order to protect the Java APIs.
Further, the nine lines of Java code Google was found to be responsible for having used in Android could cost it well over the US$1 billion in damages Oracle had originally sought.
The judge ruled Google will have to pay statutory damages not exceeding $150,000. However, that sum "is the maximum for each inappropriate instance of copyright infringement under statutory damages," Raymond Van Dyke, a Washington, D.C.-based technology and IP attorney, told LinuxInsider. "With millions of smartphones using the adapted code, the cost could be huge if these statutory damages accrue."
Going Back to War
"Presumably [Oracle] can bring in additional evidence [for the appeal]," Al Hilwa, a program director at IDC, told TechNewsWorld. "I don't think this case was APIs being patentable. It definitely was about whether these specific APIs are copyrightable."
APIs might be copyrightable in certain situations, Hilwa suggested. "I personally think that, in the end, whether APIs are copyrightable depends on the complexity and creativity embedded in them."
The Judge's interpretation "is open to further scrutiny," Van Dyke said. "Copyright law covers the exact copying of a work or portion thereof and any copying or adapting that is substantially similar. Adapting copyrighted Java interface codes for a related use may not remove the adaptation from the aegis of copyright. The amount of original code left is a key consideration, since derivative works are also deemed within the original owner's control."
Oracle spokesperson Deborah Hellinger declined further comment.
The high-tech industry "will try to understand from the ruling what can be applicable to other specific situations," Hilwa continued. The Oracle-Google lawsuit "may embolden other companies to duplicate what Google is doing, namely to fork Java without calling it 'Java.' In the long run, this may hurt the Java brand as it would fragment further."
Elements of the Case
The complexities of the case led the judge to break it up into three phases. The first dealt with copyrightability, copyright infringement and equitable defenses. The second looked at patent infringement. The third, and final phase, was set to deal with damages, but it was obviated by stipulation and verdicts.
All parties agreed that Google had not literally copied the software but had, instead, come up with its own implementations of the 37 APIs in question. Oracle's main claim was that Google had replicated the structure, sequence and organization of the overall code for these APIs.
Put another way, if the APIs were essays, Oracle contended that Google had used the same essay structure, put the sentences in the same sequence, and organized the thoughts in the same way.
In the first phase, the jury found that Google had infringed copyright but deadlocked on whether or not that was covered by the fair use doctrine. Only nine lines of code, called "rangeCheck," had infringed copyright.
In phase two, the jury found no patent infringement across the board.
What the Ruling Stated
The latest ruling looked at whether the elements Google had replicated in Java were protectable by copyright in the first place. It relied on general principles of copyright law announced by Congress, the Supreme Court and the Ninth Circuit.
The judge found that, under the rules of Java, the declaration and method header lines of a method must be identical to another in order to declare a method specifying the same functionality as the first, even when the implementation is different. When there's only one way to express an idea or function, then everyone is free to do so and no one can monopolize that expression.
Further, the names in Java are actually symbols in a command structure. This command structure is a system or method of operation under Section 102(b) of the Copyright Act and, therefore, cannot be copyrighted. Duplication of the command structure is necessary for interoperability.