How Oracle Versus Google Could Ruin Software Development

The Java programming language, which has just turned 20 years old, provides developers with a means to write code that is independent of the hardware it runs on: "write once, run anywhere". But, ironically, while Java was intended to make programmers' lives easier, the court case between Oracle, Java's owner, and Google over Google's use of Java as the basis of its Android mobile operating system may make things considerably more difficult.

Boxing picture from Shutterstock

Google adopted Java for Android apps, using its own, rewritten version of the Java run-time environment (the Java virtual machine or VM) called Dalvik. The Oracle vs Google court case centres around the use of Java in Android, particularly in relation to Application Program Interface (API) calls.

An API is a standard set of interfaces that a developer can use to communicate with a useful piece of code — for example, to exchange input and output, access network connections, graphics hardware, hard disks, and so on. For developers, using an existing API means not having to reinvent the wheel by accessing ready-made code. For those creating APIs, making them publicly and freely accessible encourages developers to use them and create compatible software, which in turn makes it more attractive to end users.

For example, OpenGL and Microsoft's DirectX are two APIs that provide a standardised interface for developers to access 3D graphics hardware, as used in videogames or modelling applications. Hardware manufacturers ensure their hardware is compatible with the API standard, the OpenGL Consortium and Microsoft update their APIs to ensure the latest hardware capabilities are addressed and games developers get a straightforward interface compatible with many different types of hardware, making it easier to create games.

Fight for your right to API

Google designed Android so that Java developers could bring their code to Android by recreating (most of) the standard Java API calls used in the Java libraries and supported by the standard Java VM. The case revolves around whether doing this — by essentially re-creating the Java API rather than officially licensing it from Oracle — is a breach of copyright. If the case finds in favour of Oracle it will set a precedent that APIs are copyrightable, and so make developers lives a lot more legally complex.

To be clear, the case doesn't revolve around any claim that Google reused actual code belonging to Oracle, but that the code it produced mimicked what Oracle's Java run-time environment was capable of.

The initial finding came in May 2012, when a US court agreed with Google's claim that using APIs them falls under fair use, and that Oracle's copyright was not infringed. Then in May 2014, the US Federal Circuit reversed part of the ruling in favour of Oracle, especially related to the issue of copyright of an API. Now, at the US Supreme Court's request, the White House has weighed in in Oracle's favour.

Can you 'own' an API?

For most in the industry, a ruling that it's possible to copyright an API would be a disaster. It would mean that many companies would have to pay extensive licence fees, and even face having to write their own APIs from scratch — even those needed to programmatically achieve only the simplest of things. If companies can prevent others from replicating their APIs through recourse to copyright law, then all third-party developers could be locked out. Also the actual call to the API and its functionality could be copyrighted too, so that the functionality would have to be different too, otherwise it would be a copy.

In the initial trial, District Judge William Alsup taught himself Java to learn the foundation of the language. He decided that to allow the copyrighting of Java's APIs would allow the copyrighting of an improbably broad range of generic (and therefore uncopyrightable) functions, such as interacting with window menus and interface controls. The Obama administration's intervention is to emphasise its belief that the case should be decided on whether Google had a right under fair use to use Oracle's APIs.

It's like the PC all over again

Something like this has happened before. When IBM produced its original PC in 1981 (the IBM 5150), a key aspect was access to the system calls provided by the PC BIOS, which booted the computer and managed basic hardware such as keyboard, monitor, floppy disk drive and so on. Without access to the BIOS it wasn't possible to create software for the computer.

One firm, Compaq, decided to reverse-engineer the BIOS calls to create its own, compatible version — hence the term "IBM PC compatible" become standard language to describe a program that would run on an IBM model or any of the third-party hardware from other manufacturers that subsequently blossomed. IBM's monopoly on the PC market was opened up, and the PC market exploded into what we see today — would this have happened had IBM been able to copyright its system calls?

So 20 years after the birth of Java, through the groundwork laid by its original creator, Sun Microsystems, Java has become one of the most popular programming languages in the world through being cross-platform and (mostly) open. But now it seems it ends in a trap. The wrong decision in this case could have a massive impact on the industry, where even using a button on a window could require some kind of licence — and licence fees. For software developers, it's a horrible thought. Copyrighting APIs would lock many companies into complex agreements — and lock out many other developers from creating software for certain platforms.

For Google, there's no way of extracting Java from Android now; its runaway success is bringing Google only a whole lot of problems. But as we go about building a world built on software, be assured that one way or another this ruling will have a massive effect on us all.The Conversation

Bill Buchanan is Head, Centre for Distributed Computing, Networks and Security at Edinburgh Napier University .

This article was originally published on The Conversation. Read the original article.

WATCH MORE: Tech News

Comments

    This is a very scary court case for every programmer out there. It won't make Oracle any money, it'll just screw over everyone else.

    Interesting.

    I wonder how Google feel about Cyanogen replicating all the Google service APIs in their own version of Android? This would completely undermine the Google ecosystem lock-in they're working so hard for with Android developers.

      It's not just about Google or Android. It effects the principle of programming languages and all the software that were created. If APIs are copyrightable (I am sure Google will not lose on the copyright claim for API), all other language creators can ask money for the use of their language (even though it might be now open source). There are 1000s of computer programming languages, and there are that many companies waiting to buy false patents to threaten programmers and software companies.

    I'm not sure if it's been mentioned in the case, but Sun made the Java API and class library open source under the GNU licence back in 2007. It doesn't matter who owns the copyright, the licence is not revocable unless it's breached.

    Last edited 03/06/15 3:22 pm

      Some of the source code is GPL, but Google didn't use the source code, it wrote new code with the same APIs. Nor did it use the GPL license. Using the GPL would have required Google to release Android as open source, which it has not done. However, this isn't relevant to the case. Oracle's position is that Java APIs, not just source code, are our copyright property, you can't write new code using the same names and arguments that does the same job without paying Oracle for the privilege. That's what so stupid about it.

        So DirectX and OpenGL could use this to sue each other?
        Because they both have API's that [for example] draw a circle on your screen?

          Sorry for the late reply.

          It's not what the API does, it's the method signature that's at issue. I don't know how much programming knowledge you have so I'll cover everything, sorry if you already know this stuff.

          Say you want a method that multiplies two numbers together. In Java you'd write something like this:

          public int multiply(int value1, int value2)
          {
          return value1 * value2;
          }

          The first line is the method signature, which is just a description to say what the name of the method is, what its parameters are (and in what order) and what type of value is sent back to the caller. The part inside the brackets is the implementation. You'd call the method by writing something like 'x = multiply(5, 4)', which puts the result into the variable 'x'. Code that wants to call this method only cares about the signature, it doesn't care about the implementation at all. Maybe multiplication is really difficult so instead of using the implementation above, a database lookup happens instead. The rest of the code doesn't care as long as the signature stays the same - the method is called multiply, it takes two integer parameters, it returns an integer and it's a public method. The signature of methods and variables are collectively referred to as an interface, and one or more interfaces can collectively make up an API.

          Java is like this too. In Java there's a method called println, which takes a string parameter and writes it out to the console. You can write code that says println("Hi there!") and you don't have to care how it writes the line out to the console, just that it does. All you care about is the signature - that it's called 'println' and that it takes one parameter, a string.

          So that you can write Java code, all the signatures for every method of every class and interface are publicly documented. If they weren't, you wouldn't know that println() even existed. When Google wrote Dalvik, their Java interpreter, they copied all the method signatures from the Java API but wrote the implementations for all those methods from scratch. The signature has to be the same because Dalvik needs to be able to run Java code that was written to work in Oracle's Java interpreter, the Java Runtime Environment (JRE). So when Java code says println("Hi there!"), there needs to be a method in Dalvik with the same signature otherwise the program won't work properly. Dalvik's println() may do the same thing as the JRE's println() (ie. write the line to the console) but it goes about doing that in a different way. What's important is the implementation (the stuff inside the brackets) wasn't copied from the JRE to Dalvik, it was written from scratch.

          Oracle is arguing that the public API for Java, all the method signatures like println(String message), are copyrighted just the same as the part between the brackets. Google, the Free Software Foundation and just about any sane programmer out there is arguing that the public API can't be copyrighted because it's a "system or method of operation", which is not copyrightable under US law.

          A comparable example might be a painting. Oracle has made a painting of a landscape with a mountain on the left, the sun on the right and a river running down the middle. Google has also made a painting of a landscape with a mountain on the left, sun on the right and a river running down the middle, but where Oracle used watercolours, Google used oil paints. Oracle's painting was done in pastels, Google's was done in vibrant colours. Google's painting is a derivative work of Oracle's painting, but it's different at a fundamental level even though they both have essentially the same description. Copyright law says you can copyright the content of the painting but you can't copyright the description, and that derivative works are okay as long as the changes are substantial. The description of the paintings may be the same, but the way they were made is very different. Similarly, the method signatures may be the same between Dalvik and the JRE, but the implementation is very different.

          So it's a bit more complicated than DirectX and OpenGL both being able to draw circles. It's like if both DirectX and OpenGL had a method called drawCircle(Vector2 origin, float radius), even though the way they both actually draw the circles is completely different to each other.

          Last edited 14/06/15 8:53 pm

        I didn't get alerted to this response for some reason.

        Almost all the Java API is covered by GPL, there's only a few modules that didn't make it, none of which are particularly important. OpenJDK exists specifically because the API is open source, it wouldn't be able to exist otherwise.

        Android IS available as open source (Apache licence), you can download it from https://source.android.com/. That said, Google wouldn't have to release the whole Android project as open source to comply with the licence, only the Dalvik module.

        The dispute revolves around whether the API, not just the implementation, is copyrightable. That particular question shouldn't matter because both the API and implementation were open sourced in 2007.

    This would be terrible if Oracle won.
    Oracle would have to sue Microsoft for copying Google's copy of the Java APIs in their new Windows 10 development. Also, Apple will then sue Microsoft for copying their APIs.
    Xamarin, which is a framework for writing iOS and Android apps in C#, would cease to exist for the same reasons.
    And I haven't even gotten out of app development yet. Web development would become a nightmare.

      Microsoft paid Apple to use a lot of their technology and patents. The licensing they paid Apple may also include the use of their APIs too.

    Dart is a possible migration path from Java for Android.

    I really don't think this is all bad. After all, Oracle spent millions on a product, and Google has deprived them of substantially the ENTIRE benefit of their work. Instead of creating their own thing, Google has copied Java, and expects to get away without paying a cent.

    If you are a programmer, just imagine putting in thousands of hours on a new piece of software, the entire benefit of which is then completely replicated by the world's largest tech company without so much as a glance your way.

    If you wanna get into whether copyright/patents should exist at all, this would be an entirely different discussion, but so long as they do, stuff like this /should/ be copyrightable. In fact, this is EXACTLY the sort of thing copyright exists to protect: stuff that is technically easy, but grossly unfair, to copy.

    i think the community should come together and design and implement a free (speech + bear) alternative to java from scratch. for me i would like to put google in charge and even pay them to do so.

Join the discussion!

Trending Stories Right Now