On 23 Jul 2015 at 14:15, Glen Fernandes wrote:
It has the best debugger in the business, and still far outclasses anything in the GCC/clang ecosystem
It's interesting you say this. At least one team I was in during my 5+ years at Microsoft elected to (or in some cases had to) use WinDbg over the VS debugger.
As have I in the past. The VS debugger isn't an end all be all debugger, it's just very good at what it's good at. Edit and Continue is a major boon, but for obvious reasons can't work in many places.
It has a totally unique interpretation of the C++ standard
This sounds almost dangerous - like commending a criminal for having a unique interpretation of the law. :-) I thought we prefer compilers to have a correct interpretation of the standard.
Microsoft can read a standard just as well as anyone, and that's exactly where the value add comes from - the same text means different thing to different people. Correctness is relative. Imagine a world with just clang and GCC. Firstly, clang would utterly destroy GCC in short order as it's so much easier to modify and evolve, so then it would be just clang. Then there would no longer be much need for a C++ standard at all, because whatever clang does IS the standard. Even the lead clang engineers get a bit uncomfortable with that idea. They'd prefer someone not them to bounce against their decisions and interpretations against, even if that is infuriating sometimes. I can't think of a better team to do that than the Visual Studio team.
It's vastly faster to compile, like 5x-10x faster as it's not an AST based compiler like clang and GCC.
This is interesting. Which (preferably public-available open source) project(s) have you compiled with all three, and what were the build times?
It depends on if you use precompiled headers or not. I would assume anyone sane in Boost-land does. https://svn.boost.org/trac/boost/wiki/BestPracticeHandbook#a16.BUILD:C onsiderdefaultingtoheaderonlybutactivelymanagefacilitiesforreducingbui ldtimes for some empirical numbers. tl;dr about 2x faster in debug than clang, about 3x faster in release than clang. clang itself is 2x faster than GCC in debug. AFIO is very easy on the compiler as it's a tiny simple library. The more templates you feed it, the relatively faster MSVC becomes because it doesn't do two phase lookup i.e. it completely ignores template code until instantiation and neither clang nor GCC do that. Lightweight future-promise is much harder on the compiler, and the differential in release mode is about 6x which is enough I very rarely test in release mode (I let the CI do it for me). If you don't use precompiled headers, or don't have lots of test executables to compile, clang and MSVC are about equal on average in my experience. Perhaps this explains our divergent experiences? Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/