![[info]](http://p-stat.livejournal.com/img/userinfo.gif){kind=small}
An Open Letter to Jonathan Schwartz and Miguel de Icaza
Jonathan, you are leading the development of a Free Software, high-quality, multi-language VM runtime with an extensive class library, called OpenJDK.
Miguel, you are leading the development of a Free Software, high-quality, multi-language VM runtime with an extensive class library, called Mono.
How about a merge? We'll call the new project "OpenVM", for convenience in this letter.
Let's jump right in to the advantages for the projects:
Advantages for Mono
In one word - control. Miguel, your original goal with Mono was to bring a modern and Free Software development stack to GNOME and Linux. In many respects, you and the Mono community have been succeesful, helping spur the creation useful applications for the Free desktop, as well as getting Mono deployed in interesting applications like Second Life. However, you are largely not in control of your destiny. You're stuck implementing a clone of what Microsoft creates, and besides the fact that cloning something is much less fun for your engineers, you can't help but be behind.
By helping to create the OpenVM project, you will regain control. In an OpenVM effort, drawing on the common shared work of several corporations (Sun, Novell, Red Hat, Google, and IBM, to name a few), your engineers get to help design the future of Free Software. You will instantly remove all hesitation that the Free Software community has about your work, and have been the a key part of not one but two cornerstone projects for Free Software (GNOME, and Mono->OpenVM).
Advantages for OpenJDK
Jonathan, you have said you want to take the J out of JVM. By stepping up and adding Mono technology like a high quality C# compiler to this OpenVM effort, in the short term you will regain the eroding market share of the JVM on Windows by allowing interoperability between the growing C# code base and existing Java code. In the longer term, developer attraction to OpenVM will let you accelerate improvements to Java, and reverse gains in C# market share.
Moreover, the community agile languages such as Ruby and Python are nearly certain to join an OpenVM effort. Your company will again be at the core of the stack for the vast majority of the computing industry, from the Free Software community to the proprietary applications.
From the Free Software side, turning Mono from a Microsoft technology clone into a part of a truly Free project would eliminate the increasing use of .NET in the community.
Finally, leveraging the Mono team would bring a number of excellent engineers who know the Free desktop very well, having created high-quality bindings for GNOME, and Free applications that many people use.
Advantages for the Free Software community
The Free Software community has long been split between developers using Free and agile languages like Ruby and Python, the the Mono-based community, and a huge community of developers in the world who used in the formerly-proprietary Java in Free projects like Apache. A combined OpenJDK and Mono would dramatically further the merge of all three of these communities, increasing the control the Free Software community has over the stack and reducing duplication of HTTP libraries, database access libraries, etc.
Details
Obviously, there would be many details to work out in such an effort, like how the class libraries could be merged. My intuition is that initially OpenVM would have both JDK and .NET "personalities". Over time, the Mono .NET class library would be rebased on top of an evolved JDK class library, and eventually the .NET personality could be relegated to a separate "OpenVM-.NET emulation" project as most applications are ported to use the OpenVM JDK-based class library.
But the details are just that - where there's a will there is a way. So the open question is - who will register the domain name first?
(Anonymous)
+1
(Anonymous)
Fail
All your proposed project could really hope to achieve is getting a Java 2.0 that runs on CIL instead of the old Java bytecode. You'd just end up with Java becoming a new standard .NET dialect. Technical benefits aside, this would take care of none of your thinly veiled political issues with the Mono/Microsoft relationship.
Sounds like a really great idea.
Would it? Why?
Gosh, if only....
I think you also missed a VM - Dalvek/Android, which seems to sit somewhere between the CLR and JVM technically. I would be quite happy to develop against Android on the desktop for the most part - again, it's pretty rich, with nice extras like webkit and SQLite.
I doubt strongly that anyone is going to give up "their project". I would think mono would be the easiest to persuade, and I don't seem them being swung too heavily if .net doesn't join in. I don't see .net and Java merging, nor Google giving up Dalvek.
Do the runtimes need to merge though? IKVM is a nice proof of concept; perhaps the answer is you can choose your VM like you choose your OS at the moment. If the class libraries can be made available for any VM, and the bytecode is convertible somehow, suddenly that's very interesting. As a developer, you care about userbase and speed of development really.
(Anonymous)
More candidates.
Next up on the list, lets merge:
GNOME/KDE
Linux/BSD/OpenSolaris
Gecko/WebKit
Perl/Python
All Linux distributions
There cannot possibly be any good reasons to have this type of duplication. One size should fit all.
(Anonymous)
Re: More candidates.
Re: More candidates.
Same reason for Linux,BSD,and OpenSolaris.
Parrot
As it has been mentioned each platform is based on different approach. However as "we" have practical control over one enviroment[1] we could change JVM 1.8 into partially register based machine (with stack instruction to backward compatibility with 1.7). Is it worth? I don't know.
Also it seems that nothing stops "us" from C# etc. to JVM compillation. However it would break the ABI with .Net (not a good solution).
[1] JVM - parrot doesn't count. At least yet.
(Anonymous)
LLVM
It's nice with a common runtime, but people are never going to agree on one ;).
What about LLVM? It appears to be a more evolutionary approach. it splits runtime/garbage collection from a VM it' using it with C is actually possible ;). I think that might make it useful for future gtk runtime enviroment.
For an outsider a toolchain based on llvm would be easier to grasp than gcc code ;).
(Anonymous)
Java
I would not like Java to become...J#...which is just another rarely used .NET language.
And I would not like C# with the Java class library...cause lets face it: the .NET class library are superior to the aging Java class library (which is clearly marked by its backwards compatibility). Sometimes you need to break stuff to get it right, but has Java broken anything the last 10 years? I am a (professional) Java programmer, but for the .NET class library and nothing else I am learning C# as we speak. its all about how .NET is designed top town, while the Java library is the results of years of evolution, and thus haven't gotten rid of the mistakes made many years ago.
(Anonymous)
In one word - control."
Sun controls Java and do not seem willing to give it up, so Miguel & team switching to the JVM would not be a win for them.
[thread continuation]
For compatibility with .NET bytecode, a system could be created for translating from .NET to the new OpenVM bytecode. This is certainly possible if OpenVM adds some new codes which would be good enough to emulate what .NET has.
There are several advantages. First, in the *long term*, OpenVM has one class library, and most free programs wouldn't need to use the .NET compatibility later.
Second, the Mono engineers combined with OpenJDK engineers could create a much better runtime and libraries, and would likely get strong interest from community dynamic languages like Ruby and Python.
Re: [thread continuation]
-JRuby/IronRuby/MRI Ruby & Rubinius
-Jython/IronPython/C Python
-Java/IKVM/?(Couldn't gcj compile to native?)
Nobody writes for a VM. They write for a language that runs on top of it. And the focus should appropriately be there - on the languages.
But that does mean that either we need really good tests to validate languages with each other or implementations that write most of their class libraries in the language itself to reduce mismatches between them. Rubinius is an example of this in Ruby-land (they've collab'ed with JRuby) and there's one in Python (but I don't know what it's called).
It also means we might need to use community pressure to discourage using "cul de sac languages" like C# and Java.
(Anonymous)
(Anonymous)
is it possible to be a little less cheeky and little bit more honest?
Step back from this pie-in-the-sky revelation that OpenJDK is now totally "Free". The possibility of a fork is in this context just about meaningless-pray tell who is actually considering forking it ? right. Noone.
For someone like you with multiple years of experience in Free software communities your naivete when it come to Sun is simply baffling. I know Redhat has gone 100% pro-java in the past years, culminating in the acquisition of JBOSS, but feel-good-java-googoo-gaagaa will not change the fact that a) contributions from outside of Sun account for perhaps 0.001 % of Java code and b) that Sun has never understood or been adequately capable of working cooperatively with larger communities-Sun + Community=Sun Community=total Sun Control and token interaction with others. And no licensing does not effect this at all.
(don't get me wrong-I would love to proven wrong-but 20 years watching Sun and their "community" work makes me more than a little sceptical)
Right now Mono + GTK# is an active, vibrant part of the GNOME desktop. Java is not, has not ever been, and unless you fanboys start actually producing code-it never will be. Now one could argue that Java's strength is in the server domain as opposed to the desktop-and many, many people would agree-but if this is the case why the hell talk about a merger?
Mono is doing more to improve the state of the art of the Free desktop right now than Java ever has or will. And this despite your claims that it is doing nothing more than slavishly following MS's footsteps. What a bunch of hogwash.
You merely brush aside all of the concrete positive contributions that Mono has made to the Free Desktop, pointing towards Java which has contributed practically Zilch, and lambast Mono for being a clone of MS-which plays 0 role in the Free Desktop applications written in Mono. Talk about a strawman argument.
Mono as far as I can see it had two concrete goals since it's inception: 1) to create a platform-independent .NET implementation 2) to create a set of tools for the rapid creation of Desktop applications for the GNOME enviroment.
If you want to talk about "merging" VM's then you mean breaking the initial goals and thus fracturing Mono into 2 parts which could only diverge in the future. MS has not interest in "merging" the CLR with JVM. It ain't going to happen. If MS won't do this you want Mono to fracture it's own base and basically commit suicide.
At least be honest about this desired outcome. Don't make pretense about it pretending as if some merger would be good for the "community"- which damned community are you talking about ? Sun's "community" ? OpenJDK-non-sun-employee "community" Mono's "community" GNOME's ?
The opening up of Java code by Sun GPL'ing it is a tremendous step forward. I applaud their decision. I equally value the intense amount of work on behalf of the Free Software community to make the OpenJDK into a compelling Free Software framework. Java is fundamental to all server side software nowadays and will probably gain more traction now that it is GPL.
But Java is not of immediate practical importance to the Free Desktop-it may become more so with Web-based Desktops of TomorrowLand, but not here, not now. This is where Mono comes in-Mono also has a server side which ought not be overlooked-but it's real practical implications are for the Free Desktop right here, right now.
Please recognize these distinctions and value each for what they have to offer
On Java->OpenVM
Secondly, OpenVM would *not* have Swing (it would be part of the "Java" distribution though), which is certainly going to be hard to take for Sun.
But Sun's dream of "Java" being a development "horse pill" is pretty dead now. Swing is an OK toolkit but there's no reason for example you shouldn't be able to use OpenVM to write Windows.Forms apps on Windows, and "Gtk#" (which is really FreeDesktop/OpenVM bindings) on GNOME/Linux.
(Anonymous)
Re: On Java->OpenVM
Sun is still a company. They still want total control. Who cares that it is GPL when you can't contribute to the main project?
Face it, if you want to make modifications to Sun's JVM, then you have to fork it.
(Anonymous)
Why Merge?
The only reasons for merging projects are technical reasons and political/governing issues. Neither of those make sense.
Technically merging them doesn't make sense, because JDK and .NET are the same basic thing. There are hundreds of pros/cons to each, and each side is slowly adopting the advances of the other side which is a good thing. And the JDK is already catering to the Ruby/Python crowds.
From a political, governing perspective, JDK is open, and reasonably politically neutral.
So why merge the two?
I don't even think Mono has a good reason for existing in the first place. I know why it exists: for the same reason that there are a thousand different linux distributions. It's human nature to never-endingly fork, branch, and create new versions of products already out there.
(Anonymous)
Re: Why Merge?
Oh yeah, the closures controversy sure is a lot of fun!
Apart from that, Mono+JVM merge, excellent idea!
Re: Why Merge?
This was discussed in earlier comments; see for example
http://cgwalters.livejournal.com/14
(Anonymous)
Beautiful idea
It's a beautiful idea though, but perhaps in the same sense as communism, one global language or one global currency.
Re: Beautiful idea