back
82 comments
This brought myself into a grand realization.

I've always anticipated that the right thing for myself would be to pass any opportunity to contribute to any patent applications should I ever "invent" anything potentially "worth" patenting. I have seen that patents greatly harm the software ecosystem and I don't think I would ever want to take part in any of that.

However, now that I think about it I will never even consider. I'll just say "No" right out of the way, and walk away from the opportunity as quickly as I can.

I announce that, as of today if my current, at any time, employer happened to be patent-unfriendly, only file defensive patents, never litigate anyone, and perhaps win some patent trolls because of their accumulated defensive intellectual "property" I will still say "No" to getting myself involved in any patent application. Even if I was offered a bonus for that. Or a job.

This whole Sun vs. Oracle thing made me realize that software patents are categorically undesirable.

Patents are like guns. Maybe so because I'm a pacifist. Now: sure, you can buy a cabinet full of rifles, shotguns and pistols to defend your house on the prairie should the evil gansters arrive. However, if they do and succeed in taking over your house, then they have the guns. This is exactly what has happened here. And with companies desperate for money, it's probably easier than robbing a house.

Thus, there's no such thing as a defensive patent: patents are all offensive, even if most of them (software patents) are bogus. While a good-spirited company or person might choose to not exercise the monopoly granted by patent law, it only postpones the inevitable unless the patent expires before that.

Similarly, there are no defensive guns. All guns are designed to wound or kill people. All patents are designed to take away other hackers' freedom to make the world better. I'll reconsider my stance when I see the first useful software patent and when all the useless ones are revoked.

While I think the gun analogy was a little superfluous - perhaps because we clearly look at the gun situation differently - I completely agree with you otherwise. Software patents, even if "unused", are a threat lingering above your head like a guillotine. Even if the person in charge of that guillotine promises you they'll never let it drop, you'll probably not put your head under there for fear of what could happen.

Sun guarded the guillotine. Oracle "bought them out", and now they have the guillotine. Google put its head under the guillotine. Now we get to see how sharp it is, and whether Google brought body armor.

I'm wondering how - if you created something that is potentially patentable - would you "protect" it? Not protect in the sense of "ensure a revenue stream" but protect in the sense of "ensure it's available royalty-free for any future users"?

From what I understand, Licenses (MIT/Apache/GNU) are different than Patents, so it seems that just licensing it wouldn't work. Can you receive a patent and then immediately put said patented idea into the public domain?

Truly an epic post. Halfway through it, I had to come back and upvote it before returning to the article.
Stephen Colebourne's "Oracle, Google and the politics of money" is also a great shed of light on this topic: http://www.jroller.com/scolebourne/entry/power_corrupts_abso...

I kinda agree with Stephen on the damage Oracle does to open source and the added uncertainty for collaborators on the open parts of java. I think Charles underemphasized this aspect.

I finished half my #noprocrast time limit reading it :)
http://www.xkcd.org/743/
Remember when NTP sued RIM and won over $400 million? Their patent for sending email over RF seemed pretty silly at the time too. So, while this is a good article on the whole, it may be a bit naive to assume that Oracle can't win the case on a few simple patents. This case appears to be the only reason they bought Sun, and I suspect they're smart enough not to place a $6 billion bet without some very smart lawyers feeling like they've got a good shot at winning.
Regarding NTP vs. RIM: seems like the NTP patent was, in fact, invalid as will be determined by an ongoing patent office reexamination:

http://spectrum.ieee.org/at-work/innovation/rim-v-ntp-yet-ag...

Well, one encouraging thing in Headius' post is the indications that Google has been preparing for this for a while (and we know they have deep pockets).
OpenJDK itself took years to gain acceptance from OSS purists

Recent events seem to indicate the "purists" had a point...

it's important to point out that OpenJDK actually is safe. The Java specification has a patent grant clause for compliant implementations, which obviously includes OpenJDK. We can also hope that Sun did their due diligence during the development of Hotspot and during the open-sourcing of OpenJDK to ensure other patents not covered by the grant would not affect it (but of course we can't be sure).

Outside of that, it's no more at risk of patent attacks then any other piece of open-source software.

Personally, Open Source is my platform ... gcc, python, ruby, perl are my languages ... now with exciting new developments like Rubinius, Pypy, LLVM and Parrot.

Java always had a certain appeal to it, and I've given this platform 2 years of my life ... but the corporate stench just won't go away.

And here it is again, the owner of Java ... instead of redirecting resources to Java 7 which is a crippled release already, they are starting lawsuits.

"But I think the real damage will be in how the developer community perceives Java, rather than in any lasting impact on the platform itself."

A change (for the worse) how the dev community perceives a platform is (or will lead to) a significant impact on the platform?

Or is he saying usage in big corps (where devs don't decide the platform, mangers do) won't be affected?

Minor nitpicks aside, decent essay!

I think he's saying it's not actually going to kill Android or any other Java-based platform (like some people fear), but it might make some people a little more skittish about embracing the platform and it might drive OSS development to a platform whose rightsholder doesn't go around suing people for trying to create their own version.
I think it's likely a strategic cross-licensing play, which is to say that Oracle have found they read on one or more patents held by Google and are knocking on the front door with a sledgehammer.
From what little legal knowledge I have, I think you don't go looking at your own patents that way, because then you are knowingly infringing, which means you would pay more damages.

It's simpler: they just want to shake Google down for some cash.

That Oracle chose to go "knocking on the front door with a sledgehammer" implies they want something fairly big.

Could be patents, yes.

Could be a yacht-load of cash.

Could also be software source code, or data center or fiber access, or search data, could be the search technologies and implementation, could be a partnering agreement. Or some combination of these.

Google knows what they want. Or will soon.

Whether additional information leaks out from either camp?

Very good. The patents described really are laughable. An implementation of "fork"? Really?
Patent lawyers who filed that patent would probably laugh at you for talking about kitchen utensils in respect to such an awesome patent idea ;-)
I am not a Java developer, but how is this situation is too much different from the Java/J++/C# issues that were had between Sun and Microsoft? It is a different type lawsuit, and (arguably scary) patents are involved, but it seems to be similarly motivated.

Sun originally developed Java to be a standardized, cross-platform development tool.

The original intent (as I see it, anyway) was to get some market share away from Microsoft/Intel by providing a tool that would allow a program written and compiled once on one platform to run on any platform. (The actuality is that you have to make small changes, but for the most part, this works).

So Microsoft started working on J++, and did/were doing the same thing that they did in the web browser space. They built non-standard extensions that would not be compatible from one platform to the next. Exactly the opposite of what a vendor providing an OS/Hardware combination wants, when the entire idea of the language is to make the OS/hardware a reasonable option.

Dalvik doesn't support certain parts of either SE or ME. I would have to believe that this is the reason Google is unwilling to license; they would then have to comply with one of the (bloated/inefficient) standards. (This isn't because Google doesn't have the cash to pay up).

From Oracle/Sun's perspective, this could easily be seen as a long term threat to the platform. If you have runtime compatibility issues, the ship is sunk. You have reliability issues, as with early C++ implementations (can't use 1/2 of the features); Or you have compatibility issues, as with the current state of Common Lisp implementations (many rock-solid implementations, but things are subtly different from one to the next. Aside: subtly different is the worst type). So from that perspective, that they do not want the JVM fragmented, I sympathize with Oracle.

From the perspective of the patents as described in this article, as a computer scientist and programmer, that these things can be patented is shocking. What worries me, is that I will unknowingly build something which has already been patented.

In particular, the hybrid compilation technique does not seem to be very much different from the methods involved in having a lisp (for example) with both an interpreter and a compiler. It is an interesting technique, and very clever, but how can a compilation technique be patented? Specifically this early in the history of computing. What if someone had patented using assembly instead of machine code, or intermediate representations of code? What if McCarthy had patented the AST? Or if the various ways of implementing regular expressions had been patented? It seems morally objectionable.

I honestly, truly hope that Oracle loses this patent suit.

I probably should have made this clearer, since others have asked the same question.

This suit is unlike the Sun v Microsoft suit in that Microsoft was building a licensed Java implementation, which they actually advertised as being a compliant Java implementation...and then they started making incompatible modifications to it. Not simply to the VM or by adding their own libraries off to the side, but by actually modifying some of the java.* core classes. This is obviously way out of bounds when claiming you're a specification-compliant Java, and as a result Sun went ape all over their asses.

FWIW, even though Android doesn't claim to be "Java", they've kept the core classes they ship API-compatible (and no supersetting) with Java 1.5's.

One difference between J++ and Dalvik is that Dalvik is free software. Another is that the JDK is supposedly under the GPL at this point; this is probably the first time a GPL licensor has sued a free-software compatible reimplementation of their GPL code for patent infringement. It's a new level of "shocking" in this area, although it may not really rise to the level of the SCO case.
Very good read. I'm not considering myself as a Java developer (even if I wrote some java) neither an Android one and this really helped me to have context and more background about this lawsuit. Thanks !
I suspect if the case was as open and closed and without merit as many are thinking, Oracle wouldn't have bought it.

Google aren't some tiny outfit who are going to fold at the first threat. They have very deep pockets and plenty of lawyers and there is no reason to think that they'd give in easily.

Oracle will know this and therefore we can reasonably assume that they have bought this case with the willingness to fight it (and spend the significant amounts of time and money involved in doing so).

Certainly if the suspicion is that they spent $7.4bn buying Sun primarily so they could bring this case it seems even more unlikely - you don't cough up that sort of money unless you think your case is really pretty strong.

(Incidentally I think the suggestion that this is the primary reason they bought Sun doesn't really add up - it's far too big a gamble and the damages award would have to be vast, way beyond the Microsoft / Sun damages to justify it. Oracle are a proper company with proper products, generally speaking they're not patent trolls and have better things to do with the money than take this sort of punt.)

I'm not saying that they will win it, just that the frequent claims from technologists that their case is without merit fail to explain why a bunch of smart people (because whatever you think of them over this the evidence is that the people running Oracle are not stupid, they are not SCO) with a lot of very smart, very well paid lawyers, were willing to take such a punt when their case is evidently so weak.

This one: "System And Method For Dynamic Preloading Of Classes Through Memory Space Cloning Of A Master Runtime System Process (7,426,720)"

Sounds fairly similar to one of the tricks that ETLinux used:

http://www.linuxfordevices.com/c/a/Linux-For-Devices-Article...

Prior art is not as easy to use as a defense as people usually think. On that topic, I found the talk by Andew Tridgell quite interesting:

" You need to learn to read patents. And that doesn’t mean just the abstract. In fact, many people in the free software community, a lot of discussions on sites like Slashdot, people stop at the title. And they think that based on the title they can say "Ah, that was done by the FooHits Corporation in 1925, therefore it’s not a problem". Right? And it doesn’t work like that. You can’t stop at the title, you can’t just stop at the abstract. "

http://news.swpat.org/2010/03/transcript-tridgell-patents/

Circa 2000 I and another developer at my company implemented two systems which are very good examples of prior art for this patent. Both of those systems are still in use today, and I consider the mechanism to be a standard design pattern for robust SOA components. Reading the claims, the only ones that don't match what we did are the claims that say the system is implemented in Java; ours are C++ and Perl. That should be sufficient to invalidate the patent though, at least in a reasonable world.
It is a bog-standard technique in the mod_perl world.

For instance chapter 10 of Practical mod_perl is titled, Improving Performance with Shared Memory and Proper Forking. Guess what that was about? This was published in dead tree format in May 2003, before the December 2003 filing date for this patent. And it appeared in online documentation before that.

Charles' main take-away point, at the end of the article, is that for 99% of Java developers this law suit should have no effect at all, except that it might stifle the future of the Java platform. So, maybe we just have JDK 6 forever.

Since I find myself switching between Java/Clojure, Common Lisp, Ruby, and Scheme (and would like to be better at Haskell), I am not losing any sleep over this law suit. If Java stagnates, I'll just slowly migrate to new languages.

Even if Oracle and Google settle in some peaceful way (best outcome out of the likely ones), it is very likely Oracle will continue this avenue of profit. Perhaps IBM is next, given the long time hostilities among both. Or the Android-based handset manufacturers and sellers. There's a lot of shakedown money to be made for Oracle. And it is probably even lawful in spite of it being labeled as morally wrong. Good luck.
IBM is safe, since they've played by the rules and since they have an even bigger patent bat than Oracle does. There may be tensions, but probably nothing we'll ever see from the outside.

I think other OSS Java implementations are safe too, because: a. they don't harm Oracle's business in any substantial way (nobody's using them), and b. there's no profit in going after them.

If you start to look at everything Oracle does through the lens of "profit above all else" the clouds become a little less cloudy.

As the article says, IBM's JVM is an officially licensed (and sanctioned) implementation, meaning they had Sun's / have Oracle's permission. So what could they be sued over?
I think the patent "Interpreting Functions Utilizing A Hybrid Of Virtual And Native Machine Instructions (6,910,205)" is a important arsenal, dalvik or alternate implementation would need to grow to this level some point in the future.

cutting access to a growth path can hold back development of the android platform

It sounds to me like it would be easy to circumvent, just like JRockit does (as describe in the article): instead of mixing interpretation and JIT compilation, have different levels of JIT compilation: cheap and unoptimized vs. slow and highly optimized.
Could someone explain what the heck "One of the big contentious items is the addition in Java 5 of parametric polymorphism as a compile-time trick without also adding VM-level support for reifying per-type specializations as .NET can do." means for a language implementation layman?
"parametric polymorphism" is fancy way to say "I'm declaring a type that is composed of other types".

The canonical example is a set.

In C# (that's what I'm familiar with) we have IEnumerable<T>. It represents enumerating over some homogeneous set of type T.

so when you write "var myList = new List<int>() { 1, 2, 3 };" the type that gets written down in the bytecode is List<int> (which implements IEnumerable<int>).

So the statement "typeof(myList) == typeof(List<int>)" returns true. The type you specified at compile time doesn't loose information at runtime. (For instance you can also do typeof(IEnumerable<>).MakeGenericType(new[] { typeof(int) }), which gets the Generic Type Definition and then you can fill that in at runtime).

The Generics implementation in Java 5 however was all a compiler trick. All the benefits only existed in the AST of the compiler, they never got down to the runtime. So it was easy to check that you couldn't add a int to a strongly typed list of strings, but only in source. (I think, I'm not as well read as javac / JVM internals)

Hopefully that helps.

At the VM level, List<String> is still a list of Objects that need to be cast to String whenever you access an item in the list.
Something hit me:

BSD history is repeating itself...

That was rather markedly different, since it was a copyright suit, not a patent suit. AT&T never claimed that they had patents that forbade using BSD; they simply claimed that BSD could not possibly have been written without violating AT&T's Unix copyrights.

In this case, as far as I'm aware, Oracle is not claiming that Google misappropriated any Java source code, but rather that they violated numerous patents that cover JVM-like technologies. This would be akin to AT&T saying that Linux was illegal because it violated patents it held on Unix.

Huh? Someone changed the title. Is that customary around here?
That was an epically long post. It was good.
It reminds me of the apt quotation (I can't get an authoritative source on it in 30 seconds of searching), "If I had more time, I would have written a shorter letter."
If there was a word for 'text bukkake' it would likely summarize this post.