[Mono-list] FW: evangelizing mono

[Jakub Hegenbart]

V Út, 17. 02. 2004 v 11:59, Radu-Adrian Popescu píše:
> I think you're plain wrong calling C# bare metal performance when
> you've used that exact
> phrase to describe C++'s performance.
> I'm not Java against .NET here, but:
> Like it or not, the JVM's performance is superior to that of the .NET
> VM, and it sometimes 
> outperforms even C++ native code. This is not FUD, it's not
> lets-do-it-this-way-cos-it-will-prove-me-right  benchmarking, it's due
> to the differences in
> the way some code you wrote runs: compiled once to native code versus
> compiled
> to byte-code and then re-compiled and profiled and adjusted multiple
> times during run-time.
> This performance improvement has often been noticed when doing stuff
> like regexp or xml.
> I don't really see any reason the .NET VM would not achieve this state
> of the art, but it's just
> not there yet. Naturally there's loads of other areas where .NET is
> faster than Java, take for one
> GUI applications. But that's a corner-case (no, don't start cursing,
> it's probably more important than
> regexp or recursive methods) compared to the raw ability of
> dynamically re-writing and optimising
> pieces of code. And hey, let's not forget Java/IBM's SWT :-)
> 
> Cheers,

Yes, today's JVM is an amazing thing. Even if it consumes more memory
than C#, C++ and C apps (but not much more than C#!), the speed is
amazing if you imagine the level of abstraction it allows while staying
almost at par with native compiled code.

The CLI might be technologially more advance by the means of the IL
expressivness, but ain ll the implementations (even in Mono :), there are
still many things to improve. (Having said that, there were many things done
already. Thanks, Ximian!) CLI needs a few more years. And yes, Java's 
denial of AOT compilation might really be compensated by dynamic
recompilation features more than adequately. 

For an server app, it doesn't matter how fast it starts (well, ALMOST
doesnt :). The only important thing is how fast it runs and even if Gtk#
+ C# responds faster than Swing-based Java GUI on my Linux-powered
notebook, how can it be that JVM (Sun JVM 1.4.2) is some 20% slower than
C++ (GCC 3.2 -O switch) on an equivalent piece of code, while C# (Mono
0.30) is twice that slow? (I wrote some simple code to prove late/early
binding calls efficiency and the results were exactly the same for both
version on all three languages.)

For me, personally, the most beautiful things on Mono are its GPLness
and ust (althougn not explicit) anti-MS-monopoly orientation (the second
goes for Java as well of course). That doesn't mean i'm an anti-MS
zealot, that means that i just happen to like alternatives :) If the
language behind CLR was Java, i wouldn't mind.

And with Mono, the "bare metal performace" still lies far ahead. Which
is nothing wrong - it would be if it stayed this way but i strongly
diselieve that Mono won't develop. The momentum seems to be there
already. 

Just my humble opinion. Competition is good! (somebody should finally exlain it
to the Redmond company :)

Jakub Hegenbart