this does not mean that competition in general is also for oos recommended.
no, this is wrong! actually this has quite little to do with gcc's current state of performance. if your claim would be true than gcc wouldn't had performed so well in comparision with other compilers that existed over the years. just consider ms c++ compiler which actually performes quite bad, or compare it to the intel compiler, which used to perform better, though gcc still could hold up quite well.particularly when it's a monolithic product as opposed to a more modular one*. The only reason that GCC is somewhat faster at this point in time is that it's been being developed since 1987, LLVM on the other hand was started in 2003, which means GCC has 13 years of development time in advance of LLVM, that's more than twice the lifespan of LLVM.
the reason why llvm start to enhance so fast is that it could and did learned from the past of the others.
actually you don't need to post this here as i haven't seen somebody denieng that competition is good.A perfect example of the competition bringing forth better products...
you are simplifying things quite a lot. it is easy for interpret things like this while ignoring the fact that llvm can look back on the work of all the other compiler devs and learn from it.What we're seeing here though is the natural result in the difference in design between Modular and Monolithic architectures, a modular project make take a bit longer for initial design and setting up but once it's there it can accelerate far faster and far longer (almost if not indefinitely) whereas a monolithic application is much quicker to design and set up but without refactoring to a more modular design the development will slow eventually to a halt no matter how many people you throw at it, just because the codebase is so unwieldy, thus allowing a properly modularly designed application to accelerate past it.
i like how you are talking about a "completely modular codebase". there is no completely modular codebase, and even less a viable definition of such a thing. you can overmodularize things and make it worse. there is always the need of a design decision what and how much do you modularize. and afterwards you always see you could have done it better. LLVM has the advantage to look "afterwards".* Now theoretically a Completely Modular codebase could exist in a vaccuum and do quite well, but it still benefits if nothing else from pulling ideas from competing products
this helps llvm to improve fast to the current level of gcc. but if it can top it significantly is yet to be seen.