Oracle accepts a nice round number in damages from Google Oracle has agreed to accept damages of $0 from Google in the Java case for the small bit of copyright infringement of which the judge found it guilty. Judge William Alsup cleared the Chocolate Factory of most of Oracle's infringement claims last month and ruled that Google had copied only a few small bits of Java code. Oracle …
Damn. I expected $1 more...
Oracles case hit the buffers long before the copyrightability ruling, when the jury deadlocked on Googles fair use defence. At the time Oracle reportedly looked really happy, obviously assuming they'd just missed winning and could fix the problem at retrial. The rest of us weren't well pleased. It was only after the jury was dismissed Oracle discovered the vote was 9-3 FOR Google, they reportedly looked surprised and shell shocked. At that point the API ruling barely mattered, all that was left was an appeal.
> I expected $1 more...
I expected a £50 slap on the wrist. Technically, there *was* infringement, even if Alsup was less-than-impressed with Oracle suing over code erroneously incorporated and already removed. As for RangeCheck() - well, how else are you going to code it?
BSF are taking this to appeal, of course. Just like they did with SCO's case. I expect they'll have a similar amount of luck with that...
Vic.
> Oracles case hit the buffers long before the copyrightability ruling
That's indeed true, as I and others have said on el Reg's very forum, only to be answered that the rulings were "a win for Oracle" (by Any O. and some readers).
Basically the case was comprehensively taken appart bit by bit since the beginning, and I really doubt that Oracle's lawyers are going to be able to get anything. In my view this "0$" damage is a way for them to:
1) trumpet "we won, our IP was recognised", always a big hit with the shareholders.
2) try and avoid having to pay Google's massive legal fees (since technically, it's a win).
But I have been wrong in the past (never on that particular case though).
Google didn't sign a contract with Oracle, didn't pass off Android as Java, didn't use any Sun / Oracle code aside from one small snippet and didn't infringe on any patents of note (certainly not tried in a court).
It amazes me it was taken this far. I think it would have been more productive for Oracle to work with Google, to cross licence stuff such as folding Dalvik work back into J2ME in exchange for JavaFX going into Android and so on. That might have worked out quite favourably for everyone concerned. As it is Oracle gets nothing but a large legal bill and Android steamrollers on.
> in exchange for JavaFX going into Android
AIUI, Google didn't want Java code in Android; Dalvik is a much better fit to their view of how phones should work.
The Java API use seems to be more about giving developers an environment to which they are already accustomed...
Vic.
> AIUI, Google didn't want Java code in Android;
Citation please? Andy Rubin himself said in an e-mail:
"If Sun doesn't want to work with us, we have two options: 1) Abandon our work and adopt MSFT CLR VM and C# language - or - 2) Do Java anyway and defend our decision, perhaps making enemies along the way"
But you clearly know better than him.
Google had decided not to use Java - Sun said in trial they probably would've paid Google to use it. Google didn't want to .
JavaME is no good for smartphones -it barely scrapes by on featurephones. Java SE is too bloated and has too many restrictions it would need to be scaled down and the licensing changed - to something like Davlik.
Sun never refused to license Java to Google, they just couldn't agree on the deal. therefore they would be unlikely to want to do any sort of deal now as there would be no advantage.
> Google did not want the Java VM because it is not suited for mobile devices - fact.
I find that VERY hard to believe, since Mr Rubin successfully used the Java VM for mobile devices at his previous company, Danger Inc - makers of the T-Mobile Sidekick - where he was CEO.
From the court transcripts:
"Oracle: So Danger, Inc. took a license from Sun?
Brian Swetland: Yes.
Oracle: Danger then made the JVM compatible?
Brian Swetland: Yes."
So what's up with the JVM unsuitable for mobile devices claim? Sounds like a lot of rubbish. References please.
The Danger OS was a subset of JavaSE with it's own extensions - sound familiar?
The Danger OS was made J2ME compatible (you have the quote). So that J2ME apps could also run on it. You've made a massive leap from making an OS compatible to that being what the core of the OS is.
Using an emulator I can make my PC compatible with programs for a ZX spectrum - doesn't mean the ZX Spectrum ROM is suitable for running a modern PC.
Check out http://developer.danger.com/site/faq for the reference you so anxiously desire.
More references - try out a phone with J2ME and see what it is capable of. Read the developer's guides - then consider using it for a complete smartphone OS.
@Daf L
How silly can this discussion get. Are you being obtuse on purpose?
My court transcript was for the JVM itself, not J2ME. Danger, arguibly Android's alma matter, successfully deployed JVM on a mobile device, contrary to OP's suitability claims. The link you provided further solidifies THIS fact.
The core of Android doesn't run on top of Dalvik either, we're obviously talking about the application layer.
Both Danger and Android are very similar, not surprising given Andy Rubin was the main driver behind both. The difference was Danger had a licensed JVM implementation, which ran J2ME with hiptop extensions. Which is an important fact: Hiptop apps weren't limited by MIDP/J2ME restricted functionality, but still ran on a standard JVM.
I agree that J2ME would not be suitable for a modern smartphone, HOWEVER Danger showed it was possible to extend it. It also showed that the Java Virtual Machine is suitable to run any kind of Java on a mobile device.
JVM and Dalvik are ver similar in concept, only different in implementation. One favours the stack the other registers. Comparing JVM to a Spectrum and Dalvik to a PC is, to be frank, daft.
" successfully deployed JVM on a mobile device"
Which JVM? They deployed their own JVM, which was a subset of the J2SE API and had extra API calls. This is the same as Android - they have used a subset of the J2SE API (37 elements) and added their own extensions to create their VM.
Danger did not extend J2ME they extended a subset of J2SE - same as Google (albeit via Harmony).
Danger also, later, added compatibility for J2ME, however this doesn't really have any point for Android.
The point is the Danger JVM is pretty much the same as how Android did it. J2SE is unsuitable for a mobile phone and neither Danger, nor Android tried to use it on a phone. J2ME is too limited for a smartphone adn neither company tried to use that either.
Neither company took the code from Sun/Oracle for the JVM and used it for their phone OS.
You seem to know a lot, so I ask again, why are you deliberately confusing the *virtual machine* JVM - effectively a virtual processor executing the byte codes - with high level APIs such as J2SE and J2ME?
The JVM is defined by the Java Virtual Machine Specification, over at http://docs.oracle.com/javase/specs/jvms/se5.0/html/VMSpecTOC.doc.html
This was the "virtual CPU" which Danger implemented for their applications, regardless of what APIs they then put on top - and it worked rather well.
So the point is the opposite, Danger's JVM is not the same as Android. Danger followed the official JVM spec and had it working on mobile devices.
With Dalvik however, Google went to their own VM simply to avoid the licensing involved. There's no real technical reason - outside of Google's marketing, like they use for Go - that makes Dalvik VM more suitable for mobile devices instead of Sun's JVM - and if anyone had doubts about it, Danger actually proved that years before.
I'm not sure if you are the same AC that has filled this thread - so hard to tell with ACs!
But note that Wikipedia browsing is not useful for a convincing argument...
"You seem to know a lot, so I ask again, why are you deliberately confusing the *virtual machine* JVM - effectively a virtual processor executing the byte codes - with high level APIs such as J2SE and J2ME?" - what do you mean 'high level APIs', how are they high level? They are part of the JRE and I presume by JVM you were talking about the runtime environment - they kinda go hand in hand and the thread was talking about APIs, J2ME etc. You can't sensibly decouple the JVM away from the specification.
"2) Do Java anyway and defend our decision, perhaps making enemies along the way" would not be relevant if talking about the JVM.
"...successfully used the Java VM" - as I asked what is "the JVM"? Danger wrote their own.
"we're obviously talking about the application layer." - er no, nothing to do with the application layer.
"The difference was Danger had a licensed JVM implementation, which ran J2ME with hiptop extensions. Which is an important fact: Hiptop apps weren't limited by MIDP/J2ME restricted functionality, but still ran on a standard JVM." - eh, this doesn't make any sense at all.
Danger, Apache whoever could look at the JVM specification and make clean room implementations of it. Java was pretty open. However, you seem to be claiming that Danger not only got a licence for their JVM/JRE and passed the TCK and were still able to run the J2SE implementation on a mobile device? Really, that reference I would like to see.
Do you not think that maybe they licensed the J2ME compatibility of their JVM? Kind of make more sense in the context? I don't know but maybe start here Danger Brings Java to Hiptop
"So what's up with the JVM unsuitable for mobile devices claim?" - what JVM? Who's - Sun's? With which class libraries?
"..and if anyone had doubts about it, Danger actually proved that years before." ... by making a cleanroom implementation of a JVM with a subset of JavaSE class libraries, extensions and J2ME compatibility for MIDP & CDLC specs.
"JVM and Dalvik are ver similar in concept, only different in implementation. One favours the stack the other registers .. oh dear.
@Daf L
There continues to be a divergence in the meaning of JVM between us.
I never said the JVM is the runtime environment. The Java runtime environment is - quite obviously - called JRE, which consists of the JVM plus appropriate core APIs on top.
You CAN decouple the JVM, in several ways:
Use it on its own without the Java standard library (rt. jar). Actually even without any Java (language and core API) by coding straight in a JVM assembly language such as Jasmin.
Going the other way take something like CacaoJVM, which conforms to the JVM specification , and plug in a class library of your choosing: GNU Classpath, OpenJDK or Sun's phoneME. Yes, all under the same JVM. How's that for decoupling...
So again, the JVM on mobile is not the problem. Google could have used a spec-compatible JVM just as Danger did and added their stuff, instead of going with their own Dalvik VM. The excuse that the JVM is not suitable for mobile devices is really crap.
"Rubin's quote says nothing about Java code, it is referring to Java the programming language. Google did not want the Java VM because it is not suited for mobile devices - fact."
Java VM has run on mobile devices and has done so for a long time. So it's emminently suited but it's age is part of the problem. J2ME (the VM in question) has barely changed in all the last decade and programming is an exercise in pain and suffering. Imagine programming Java 1.3 with an extremely subset of the Java APIs and that's J2ME.
If Sun / Oracle had continuously revamped J2ME and kept it up to date with J2SE / EE and had built out a bunch of OS service interfaces then there would have been no need for Google to do what they do. My feeling is that Google took one look at the mess that was J2ME and instantly decided they could and had to do better to stand any chance of pulling off a smart phone. There is actually a J2ME framework for Android developed by a 3rd party though I don't know what use it would be.
JavaFX is a scripting language that sits on top of Java. Dalvik can host Groovy, Scala etc. so it could probably host JavaFX.
The reason Google might see merit in it is because it's a very good language for writing graphical apps. Think along the lines of Flash but integrated with Java. It would serve an important role for producing widgets and apps like Currents when you want a slick UI but programming that slick UI with Android's layout model, or in Open would be a pain in the arse to say the least.
Anyway it's all academic. Google would probably piss themselves with laughter if Oracle tried to strike a deal now.
... what's the difference between Oracles expected "$1bn from the patent part of the suit and a cool $6bn on copyright infringement" and the $0 granted ... reason ... we should all hurry and sign the "The Patent System Is Broken -- And We Need Your Help" petition from the Electronic Frontier Foundation, to put an end to this nonsense ...
I'd be glad to sign it if EFF offered any actual solution. As it stands they're just complaining, but don't suggest any viable solution.
I also don't subscribe to the "patents hinder innovation" meme that seems to go around. If we look at most recent innovations we'll find they're all pretty well patented.
Ideas are all very good, but companies would not put large investments in to go from drawing board to products without any protection.
Of course this outcome is great news for Google and doubly so if they can claim legal fees from Oracle. That said, I'm disappointed because even though I don't really like the way Oracle operates, I wanted them to win so that everybody starts abandoning Java like the sinking ship that it is!
This post has been deleted by its author
Microsoft did much less damage to Java with their J++ stuff. After all it was licensed and for most part compatible.
Google on the other hand did a "Embrace, Extend and Extinguish" in one fell swoop, Android essentially destroyed Oracle/Sun's Java chances on mobile forever,
Microsoft were also sued by Sun and eventually settled forcing them to abandon it, which paved the way for .NET to take over.
I wonder if, in light of the outcome of this case, Microsoft would not have settled then and would have gone for a full trial..
I also remember how everyone was pretty angry at Microsoft for doing this. But these days it seems Google get loved for it. Weird how things change.
You're comparing apples to pears...
Microsoft licensed Java, signed a contract stating they would comply with the Java spec, and then did a 180 and made their implementation slightly incompatible with Java, while still calling it Java. Since this implementation was installed more or less by default on all new computers, they were in a position to make developers code for their implementation instead of the official, and Sun risked losing control.
Googles Dalvik isn't Java at all. Instead it's a runtime mostly compatible with the Java API, which means developers can code in a language they already know and publish for the Dalvik VM.
Hope that clears up things.
The Register 
Biting the hand that feeds IT
Copyright. All rights reserved © 1998–2024
