[cxS]

The use of an IL throws another step or two in that process.

The JVM is a JIT compiler. Look it up. The core difference between the two is that Java sandboxes the code more from the running computer, whereas the .NET framework is just pure conversion

The second step of the CLR is interpretation, by the definition of the word. It converts information of one type( MSIL ) to another type( ASM ).

Now you're just reiterating what I've already said. I don't care what JVM is though, this is not Java we're talking about at all. .NET doesn't use JVM; we have the CLR. It doesn't use a virtual machine at all. As I've been trying to say, you can't mix Java and .NET -- they are different. Just because the JVM is a JIT compiler doesn't make the CLR a VM. Did you neglect to read any of the links I posted? :S

"Java sandboxes the code more from the running computer, whereas the .NET framework is just pure conversion" -- This is basically what I've just told you in my last post because you falsely stated that .NET runs through a VM. This is nothing like what you originally stated as it contradicts your statement about .NET running through a VM. Your credibility here is decreasing as you're jumping all over the map now.

Because Mono is not a Microsoft project, and it is not well defined how specific parts of the .NET languages should be assembled and ran, you cannot expect that the same code will assemble and run the same on every computer, a key aspect of portability. It may be well defined, in that there are standard functions and objects that are expected to complete a certain task, but that is as deep as the documentation goes.

Can you guarantee that for any language just because something is written with C/C++/etc? It's not a Microsoft project, therefore it is irrelevant when considering any standardization. .NET was not designed for portability in the first place, by Microsoft standard, so I don't even know why you throw this up there as a negative against "standardization". Your points are flawed.

You're posting information here that doesn't really say much, there's no catch in the points you're attempting to make that explain why .NET languages are "shit", which is originally what this conversation was about. If you want to continue this debate you should start explaining your reasoning IMO, instead of just rambling off a bunch of contradictory and irrelevant information.

So far this is all you have:
1. .NET adds another step in the process of getting to machine code that the CPU can understand
2. There's no standardization

Although, point #2 is flawed because you're still basing it off of non-standards of the language itself, and point #1, I've already stated.

[3SidedSquare]

Here's a quick summary to help you decide:
Python:

• Automatic memory cleanup
  
• Up to 40000% slower than non-interpreted languages like C or C++ source
  
• Will not complain until run-time about most errors
  
• Object oriented
  
• Interpreted
  
• Requires more overhead memory than the other languages you listed
  

C:

• Spaghetti-string code (hard)
  
• Requires management of memory
  
• Fastest of the languages you listed
  
• Compiled
  
• Requires a lot of coding to do even simple tasks
  

C++:

• Requires management of memory
  
• Generally accepted as the "best" language (little waste of memory and cpu, while still being bearable to code)
  
• Compiled
  
• Object oriented
  

Java:

• Automatic memory cleanup
  
• Runs on most machines today (almost all pc's,some phones, you can hack your DVD player and stuff too)
  
• Occasionally has 0-days due to popularity
  
• Built-in libraries to simplify most tasks
  
• Compiled, but can be decompiled the most easily to get the source (with the exception of .pyc, python compiled files)
  
• Compiler will catch most errors before runtime, and will force you to use hiarchy correctly.
  
• Object oriented
  

I'm know I'm bias, but I would say to start with python, so you can get the hang of programming before you're thrown into memory management and data structures.

[w00t]

Please, do tell, when did I say that it was somehow interoperable with Java? Whether or not it is considered is semantics, as your source itself said. The important thing to note is how they are different.

You argued that the CLR was better because it didn't run through the Java VM, but all the things you pointed out as "features" of .NET are done identically by the JVM( JIT compilation, caching ).

.NET was designed for portability, portability in .NET was the sole reason for Silverlight.

Because the standard is not well-established, someone programming .NET with Mono, or for anyone using Mono, doesn't know what functions and libraries are automatically included. I would agree it is well-defined, but it is not well standardized.


If I must reiterate a thesis...

.NET languages are shit because of their sub-par performance, the programmers inability to rely on the code to run identically on all systems, a lack of standardization in what utilities are always linked in, and the uncertainty of what code is actually being ran by the processor.

[Dev]

Java is one of the largest growing markets the last time i Checked & supposed to be simple, C++ is worth more but is also time consuming from what i've heard.

I Would suggest Java because its easier to get a grasp on rather than C++

now its also evolving into C#

Python is also a good starting language, I've Heard its one of those you don't ever feel like sticking around in

[w00t]

Python is good for simple tasks that warrant programming( calculations, data entry/analysis ), but I couldn't imagine doing a complex program in it.

[cxS]

Please, do tell, when did I say that it was somehow interoperable with Java? Whether or not it is considered is semantics, as your source itself said. The important thing to note is how they are different.

You argued that the CLR was better because it didn't run through the Java VM, but all the things you pointed out as "features" of .NET are done identically by the JVM( JIT compilation, caching ).

.NET was designed for portability, portability in .NET was the sole reason for Silverlight.

Because the standard is not well-established, someone programming .NET with Mono, or for anyone using Mono, doesn't know what functions and libraries are automatically included. I would agree it is well-defined, but it is not well standardized.


If I must reiterate a thesis...

.NET languages are shit because of their sub-par performance, the programmers inability to rely on the code to run identically on all systems, a lack of standardization in what utilities are always linked in, and the uncertainty of what code is actually being ran by the processor.

I shouldn't have to tell you where you said it:

1. You said .NET uses a virtual machine (it doesn't)
2. YOU brought up JVM

I don't even know why you bothered bringing Java into the conversation for these reasons. You told me to look up that Java runs through a VM, I said this conversation doesn't concern Java, but rather .NET...

The important thing to note is how they are different.

How so? Not at all! The debate was about whether .NET was shit or not (as you previously mentioned), and I was trying to get the answer to "Why?" from you. You couldn't provide anything other than relate it to Java seemingly.

You argued that the CLR was better because it didn't run through the Java VM

Better? No.. I think you should understand what has progressed through this conversation before making another reply. I said the only thing .NET has is the CLR, because it doesn't have JVM, or run through it's own virtual machine, and that the CLR is NOT a virtual machine either. This was brought up by myself, because YOU had said .NET uses a virtual machine.

1. You were wrong
2. You derailed this conversation on your own from ".NET is shit", to which is better, or perhaps just in general "Java vs .NET".

but all the things you pointed out as "features" of .NET are done identically by the JVM( JIT compilation, caching )

Explain how this means that .NET uses a virtual machine to me. I'd like to see you win that debate with any professional .NET programmer, because you'll lose.

.NET was designed for portability, portability in .NET was the sole reason for Silverlight.

Why are you dragging this conversation into Silverlight now? It came out several years after the .NET framework itself. Silverlight is more of an SDK, it's an implementation of the .NET framework... This doesn't mean that .NET was initially designed for portability either. I can guarantee you that it was probably never considered when .NET 1.0 came out. The standard is still set, but as with most other languages, there will always be something that deviates from that standard.

Because the standard is not well-established, someone programming .NET with Mono, or for anyone using Mono, doesn't know what functions and libraries are automatically included. I would agree it is well-defined, but it is not well standardized.

Explain how this would be different for a developed C++ programmer trying to use DirectX for the first time, or OpenGL. Standards change over time, as with any language, so not very well standardized based on what?

.NET languages are shit because of their sub-par performance, the programmers inability to rely on the code to run identically on all systems, a lack of standardization in what utilities are always linked in, and the uncertainty of what code is actually being ran by the processor.

sub-par performance in comparison to what? That's subjective, but still this entire paragraph is no reason for why one shouldn't learn .NET. Nobody in the real world is going to be willing to pay a C++ developer to make something that C# or VB.net would be capable of creating based on the requirements set.

"programmers inability to rely on the code to run identically on all systems" -- No different than most other languages.
"a lack of standardization in what utilities are always linked in" -- This needs further clarification.
"and the uncertainty of what code is actually being ran by the processor" -- ?

[w00t]

You argued that Java was worse than .NET because it ran through the JVM, but the things you identified as features of .NET are done identically with Java.

...and I don't like Java because of Jata Auth and running through the JVM.

I brought up Silverlight because you said that .NET was not designed for portability.

I wasn't very good at explaining what I meant with the difference in how Mono and MS .NET work together, that's my bad. In Mono, certain things are added to the System namespace, and certain things aren't there that are there in .NET. Mono also tends to develop and add in features to the languages that aren't found in MS .NET

I cannot think of any application in which a faster program would not be a good thing. The very purpose of software is to make things faster.

When I compile a program in a native language and distribute the executable, I know that exactly the same code will be ran on every computer. When you distribute a .NET .exe, your program may behave differently on different computers and configurations of the CLR.

[cxS]

No, I said this:

...and I don't like Java because of Jata Auth and running through the JVM.

Purely out of my own opinion, I never said it was bad because it uses a VM, hence why I said "I don't like", instead of "Java is bad because". You're out to lunch with your interpretation on that sentence unfortunately. :S

Mono modifies the standard, that's all it does. This further just supports my idea of .NET not being designed initially for portability because Mono for one, was not developed by Microsoft, and they make changes to what is used and what isn't for it to run on other platforms.

I cannot think of any application in which a faster program would not be a good thing.

Speed isn't everything, if you were designing an application this would be thought of, and measured after all other considerations, then perhaps improved where appropriate if need be. Some sorting algorithms are chosen because they use less memory (they need less to be stored on the heap for instance than other methods), not because they are faster. I could make every program of mine faster, but in some cases it would require that the average person using my app might need a better CPU and 12-16 Gigs RAM. If speed was everything I doubt interpreted languages would even exist.

When I compile a program in a native language and distribute the executable, I know that exactly the same code will be ran on every computer. When you distribute a .NET .exe, your program may behave differently on different computers and configurations of the CLR.

This doesn't really mean anything because running the same on every computer doesn't mean it's bulletproof in essence. And this is why we have visualization btw; testing.

[w00t]

ILs purpose is to reduce the time needed for a programmer to produce a program. If the programmer is the same person as the user, using an IL becomes the "faster" choice, as less time is needed before you can run it.

Mono doesn't modify the standard, though, because the standard Microsoft sent to ISO leaves a lot of things out. If it were well standardized, Mono would be off-standard, but its not.

Random fun trivia fact, somewhere on this forum I did the math, with the best processor out right now, you could conceivably only use around 22 GB of RAM and be running as fast as the computer can go.

You're correct in that it doesn't make the program infallible, but when I know exactly what code will be running, how memory will be allocated, etc, I only need to debug the program in one environment.

[cxS]

Mono doesn't modify the standard, though, because the standard Microsoft sent to ISO leaves a lot of things out

Like what? There's a reason some things were left out because they are old legacy methods from a castaway VB6 for instance.

I only need to debug the program in one environment.

This is not true, because even if you can guarantee that the code will run the same, not all environments are guaranteed to be the same, making a possibility that your code won't work anyways. You still need to test across different environments.