 Hi there, I'm Andrew Pardo, a program manager with the VC++ compiler and code analysis teams. In this video, I'm going to show you what's happened in the language support since we shipped Visual Studio 2015. Let's start off with a couple of handy links. The first is the C++ team blog. There's a lot of great information on our teams blog, and it's one of the best ways to get in touch with the team members directly. The second is a reference on MSDN that includes the work we've done on C++ standard support as a Visual Studio 2015. Today's video covers the differences from that release. We'll be talking about five areas today. First, improvements we've made in standards conformance. Second, how we're rolling out experimental features such as C++ module support. Next, enabling you to use the Clang compiler in addition to the VC++ compiler. Then, co-routines, a negative overhead abstraction for concurrency. Lastly, one you might have already heard about, the C++ core guidelines. First, standard support. A lot of our standard support work comes down to fixing bugs. Mostly bugs we've gotten from you through Connect. We fixed over 200 of them in Update 1 on top of the 500 we fixed for VS 2015. Fixing bugs is difficult because while we want to fix bugs, we often can't change anything. It's kind of like making an omelet without breaking any eggs. We had a handful of source breaking changes that we had to make this cycle, but we're trying our best to make these infrequent and painless through better diagnostics and backwards compatible changes. Old features, and by old I mean C++ 11, old features that we've improved upon include constexpr and partial support for expressions finay. Let's look at those two in some detail. So constexpr, for those of you who aren't familiar, the constexpr keyword lets you create constant variables, functions, and user defined types. Generalize constant expressions, improve runtime performance by doing the work early at compile time. When the feature was first introduced in C++ 11, constexpr was mostly about computing math values. But with new features in C++ 11 and 14, constexpr gets way more interesting and harder to compile. We're constantly improving our support for constexpr. The Update 1 compiler parses more valid constexpr than the 2015 compiler did. Again, mostly from bugs that we fixed on issues you've reported on connect. String and array manipulation is improved and static aggregate initialization as well. And use of decal type in constexpr expressions now works. Oh, and lambdas. There's kind of a famous example out there called the static lambda hack, where you use a constexpr lambda as a global variable by putting it into the one valid branch of a ternary expression. That hack now works too. So, Sphinay. Y'all remember Sphinay? It's a trick that allows compile time introspection of template arguments. The template can ask what are the properties of its arguments. The idea is that the compiler only needs one valid overload resolution in the set of possible overloads. So there's no need to error out if the compiler fails in substituting any particular set of arguments for a given template. As long as you've still got one that works out, the code is still valid. It's that easy. In Update 1, we're introducing support for expression Sphinay. Previously, we'd fail when you used a dependent expression or decal type in a default argument of a template type parameter. Or the type of a function parameter. Or in the partial specialization of a class template. All of those work now, but we're not done yet. Our support will get better in Update 2. In Update 2, expression Sphinay works for STL across the whole STL. Though we still have some outstanding Sphinay bugs to fix. We're really limited here by the way that our very old compiler works. But we're changing the compiler to make it better at parsing modern code. There's a great blog post about rejuvenating the compiler on the VC blog you should take a look at. So enough talk of bug fixes. Let's talk about new stuff. Starting with the experimental switch. We've been shipping new and experimental features for years. But we know we can do a better job of letting you know when the feature you're using is a preview that isn't yet fully supported. That's where the experimental switch comes in to warn you. C++ modules are the first preview feature being guarded under the experimental switch. Modules let you create componentized code. You define an interface for your library rather than including textual header files. But this isn't just about componentization. It also speeds up your builds because you're not reparsing and recompiling all those pound includes for every source file in your build. C++ modules are a real language feature, not just a build system improvement like pre-compiled headers are. C++ modules are a preview and update one, but they're on their way to standardization. They'll be in a technical specification with C++ 17. Because the standards committee likes to change things and we don't want you to be surprised if they do change, we've put modules into the experimental bucket. Now, just about changing the compiler. One of the more exciting things we're doing is letting you use the Clang compiler with the C2 code generator. A little explanation. We've got a fabulously boring set of names for our compiler toolkit. C1 is the C compiler, C1XX is the C++ compiler, and C2 is the code generator and optimizer. So letting you use Clang as the compiler with C2 means you can optimize and link together code compiled with the Clang compiler and code compiled with our C1XX compiler. This lets you share more of your code across target platforms and being able to use our optimizer with Clang will provide you with better optimizations on Windows. Note that we're not reducing our support for C1XX in any fashion. This is about giving you more options, not about forcing you onto a new compiler. So now on to co-routines. Co-routines are generalized, awaitable functions. Resumable functions with await were included in VS 2015. But you remember how the committee likes to change things? We're moving our focus away from the old await syntax towards co-routines. Co-routines are on a track for C++17 and we've got full support for these coming in Update 1. These functions offer better performance and improved syntax over the old await syntax. And they come with a new set of beautiful keywords. Last up is the C++ core guidelines. They were one of the main topics at this year's CPPCon. Bjarne Stroustrup announced them in his keynote. They're a way to help make C++ into a safe and productive but still close to the metal programming language. We're doing a lot of work at Microsoft to help make this cross-company effort successful. We've got an implementation of the guideline support library up on GitHub already and we're working on getting the library changes into C++17. And we've got tools that will statically check your code against the rules and the guidelines. Both the guideline support library and the guidelines checkers will be released as new get packages with Update 1 so that you can plug them into your project easily. And there you have it. What are you getting with this update? We support more standard C++ code, bring new features to you, enable entirely new scenarios and help you make your code better, safer and more correct. So a couple of links for the road. The first is a link to the C++ core guidelines on GitHub. There's a lot of great information there about the work that we're doing. And a link to the CPPCon talks. Both videos on YouTube from the conference and a repo containing all the slides. All the features I talked about today were discussed in detail at CPPCon so it's well worth your time to check out those talks. So thanks for your time. Thanks for watching this video. Have fun trying out the update and let us know what you think. Thank you.