The Oracle vs. Google Patent Lawsuit Demystified
Oracle has alleged that Google, in the making and distribution of Andriod, has violated five key patents. If Google is found to indeed be in violation, the penalty will be significant.
To put it in some perspective, Canada’s i4i sued Microsoft over a little XML based patent infringement. Microsoft was hammered with a $290 million dollar bill for damages, along with a judicial order to stop selling their flagship Office software until restitution was made. And this was all over what everyone but i4i would consider a fairly minor feature buried within Microsoft’s Office Suit. Java is certainly more intertwined with Android than Microsoft Office and i4i ever was. (See Android = Java by Osvaldo Pinali Doederlein)
Does the Oracle Patent Suit Have Merit?
So, the big question the industry is asking is whether or not this lawsuit has merit? Will Google fall on Oracle’s patent sword?
First of all, in order for a patent to be defendable, it must be novel, and its invention must be non-obvious; that is the invention must not be obvious to someone in that field. Now, I mention here that this is the requirement for a patent to be ‘defendable.’ Just because a patent is filed doesn’t mean it is defendable in a court of law.
When is a patent a patent?
There is some significant opinion in the industry that would indicate that many do not believe the majority of these software patents are defendable. In fact, Oracle may have some seriously difficulty in patent court with their former employee, James Gosling, going on the record in his August 15th blog asserting that while working at Sun there was "an unofficial competition to see who could get the goofiest patent through the system." It’s going to be an obstacle for Oracle to get a court of law to take a serious look at a their lawsuit when one of the most respected names in the Java world has described his own patent filings as "goofy." Lets look at these patents, one by one, and see if we can’t glibly poke some holes in them.
As a Java or IT professional, I think one could look at the five patents that make up this case, and simply ask ourselves if these filings even have merit as novel and non-obvious patents, let alone whether Google and Android have actually violated them. Here they are, one by one.
United States Patent 6,910,205 June 21, 2005
Interpreting functions utilizing a hybrid of virtual and native machine instructions
(The "Speeding Up Something Slow Makes It Faster" Patent)
Here's a precious little nugget from the abstract of the patent itself: "A portion of the virtual machine instructions of the function are compiled into native machine instructions so that the function includes both virtual and native machine instructions."
As we all know, bytecode is slow, and native code is fast. Similarly, gasoline is slow to ignite, while nitrous oxide is fast.
This patents seems to be the information technology equivalent of someone patenting the idea that you can make your car run faster if you add a more explosive fuel. This hardly seems like a unique and novel idea, and in a court of law, it’s hard to believe that any judge with a modicum of technical savvy would believe that this idea elutes from anything more than the natural and normal use of technology as it was designed.
Verdict? Patent 6,910,205 is hardly convincing as a novel and non-obvious idea.
United States Patent RE38,104 April 2003
Method and apparatus for resolving data references in generated code
The "Direct is More Direct Than Indirect" Patent (James Gosling's Patent)
James Gosling mentioned that when he worked for Sun, "IBM sued over a RISC patent that asserted that 'if you make something simpler, it'll go faster.' Seemed like a blindingly obvious notion that shouldn't have been patentable, but we got sued, and lost." I can only imagine that seeing this patent of his involved in the fray put a bit of a smile on Gosling's face.
This patent basically seems like a rewording of the IBM RISC patent. In this case, the patent says that if you reference something directly, you can get to it faster than if you reference it indirectly; or more technically, if you rid your code of symbolic references, and replace them with direct references, things are more efficient. Essentially, this patent says that 'direct references are more direct than indirect references.'
Was it really Spring of 2003 when the IT world finally came to this conclusion? Again, this hardly seems like a novel idea, and as was stated by Charles Nutter, "the techniques seem obvious to me, but perhaps they're obvious because this patent helped make them standard. I'm not qualified to judge. What I can say is that I can't imagine a VM in existence that doesn't violate the spirit – if not the letter – of this patent as well."
Verdict? Again, this seems like a pretty flaky patent, and anyone with a background in IT would have a hard time seeing this as being novel and non-obvious.
United States Patent 7,426,720 September 2008
System and method for dynamic preloading of classes through memory space cloning of a master runtime system process
The "Memory Access is Faster than Disc Access" Patent
This is another great patent. Digging into the Summary of the Invention you get this great little piece of insight: "A representation of at least one class is obtained from a source definition provided as object-oriented program code. The representation is interpreted and instantiated as a class definition in a memory space of the master runtime system process. The memory space is cloned as a child runtime system process responsive to a process request and the child runtime system process is executed."
So, in layman's terms, this patent says that it’s easier and more efficient to clone a class that is in memory, than to create an instance of that same class by reading its representation on a disc, and then loading it into memory.
Imagine that? Someone discovered that memory access is faster than disc access. This sort of puts Edison and his whole light bulb invention to shame, doesn’t it?
Verdict? Really, there doesn't seem to be anything here that isn't obvious to anyone that's booted a computer and waited for the operating systems to load from disc into memory.
United States Patent 5,966,702 October 12, 1999
Method and apparatus for pre-processing and packaging class files
The "Smells like WinZip" Patent
This revolutionary patent suggests that we "remove duplicate information elements from a set of class files to reduce the size of individual class files and to prevent redundant resolution of the information elements."
Yes, in the most simple of terms, this patent describes WinZip. Of course, this patent does go beyond basic compression. This patent incorporates expansion too!
This patent includes the act of estimating the memory allocation requirements of a given class once it’s been expanded so that the application has some sort of idea of its post-compression size. Of course, it would seem rather silly for the program to base the memory allocation requirements of a given class on its compressed sized, so again, this patent hardly seems to be revolutionary in its design.
Verdict? Compression and expansion is hardly a novel idea, even if this patent was filed in 1999.
United States Patent 6,125,447 September 2000
Protection domains to provide security in a computer system
The "Well, it works for Users and Groups" Patent
"As new code arrives at a computer, a determination is assigned to a protection domain based on the source from which the code is received. The protection domain establishes the permissions that apply to the code."
Let me rephrase this patent a in a slightly different context: users belong to domain groups, and domain groups are assigned permissions. When a new user is added to a group, the group establishes the permissions that apply to the user. I'm not sure, but I think Unix was doing something like this with users and groups a tad before September 2000.
Verdict? Again, this isn’t a revolutionary idea. In fact, if you were applying security to any system, this is pretty much the natural pattern that would elute, and it’s been prevalent in various capacities in the IT industry long before this particular patent was filed in September of 2000.
United States Patent 6,061,520 May 2000
Method and system for performing static initialization
The "Static Side-Step" Patent
This is probably the most specific and technical patent of the entire group. It's certainly the one I understand the least.
Essentially, initializing a static array takes a huge number of machine instructions. The sequence of steps required to initialize an array of four int values is outlined in the patent, and it would appear that for some freakish reason, doing something as simple as initializing a static array is very cumbersome. This patent addresses this problem by very creatively adding new instructions to .mclass files about static initializations that need to happen at runtime, and then modifying the JVM to recognize that this new instruction exists and is indeed valid.
So, what's the verdict on this one? Well, eliminating redundant code isn't a novel idea, but I can't say that the solution is necessarily simple or obvious. Although Chris Nutter, in his previously referenced article, disagrees. "The mechanism described are again not very unusual, but there's probably a good chance that the "dex" tool does something along these lines to tidy up static initializers in Android applications." Who knows, maybe this particular patent will be Google's Achilles Heel?
Verdict? This is a pretty technical patent, and it seems very specific. This one might actually pass the sniff test.
And that’s it. Those are the five patents that make up the legal fight that has now begun between Oracle and Google. Do the patents themselves seem a tad frivolous? Of course they do. Will Oracle defend these patents vigorously in a court of law? Of course they will. And will the judge or jury that evaluates the merits of this case be informed IT professionals that can cut through the legal mumbo jumbo? Of course they won’t, and there lies the problem.
"IBM sued [us] over a RISC patent that asserted that 'if you make something simpler, it'll go faster.'...and we lost." -James Gosling
This case will likely be resided over by a judge that was born in the 1940’s, and is still amazed by the ingenuity and insight of Amazon’s 1999 Single Click Checkout patent. And the fancy legal team Oracle will surely put together will be more than capable of convincing a jury that Google’s Android shenanigans more than violate Oracle’s copyright on Java and its related technologies. And what happens when Oracle wins this lawsuit? Well, that will have to be fodder for another day.