There was a post and comment thread on Javalobby/DZone (Did Sun C&D them to get the name changed too?) regarding the ASFs ongoing battle with Sun to secure a test kit for Apache Harmony. It's interesting because of the confusion that still exists surrounding the issue. It's worth a read through. Be sure to read my comments at the end, as I try to frame the problem around the core issue of spec lead obligations, and how Sun's behavior is threatening the JCP's ability to deliver "open" specifications.
Anyway, I saw the thread late, and when I was traveling to London for QCon and jetlagged and tired, so I skipped over Dalibor's response (as I know he understands the facts) and tried to address the comments from others.
Yesterday, someone suggested I read his response, as it represents a really unique change in Sun's positioning of the situation. I think it boils down to the following (my interpretation):
Sun is withholding TCK licenses from those of us doing independent implementations for our own good. Passing the tests is hard, Sun is very concerned about us, and Sun don't want us to waste time and resources.
In the thread, Dalibor says :
So why does Sun restrict the OpenJDK Community TCK to 'substantially derived' implementations? I wasn't at Sun when the license was conceived, but I think the obvious answer is that TCK testing is a lot of (manual) work, even when one is starting from a feature-complete implementation, like OpenJDK 6, and just needs to focus on setup, testing and bug fixing.
I keep reading this over and over, thinking "he didn't really just say that, did he? He must mean something else..." Later on, he says :
So, in a world in which any compatible free software Java SE 6 implementation in the foreseeable future is likely going to be substantially derived from OpenJDK 6 for very simple, rational economic reasons (it works well, it can be done on a rational schedule, etc.) - do you just toss the TCK binaries over the wall, or do you nurture the community of free software, fully compatible Java SE 6 implementations and work on gradually having a sequence of doable success stories, while expanding the clout of the platform? The latter approach works actually much better in practice, as experience shows, and has already delivered several fully compatible, fully free software Java SE 6 implementations.
This is such utter, self-serving nonsense, it's hard to know where to start. Let me throw a few facts into this :
The only logical reason why "any compatible free software Java SE 6 implementation in the foreseeable future is likely going to be substantially derived from OpenJDK 6" is because Sun won't allow any other free or open implementation to get a TCK license. If people can't get a license for the test kit unless they agree to add Sun's terms to the license under which the implementation is distributed, then of course you won't see any other open implementations that are compatible, because Sun's additional terms aren't open. Without the TCK, you can't test compatibility. If you can't test compatibility, you can't be compatible. Nice how that works out for Sun, doesn't it?
Sun has made the mistake of underestimating what others are capable of doing before. When we started Apache Harmony, they were very gracious and welcoming publicly, as (so the inside baseball goes), they were utterly convinced internally we had no hope of succeeding. Their perspective changed radically a year later when we showed up at JavaOne with a functional implementation of AWT and Swing, and good progress with a virtual machine w/ a JIT and modern GC. (Ironically, the lore has it that Sun was running the TCK on Harmony to track our progress...) So implying that doing an independent implementation is economically irrational is either conveniently forgetting history, or willfully misdirecting the discussion.
Finally, I'm just astonished that Dalibor of all people - someone I respect, with a very commendable track record of open/free software contribution and leadership - would be directly suggesting that instead of a free ecosystem where people are able to spend their time and effort where they choose (independently implementing a spec and testing it), that it would be better instead to artificially limit work only to [the Sun controlled] OpenJDK codebase and derivatives (why do I keep thinking of Bush's limitations on stem-cell research here?) for the "clout of the platform" (for the good of the State?).
This stinks. The beauty of the Java ecosystem is that there can be multiple implementations of a spec. This has served us so well over the years, I'm surprised that I have to bring this up.
Think about Java EE for a second. (BTW, we had the same knuckle-headed resistance from Sun when the ASF licensed the Java EE TCK for the first time for Geronimo.) The incredible choice we have had over the years - Apache Geronimo, JBoss, Sun's Glassfish, IBM's WebSphere, BEA's WebLogic, Oracle's appserver, JOnAS, etc - gave users options in licensing, support, performance and features. Without sacrificing compatibility (which was Sun's public motivation for the resistance). We've also had beneficial variety in the Java SE space - Sun, IBM and BEA all had competitive, compatible SE implementations. While all licensing Sun's class library implementation, they had independent or semi-independent virtual machines, which helped drive benefits in performance, stability and manageability to a degree that a single-vendor ecosystem would never have realized.
Think of the positive, constructive disruption that Google's Android platform (which is powered in part by Harmony's class library) is bringing to the phone/embedded ecosystem. Smart phones are exciting again.
I hope I'm just misunderstanding what Dalibor is trying to say.