Okay, I made it through the entire decision.

The more I read of the decision, the more I think it actually strengthens copyright protections upon which GPL and copyleft philosophy rely. The crux of the case isn't fair use, but rather copyrightability. The appeals court essentially asserts that that district court's decision implies that no software is copyrightable, based on the copyrightability analysis methods the district court used. The appeals court reverses the district court's decision regarding copyrightability of Structure, Sequence, and Organization (SSO) of the APIs in question, affirms the district court's decision that interoperability needs did not render the APIs uncopyrightable, and remands to the lower court the fair-use defense upon which the jury hung.

As you can see from the conclusion, this decision is actually a win for free software, because it affirms the fundamental copyrightability of software SSO and declaring code, in addition to the copyrightability of implementing code. To wit:

For the foregoing reasons, we conclude that the declaring code and the structure, sequence, and organization of the 37 Java API packages at issue are entitled to copyright protection. We therefore reverse the district court's copyrightability determinations with instructions to reinstate the jury's infringement verdict. Because the jury hung on fair use, we remand Google's fair use defense for further proceedings consistent with this decision.

If the court hadn't held that declaring code and SSO are copyrightable, someone could take the entire /wp-includes/ directory, files and all, keep all the same file structure, organization, and function/class names and declarations, then rewrite all of the implementing code, and distribute it as a new work not subject to the GPL under which WordPress is distributed.

Let me try to explain a bit better.

The question of the implementing code isn't really at issue. Even Google admits that the implementing code is copyrightable. Google took the SSO, and wrote new/original implementing code for all of the API declaring code. (Except for the implementing code in 8 files that Google reverse-engineered, and the rangeCheck method - the use for which Google claimed fair use as de minimus. This issue, and Google's fair use claim, was remanded to the circuit court for further proceedings.)

What Oracle was appealing, in part, was the circuit court's decision that their expression of an idea, as embodied in the programmatic structure, declarative conventions, and nomenclature (i.e. the Structure, Sequence, and Organization, or SSO), was not copyrightable. The appeals court agreed with Oracle, in that the way they chose to organize and define some 7,000 lines of code represented copyrightable creative expression.

The actual functionality (i.e. the idea being implemented) is not copyrightable. Java has a max() function that determines which of two integers is the larger integer value. Google could have chosen to write a separate function, with the same or a different name, to accomplish the same purpose, and would not have violated Oracle's copyright. But the court held that, as a whole (37 APIs, with however many classes, and class methods), since it included a deliberate, creative expression (SSO), met the very low bar of creativity used in determining copyrightability. But the copyrightability applies to the collection as a whole.

Think of it as a compilation of public domain, classical poems. The poems themselves are not copyrightable; but the act of compiling those poems in a particular manner represents copyrightable creativity. That's the core of what's at issue here, with respect to the API structure and declarative code.

Note the distinction in applicability of the merger doctrine. The appeals court holds that use of the Java API is not copyrightable under the merger doctrine, but in writing a new API, wholesale copying of the declaring and implementing code does not fall under the merger doctrine:

The focus is, therefore, on the options that were available to Sun/Oracle at the time it created the API packages. Of course, once Sun/Oracle created "java.lang.Math.max," programmers who want to use that particular package have to call it by that name. But, as the court acknowledged, nothing prevented Google from writing its own declaring code, along with its own implementing code, to achieve the same result. In such circumstances, the chosen expression simply does not merge with the idea being expressed.

The appeals court then turns its attention to the question of copyrightability of the method names - i.e. the "short words and phrases". The district court held that Oracle's nomenclature, conventions, and structure of 7,000 lines of declaring code was not copyrightable because it consisted of several one-line instances of "short words or phrases". The Appeals court reverses that decision, noting that the combination and compilation of uncopyrightable "short words and phrases" constitutes creative expression that is copyrightable.

The appeals court also agrees with Oracle that the circuit court erred in declaring the SSO uncopyrightable as a "method of operation", in that the Lotus decision was not applicable to the case at hand, and did not properly apply the Abstraction-Filtration-Comparison method of determining copyrightability and copyright infringement.

The appeals court then discusses a rather odd argument by Google that the code they copied was not copyrightable, because it was necessary to achieve interoperability with Java - even though Google deliberately wrote Android so as not to be interoperable with JVM.

Also importantly: the appeals court rejected Google's appeal on the basis that software should be protected under patent law rather than under copyright law. The legal precedent set by such an argument, if successful, would be absolutely chilling to software development, and to the free software movement.