In the long-running litigation over Google’s unlicensed copying of Oracle’s Java code, Google is trying to convince the Supreme Court that declaring code isn’t protected by copyright and that software engineers routinely steal from each other.
I’ve been a software engineer for more than 15 years and neither is true.
It is true that I find myself increasingly working with other people’s software, integrating it into whichever product I’m working on. The general idea is that other developers create something useful, and devise a way that we can make use of that software.
We can then write our code to use their software, using their functionality inside our program. By being able to connect different complementary pieces of software together, we can build complex functionality more quickly and effectively. But we get a license and follow its terms.
Obviously the most pertinent consideration when choosing which software to integrate with is the functionality it offers. The next biggest question is, “how well will it integrate with our existing software?”
The developers doing the integrating want to know that they will be able to easily and reliably access the functionality they need. In practice this means that for almost every type of modular software, there are often several different ways to write declaring code, each shaped by the values and intentions of the creators.
Even when the underlying functionality being provided is broadly the same, two different software packages could (and usually do) offer quite different declaring code.
As such, it is strange that Google, in its argument to the Supreme Court, should attempt to argue that the Java declaring code — the code that describes pre-written Java programs — would be purely functional.
The declaring code is not just a ‘method of operation’ for underlying functionality – it’s a complex and opinionated expression of one particular way in which to describe that functionality.
Google has also approached this from a different angle, namely that of the ‘merger doctrine’. In Google’s own words, merger “provides that, where an idea is incapable of being expressed in more than one way, the idea and expression “merge” and become unprotectable.” The problem for Google is that there is no reasonable way this could apply here.
To reach the conclusion that there was only one way to express this “idea,” we need to specify what the idea actually is. The Java declaring code exists to allow Java programs to make use of a Java “runtime,” which intermediates between the program and the operating system on the computing device.
If the idea is merely “to interface with a runtime that facilitates programs to run on the device” then it is painfully clear that this code is not the “only and essential means of accomplishing a given task” as the merger doctrine requires. Microsoft offers a competing runtime (the Common Language Runtime) and set of declaring code (.NET) which facilitate exactly the same task.
But what if the idea was more specific — perhaps the idea is “to run programs on a Java runtime?” Again, it is not true that the Java declaring code are the only way to achieve that. The runtime has a public specification and it is possible to write software for it without using the Java language at all.
Perhaps Google’s argument is even more specific — that copying the Java declaring code is the only way to allow Java programs to run on the Java runtime. As noted above, the Java runtime is one specific expression of the idea of “software that mediates between user programs and the operating system.”
Similarly, the Java declaring code is another expression of the idea of “a collection of interfaces providing core functionality to computer programs.” Copying the Java declaring code in order to facilitate the use of the Java runtime is a choice regarding these particular expressions.
Oracle’s expressive declaring code reflects the work and creativity of its creators, and is worthy of protection.