You don't know anyone with an Android phone or a wireless router?
Just because they are signed by Microsoft, doesn't mean that Microsoft wrote them. For Vista, and even more so for Win7, large number of drivers was included out of the box to cover a wide range of hardware without needing driver CDs as often as XP did. Most of those are third party drivers, but because they are redisted by MS, they have the MS signature on them.
Basically, if you see MS certificate on some binary, it means that someone at Microsoft has built that binary. It doesn't mean that they wrote the source code for it.
Note that only 65k are in "engineering". This is across the entire company, working on numerous products (many of which you probably don't even know exist), and also internal infrastructure like build systems, test automation, and internal dev tools.
Quite obviously, one third of that cannot be working on the drivers, and even one tenth is an unreasonably high estimate.
To be more specific, what they need to do with Android is what Microsoft is doing with the next version of Windows (for store apps): put a full-fledged multi-window desktop there, complete with a taskbar/dock, and allow it to run existing Android apps in resizable, closeable windows. They already have fairly decent mouse support in Android, in fact (and the browser even understands hover), and most apps aren't that bad with a mouse, either. They just need to make the core UI around the same, and make it an official Android platform, so that people writing apps keep it in mind when doing UX design.
C99 support there is still more like 50% (no VLAs, no "restrict", and no complex/imaginary).
It didn't make it for C++14, right? My understanding is that C++17 is where the "big things" are supposed to be happening - are you now aiming for that?
I believe this kind of polymorphism is already possible, between std::function and boost::any (and, of course, they're planning to add "any" as part of the standard in a future version).
C++ IDEs have also gotten much better, as well. In Visual Studio these days, you can hover over an identifier, and it'll tell you its actual type, regardless of how many levels of auto there are between it and the actual named type. And it works reliably on anything that is valid C++, no matter the complexity.
In fact, B had it as early as 1969, and it was 100% correct even on arbitrarily complex programs!
(It always inferred type "machine word", which was the only one that the language had.)
If you really can't live without it, there's always libgc.
The alternative might be polymorphic lambdas, which would require dynamic typing.
Polymorphic lambdas (which were added in C++14, in fact) don't require dynamic typing. They only require the ability to use template parameters for lambda arguments. In case of polymorphic lambdas, this is implicit (i.e. basically you can elide the type of the function parameter, and it will become a template parameter on the operator() for the type generated for that lambda).
You can definitely over-do auto typing to the point where a human can't figure out the types involved
Thing is, in most cases the human doesn't particularly care about the types involved. Provided that variables are named descriptively, I can look at a piece of code and figure out what it does, without having to determine whether "files" is a vector, a list or a deque, and whether the elements are raw, shared or unique pointers.
Every lambda is of its own unique type. Even if you have two lambdas with the same capture-list and parameters, they're still of different types.
It's a crying shame that C and C++ still haven't added safe arithmetic as part of the standard library (or in case of C, maybe even as part of the language, for the lack of operator overloading). Back when I first saw "checked" in C#, I wondered what this was supposed to be about, but I have since learned the wisdom of having it in the language.
This is not entirely true - they have added a bunch of C11 features in VS 2013.