Because it's slow, buggy, and it generates bad code.

RMS is so obsessed with keeping control over GCC (and GNU because he has nothing else in his life) that he's become a deliberate, malicious, mincing obstacle to new development and improvement in GCC. For example, most modern compilers are built around a far more modular design but RMS blocked it. It's not even worth forking GCC because it's so poorly-designed. And there's a really strange disconnect here, because GCC is very bad at optimizing x86 code due to its deliberately flawed design but the GCC developers have no problem breaking non-x86 code generation for months on end.

It's actually easier to talk a member of the Visual C++ team into making a change or bug fix than it is to convince a GCC maintainer to do anything. The whole FSF is pretty much the biggest flaw with open source software today which is awfully funny since they claim to have invented the concept.

Thoughts?

Agreed in part.

[edit.. wait no I don't know]

Really, a guy that looks like this is being overly possessive and halting progress? Inconceivable.

root mean square is so obsessed with keeping control over global carbon cycle?



(...so it has come to this! a night of blood I've long awaited.)

RMS is the guy that said selling software is a "crime against humanity."

I wonder what kind of performance gains you'd get if you swapped GCC for ICC when building a Linux system.

Why bother? You can just use MSVC++ to build for linux.

I'm talking about compiling an entire Linux system using ICC instead of GCC. I wasn't aware there was a Linux port of MSVC++ that functioned as a drop-in replacement for GCC.

It's people like RMS that I actively avoid GCC or much of GNU stuff. I did my whole "rarrr Linux > M$" days back when I was a senior in high school. Now I realize that Linux development has been retarded so much because of stodgy and stubborn neckbeards.

There isn't a linux port; you would have to run the compiler under windows. But the compiler itself targets x86, and not windows specifically. It's non-trivial but possible to re-target the entirety of Visual Studio to linux.

I see no reason why ICC wouldn't be able to compile some flavor of nix. There's bound to be a port to it somewhere.

except VC only produces PE, so you'd need some kind of munger to convert it to ELF. This isn't at all practical for general-use: it's the kind of thing you'd do if you wanted to write an OS kernel using Visual C++.

ICC functions as (essentially) a drop-in replacement for GCC. It's a lot faster on Intel hardware.

What brought about this rant on GCC, Jon`C?

He's making fun of the CCG thread.

You mean like the official Linux version?

Selling anything is a crime against humanity.

And the performance improvements aren't all that significant if you use ICC across the board for the same reason that Gentoo is a retarded idea. Computational costs on a desktop computer are amortized over a long period of time because everything is event-based: at best you might notice a little bit of extra responsiveness but this is difficult to quantify. The system sits idle most of the time. Incidentally, the Linux scheduler does nothing to accommodate this behavior.

If you graph the performance of binaries generated GCC, ICC and Visual C++ you'll find out pretty quickly that ICC is the fastest, followed by Visual C++, followed by a huge gap and then GCC. It's really really bad especially when you consider that Visual C++ 2005 and 2008 both suffer from some bugs that are reducing performance across the board if an application uses STL containers. Visual C++ for x86 implements exceptions poorly too (although it's corrected in x64). There's no reason GCC should be so bad at everything.

As an aside, I'm really looking forward to C++0x (which is going to be partially supported in Visual C++ 2010). C++ is about to get a major speed boost.

It is usually a bad sign when one's misguided ideologies significantly influence the design and architecture of a software project. I don't want any politics in my compiler, thank you very much.


Though it isn't perfect, MSVC has made leaps and bounds in recent years. Its performance puts GCC's to shame and the language support is really good now. The VS team blogs are pretty informative too; it is nice to see that they are actively improving the IDE and compiler. Once they fix the scalability issues and the lack of decent refactoring support in the IDE, I would consider it an excellent development environment (which is saying a lot when coming from a *nix aficionado).


That is why I am hoping for LLVM (which has an MIT style license) to overtake GCC. The features are pretty cool, though I don't think the optimizations are quite up to the level of GCC's yet.

Not to mention all of the awesome new language features and libraries (though I am already using reference implementations of many of the new libraries via Boost).

I try to stick to built-in support wherever I can (in the std::tr1 namespace). There's a surprising amount of C++0x support already in Visual Studio and it tends to be faster than the Boost implementations.

I'm not really looking forward to that as much as I am looking forward to move semantics, though. Being able to return a class from a function without having to create multiple copies will be nice, and it'll make auto_ptr-type patterns a whole ton more intuitive.

C++0x is going to make C++ a usable language for me.

I'm still stuck on Visual Studio 2005 at work. I do use a lot of the other Boost libraries though (accumulators, spirit, program.options, bimap, etc), so I would probably be using it regardless.


Move semantics are definitely a nice addition. However, I still tend to prefer shared_ptr's over auto_ptr's in most situations, so I do not care so much about it in that respect. I'm much more excited about the improved auto keyword, the improvements to template programming (variadic templates, concepts, extern, etc), and lambda expressions.

What's kind of funny is how some C++ zealots are going nuts over the new language features that have been in other, better languages for decades.

Yes, but most of those languages don't have deterministic finalization of objects. If you at all know what you're doing, C++ has the easiest and most graceful error handling out of any programming language.

The closest C# comes to RAII is when you implement IDisposable, but then the object's scope has to be contained within a using-statement. Properly-written C++ should automatically release any resources you've acquired when the object leaves scope or when the stack is unwound. This is why C++ doesn't have and doesn't need a finally clause.