And just to clarify, I'm currently in WI and grew up in PA. So unless you're Canadian, Alaskan, Russian, etc., it gets cold where I am too.

I don't know anyone with a personal garage who doesn't park their car in it - and apart from apartment style condo owners, if you own a dwelling, you have a garage.

I've seen it a lot. One of the houses I spent several years in as a kid had a 1-car garage that I'm pretty sure was basically never parked in -- it was used as a workshop and such.

And there are also areas around at least here and probably plenty of other places in the country where, if you look at MLS sale listings, garages are less common than no garage. There was even a million-dollar lakefront listing with no garage!

To be fair, it's pretty freaking stupid for an article about the Model E to have a picture of the Model X with a caption "The Model E will be launched after the firm's Model X SUV, pictured here." It would be pretty easy to miss the "pictured here" bit.

Most people don't have a car that can move furniture or large appliances. They just pay to rent a vehicle for those occasions. I find it odd that they don't apply the same logic to EVs.

To play devil's advocate, and I only know my own experiences, but I suspect that people go on longer roadtrips far more than they need to move furniture or large appliances. Especially if you count at the point of renting instead of just "hey, call Joe to see if he will help us move this couch; he's got a pickup."

Running from the police? That's the driver not the insurance or plates.

Until they impound your car for being used in a crime, and then file a lawsuit against it (it, not you or the driver) in attempt to take it under civil forfeiture laws.

Over a four month period observed by DePaul University's Chaddick Institute for Metropolitan Development this year, 35.9% of passengers used mobile devices at any point during the flight. In last year's study, while flight attendants still patrolled the aisles for devices that hadn't been shut off, 35.3% of passengers used devices during flight.

This is vaguely interesting, but doesn't match the headline.

Another way to read those numbers is "most people (say they) followed the no-electronics rule." The rule change was "now you can use electronics all the time." That would affect the number of people who used electronics during takeoff/landing, and you wouldn't expect much effect on the number who used it 'at any point during the flight.'

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.