You will be very hard pressed to substantiate this. C++ has an antiquated memory model, requires the use of brutal hacks like the *_ptr classes from Boost, and nearly demands leaky abstraction via friend, MI, and other methods of tangling the class hierarchy. Languages on the .NET framework, by and large, lack these problems.
You don't need to use leaky abstraction to have sensible memory models,
You are conflating two points. C++'s memory model has nothing to do with leaky abstractions. C++ not being fundamentally object-oriented
is. Event-based programming is onerous in C++. Dealing with interacting objects is a chore, and as I noted, it is rare to find a nontrivial C++ application that isn't screwing itself into the ground with MI or happily fucking data encapsulation with friend members. (For example, I would look at the Unreal Engine, if you can find a code license--that is considered to be some of the finer C++ out there, and it is replete with broken abstraction in places it just shouldn't be.) In C++, unless you are a Boost wizard, you are writing "object-oriented" code that is in truth essentially procedural-with-objects. This is true under-the-hood in .NET code as well...but you never see it there, and as such the abstractions hold up much more cleanly.
(One could mention the "internal" modifier in .NET as an analogue to "friend", and there would be some truth to that, but for obvious reasons it's nowhere near as dangerous or silly as "friend".)
nor is C++'s model antiquated, a term that really doesn't make sense in this situation.
For any sort of desktop-driven development, it certainly does make sense to call the C++ "deal with it yourself" model of memory management "antiquated.". This is 2011. Generational garbage collection is spectacularly effective in the general use case and only tremendously effective in most others. It is a rare desktop application that requires memory management that is not eminently suited to standard generational garbage collection. Hell, it's even fast enough to do so on consoles (XNA) and the iPhone (Monotouch) without significant issues. The computer is better at handling stupid, detail-oriented tasks than the programmer driving the computer. Let it do what it is good at.
.NET has certainly improved of late, although there were major issues with earlier versions if you wanted to write stable code, however I personally still find it much more clunky than using boost or stl equivalents much of the time. Although some things are handled much better, and the deep class hierarchy does push heavily for object methodology which is certainly a good way to learn to code well.
Please provide citations of duplicable instability that occurs in normal programming practice, because otherwise I am comfortable with stating that your claim here is counterfactual. .NET has not had stability problems of any significant note, ever, in its history. One thing Microsoft
does do very well is anything related to their development stack. I know a number of developers at MS DevDiv, and they're incredibly sharp.
As for Boost, etc. versus the BCL--this is much more of a "taste" thing, but the fact that Boost must even exist is damning. Boost::Bind should
never have been necessary. The language lacks what modern programming practices consider very standard features. Some fakery exists to pretend that this isn't true, and C++0x or whatever they're calling it now might eventually take steps to address this, but this is now and C++0x is still a pipe dream for standard usage. I would find it interesting that you would term the use of the STL less "clunky" than .NET, because
the libraries are virtually identical in implementation and exposed API. The .NET BCL libraries are iterative developments on top of Java Collections, which itself cribbed from the STL.
As well, I find it very interesting that you make the curiously irrational claim that C# is not a cleaner model, but Java is. You are aware, I hope, of the similarities between the two (damned near identical in most aspects that matter to a novice)?
Although it's true to a novice the api's are very similar for a lot of the code there is enough difference, especially in the graphical side of it which is often of more interest to novices, where java provides a much cleaner model to learn from. Python of course is a different style of language but allows a lot of power in clean and easy to understand ways.
Please substantiate this claim with examples. I am skeptical of this claim, because .NET provides the
fantastic XNA Framework, which is beyond simple to use--simpler even than PyGame. If you need a little more flexibility, there's SlimDX - or there's OpenTK, which is head-and-shoulders above JOGL on the Java side of things.
Seeing as how JNI et al. are absolute creeping horrors compared to P/Invoke, I fear that this one might be hollow, too.
I apologise if my previous posts came across brash to you I never meant to cause offence, my opinion mearly differs from yours.
It's not about disagreement, and I'm not offended. It's about everything you're saying being rather counter to what I've encountered in my programming career. I do Java development professionally today, but I've worked in .NET and Mono (including some contributions to Mono) in the past. For the most part, these are not really "opinion" things you're trotting out; you are making claims that should be substantiable, and I'm looking forward to seeing you do so.