Oracle Sues Google For Infringing Java Patents

Bruce Perens writes "Oracle has brought a lawsuit against Google claiming that Google has infringed patents on the Java platform in Android. Scribd has a copy of the complaint. But there's a patent grant that should allow Google to use Java royalty-free. Has Google failed to meet the terms of the grant?"

Comments

documenting it on http://en.swpat.org

[ciaran_o_riordan]

There's more info on en.swpat.org at:

• Oracle v. Google (2010, USA)

It's a publicly-editable wiki; feel free to help out.

• 6,125,447 - Protection Domains To Provide Security In A Computer System
• 6,192,476 - Controlling Access To A Resource
• 5,966,702 - Method And Apparatus For Preprocessing And Packaging Class Files
• 7,426,720 - System And Method For Dynamic Preloading Of Classes Through Memory Space Cloning Of A Master Runtime System Process
• RE38,104 - Method And Apparatus For Resolving Data References In Generate Code
  • (A reissued patent; the original number was 5,367,685)
• 6,910,205 - Interpreting Functions Utilizing A Hybrid Of Virtual And Native Machine Instructions
• 6,061,520 - Method And System for Performing Static Initialization

Re:documenting it on http://en.swpat.org

[TheRaven64]

First, you seem to think the Bilski ruling said a lot more than it did: it did not invalidate software patents and only some of the justices involved even cast any doubt on the idea that they should be valid.

The GPL is irrelevant in this case. Google's VM is not based on Sun's GPL'd code, it is an independent implementation (under a BSD-style license, as I recall). The GPL only protects derivatives of the GPL'd code from patent liability. It does not protect any other code.

Perens seems to be unable to read the text that he quoted in his blog too. The grant there only covers complete Java 2 SE implementations. Android is not a complete J2SE implementation. But, hey, he got it on Slashdot and got paid for the ad impressions down the side...

Re:documenting it on http://en.swpat.org

[PhrostyMcByte]

Miguel de Icaza gives a pretty good guess about what's happened.

The gist is that Sun very carefully licensed Java under the GPL with an agreement that anyone who implements Java 100%, without supersetting, would get access to the patents. Apparently Sun's embedded implementations have some special functionality not included in the GPLed version. This is where the "very carefully" bit comes in -- it means others can't implement their own embedded versions (adding that special functionality would be supersetting), and would have to license Sun's version. Their embedded implementation generates the bulk of the cash for them, and they wanted to protect that.

Google wanted to use Java but didn't want everyone to need to license the embedded version. So they implemented their own. To get around the supersetting issue, they changed their implementation (Dalvik) to not infringe on Sun's patents -- even going so far as to change the bytecode format and implementing a Java->Dalvik bytecode translator.

Now Sun sees everyone hopping on the Android train for all sorts of devices, and no licensing fees coming in from any of them. And they're suing.

It sounds plausible to me but Miguel is the author of Mono, so take this with a grain of salt. He's usually the one having an argument against someone saying how everyone should use Java because Microsoft will pull the same type of stunt against Mono some day, so this must be a humorous day for him.

Re:documenting it on http://en.swpat.org

[think_nix]

and also because Java is licensed under the GPL.

"Java" isn't licensed under the GPL. A single Java implementation, derived from Sun's proprietary source code, is licensed under the GPL. Furthermore, the patent grant applies only if you meet specific compatibility conditions, which no implementation other than Sun's meets.

Google implemented the Java language, not its libraries, and did it by themselves. Android (and Dalvik) are licensed under a mix of Apache and GPL, but that doesn't matter; the license under which a third party implementation is released is not relevant for the patent grant.

Google rolled their own implementation and libraries for good reason: the full Java platform would have been far too obese for Android, and embedded versions of Java aren't free at all.

There is effectively only one Java implementation, the one controlled by Sun/Oracle. Sun killed most of the others early on with legal threats, and the few remaining ones seem to fail to meet the conditions of Sun's public patent grant.

Anybody who writes Java software is pretty much stuck with running it on Sun/Oracle's proprietary implementation or its nominally GPL derivative. You're joined at the hip with Oracle, in the bending over kind of sense.

Almost but not quite , check out this interesting read: http://www.betaversion.org/~stefano/linotype/news/110/

So, Android uses the syntax of the Java platform (the Java “language”, if you wish, which is enough to make java programmers feel at home and IDEs to support the editing smoothly) and the java SE class library but not the Java bytecode or the Java virtual machine to execute it on the phone (and, note, Android’s implementation of the Java SE class library is, indeed, Apache Harmony’s!)

The trick is that Google doesn’t claim that Android is a Java platform, although it can run some programs written with the Java language and against some derived version of the Java class library. Sun could prevent this if they had a patent on the standard class library, but they don’t and, even if they did, I strongly doubt it would be enforceable since Android doesn’t claim to be compatible (and in fact, could very well claim that their subset/superset is an innovation on the existing patent and challenge Sun’s position).

Hooray Patent Minefield!

[Haedrian]

Patent Minefields - helping drive innovation forward!

Re:Why do you think Oracle bought Sun?

[Sarten-X]

I think it was all three. Sun had a decent amount of virgin un-evil products. Oracle saw them, and had an insatiable desire to corrupt and spread malevolence.

Re:Why do you think Oracle bought Sun?

[cappp]

how many other companies Oracle might have by the short and curlies now?

None of the really hip companies, they all shave.

Re:Why do you think Oracle bought Sun?

[Anonymous Coward]

Google should have bought Sun. They had all kinds of interesting projects, people, patents and research happening. Plus they also would have had the SPARC platform (not big iron, but the CMT implementations) that, given enough investment, could have paid off in the long run for their commodity datacenters.

For 7 billion, Sun was worth it. I wonder why they just let it pass.

Epic Fight on the way..

[tebee]

I wonder if this could be as big and as interesting(for the geek community) a fight as SCO v Novell

There's an interesting comment on James Gosling's blog http://nighthacks.com/roller/jag/entry/the_shit_finally_hits_the

"Not a big surprise. During the integration meetings between Sun and Oracle where we were being grilled about the patent situation between Sun and Google, we could see the Oracle lawyer's eyes sparkle"

And yet more money get syphoned out of the IT industry into the lawyers pockets. Sigh

Re:Epic Fight on the way..

[delt0r]

Patents work for the economy like breaking windows. Do your part today. Break a window.

Here's the lawsuit as a PDF

[ciaran_o_riordan]

> The text of their lawsuit isn't available

Yes it is. I put it here:

• 35811761-Oracle-s-complaint-against-Google-for-Java-patent-infringement.pdf

Other info:

• Phone patent litigation (this case is about Android)
• Oracle
• Google

Re:How ironic

[dnaumov]

That the first competing VM to be throttled by the patent holder would be a Java-based one, not a .NET-based one. I bet Steve Ballmer is laughing his ass off right now saying, "even I'm not that stupid."

Did you miss the part where SUN has (succesfully) sued Microsoft for the exact same thing?

Stallman rolling in his, er, house

[WankersRevenge]

Isn't this exactly what Stallman warned when he suggested that Open Office should be forked because it used Java?

Re:Oracle will win

[ledow]

- Software patents are not considered valid in the majority of the world, precisely because they get in the way of perfectly reasonable actions.
- Software patents on an "open" standard might not be enforceable if those patents are required to implement that standard, and are the only sensible way to do so. Interoperability with an existing product can't be protected by a patent if that patent is the only (or only sensible) way to do things.
- All the mentioned patents have prior art except one, which is so far worded towards Java only use that it falls foul of the previous statement (I didn't think you *could* patent something that specific to a particular product).
- The Oracle patents are particularly weak, most of them re-iterating 1980's knowledge of programming.
- Google probably has one of the largest patent profiles ever, especially in the area of collating huge amounts of data into a database - this is commercial suicide for Oracle who could well see a retaliatory attack that they just can't afford to defend against (yes, THAT many patents). Google's patents are likely to be MUCH more substantial than these Oracle ones.
- Sun never had a problem with IP protection. You don't need to protect your IP when "Java" is in everything from mobile phones to servers - basically Sun *WAS* Java and not much else before it was taken over, and saw no need to sue anyone at all substantial over patent infringement when it could have done at any time for even more cash.
- Going for Google first is commercial suicide - there will be other, smaller, players using third-party Java VM's.
- Suing immediately is a sign of desperation. Much more conducive to receiving compensation would have been quiet negotiations (there hasn't been ANY time for that since the Oracle takeover) and/or asking them to work around the patent at least. The path chosen is the most stupid and expensive.
- The lawyers here are Boies, Schiller & Flexner - the same ones that handled the SCO case's IP side. That went well for them. *fall into fits of derisive laughter*.

Much more likely is a quiet settlement involving cash, or Google saying "Go for it" and filing a counterclaim for a whole host of patents they own. Google can pretty much take Oracle to the cleaners if it wants. It makes me wonder why Oracle has set itself up to be that target.

Sun is to blame

[yyxx]

It was Sun who never submitted Java to ISO or ANSI, it was Sun who created a dual-licensed Java, it was Sun who filed hundreds of patents on Java-related technologies, and it was Sun who created the limited patent grant under conditions that nobody could meet.

And it was predictable that Sun would eventually fail and get bought by someone who might start to enforce those patents; in fact, the reason Oracle was willing to outbid everybody else was probably because they realized that these patents hadn't been placed fully into the public domain.

I had been warning about this for years, but all the Java fanboys were arguing that Sun was the good guys, that they would never sue, and that Java was a free and open platform.

Do your homework people: what has happened was predictable, and the evil seeds were sown by Sun itself.

Serious questions raised by Oracle patent attack

[FlorianMueller]

It will be hard to find out whether Oracle planned this kind of aggression when buying Sun, but it can certainly be stated that the free software/open source community hasn't benefited from the acquisition.

There's a number of important questions that Oracle's patent attack raises:

• Did Oracle try to resolve this amicably with Google (by way of a license deal) or is Oracle pursuing purely destructive objectives?
• Will Google solve this patent problem in a way that the entire Android ecosystem (including the makers of Android-based phones and the authors of Android apps) will be reassured, or will Google only take care of its own risk?
• Is Java less of an open standard now than C#? I don't really buy the argument that Oracle may only be suing because of deviations from the standards definition. This kind of patent attack is evil no matter whether Google adhere to certain specififcations or not.
• Isn't this now the ultimate proof that the Open Invention Network doesn't really protect the Linux ecosystem from patent attacks? This is case of one OIN licensee (Oracle) suing another (Google).
• Where are those FOSS advocates who said that Oracle's acquisition of Sun would be good for the cause and for the community? Some of them even claimed that it was important to have Oracle acquire Sun's patents. I've documented that on my blog.
• Is it perhaps time to forget about the community's favorite bogeyman and recognize that IBM, Oracle and others are a much more serious threat to FOSS at this stage?
• How can the so-called OpenForum Europe lobby the European Union for open source/open standards when its two most powerful members, IBM and Oracle, are patent aggressors against open source, especially in interoperability contexts?

This is a patent dispute with very wide-ranging implications.

Re:Congratulation ORACLE

[TheRaven64]

Google isn't really "using Java"; they are using the Java language, but almost none of the implementation or libraries.

Which is why Bruce Perens' blog entry is irrelevant. If he'd bothered to read the text that he quoted, he'd see that the patent grant only applies to complete implementations of the Java SE environment. Android uses Java-the-language but not Java-the-platform, so is not covered by the patent grant. This was intentional on the part of Sun: the aim of Java was 'write once, run anywhere' and this is not possible if various implementations have incompatible standard library implementations.

Interesting JAVA RESEARCH LICENSE

[robmv]

Just for the record: What Sun said (now Oracle still says) about reading Oracle Java source code and creating a clean room implementation: JAVA RESEARCH LICENSE FAQ Question 18

18. Does the JRL prevent me from being able to create an independent open source implementation of the licensed technology?

The JRL is not a tainting license and includes an express "residual knowledge" clause which says you're not contaminated by things you happen to remember after examining the licensed technology. The JRL allows you to use the source code for the purpose of JRL-related activities but does not prohibit you from working on an independent implementation of the technology afterwards. Obviously, if your intention is to create an "independent" implementation of the technology then it is inappropriate to actively study JRL source while working on such an implementation. It is appropriate, however, to allow some decent interval of time (e.g. two weeks) to elapse between working on a project that involves looking at some JRL source code and working on a project that involves creating an independent implementation of the same technology

Re:How ironic

[RivieraKid]

Actually, didn't Sun sue Microsoft for their usual Embrace, Extend, Extinguish tactics when they added proprietary extensions to their Java version and claimed it was still Java, thus violating Suns patents/trademarks/copyright/license terms/whatever?

They didn't sue just because MS created their own runtime/JVM, they sued because MS distributed an incomplete Java implementation, and then passed it off as the Java, something which only Sun had the legal right to do.

stop making things up

[yyxx]

Java is a spec and NOT an implementation. You are free to make your own implementation of the spec (IBM, Apple and many others do).

IBM and Apple have not "made their own implementations"; they have licensed Sun/Oracle's implementations and created derivatives.

You are not free to make your own implementation of the spec; you need to pass Sun's compatibility tests if you don't want to get hit by patent lawsuits because Sun hold essential patents for creating a conforming implementation.

For years now, there has been no implementation of Java conforming to the Java spec except for those derived from Sun's source code. That's not an accident: it's pretty much impossible to meet Sun's compatibility requirements without licensing their source code.

This would not be true if Apple cheated and did not implement some part of Java spec (which is the case with what Google did).

Google didn't "cheat", Google implemented their own platform and runtime; they just happened to use the Java language to do it. In principle, Sun/Oracle couldn't have done anything about that: Sun doesn't hold a patent on the Java language itself. But it appears as if the Android designers may not have been careful enough to avoid all of Sun's patents.