Slashdot Mirror
De Icaza Responds on Mono and GNOME
miguel writes: "Here is my reply to the various questions on Mono, the future of GNOME and the Register statements." Linux Today has a copy of the email as well.
← Back to Stories (view on slashdot.org)
← Back to Stories (view on slashdot.org)
Miguel:
> or ourselves. I want to be as compatible as
> possible with the APIs that were published by
> Microsoft.
Alan:
Be assured that the day they decide you are a nuisance the VM will acquire a patented neat feature that kills you off. Just ask the Samba people.
(from Alan's reply to Miguel's message)
There is a point in your life when you realize that you have written enough destructors, and have spent enough time tracking down a memory leak, and you have spend enough time tracking down memory corruption, and you have spent enough time using low-level insecure functions, and you have implemented way too many linked lists [1]
Last time I felt that way, I dicovered Lisp. Java also fits the bill (and so does C++ with STL, BOOST and ACE.
Seasoned industry programmers will notice that the above is very much like Java and the Java VM. They are right, the above is just like Java.
The CIL has one feature not found in Java though: it is byte code representation that is powerful enough to be used as a target for many languages: from C++, C, Fortran and Eiffel to Lisp and Haskell including things like Java, C#, JavaScript and Visual Basic in the mix.
But this is surely misleading? It's true that this doesn't exist at present, but there's nothing in theory to stop it being implemented (isn't Java sufficiently "powerful" for this to be done?)
If Java is capable of doing it, then why not work on making compilers for those languages to Java's bytecode instead of working with a new language?
So what is Microsoft aiming for? Probably two things:
- Kill Java. They need to kill it before it becomes too wide-spread. They have a really good shot at doing so given Java's performance problems [insert thousands of flames from Java developers here] and C#'s advanced features like better encapsulation (you don't need to call set() and get() methods, you can map them to the = operator, for example).
- "Write once, run on Microsoft". In order to run .NET apps on another platform you would have to virtually re-implement (or substitute) the entire Win32 API, which will probably be modified at an ever-increasing pace. No company can keep up -- only open source may be able to do that, but Microsoft's opinion might be that open source is no real threat for the platforms where they want to deploy .NET. (After all, even the average Slashdotter seems to think that Linux will never be ready for the desktop -- quite idiotic, IMHO, but the more people believe that, the better.)
Insofar Ximian's Mono project may be a good thing as it offers a migration path where previously none existed (from Windows to Linux), even if .NET apps don't run properly on Mono (think about all the GUI stuff that can go wrong, for example). Besides, Java has never really been a mature technology IMHO and it's about time to replace it with something better, even if superficially less cross-platform.
Now the advantages of having a modular architecture become clear. Mono cannot break Linux, it cannot break X, it can probably not even break GNOME. There are more alternatives than you can throw a kernel image at if something goes wrong. Let's just wait and see what the Mono guys come up with. The only people who should worry about this are Sun and their followers. And maybe RMS.
Miguel's arguments sound all well and good, but I think he is fundamentally naive about Microsoft.
.NET framework are still vague. Now, why might that be? The naive might think it's because Microsoft still haven't worked some of the details out. As has been stated many times before, Microsoft is betting the farm on .NET. Microsoft are a very competitive company, with one of the most lucrative monopolies in the world. Think about that. Imagine how Microsoft will respond if they start to loose market share, or control over developers, because of Mono.
.NET! That's because it's great technology and these days we're such nice people." But as soon as they feel it's a threat, well...
Microsoft have fought tooth and nail over many years to build their monopoly. They will do whatever it takes to protect that, within the boundries of what they can get away with these days.
Some parts of the
As long as Mono stays a little project (which it is as far as Microsoft is concerned) then they will play nice. They will be able to point to it and say "Hey, look, even the Open Source people are supporting
Don't be naive Miguel. You are implementing a copy of a system still under development the world's largest and most aggressive software monopoly. Think about that.
I liked the comparison of technologies, but it misses a main point. Or rather, I believe its primary audience misses a main point.
.NET and the JVM may be limited, let's not loose track of the fact that extern "C" {} and its ilk are far more limited. Instead of limiting languages to objects without templates and continuations, the current scheme of exporting function symbols and structs is downright embarrasing.
.NET as a library/component interface and leave each language relatively intact. For example, implement your library/component in the language of choice, but export the functionality (what is currently "handled" by library symbols) in a language-neutral but far more feature-rich manner.
.NET is not perfect. The JVM is not perfect. But I strongly believe that they are a step in the right direction. For example, the current choice(?) on UNIX systems is to have C-compatible exports for libraries.
While
What would be really nice is using
Doesn't "Managed C++" allow for advanced C++ features that simply are not exported for use outside the codeblock? C# has "unsafe" blocks for its own bit-twiddling.
We're on the right track here. Let's not throw the baby out with the bathwater!
- I don't need to go outside, my CRT tan'll do me just fine.
Yes, that's exactly what it is. I think you are misinterpreting the article. The author is trying to say that runtimes can only be optimized for one language, and that the .NET stuff will not be any better at running other languages than the JVM is.
I don't know if that is true or not, but don't try to pretend this article is saying that the JVM is better in some way. The only problems that the author has with the CLR is that (1) it is by Microsoft, and (2) Microsoft is (according to the author) lying about the CLR's capabilities to be cross-langauge.
-Mike
Yes, this is a key area where I think de Icaza has a problem. He's clearly planning on implementing Winforms (I checked on the Mono site) and those are not part of the ECMA C#/CLI/CLR spec. Microsoft will not permit those classes to be cloned - its already dropped strong hints about it.
An interesting thing to do would be to write a Java compiler (backend) for the CLR, and try to implement Swing or Eclipse in a Gnome environment...hmmmm. Of course, on the other hand I can just use one of the excellent Java runtimes for Linux, and get better performance. I can still use other languages through JNI (and DirectIO in JDK 1.4).
All that said though, competition is good. Perhaps .Net and Mono will do more to spur Sun to refine Java significantly further.
299,792,458 m/s...not just a good idea, its the law!
Galileo: "The Earth revolves around the Sun!"
Score: -1 100% Flamebait
Miguel's argument can be boiled down to this: (1) writing big applications sucks because complexity grows geometrically with each line of code, and (2) integrating code written in different languages sucks because complexity grows geometrically with each line of code in either language. Basically, Miguel is fighting the same fight that every software engineer has faced since the beginning of time. Complexity grows much faster than anyone can handle, and as soon as you let heterogeneity into the equation, you're basically screwed.
The only problem that a CLR supposedly solves is the maintanence of the bindings. Instead of binding Gtk to perl and python and ada and C and C++, etc., you bind it in a library in the CLR. Except that to access that new CLR binding, you need to have perl and python and ada and C and C++ compilers that target the CLR, which is certainly a more glamorous job than maintaining bindings for every language under the sun, but is *WAY MORE* complex.
Basically, the CLR is middleware for the desktop. It does nothing to decrease the complexity of the system, it just shifts some of the complexity to another software engineer. Applications get easier to write, but new compilers need to be written and maintained.
When Microsoft's writing the compilers and you're shelling out the cash, you're only responsible for your piece of it - the application. Obviously this is good for you. But the free software community is responsible for all of it, from compilers to run times, to new bindings, to applications. *We* have to do it all. I wonder if Ximian will really benefit from dispatching software engineers to work on Mono when they could be working on the applications. Companies that buy stuff from Microsoft don't have to send software engineers to work on Mono, but free software projects will "lose" engineers because they'll have to work on Mono, not their respective projects.
The challege that software engineers face in the future is constructing systems that actually reduce the complexity of applications, rather than just shift the complexity elsewhere.
Outside of a dog, a book is a man's best friend. Inside a dog, its too dark to read.