[cxS]

How do you not see how IL != native language?

I do, but that is entirely beside the point; the part that you didn't get from my response. As I previously said, who is required to always use a native language or write in a low level programming language? Just because it's not ASM for instance doesn't make it bad, that's only your opinion without supporting evidence.

the processor can actually understand one

A native programming language's code? :S No... It has no visibility to what language the code was created from, it only reads the instructions as opcodes usually referred to as byte code. The only difference is that .NET takes one extra step to get there.

1. Pretty much anyone writing applications that will be used by businesses better be able to roll out to more than Windows machines.

lol, mind providing an example of this? Unless the company is specialized for Linux development, nearly all companies use Windows machines for a business environment because it makes the most sense in numerous respects. Unless your employee's are in the IT field, no business owner wants to pay for the time and energy it takes to train their employees to learn Linux, when, keeping in mind, most people can hardly even operate Windows sufficiently. Software, among many other things as well.

2. You do realize C#/VB/F#/Boo/J#( there is a fuckton more ) run through a virtual machine, right?

Lol.. There is no virtual machine, you're thinking about Java. There is the JIT compiler, which takes that IL and compiles it to native code. You are far misinformed here for many reasons. You bash on .NET without having the slightest clue of how it works. The CLR is not a VM either.

There are a couple important points here, but the big one is that at no point is any code ever interpreted. Instead, you can see in step 5 that it is compiled to native code. This a huge difference than loading it into a virtual machine, for several reasons

1. The .NET code is compiled down to MSIL
2. When the program runs it is seen as a .NET assembly rather than native or raw machine code
3. The JIT compiler compiles that IL to native machine code
4. The native code is saved in memory for the lifetime of the program's running time
5. The cached native code is invoked when needed, and IL recompilation no longer occurs, it usually has the largest effect during application load. There are ways around this, by pre-JIT'ing and using a tool like ngen to save a native image cache on your computer.

This is by far, much different than running on a VM. Do you see anything interpreted here? I think you'd better read this: http://blogs.msdn.com/b/brada/archive/20...51958.aspx

Then afterwards stop pretending that you know much at all about .NET... (?)

Defined != standardized

Prove how this makes a difference. Standardized ideas and concepts don't mean that this standardization isn't put into practice 100% of the time either. There are standards for .NET languages: http://www.ecma-international.org/public...ma-334.htm

Just like others, it changes.... C#4.0, 5.0, etc...

The very existence of Mono, and other non-Microsoft uses of MSIL, highlight that there is not a standard.

How so? Mono is not even a Microsoft project.... You don't realize that? :S

So far I don't see any proof or validity in your points, and the rest is all opinion that you try to force as fact.