Skip to comments.Appeals Court Doesn't Understand Difference Between Software And An API; Declares APIs Copyrightable
Posted on 05/12/2014 1:55:35 PM PDT by ShadowAce
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."
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.
Excuse me while I go patent and copyright some system calls....
An API library is software. So it fits with copyrighting software so nothing wrong there. I just think there is a lot of software that’s copyrighted or part of an IP package that doesn’t do anything unique or non-intuitive.
What is an API? What is it an abbreviation for?
Application Program(mable) Interface. You see these two versions out there. And yes, it is software and patentable.
“In computer programming, an application programming interface (API) specifies how some software components should interact with each other.
In addition to accessing databases or computer hardware, such as hard disk drives or video cards, an API can be used to ease the work of programming graphical user interface components. In practice, many times an API comes in the form of a library that includes specifications for routines, data structures, object classes, and variables. In some other cases, notably for SOAP and REST services, an API comes as just a specification of remote calls exposed to the API consumers.
An API specification can take many forms, including an International Standard such as POSIX, vendor documentation such as the Microsoft Windows API, the libraries of a programming language, e.g., Standard Template Library in C++ or Java API. Web APIs are also a vital component of today’s web fabric. An API differs from an application binary interface (ABI) in that an API is source code based while an ABI is a binary interface. For instance POSIX is an API, while the Linux Standard Base is an ABI.”
“An API library is software. So it fits with copyrighting software so nothing wrong there.”
Nope. An API is NOT software. An API is a specification, like the list of ingredients in a cake. A list of cake ingredients IS NOT copyrightable, though a specific, written recipe that lists the ingredients IS copyrightable.
Likewise, a software library that implements an API IS copyrightable.
So, ideas are not copyrightable, but implementations of ideas rendered in terms of media ARE copyrightable.
This is an insane ruling.
True. If software is subject to copyright, then an API should as well.
One thing that you're missing, however, is that copyright protects an expression from being copied, not any form of functionality. Ergo, it is perfectly okay for software not to do "anything unique or non-intuitive," or even work, to be copyrighted.
Further, a person who re-creates an API from scratch and without accessing the original API violates no copyright even if the code is 100% identical. That said, the likelihood of 20 lines of independently designed code being identical is highly remote.
Just, FYI, I am an IP attorney.
One could say the same of medicine, energy, farming, forestry, or any older sector of American industry that has been systematically stifled by government.
Software had a good run - it left government so baffled for nearly 50 years that it remained free to grow with little interference. But government wants the same cut it has been getting from older industries, and software is just too lucrative to continue to be left alone.
If we expect to stay employed, we had better start studying for our FCSE (Federally Certified Systems Engineer) exams. :)
If this ruling stands, Brian Kernighan SHOULD sue Oracle, Apple, and Microsnot for copying "int" and "float".
I get dibs on “;”!
I do understand the issue of an API being a standard, but also software. The standard becomes functional, and therefore not subject to copyright. The code that goes into the API can be subject to copyright, however.
There is an excellent analysis available - and one critical of Judge O’Malley.
I'm just a cook, man...
...”So, there are still a few more years (and many more millions) to be thrown at this before there’s any real conclusion.”
Sometimes I think that’s why we get so many of these screwy rulings. Just lawyers(judges) making work for more lawyers. Gotta keep the BAR cash flow going dontchaknow.
I gotta give the first judge credit though. He actually took the time to learn to program so he could understand the issue before making a ruling.
To put it simply, an API is a set of instructions a software company will put out for a piece of software, that delineates how a 3rd-party programmer can write applications that then interface with the original piece of software.
hmmm...copyright of an *implementation* of an API is ok, but the API is just the declared interface to the software component. This has been ruled upon in the past, otherwise software like WINE (on Linux) would be in trouble. It *implements* the Windows API so Windows software can run on Linux but has no Windows code. Microsoft makes the API’s public information so people can right application software for it. Anybody can re-implement the API...and I’m a Software Architect that works with open source software and frequently have to deal with legal issues (GPLv2/3, Apache, etc.).
“hmmm...copyright of an *implementation* of an API is ok, but the API is just the declared interface to the software component.”
That sums it up.
Thank you for your clear exposition. It’s apparently a fairly high-level interface specification for designers of associated apps to use.