Can Oracle Turn Java Around?

A lot has happened in the last week or two in the Java space. Oracle has remained silent throughout, but the silence is deafening.

The start of the proceedings kicked off with IBM joining OpenJDK and (effectively) disbanding Harmony. One JVM down, one to go. The Apache Software Foundation board has made their thoughts known since; they thank IBM for their contributions to date and very much hope for Harmony's continued survival with other contributors.

Stephen Colebourne has been digging into the JCP and initially suggested that the JCP should be split in two as it has become clear that the Java SE components are controlled solely by Oracle rather than being voted as part of the JCP itself. However, he then claimed that Oracle are stuffing the ballot by bringing on one of their long-term customers, Hologic, onto the JCP board. This is the first time that most in the Java community have heard their name; the other two Oracle nominees are Apache and Red Hat. Up for re-election are Google and Eclipse, amongst others.

I believe that the JCP is no longer a credible specification and standards body, and there is no remaining useful role for an independent advocate for the academic and research community on the EC.

His observations are that the JCP was originally intended as a melting pot of ideas and collaborations to bring together an advance of the Java platform and ecosystem. However, many of the tools that today Java developers use haven't gone through the JCP: Servlets were initially designed outside and later brought in; Spring has been working with the community and brought dependency injection to the masses; Apache continues to host the majority of open-source Java toolset and both the de-facto Java build tools of Ant and Maven were never JCP standards but are still used daily. Neither the de-facto standard JUnit (or the lesser known but arguably better TestNG) testing frameworks have ever been near a JSR. And arguably, JSRs have helped create mediocrity in a number of ways; many shun the Logging API for Java and use Commons Logging instead, or one of the compatibility layers that use the same API. (In fact, the existence of Apache Commons confirms that standards-driven development often miss out of general utility libraries.) Doug suggests that the JCP can be nothing more than a rubber-stamp organisation for Oracle:

Rather than fixing rules or ceasing violations, Oracle now promises to simply disregard them. If they indeed act as they have promised, then the JCP can never again become more than an approval body for Oracle-backed initiatives.

For other efforts, I cannot recommend to anyone that they use the JCP JSR process, as opposed to some other group/organization/body, to gain consensus for proposed specifications. So I expect to see fewer submissions as people begin to realize that other venues provide better opportunities.

Neil Bartlett suggests that there is already a standards body for Java that is better than the JCP:

However, a credible specification and standards body does exist in the Java universe. I will leave its identity as an exercise [OSGi], but let me just point out a couple of its nicer characteristics:

It produces fantastic quality specifications.

It has worked effectively for over ten years as a collaboration forum for competing companies.

Oracle is a very active member, but Oracle doesn’t own it. Indeed, all the full members have exactly the same rights.

All its specifications are open, and come with a non-assert patent pledge from the members.

TCKs are freely available to open source projects, and the majority of the RIs are in open source already.

Throughout this, Oracle has remained silent. With the results of the JCP election being posted after the elections close on November 1st, Oracle may choose to wait until then before publicly responding. But Ian Skerrett of the Eclipse foundation think that Oracle needs to get a clue about how to handle community instead of treating them as customers:

I hate to tell you but you need some help with the Java community. The basic problem is that people don’t trust you and you aren’t very good at community building; in fact you are pretty bad at community marketing.

Right now lots of people are talking about Java but there is a silent void from you. The conversation is happening and you aren’t participating, so people speculate and hypothesise; not great for building trust.

This has been brought to the fore with Apple deprecating Java on its Mac platforms, strongly suggesting that Apple will no longer be shipping Java on existing or future versions of its operating system (it's already been confirmed that it will ship without Flash installed). An email, purported to be from Steve Jobs, suggests that Apple shipping JVMs may not be the best way to do it; the implication is that another player (like Oracle) would be better placed. There are many that think Apple's tight integration with the display pipeline, as well as the recently-released hooks for the fast shutdown, might suffer outside of the Apple platform.

Of course, Oracle may not worry about the lack of Java on the Mac platform. There's relatively few Java applications on the client anyway; and despite efforts by Apple to bring Mac OSX to the server, Apple's legendary secrecy and hidden hardware roadmap is incompatible with most server-based purchasing requirements. Oracle doesn't even ship its namesake database product for Mac; though some of its database tools are Eclipse based which (currently) runs on OSX.

Whatever the reason, Oracle is doing itself no favours by remaining silent on the issue, and the damning of the JCP by Doug Lea coupled with Ian's comments indicate that whilst Oracle is in control of the Java platform, it has lost its connection with the Java community. And although OSX is a minority platform (taking up less than ten percent of Eclipse visitors), Apple has been seen as a technology leader and one that cuts dead-wood (floppy drives, parallel ports and now built-in optical and hard drives) when it begins the transition to obsolescence.

We did ask Oracle for a comment but they declined our invitation.

Oracle needs to clarify what is happening with the JCP, and comment on OSX's removal of Java. Oracle can still turn this around, but the silence is damning. Oracle may have bought the rights to Java, but it hasn't bought into the Java community.

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.

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 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.

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 ...

Oracle's inability to respond to reasonable press inquiries should not be construed as Oracle's lack of responsibility to its customers and its constituencies. There are tens of thousands of Oracle employees that wake up and go to work each day to take care of customer needs.

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.

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.

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.

You know, nobody doubts the intent is there... I think. However, "Open World/Java One" says a lot - JavaOne is no longer the primary focus, but Oracle is. People I'd spoken to about JavaOne seemed to feel that the thrill was gone, so to speak, that the vibe that made the conference special had disappeared.

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 don't think "nothing" is happening - I'm sure things ARE happening. But what *I* see happening isn't encouraging. Oracle gutting the JCP isn't a positive thing; maybe Oracle should have done what it had wanted done when Sun was running Java? Instead, Oracle's doing what they complained about Sun doing.

Further, the problem isn't that nothing is happening - it's that nobody is telling us what's happening. It's not about inactivity - it's about visibility.

Plus, I can't really see governments stepping in to do something about Java.

[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.

Sure. Yet... the silence, the total silence except on the part of a few Coherence architects, it is deafening.

This is basic, basic customer service. You say Oracle's focused on it? Then you'd better get some results out of it. You know the drill: one negative report is worth twenty positive reports. The way Oracle has been acting, it's like you marketing gurus have it backwards, and you think Cameron's "We're working on it, our customers will be happy" makes up for a ton of people being visibly, answerably, upset.

It doesn't. In fact, as I said before, the non-statements make it worse, despite my having a lot of respect for Cameron (and a lot of other Oracle employees.)

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?

Let's see, this is the Oracle Corp. that had a lot of opinions on what Java should have had done a good bit during the Sun years, right? And this is the Oracle Corp. that has a large array of Java products?

While I'm sure there's a large amount of truth in that last paragraph, it's fallacy to think Oracle is having to build a strategy out of whole cloth.

Further, you really want to make things better? If that's really the case (*snicker*) then say so. You haven't; you've said that you "find it astounding" that it would take less than a few years. Another non-statement, in other words.

Your lawyers will be proud.

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?

Heh. The lawyers clap yet again.

We're so sorry, O Oracle - we know you aren't telling us anything we need to know (like, oh, even "we're working on it, we care" or "please wait for us,"), instead having a rare few offer things from which we're supposed to passively infer that the future will be bright for Oracle Corporation. That definitely makes up for the lack of information.

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.

If only "Don't Panic" didn't come from one of the most effective authors of absurdist humor.

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.

Having interviewed Henrik (basementcoders.com/?s=henrik) I agree that the intent is very much there, but we need proof, and I guess that implies time.

My problem at this moment is I have yet to see *any* type of reaction, press release, concern, reassurance from Oracle about Apple's "Java Deprecation" news. What the heck is up with that? PR 101 here people! Who cares if the Enterprise doesn't run on Mac, a lot of Java developers do! So we don't show up on Oracle's earnings sheets, our effect on Java (and thus Oracle's bottom line) is much more systemic than a column on an earnings sheet, we are a decent portion of a Community they claim they are committed to fostering.

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.

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.

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.

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.