Can Oracle Turn Java Around?

Oracle, such as IBM and Microsoft on other epochs, think it self is dominating the world and no have any responsability to give us any satisfaction ...

It will be interesting to see Google reaction, as Android's VM is based on Harmony...

I'm assuming that Oracle realizes that you can't run Java like Microsofts runs .NET. If not, Oracle could wake up one day and find itself irrelevant in the Java world.

Oracle has pissed off the open source community, pissed off Google, pissed off Apple. Their only remaining friend is IBM, who is not exactly an aggressive force in modernizing the platform.

Java's peaked, and it's time for the open source folks to begin looking forward. Scala, Google Go, some non-scripting environment will mature soon enough that we can begin doing incremental transitions off of the Java platform.

The only viable alternative VM I can think of is Mono. Scala, Java, and Clojure already run on it...even if it is a second class citizen compared to the JVM.

Good luck running Scala _off_ the Java platform. There are NET versions of Scala as well Clojure, but they're always lagging behind the Java versions.

The Java-ish libraries are based on the class libraries in Harmony, not the Dalvik VM.

www.petitionspot.com/petitions/macjdk

Perhaps this helps, I'd rather have Apple providing the JDK. But anything is better than nothing.

I don't want to switch my dev environment.

Cheers

Michael

Already under construction

clearly you haven't taken time to study mono vm. I've only looked at it casually, but the current release is really targeted at client side apps. The garbage collection and memory management of the current mono vm isn't there yet for heavy serverside stuff. Just go look at the mono-dev mailing list to see for yourself. That's not to say mono isn't good. It's just that it hasn't been fine tuned for heavy serverside stuff. It takes a lot of time and resources to do that and they just haven't had the man power so far.

Clearly you didn't understand my response. I wasn't saying that the Mono VM was some drop-in replacement for those JVM languages. In fact, I pretty much stated it.

But you're right in that obviously it hasn't had the resources and the man-years to fine-tune. By the way, Mono 2.8 just got the new GC. So slowly, but surely Mono is coming along. I'm actually surprised that Novell has funded it as much as it has considering the financial situation Novell is in.

I know why IBM didn't bought SAN. IBM saved its money allowing Oracle buying SAN and waiting for the moment to join and to participate in the JAVA's fork. Also, IBM doesn't need SAN hardware at all.

Oracle. Did you asked to your Oracle before doing business? - I'm sorry... I've never saw you as a good database product and you'he proved you are not good on JAVA as well....

Java4ever!

Davi

I would not like to abandon Java. It needs to be saved.

I hope Oracle acts as an responsible Java community member, by making its intentions clear on Java Most importantly it needs to clearly clarify how it is going to ensure that community plays an active role in deciding the future of Java.

I'm not an expert on GC, but it seems like the Mono people suffer from NIH syndrome. They should just copy JVM's generational GC approach, instead of reinventing the wheel. I've done my own personal tests comparing MS CLR and Mono. For my apps, Mono is consistently 30% slower than .NET CLR. My bias opinion is Mono isn't a viable replace for JVM in the current state. Maybe in another 5-8 years if they take time to study openJDK and learn from existing prior art instead of reinventing it.

Did you test on the new 2.8 release? Maybe you can email the guy that implemented Mono's new GC. I doubt he's unaware of existing, high-performance GCs.

Mono 2.8 has a generational GC (www.mono-project.com/Release_Notes_Mono_2.8 ).
Just for the record: generational GCs have existed long before the JVM, there's nothing to copy from Hotspot's GCs. As a matter of fact, Azul has the leading edge in JVM GCs:
www.infoq.com/news/2010/04/cliff_click_gc_pauses

Oracle, such as IBM and Microsoft on other epochs, think it self is dominating the world and no have any responsability to give us any satisfaction ...

No doubt, Cameron. And Oracle has a lot of good people still working for it, despite the very public egress some of its brightest minds have been making.

But internet time is passing; Oracle's not paying attention. In the old world, it was fine, wait a month or two for publication cycles to pass, THEN respond with a two-inch column in the Wall Street Journal. Now: it should be hours before a response is made, even if it's something light on content.

Look at your own response: You didn't actually address anything! In fact, you did the opposite. Good for you for following the company line (Big Brother is proud?) - but all you said was "We pay attention to our customers," and we're supposed to infer that we're part of the constituencies to whom Oracle's being responsible.

The worst thing is that it's not being responsible to Oracle's "customers and constituencies" (being specific: us, not whoever you define as being in those groups) to not respond - no matter how your employers are being responsible to who we consider to be your customers.

I'm all for profit, but in my view, this is a bit of a golden goose situation; Oracle wins by actually being responsible, not just by being responsible behind an iron curtain. Likewise, every time you damage Java's momentum - fragile in the view of public opinion - you drive the knife in the goose's neck just a little more.

Oracle is not only one person ,, there r teams of directors they take each and every action to ofcourse en-cash java.. Java is now in under banners of Oracle and oracle sales team will not leave product invasion to community...guys they paid lots of bucks to eat smaller fish(SUN)

I agree 100% generational GC existed long before JVM. I disgree there's nothing to learn from Hotspot GC. Implementing a GC isn't trivial at all. Azul's new platform looks awesome, but I seriously doubt the Mono team can match Cliff Click. Then again, 99% of the programmers out there don't have Cliff's skill, so it's not a fair comparison. If I'm not mistaken, Cliff wrote part of the GC when he was at SUN. The mono team could learn alot by reading openJDK GC code. Many years of work has gone into it, it would be foolish to not study it. But that's my bias opinion. I happen to think when time permits, a developer should do as much research as time allows.

Here are some Mono 2.8 with the new GC (actually 2.7) benchmarks compared to .NET

It's not like the Mono VM developers aren't aware of prior art. It's a matter of resources in getting it done, and getting it done right.

It's simply amazing, then again perhaps it's not, the doom and gloom that is unfortunately being reported and perhaps perpetrated by parts of the community at the moment surrounding Java. As an Oracle employee I for one can see (at some distance mind you) the ridiculous amount of effort going into both ensuring that the Sun acquisition runs as smoothly as possible (as it should for all acquisitions), and also the shaping of Java into something fantastic for everyone. You only had to be at Open World/Java One to witness this.

While I don't know and for that matter could not comment on the internal process, it's completely ridiculous for anyone think that nothing is happening. I mean, a huge part of Oracle depends on Java and letting it suffer would not only severely cause problems internally but also would undermine all of the effort Oracle makes with customers, the non-customers, competitors and the community. I mean, the Oracle stock price would have been killed. Further I'm pretty sure several governments around the world, including the USA would have something to say about such a concept.

Let's be honest, these things are never perfect and some people just won't handle the transition very well. Some will leave. Some will become very emotional. Some won't care. Others however will flourish and new leaders will emerge. Worst of all, some people just won't be able to cope mentally and will rush to all kinds of non-sensical conclusions, perhaps perform some rash actions that they may later regret, or will simply say "I've had my time, I'm not interested in the next state and I'd like to do something else". All of which I find deeply saddening, especially for the great contributors, but life moves on and we must respect everyone's decisions. We certainly should not jump to conclusions or attempt to read between the lines. In almost every case, not all of the information is presented, so random irrational conclusions just makes the situation sadder that it already is, especially for those involved.

Of course this is just my personal opinion, but having been through an acquisition with Oracle, it takes time for things to settle down and for decent intelligent plans to develop. For some reason it seems that some people in the community like to think that everything happens at "internet speed". Personally I think this is a ridiculous and misleading concept. People simply don't produce entire products, strategies and direction in milliseconds. Nor do they do it in a vacuum. Personally I think it would be irresponsible to respond to every crazy rumor in the media/on the internet, because almost all of them are just that. Rumors.

Personally I find it astounding that any company can acquire tens/hundreds of thousands of people, technical and non-technical, merge road maps for hundreds of products, some disjoint, others overlapping, get architects and designers to talk to each other, usually in different countries (and languages), consult with customers, consult with leaders in the community (should they wish to help) and formulate any form of coherent direction in anything less than a few years. Most small companies have problems simply explaining their business models for a year out, let alone something the size of an integrated company like Oracle. And yet, everyone wants an answer immediately. Who knows how long it will take, but one thing is clear. It shouldn't be rushed - we don't want to make it worse right?

I don't know about you but I find the lack of appreciation of the effort involved in any one of these activities and/or the people involved from the various companies involved in any acquisition, be it Sun, Oracle or otherwise is both naive and disrespectful of those tasked with the enormous challenges. I really admire those who put themselves forward to take on such challenges during an acquisition as there's a huge impact on their personal lives together with a great risk of endless public and personal criticism (at internet scale) from the hords of arm-chair commentators, with generally and probably demonstrably little clue and/or responsibility - perhaps apart from self promotion?

Sadly all of this is completely reminiscent of the rumors, blogs and presentations we saw that circled when Tangosol was initially acquired by Oracle, the rumor being that Coherence was going to be killed and/or was dying. All rumours.

Again, these are just my personal observations and they would apply to any acquisition. As I've found over the past few years having survived and I think flourished through an acquisition, things are rarely as bad as they seem.

The late Douglas Adam's was spot on when he wrote. "Don't Panic". I couldn't think of more fitting advice for a restless community at this point in time.

Brian Oliver
---------
Architect | Oracle Coherence

It's simply amazing, then again perhaps it's not, the doom and gloom that is unfortunately being reported and perhaps perpetrated by parts of the community at the moment surrounding Java. As an Oracle employee I for one can see (at some distance mind you) the ridiculous amount of effort going into both ensuring that the Sun acquisition runs as smoothly as possible (as it should for all acquisitions), and also the shaping of Java into something fantastic for everyone. You only had to be at Open World/Java One to witness this.

While I don't know and for that matter could not comment on the internal process, it's completely ridiculous for anyone think that nothing is happening.

[snip!]

Of course this is just my personal opinion, but having been through an acquisition with Oracle, it takes time for things to settle down and for decent intelligent plans to develop. For some reason it seems that some people in the community like to think that everything happens at "internet speed". Personally I think this is a ridiculous and misleading concept. People simply don't produce entire products, strategies and direction in milliseconds. Nor do they do it in a vacuum. Personally I think it would be irresponsible to respond to every crazy rumor in the media/on the internet, because almost all of them are just that. Rumors.

Most small companies have problems simply explaining their business models for a year out, let alone something the size of an integrated company like Oracle. And yet, everyone wants an answer immediately. Who knows how long it will take, but one thing is clear. It shouldn't be rushed - we don't want to make it worse right?

I don't know about you but I find the lack of appreciation of the effort involved in any one of these activities and/or the people involved from the various companies involved in any acquisition, be it Sun, Oracle or otherwise is both naive and disrespectful of those tasked with the enormous challenges. I really admire those who put themselves forward to take on such challenges during an acquisition as there's a huge impact on their personal lives together with a great risk of endless public and personal criticism (at internet scale) from the hords of arm-chair commentators, with generally and probably demonstrably little clue and/or responsibility - perhaps apart from self promotion?

Sadly all of this is completely reminiscent of the rumors, blogs and presentations we saw that circled when Tangosol was initially acquired by Oracle, the rumor being that Coherence was going to be killed and/or was dying. All rumours.

Again, these are just my personal observations and they would apply to any acquisition. As I've found over the past few years having survived and I think flourished through an acquisition, things are rarely as bad as they seem.

The late Douglas Adam's was spot on when he wrote. "Don't Panic". I couldn't think of more fitting advice for a restless community at this point in time.

Being aware of prior art and needlessly re-inventing GC are two different things right? Clearly, the first GC that Mono had wasn't very good and isn't as good as the new generational GC. I agree the developers were probably aware of GC. It's another thing to invest several years studying GC before implementing it. I know we "us programmers" often don't have the luxury of research time, but open source is "suppose" to allow more research time. In my own open source projects, I take time to study prior at before implementation. By study I mean take time to read the latest research, analyze other open source projects, review existing textbooks and discussions in forums.
The last time I benchmarks Mono was last year, so I haven't tried the latest build. I'll give it a try and see if they've really made a difference.

I just tried 2.8 release on my rule engine and I'm happy to report 2.8 is faster than previous releases, but it's still 20% slower than .Net 3.5. I also noticed higher memory usage with Mono 2.8. they are making progress, but more work is needed. Eventually they may get there.

One of my favourite quotes:

Words are not deeds

Remember that you have to explicitly pass in the command line argument to invoke the SC GC.

thanks for pointing that out, I totally missed command line argument. I ran the same test with --gc=sgen and it's 18% slower than .Net 3.5. That's an improvement, but I noticed the generational gc eats up 25% of the CPU time on my quad core box when my rule engine is idle. When I run Mono 2.8 without generational GC, I don't have that behavior. My bias opinion is the generational GC has a long way to go.
Again, if only the mono guys would study the GC code in OpenJDK, they could skip alot of mistakes. The JVM guys at sun and Clif Click spent a lot of time getting generational GC so it performs well. It's just silly to ignore the wealth of knowledge in the code. My opinion is still the same, Mono in the current state is not a viable replacement for JVM. Give it another 5-10 years, it may get there.

Again, if only the mono guys would study the GC code in OpenJDK, they could skip alot of mistakes.

Being aware and actually studying it are two different things. I'm aware of openJdk gc code, but I've never spent time studying the code in-depth. I've studies several papers on GC algorithms going back to 2002, but that's quite different than spending 12 months studying openjdk. There are issues and subtleties with GC implementations that are rather tricky from my pedestrian knowledge. I'm sure once you dig deep into implementation, the issues are far more complex and tricky. If mono developers don't want to study openjdk for other reasons that's fine, but it's their loss. The bottom line is Mono 2.8 generational GC is still years behind JVM 1.3.1.

Looking at this old thread, it appears the mono people suffer from NIH.

lists.ximian.com/pipermail/mono-gc-list/2008-Oc...

They dismiss openjdk gc without having studied it in depth. Microsoft's clr was influenced by jvm gc and the performance of .Net 2 and 3.5 clearly show better performance than Mono. It's pretty clear many of the issues with GC in Mono result from design choices, so it's not an easy fix. If that's really true, achieving good performance will take a lot longer and makes Mono a less likely replacement for the JVM.

Obviously you have some preconceived notions and opinions that you intend on sticking with no matter how wrong they are. Many others are happy with Mono. Have fun with the JVM or the .NET runtime or whatever.

Once again, you're just not reading things correctly, or you're so stuck in your position no matter how wrong your premises are, that you've basically forced yourself into making things up as you go along. Have fun.

I'll happily admit I'm wrong when I see clear proof otherwise. I didn't make up that thread. I spent 30 minutes reading the gc thread to "try" to understand where they are coming from. Unfortunately, the gc thread discussions don't really reveal anything. I've been following Mono dev for 5 years now and lurk on the Mono dev mailing list. I would love to see Mono reach the same maturity as .NET and JVM, but I just don't see it today. That's not to say it's not suitable for general consumption. quite the contrary, it works fine for my open source XML schema compiler and for GUI stuff it seems to be ok. That's a completely non-scientific opinion on my part. Others might disagree. I do have biases and some preconceived ideas about most everything, that's without a doubt. I don't believe everythhing is black or white, to me everything is a shade of gray. I've recommended people try and use Mono dozens of times over the years, so my intent isn't to make a blanket statement like Mono sucks. Mono has achieved alot, but there are major issues if someone wants to drop in Mono in place of the JVM. Some Java users aren't going to use Mono because it's server side performance isn't as robust as Jdk1.6. That's not fair, since java is older and has a 10 year head start. Unfortunately, reality isn't fair.

Peter, the problem isn't really that Mono doesn't work for your needs or even if you're sticking to your guns regarding your opinion whether new facts have come to light or not.

The problem is when you make assertions like "Give it another 5-10 years, it may get there." or "The bottom line is Mono 2.8 generational GC is still years behind JVM 1.3.1." when you're not following the progress of Mono, which clearly you haven't since you weren't aware of 2.8's new GC. It's just better to say that Mono doesn't work for you at this time instead of making outlandish claims when you're not in the know about said technologies.

And I'm curious why you distorted what was said on the link your provided to the mailing list.

"They dismiss openjdk gc without having studied it in depth. Microsoft's clr was influenced by jvm gc and the performance of .Net 2 and 3.5 clearly show better performance than Mono. It's pretty clear many of the issues with GC in Mono result from design choices, so it's not an easy fix. If that's really true, achieving good performance will take a lot longer and makes Mono a less likely replacement for the JVM. "

That statement clearly does not reflect what Paolo said. First off he mentions the license which is/was incompatible with Mono. Secondly he states that OpenJDK's GC has different requirements than Mono, e.g the JVM doesn't support value types or managed pointers.

So there's no indication from those statements whether Paolo did or not study the openJDK GC. Also, there's a difference between Microsoft's GC being influenced by Java VM and "studying it indepth". Obviously, Microsoft engineers wouldn't have been permitted to study Sun's Java GC for legal reasons. So the only conclusion you can make is that there are general technical concepts that were gleaned from the Java GC without studying it "in depth". And there's no indication that Mono engineers weren't aware of these technical implementation strategies at a general level for the Java GC.

You clearly overestimate the cost/benefit ratio of studying tens of thousands of line of complex code that much of isn't going to benefit you anyway. It's much better to glean the generalized conclusions of the implementation than studying code.

Like I said, it's my opinion. Right or wrong, I say what I feel. I never claimed to be an authority and I'm sure plenty people will disagree. I've have been reading mono dev list for many years, so it's based on my own misguided side line perspective.

regarding Microsoft, I could be wrong, but I believe they learned quite a lot from java. how much they actually learned is only privy to microsoft, but there have been interviews in the past with clr developers. My memory is faulty, but I "seem" to remember microsoft clr developers saying clr gc is quite similar to JVM. Again, that's not a scientific fact and is based on faulty memory.

The reason I feel it's 5-10 years is it took java 3 versions to get server workloads to work well. Lots of people remember how badly java 1 and 2 sucked on the server. Given it took Sun quite a few years to get generational GC to work well, I'm guessing it will take about the same amount of time. Microsoft went through similar growing pains to get .Net 3.5 to where it is. It's not scientific, but it seems to take 4-6 years to get generational GC working well. Given Mono only started the generational GC in 2009, how reasonable is it to assume they can magically shorten the time?

Actually, I believe SUN permits people studying JVM GC as long as they don't copy code or have sufficient time between the time they study the code and attempt to implement Java. In the case of C#, those restrictions doesn't apply since it's not Java.

One point I completely disagree with you is the cost/benefit of studying tens of thousands of lines of code. I have an open source RETE rule engine. Before I implemented my engine, I spent over 12 months reading over 50K lines of code before attempting an implementation. If I didn't do that, it would have taken me 5-10 years to get an implementation that is half way decent. By studying for 12 months, I was able to shorten the time to 3 years. So from my own experience working on complex applications, the benefit is tremendous. I'm sure plenty of people will disagree, but that's my first hand experience.

Blah....InfoQ just ate my response to you.

I'll just say that I found your 12 months of reading 50k lines of code interesting. Besides just reading the code what else did you do to learn it - test cases, reverse engineer to UML, notes, mind maps...?

Microsoft (like many other companies) does have very strict policies regarding reading non-liberal (not BSD/Apache..) code, so it's more likely that they didn't read any code, but learned from general technical strategies that had been communicated by the JVM team.

I would be interested to see in say 3 years in what cases using Mono would be show stopper, where using the CLR wouldn't be - as opposed to dropping down to write some native C++.

too bad infoq ate your first response. In those 12 months I read the source code of several rule engines. A short list is CLIPS, JESS, JLisa, several prolog implementations, OPS5 documentation, Art documentation and a few others. I compared the designs and approaches across the engines to see how they designed it and tried to figure out "why" they made those design choices. I also read every single paper on RETE I could get my hands on. By the time I started my in-depth study, I had already spent 3 years using JESS and had profiled/debugged it numerous times. I also did some work extending JESS to add functionality we needed for a project.
With CLIPS, I looked at different versions to see how it evolved. Even with 12 months of study, I missed a ton of lessons. As I began to implement my engine, I kept going back to see if the other engines encountered the same issues and look for inspiration. In reality, studying prior art was a huge help before and during implementation. Even in cases where I chose a different design, the other engines encountered similar issues. Looking at how they addressed those issues help me figure out solutions that wouldn't work.
I did a similar thing when I wrote my XML Schema compiler for C#. Before I implemented it, I had already studied castor, jaxb and worked on 2 other schema compilers. All of that study and practical experience shorten the development time and increase the quality.
Others will disagree, but even though Mono has different requirements, many of the same problems and issues with generational GC will apply. Studying it and learning those valuable lessons can be a huge benefit. From my own experience, the theory of something is often quite different than the reality.