Has a Decade of .NET Delivered On Microsoft's Promises?

cyclocommuter writes with this snippet from The Register's assessment of whether Microsoft's .NET framework has been a success: "If the goal of .NET was to see off Java, it was at least partially successful. Java did not die, but enterprise Java became mired in complexity, making .NET an easy sell as a more productive alternative. C# has steadily grown in popularity, and is now the first choice for most Windows development. ASP.NET has been a popular business web framework. The common language runtime has proved robust and flexible. ... Job trend figures here show steadily increasing demand for C#, which is now mentioned in around 32 per cent of UK IT programming vacancies, ahead of Java at 26 per cent."

Comments

.Not

[should_be_linear]

Joking aside, Java is multiplatform in practice and .Net is only in theory.

Re:.Not

[ByOhTek]

Actually, I'd argue Java is also only in theory.

I've had to re-write too much stuff because a java built in function relied on native libraries, which did not act the same (regular expression handling in 1.4 and earlier, is a good example - go betweeen HPUX, Linux and Windows, and there can be serious issues). A lot of the UI stuff doesn't work well between versions either.

It's gotten better, but on a similar note, anything I've used from .NET in VS 2003 and earlier, and quite a bit of later stuff, works just fine on Windows, Linux and FreeBSD.

Each has their flaws in cross platform use - .NET's issues tend to arise when using newer APIs, and Java tend to have small gotchas, which in most cases are rare, scattered throughout the code.

The really big win with .Net

[wiredog]

Is that so much of it wraps, and hides the complexity of, COM. I haven't had to deal with COM programming in 5 years now.

Re:Java too complex

[thetoadwarrior]

That's the idea behind JavaFX.

Re:"mentioned"

[dragonxtc]

Ironically did you know the guy that designed Delphi also designed C#?

Re:Point & Click programming

[Mr2001]

You realize the "point and click" stuff is for laying out dialog boxes, right?

Writing boilerplate code to lay out controls and handle window messages wasn't some noble art that's been lost. It was low level tedium that distracted from real programming. I remember opening Petzold's Windows programming book and being horrified that the code for "Hello World" spanned several pages.

I don't know about your wages, but I get paid a fair amount for my time to write C#, and that time is a lot more productive and enjoyable thanks to such things as IDEs and component libraries.

Current Monster Numbers: Java vs .NET

[CritterNYC]

I thought the article may be overstating .NET's popularity, so let's take a quick look at listings on monster.com. Here are the results of a US-wide search for each of the terms (at 9am on 2009-12-18):

C#: 2,920
(Just) .NET: 3,632
ASP.NET: 1,714
Java: 5,000+

If we narrow it to posts in the last 7 days:

C#: 971
(Just) .NET: 1,095
ASP.NET: 524
Java: 1,608

Or if I select my location, New York City, over the last 60 days:

C#: 223
(Just) .NET: 239
ASP.NET: 91
Java: 591

As expected, there is a lot more demand for Java developers than C#, ASP.NET or even .NET framework itself.

(Note: I added the prefix (Just) to the .NET line as otherwise SourceForge won't let it be separated onto a new line)

Re:Java too complex

[rabbit994]

Powershell was never designed to be used by day to day admins in general administration tasks. GUI for many things allows you to look up data or make one off changes much quicker. Powershell is designed to be used by admins to script common tasks they do daily. I have a Powershell script that will parse a comma delimited text file and add every line in there as Active Directory user with Exchange Mailbox. When we get 30 new employees at work, I modify some parameters on Powershell script, take list from HR and bam, in 15 minutes, I've added 30 new users with Exchange mailboxes. That's purpose of Powershell.

Re:Java too complex

[WinterSolstice]

You may be right here. I have, on many occasions, had to program reasonable size DB apps in both.

Java.makes.me.want.to.claw.my.eyes.out() .NET may only be truly on windows, but it's actually not so bad to code in. I wrote a DB reporting and maint. app in C# in roughly 2 weeks, the previous version of which in Java took almost 2 months.

Major things, IME that made the difference?
Crazy easy remote DB access (sure, neither are exactly rocket science, but .net was quicker and more flexible)
Easy installs - this had me from the start. I wasn't writing a web app, but a desktop app. The C# one was a breeze, the Java one a major headache
Attractive frontends - this will probably start yet another flamewar, but many of the java frontends are HIDEOUS
Performance when doing large dataset manipulations - for example, determining which server had the least free space, or which one had the most obsolete users. These are fairly trivial sorting tasks, but the java version took probably twice as long and more memory (in my implementation, which may well have sucked to be frank).
Support for dumping data into Excel and Word - this was a killer feature. I was able to generate SOX and sizing reports on the fly with C#. Java? No such luck. I never did get it working quickly and properly.

Re:Java too complex

[adonoman]

Have you actually used powershell? They've predefined common aliases for most of the command (ls, cd, del - just type get-alias (or gal) to get the full list). All the parameters can be used both positionally, or as named parameters where you only need to provide enough of the name that it's unambiguous (usually one or two characters is enough). On top of all that, there is tab-completion for object members and such. The purpose of the long, descriptive names is for writing scripts. I can use the abbreviated aliases and shorthands when I'm at the command line, and yet still write scripts that are legible, without having to look up whether -r means recurse or revision in a given context when I'm debugging a script a year later.

Re:Java too complex

[shutdown -p now]

One thing I've noticed with generics as a "Java-by-profession, C#-by-hobby" developer is that I prefer many parts of the Java implementation. Having access to the generic parameter type in C# is useful, but it is far more likely that I need the "PARAM_TYPE extends SomeClassOrInterface" method rather than C#'s fixed generic parameters (at least in C# 2.0, which is what I target since Mono has good support and it isn't too huge a download for WinXP users if they don't have it).

C# 2.0 has constraints on generic type parameters of classes and methods, which are exactly equivalent (albeit more verbose) than Java "extends". E.g. you can write:

void Sort(T[] a) where T: IComparable<T>

It doesn't have wildcards, though those can always be replaced by named parameters in generic declaration context.

There are two things missing. First, you cannot write anything equivalent to this Java code:

List<? extends Foo> list;

Again, this is because wildcards aren't supported, and it's not a generic declaration, so there's no way to introduce a named type parameter.

The other thing that's missing is "super" constraint. For example, this cannot be rewritten in C# while preserving full genericity of the method:

<T> void add(List<? super T> xs, T x) {
    xs.add(x);
}

because "add" is contravariant, this needs the corresponding supertype constraint if we want this to work on any compatible list, but there is none in C#.

On the other hand, C# generics are fully reified - so you can have T[], and new T(), and x is T.

Also, in C# 4, a new feature is declaration-site covariance and contravariance of classes. For example, IEnumerable - which is the .NET counterpart of Java Iterable - is now declared thus:

interface IEnumerable<out T /* covariant*/> { ... }

which means that you can write:

IEnumerable<Derived> xs;
IEnumerable<Base> ys = xs; // implicit upcast

In Java, you'd have to use "? extends Base" on the second line above, and in any similar context.

Unfortunately, this doesn't help with classes for which some operations are covariant, and some are contravariant, like List. For those, Java wildcards and constraints (which are effectively use-site variance declarations) do better.

Re:no, you are talking out of your ass.

[beuges]

A common trend I've noticed amongst the vast (99%) majority of PHP developers is that they are almost guaranteed to be
a) completely devoted to PHP
b) incredibly arrogant
c) mediocre developers at best