Also, with regard to "Of course it's different for an open-source organization or a library vendor that needs to support multiple build/run environments"... it's not an edge case to support multiple platforms. There are lots of closed-source programs that run on multiple platforms you know; possibly more than single-platform ones. (At least if you look at software you can actually buy, as opposed to stuff developed for in-house use only.)

That pretty much reflects our situation, except that "one to two hours" can easily be higher even if all your platforms are going at once, depending on how much hardware you want to throw at it. Getting everything set up so that everyone can easily build on all platforms before submitting would provide relatively little benefit (especially when you consider that running the full test suite on all of those platforms pre-commit is basically completely unfeasible) and cost a tremendous amount of money in hardware. Meanwhile, like Darinbob's setup, if you check in something that borks the build, you get an email a couple hours later (ok, sometimes several hours later) telling you to fix it.

In addition to the other response, I have a couple others.

First, having a code base that will compile under two disparate compilers (e.g. GCC + MSVC) will help you have cleaner code. Each compiler will find things (whether they be real problems, latent problems, or completely spurious non-problems) that the other won't, and your code will be better for having done it.

And sometimes those differences matter; e.g. MSVC is (slowly) moving toward better standard compliance with C++. I'm not sure what the deal is with flags when it comes to whether you need to explicitly request the conforming behavior or what, but those changes could, in edge cases, silently change the behavior of your code. Building with GCC as well as you go would reduce the probability of that, as well as mean that you make required changes to get it to compile under a conforming compiler gradually instead of all at once when you decide to upgrade to the new version.

Now, worth it if you're as sure as you can practically be that you're sticking on one platform? Up to you to decide. But there's a pretty big benefit.

You also can't forward declare objects you are making a typedef to for now but think you may replace with a full-blown class or whatever at a future point. (Or if you do, not via making a "blah_fwd.hpp" file, then sucks to be whoever is doing maintenance when they go and make that switch.)

If I were to pull a number out of my ass, I'd guess forward declarations suffice... maybe a third of the time? You can't forward declare types you want to return or pass as parameters (i.e., not by reference/pointer). You can't forward declare types you want as members in a class you're declaring. You can't forward declare types you're using (beyond having just a pointer/reference) in a function's implementation, which you "need" to have in a header if it's actually a template and you may need to have in a header if you want it available for inlining.

If you start out with warnings enabled, you learn pretty quickly how to write warning free code and it never becomes a problem.

"Never" is strong, because compiler writers release new versions that change things that get warned about. You can have software that works wonderfully now, but next compiler upgrade generates 20 bazillion warnings. If you compile with -Werror, now you've got a big effort getting to the point where you can use that compiler.

Not that I disagree with your overall message. :-)

I'm reasonably competent, so I can recognize a warning that refers to a line of code I've just changed, even if there are other warnings.

My counterargument would be that I think this sounds very error-prone. I don't think it's a matter of "competence", I think it's a matter of "I just changed a header and now it's rebuilding 100 files and so noticing a new warning requires scanning thousands of lines of output."

The one thing I'll grant is that there's an opposite direction you can go. Instead of disabling warnings you don't like, if you -Werror those that you [i]do[/i] like, that's also sufficient.

Let me ask this: do you have on all warnings when you build? Unless, on GCC for C++, you're passing -Wall -Wextra -Wabi -Wctor-dtor-privacy -Wnon-virtual-dtor -Weffc++ -Wstrict-null-sentinel -Wold-style-cast -Woverloaded-virtual -Wno-pmf-conversions -Wsign-promo -Wformat=2 -Winit-self -Wmissing-include-dirs -Wswitch-default -Wswitch-enum -Wsync-nand -Wtrigraphs -Wunused -Wstrict-overflow=5 -Wfloat-equal -Wundef -Wshadow -Wunsafe-loop-optimizations -Wcast-qual -Wcast-align -Wconversion -Wlogical-op -Waggregate-return -Wno-attributes -Wmissing-declarations -Wmissing-noreturn -Wmissing-format-attribute -WWnormalized=nfkc -Wpacked -Wpadded -Wredundant-decls -Wunreachable-code -Winline -Wno-invalid-offsetof -Winvalid-pch-Wdisabled-optimization -pedantic? (Possibly there are a couple redundant ones there, but GCC has lots of warnings included in neither -Wall nor -Wextra.)

If you're not passing those to GCC, what that means is that you have, implicitly or not, decided that the cost-benefit ratio of the warnings you are not enabling is not in favor of enabling them. Well, saying "there are too many of these warnings, I'll disable them" is making the exact same decision: that the cost-benefit ratio of leaving that warning enabled is not in your favor.

Actually I've had "variable declared but not used" catch mistakes on multiple occasions. I'll grant you that it generates a ton of false positives, but I'd definitely not say it's pedantic or noise.

I'm a fan of warnings as much as the next guy, but there are plenty of times that's not practical. Even if you accept nothing else I say, there are plenty of times where third party code (say, for example, Boost...) has warning-producing stuff in it. Do you fix it and maintain your own branch? Submit it upstream, hope it gets accepted, then wait a month for the new release, then demand everyone upgrade to the latest bleeding-edge? That's often (maybe usually) not feasible, which means it should probably just disable it. Fortunately, GCC finally got around to adding #pragmas that sometimes let you disable and re-enable warnings for just the offending headers.

But beyond that, there's also a reason that compilers have most warnings off by default. And why -Wall doesn't turn on anything close to all warnings. And why even -Wall -Wextra isn't all warnings. Because there's a gradation of false positive/false negative tradeoffs, and what's appropriate for you isn't appropriate for everyone. Do you really compile with all warnings, or do you suppress some? Because I can almost guarantee it's the latter, even if you're suppressing them through inaction.

I've seen nightmares in C++ APIs with something as simple as the max() function. Sometimes it's as simple as someone re-"#define"-ing the symbol...

*cough*<windows.h>*cough*

Not only that but with "over 26 million" builds over a period of 9 months is approximately 1 build per working hour per dev. Sounds kind of excessive.

Really?! Not to me.

Let's say you're only actually coding half the time you're at work. Now you're talking 2 builds per hour, or one every 30 minutes. I can't speak for everyone, but I start getting pretty antsy if I haven't at least built, let alone tested, what I've been working on for that long. And we haven't even gotten into things like dealing with the failures. It's easy to go through multiple builds in almost no time at all as you see a silly syntax error or whatever, fix, and rebuild. Or even in testing: hit an assertion, look into it for 2 minutes, see what's wrong, fix, rebuild, rerun, repeat.

Yes, he was teaching you to turn off warnings for certain operations so that when the warning was really significant it wouldn't happen.

Is that better or worse than teaching someone to leave warnings on for those operations and then not noticing when a really significant one appears because it's buried in an avalanche of other output?

Errr... what?

Care to give a quick summary of what the alternative is?

And of course everyone always builds with the same configuration, same compiler, on the same platform.

(We have CI servers in our environment. They break not infrequently. Why? Because someone commits a change that builds fine on Linux, and when MSVC gets ahold of it, it produces a warning that GCC doesn't catch and so the build fails. Or MSVC accepts some piece of code that is not actually legal C++ because it's too loose, so when the Linux buildbots get ahold of it, they complain.)

The biggest thing I miss from CRTs is the ability to dim them below "actually still pretty bright". The only LCD I've seen that actually gets fairly dark is the one on my camera.