What is .NET?

CyberBry writes "There's a great technical overview of Microsoft .NET over at arstechnica: "In a remarkable feat of journalistic sleight-of-hand, thousands of column inches in many "reputable" on-line publications have talked at length about .NET whilst remaining largely ignorant of its nature, purpose, and implementation. Ask what .NET is, and you'll receive a wide range of answers, few of them accurate, all of them conflicting. Confusion amongst the press is rampant. The more common claims made of .NET are that it's a Java rip-off, or that it's subscription software. The truth is somewhat different.""

Comments

Was that so complicated?

[JohnDenver]

.NET is a "software platform". It's a language-neutral environment for writing programs that can easily and securely interoperate. Rather than targetting a particular hardware/OS combination, programs will instead target ".NET", and will run wherever .NET is implemented.

When your friends ask, just tell them "It's a language-neutral Java knock-off..."

Why do people try to make it more complicated? Ok, .NET never interprets bytecode, rather it does JIT compiling. Big deal. Ok, .NET uses SOAP as it's RPC conduit. Yawn. .NET offers Passport for developers who don't want to write thier own user authentication and may want to offer thier users the convienence of not having to enter thier condo's address. *snore* (wipe drool from mouth in a dazed stupor)

Others like to confuse the application that can be written by .NET (You can write them in most other languages too) like Web Services and equate .NET with Web Services, when Web Services are just one type of program you can make in .NET

The Platform != It's Applications

It's Simple: It's a Java rip off!

Review misplaces priorities

[RovingSlug]

This is perhaps a little disappointing. ... But these features are somewhat notable omissions from Microsoft's first release; profiling JIT compilers are becoming common in the Java world, and optimizing native code compilers are becoming the norm, with considerable benefits from their use.

Stability before performance, every time.

Or he'd rather be writing, "The JIT produces fast code, but sometimes crashes."? Or, ".NET is vaporware, still three to five years on the horizon."?

The reviewer should recognize and applaud the focus of the developers. Because you know they were sitting around saying, "Wouldn't it be nice if we did this fancy optimization...". Instead, they put first things first.

"Premature optimization is the root of all evil," D.E. Knuth. Learn it. Live it.

Re:MS is developing for FreeBSD?!?!?

[sydb]

You can't believe it? It's a natural part of their onslaught on the "viral" GPL. And it makes a Mac version just moments away.

Actually excited about .NET

[Tom7]

I'm excited about .NET (when I say that, I mean the CLR). I think it's an idea (while not very original) whose time has come. I think that superior technologies exist (for instance, stuff like typed assembly language), but none are really mature enough to be rolled out across the board.

And really, Microsoft.com is the only one that could manage to make this a reality. As much as I hate the company, I can't help but feel grateful that I'll finally be able to write apps in a nice high-level type safe garbage collected language and have that be the most well-supported method. (And if others start using high-level languages, maybe my computer will not crash so much, or have so many buffer overflow sercurity holes.)

(As an aside... I fucking hate when people (like the author of this otherwise good article) use the word 'whilst'. Just say 'while'. It's not like we live in Medieval Britain.)

Re:Classes and APIs more important than language

[BitwizeGHC]

This reminds me of something...

One of the early premises behind the Guile project was that all languages are essentially Scheme, modulo their different syntaxes. Guile was thus to become a Scheme interpreter with various syntax front ends on it to translate from Perl, Tcl, etc. Essentially achieving language independence in a unified runtime. The Guile team has largely abandoned these efforts, however, and concentrated on making Guile a practical workhorse Scheme for standalone use or embedded in a larger program.

I'm a big Scheme and Guile fan, and a part of me is disappointed... Scheme, being self-extensible, would make for a much more robust base upon which to construct a language-neutral runtime than the C# and VB-oriented CLR.

Re:I honestly can't figure out

[Jerf]

For what its worth, Javascript has been effectively standardized for, oh, I'd say the last five years, even before the ECMA standard. (Note the word 'effectively', it's a critical one to my point.)

What you're complaining about (justifiably) is the DOM, or Document Object Model. The DOM was standardized much more recently, and unfortunately contains a few holes large enough to drive a truck through, necessitating the need for non-standard extensions in practice. (One of the most-commonly-used of these is the "innerHTML" attributes, which is *not defined* in the standard, despite the fact that it is wonderfully useful. Mozilla actually explicitly added it many milestones ago because people were screaming for it. The 'standardized' way of doing that was upwards of 10-20 lines of rather difficult-to-read code, involving walking the tree and regenerating the HTML, then nearly-manually parsing the given HTML back into a tree, then swapping the newly-parsed Node tree into the document! Is anyone surprised nobody, even those who understood it, wanted to do that?)

The DOMs are inconsistent, partially because they're hard to get write. But Javascript itself is nearly unchanged since Netscape 3.0. That's not a typo. Yes, a few nice things have been added (for instance, I think an exception mechanism has been added since then), but effectively all of the language anyone uses on a web page script was there in Netscape 3.0. (How many people here have created their own objects in Javascript, or fiddled with the prototypes? IIRC, this feature was in 3.0, and it's still too-advanced to be necessary in most web scripts. Short scripts don't need a lot.)

This works out on topic nicely... because you're very likely looking at the future of Mono. "What use is Mono when the same code doesn't *quite* run on .NET?" What use, indeed? The greatest challenge facing those who would implement the CLR is not in writing the class libraries, it's matching them bug-for-bug. (One of the reasons Mozilla and IE still don't work identically is that Mozilla was forced to abandon its plans for bug-for-bug compatibility with IE, due to the feature's excessively high "pie in the sky" factor.)