An article was recently published on a site I generally value, one of the authors of whom I am familiar with and know to be highly knowledgeable of intellectual property issues. However I am in disagreement with their opinions of this case.
My disagreement is based on my understanding of what was actually copied by Google - that it was interface code, not implementation. If this assumption is incorrect then my opinion could change.
In programming, interface code is analogous to a template or blueprint for something to be built. There is no functionality attached to it, but it describes what functionality needs to be provided.
The entire purpose of organizing computer code so that an interface is separate from the implementation is to make it possible for different - but compatible - implementations to be created. Most programming languages, and all Object Oriented ones such as Java not only allow but encourage this separation as a best practice.
As an example, I decide to design an interface that describes the functionality of a dog, it may be something like:
interface DogInterface = {
function bark();
function wagTail();
function rollOver();
function heel();
// etc
};
The functions described above have no implementation - they do nothing unless I create a class to implement it.
class Collie implements DogInterface {
function bark() {
// code that makes the sound of a Collie barking
}
// ...
}
It is important to note that providing the above DogInterface is not actually necessary; the Collie class can be implemented without it. The difference is that, without it, anyone wanting to implement a class for (e.g.) a Poodle would either have to code their class however they think of it and thus almost certainly be incompatible with the Collie implementation, or else spend time attempting to discover the functions and calling formats of the Collie class in order to make their implementation compatible so that both could be called the same way by other code.
By providing the separate DogInterface, I have explicitly made it possible for others to write any number of implementations, whether in the same programming language or any other able to define or consume interfaces. As a result, someone wanting to write software needing various dog classes could use classes adhering to the DogInterface and thus only needs to know the functions available in that common interface rather than possibly different function names and parameter formats for every Dog class.
An interface is essentially nothing more than a list of function or property names to be used as a standard to code compatible implementations against. Far from being inherently tied to an implementation, their very purpose is to untie them!
Now that the purpose of an interface is established, consider what it means to say the interface is “protected” under copyright - meaning others are not allowed to copy it without permission. The only possible meaning is this: If I want to implement a class using an interface to represent a Poodle, I cannot have functions named bark(), or heel(), etc but would have to make up different names just to comply with the copyright. Thus my interface might look like:
interface PoodleInterface = { // "DogInterface" cannot be used!
function speak();
function shakeTail();
function showTummy();
function stayAtSide();
// etc
};
Now, since I too have a copyright on my PoodleInterface, the next developer wanting to create an interface and class for Terriers would have to come up with yet another set of function names so that it does not violate the copyright on the two existing interfaces. You can see how quickly this would get out of control and how absurd it is to be required to continually come up with different naming because someone is able to claim a copyright on the name of an interface and/or the set of function names within that interface!
It is exactly in this respect that a comparison was made to the Lotus vs Borland lawsuit many years ago. Lotus attempted to claim copyright on the shortcuts used in their menus, essentially saying that no other software should be allowed, for example, to use Ctrl-S to represent the Save function, that Borland and every other competitor would have to come up with different shortcut combinations to represent the same functionality.
Thus, as long as it is strictly interface code that was copied by Google, no matter how many 1000s of lines of code that may be, they have not violated any intellectual property rights. To have found them guilty of copyright infringement in this case would have essentially forced a stop to all software development on the basis that the simple names of interfaces and functions can be owned.