Advantages Of .NET Over Java

ansonyumo writes "ZDNet is carrying an article written by one John Carroll that outlines specific advantages of .NET over Java. It's written from the point of view of a Java advocate who has 'seen the light.' First of all, comparing .NET and Java isn't very fair; you have to compare .NET and J2EE. When you level the playing field, most of his arguments readily fall apart."

Comments

J2EE response

[wickedhobo]

A lot of this is basically a load of crap. Plenty of people use XML for configuration issues. I personally still use text for most of my config files, just because it requires simpler and easier code.

And all of the default configuration files in J2EE ARE xml. web.xml,ejb-jar.xml, whatever.

Also, what's so great about having your "system wide " xml parser? In my world, you specifically don't create environment variables for your XML jar's because that makes it a common resource and creates conflicts. What if you want to use a different parser and both parsers have a class called XMLParser? How does MS deal with knowledge of which is which. J2EE servers (for the most part) simply provide application level resources (WEB-INF/lib and WEB-INF/classes) and server-level resources (app-server/lib).

Next: Metadata: XDoclet provides this ability and a lot of people use it. More importantly, it's not tied. You can use your own system.

Next: I honestly don't know enough about assemblies, but it does look like there are some cool things in there. I have to admit, CLASSPATH for Java can be clunky. However, JAR/EAR/WAR is pretty good stuff, and does most of what people need.

Next: The remoting issue is a non-starter. The protocol is really up to the vendor, and some vendors provide proprietary, somy RMI/JRMP, some strict RMI-IIOP. SOAP also changes some of this (no advatages to either side).

So blah, for the most part.

C#/.Net vs. Java/Java

[GCP]

I've used Java longer than the reviewer -- since it was an alpha. I still use it and am an official participant in the JCP. I plan to continue using Java, probably for years to come.

That being said, I find the C# language to be significantly better designed than the Java language. Things like delegates are a great improvement over interfaces. When Anders Hejlsberg was still at Borland, he tried to persuade Sun to use them in Java instead of the interface approach and they just blew him off. "Syntactic sugar" they called it, and then they went ahead and implemented their own syntactic vinegar. I'll take the sugar, thank you.

Using "properties" in an OO language is a natural.

a.b.c++ calls a set() method instead of directly accessing a member var named c. (The c property may not even be backed by a variable. It may be calculated on demand.) In Java, to use OO methods instead of exposing private variables, you would do something like

a.getB().setC(a.getB().getC()+1);

although usually it would be broken into several simpler steps with temp variables for ease of reading.

C# makes it a breeze to create visual interfaces to object properties without losing the encapsulation of the implementation of those properties.

There are so many other improvements in C# relative to Java that it really annoys me to hear the political refrain "C# is just a knock off of Java". It's such a superior "knockoff" that, for the first time in years, Sun has gotten back in the mode of making language improvements (all of which make it more like the "knockoff") instead of their knee-jerk "you're not language designers so, trust us, you don't need that" reaction of the past.

The Java class libraries are far more complete than those of .Net, though .Net's have the benefit of learning from Java's mistakes. (A nice, consistent way of converting between fundamental data types, well-designed containers, etc.)

I now find myself in the position of using C# when I can (mostly for personal utilities) and Java when I must (for professional production). Since I strongly prefer to use Linux servers and strongly prefer to avoid the MS license ball-and-chain, I anticipate having to continue using Java for years.

While doing so, though, I will continue rooting for Mono and working thru the JCP to try to steer the Java language to embrace and extend what I consider the significant advantages C# (and to some extent the .Net classes) have over Java. All the anti-MS bigots don't make that easy, though.