We’ve all heard stories about the independent screen or songwriter who had his or her work ripped off by big corporations; material submitted then stolen without credit or compensation. And many of us have seen, read about or, ahem, even bought cheap imitation knock-off products, usually originating from the Pacific Rim area. These scenarios are just some that fall into the realm of copyright infringement; a convoluted and ill-defined area of legality where money spent usually supersedes morality when it comes to precedent and judicial decisions.

So how does copyright infringement play out when it comes to intellectual property ownership in the tech world? It’s no secret that this is an industry that arguably “borrows” more from its peer group than any other - if something works well and makes life simpler everyone wants access to it. The problem is that multitudes of engineers are working on the same problems/shortcomings simultaneously, making it hard to determine who “discovered” what first, and there are only so many valid derivations of ones and zeros that will provide results. Another problem is that improving on an existing breakthrough can be seen as theft on the original idea, but chances are this original “breakthrough” came from improving on existing code before that - the classic chicken/egg syndrome.

Of course that’s not to say that outright code and execution theft does not occur on a regular basis and this goes beyond due credit and financial gain; it can get into ethical use and who should have access to the technology. So what portion of written code can be claimed as “original”? What can be reused without compensation or credit?

Let’s look at the example of the US Supreme Court copyright infringement case of Google vs. Oracle. Google has attempted to set precedent as to the extent of basic code elements that companies can legally access in response to Oracle’s claim that Google’s Android OS is based on stolen code from the Java software platform under the non-fair use ruling. Google counters that it fairly developed its own “alternative” to Java code and bigwigs like Microsoft, Mozilla et. al. are quick to side with them, arguing that any such precedent would hinder other developers’ ability to freely build new programs that work with existing software platforms.

This multi-million dollar hot mess has the scary potential to make it so that development companies can copyright application programming interface (API) packages - which are vital in allowing different software programs to work together copacetically - and prevent other companies from using them commercially without a license, which will stifle competition and further entrench collusion and dominance for major technology players.

To convolute the situation more, let’s look at why the code was re-used in the first place. Take an API, which is essentially a set of rules that define the correct way of exchanging information between computer systems, whether it is a communication between several parts of the same program or between different physical computers. Technical mainstays like Wi-Fi and every computer and device using modern communication technology to communicate with other systems have to implement a whole array of different APIs (ex. The Gmail application on one’s phone implements several Google APIs so it can fetch mail correctly).

In the case of the Java platform, certain tasks must also use pre-defined commands and grammatical structures. Google’s Android was designed to be compatible with the Java API so that programmers could easily bring their software and knowledge over to the new mobile device platform. To do this, Android had to exactly copy the relevant Java API commands and grammatical structures.

Now, a different programming language could be used so the internal software code might not look like verbatim copying. But implementing an API into another computer language is simply an act of interpretation (tomato/tomahto) and translating a copyrighted work into another language is specifically known to be a copyright infringement, according to recent law interpretations.

Both sides have a point, and the issue here is can developers’ use other developers code without compensation, credit or permission? To what extent? And ask yourself this, can one company truly claim that their code is all original in itself and not at least partially borrowed?

If you’re on Oracle’s side here, consider this irony.

Amazon has released their S3 storage platform that involved the design of a proprietary API to store and retrieve files. Outside software must use these exact, cryptic commands to work with Amazon S3.

In order for competitors to convince programmers to switch away from Amazon’s rather pricey offerings, they have to reimplement S3’s API command names, parameter tags, “x-amz” phrasing, grammatical structure, and overall organization of the S3 API to mimic its features; the very same thing Oracle argues is protected by copyright and sued Google for, despite the fact that Oracle has copied numerous elements of Amazon’s API themselves verbatim.

Oracle counters that using an API is unrelated to reimplementation and not an infringement of copyright (or else every app developer using Java would infringe), seemingly oblivious to Google’s very similar defense claims about Oracle’s Java API. Hmm.

The outcome of the ruling on API copyright infringement will send major shockwaves through the entire industry, making almost anything you do with a computer—from uploading a video to watching eSports—into a bigger legal minefield than it already is. And unlike other major precedent-setting cases, the root of this is not about protecting the innocent, giving due credit and protections to the rightful persons nor making anything safer, it’s entirely about money and controlling power. If Oracle gets its way, how will smaller technology companies be able to compete, to build compatible and/or lower-priced versions of dominant software platforms?

To avoid these far-reaching consequences, a balance has been postulated to limit copyright infringement to partial reimplementations of an API that are “incompatible” with the original, but this still leaves a huge grey area and gives companies the power as to how much of their code can be used without licencing and ad nauseum fees that will be sure to creep up.

Here’s a real solution: Give credit where credit is due, use what you need to make the world a more evolved, safer place to be and look in the mirror instead of at the stock ticker tape.

Sources: