Appeals Court Doesn't Understand The Difference Between Software And An API; Declares APIs Copyrightable

Copyright

from the total-failure dept

We sort of expected this to happen after the appeals court for the Federal Circuit (CAFC) held its oral arguments back in December, but CAFC has now spit at basic common sense and has declared that you can copyright an API. As we noted, back when Judge William Alsup (who learned to code Java to better understand the issues in the case) ruled that APIs were not subject to copyright protection, his ruling was somewhat unique in that it was clearly directed as much at an appeals court panel who would be hearing the appeal as it was at the parties. Alsup rightly suspected that the judges on the appeal wouldn’t actually understand the issues as well as he did, and tried to break it down clearly for them. Unfortunately, the three judge CAFC panel did not pay attention. The ruling is so bad that legal scholars are suggesting that it may be as bad as the horrific ruling in the Garcia case.

It’s tragic that this case ended up before the CAFC. It shouldn’t be there. It should be before the 9th Circuit (who issued the Garcia ruling, so it’s not like they’re particularly good either…), but because this case started out as a patent lawsuit, even if the patent stuff went away early, the appeals went to CAFC. CAFC is already famous for its maximalist bent on patents, and so it’s perhaps not too surprising that it takes a similar view towards copyright. Or, as law professor James Grimmelmann astutely notes: “Is there any body of IP law that the Federal Circuit hasn’t done its best/worst to screw up?” The answer, James, may be publicity rights. But, give them a chance and we’ll see what it can do there too…

As for the ruling itself… well… it’s bad. The court seems to not understand what an API is, confusing it with software functionality. It also appears to misread Judge Alsup’s ruling, thinking that he’s mistakenly using a fair use analysis to determine whether or not something is copyrightable. But that was not the basis of Judge Alsup’s ruling. He very specifically noted that the “command structure is a system or method of operation under Section 102(b) of the Copyright Act and, therefore, cannot be copyrighted.” The CAFC panel doesn’t seem to understand this at all. In case you’re not readily up on your Section 102 knowledge, it covers what is copyrightable subject matter, and (b) is pretty explicit:

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.

Got that? Well, CAFC doesn’t seem to get it. At all. They basically seem to think that because the API is “big” it must therefore be copyrightable as a “literary work” even though — as Alsup rightly pointed out — it’s nothing more than a “system or method of operation” which 102(b) clearly states is uncopyrightable. And yet, CAFC spends many pages arguing how an API is not unlike a “literary work”, ignoring its intent and purpose. CAFC argues that the various names that Sun/Oracle used for naming things in the API are subject to copyright because they’re “creative.” Yet, as Grimmelmann against notes, if that’s the case, Brian Kernighan should sue Oracle for its “copying” of his creative choices in “int,” “short,” “long”, “float”, “double”, and “char.”

The original ruling pointed to the ruling in Lotus v. Borland, which found that pull down menus in an app weren’t copyrightable. But here, the CAFC rejects this (in part) by saying that a big difference is that the “source code” wasn’t copied. But in that case, the menu structure and names were copied — which is basically the same thing that was copied from the Java API. But the CAFC judges don’t even seem to realize that.

It seems fairly clear that the CAFC judges don’t understand the difference between an API and software. And thus they make a decision that makes no sense. There is no distinction recognized when it comes to the functionality of an API and how it’s entirely different than the purpose of the software itself. This is especially clear towards the end, in which the CAFC ruling misrepresents some discussions on whether certain functionality is best protected by patents or copyright. But the problem is that they misinterpret statements people are making about APIs, thinking that those statements were made about software as a whole. This is just a flat-out fundamental misunderstanding of what an API is, assuming that it’s just software. Take the following example:

Many of Google’s arguments, and those of some amici, appear premised on the belief that copyright is not the correct legal ground upon which to protect intellectual property rights to software programs; they opine that patent protection for such programs, with its insistence on non-obviousness, and shorter terms of protection, might be more applicable, and sufficient.

But that’s not true. No one is arguing that patents are more suitable overall for software. In fact, many in the software field have long argued the exact opposite. What they’re saying is that copyright is inappropriate for APIs — but the CAFC judges don’t seem to be able to distinguish between APIs and software. In fact, they’re so confused that they throw a bogus parenthetical “software” before “interfaces” in quoting Google:

Google argues that “[a]fter Sega, developers could no longer hope to protect [software] interfaces by copyright . . . Sega signaled that the only reliable means for protecting the functional requirements for achieving interoperability was by patenting them.”

Note that “[software]” thrown in before interfaces? Google is talking about whether APIs — “application programming interfaces” — are copyrightable. Not whether or not software is copyrightable. And yet the CAFC doesn’t even seem to realize this. Ridiculously, CAFC then uses its own misunderstanding and misquote, and points to some of the (many) arguments where people argue that patents are inappropriate for software to dismiss Google’s argument about APIs. It honestly doesn’t realize that it’s comparing two totally different things. What lots of people agree on: software shouldn’t be patentable and APIs shouldn’t be copyrightable, but software can be copyrightable and API functionality may be patentable. But by confusing APIs and software, CAFC totally misreads both arguments.

This is a disaster all around. Of course, it’s not over yet. Google can (and likely will) seek a review of this ruling, either en banc or by petitioning the Supreme Court. And even if that doesn’t happen, the CAFC ruling tosses it back down to the district court for an entirely new battle about whether or not — if the API is covered by copyright — Google’s use was fair use. So, there are still a few more years (and many more millions) to be thrown at this before there’s any real conclusion. In the meantime, CAFC has mucked up another form of intellectual property law through a basic (and near total) misunderstanding of technology.

Filed Under: api, cafc, copyright, java, patents, software
Companies: google, oracle, sun