CppCast - Visual Studio 2017 for C++ Developers

Episode Date: March 7, 2017

Rob and Jason are joined by Daniel Moth to talk about the new C++ features of Visual Studio 2017. Daniel Moth joined Microsoft in the UK in 2006, before transitioning to Redmond in 2008 to work as a Program Manager on Visual Studio, which is where he is still working today. Before Microsoft he worked as a software developer in the industry for almost a decade, most of that time building mobile apps. News The C++17 Lands Learn C++ Concepts with Visual Studio and the WSL Partial Ordering: An enigma wrapped inside of a riddle, wherein all compilers agree to be wrong Daniel Moth @danielmoth Links Visual Studio 2017 for C++ Developers - you will love it Top 7 things to be excited about as a C++ developer in Visual Studio 2017 CppCon 2016: Carroll & Moth "Latest and Greatest from the visual Studio Family for C++ Developers" Visual C++ Team Blog Sponsor Incredibuild JetBrains

This episode of CppCast is sponsored by Incredibuild. Accelerate your C++ build by up to 30 times faster directly from within Visual Studio 2017. Just make sure to check the Incredibuild box in the C++ Workload VS 2017 setup. And by JetBrains, maker of intelligent development tools to simplify your challenging tasks and automate the routine ones. JetBrains is offering a 25% discount for an individual license on the C++ tool of your choice, CLion, ReSharper, C++, or AppCode. Use the coupon code JETBRAINS for CppCast during checkout at JetBrains.com. Episode 92 of CppCast with guest Daniel Moth recorded March 1st, 2017.

In this episode, we discuss the updated C++ Lands map. Then we talk to Microsoft Program Manager Daniel Moth. Daniel tells us all about the new features for C++ developers by C++ developers. I'm your host, Rob Irving, joined by my co-host, Jason Turner. Jason, how are you doing today? Pretty good, Rob. How about you? Doing good. Got a bit of a storm over here in North Carolina, so hopefully power doesn't go out during the show. Or your computer blow up from a direct strike or something. Yeah, that would not be fun. Our internet wires go down. So, you know, fingers crossed nothing happens.

Any news of you? I'm sure I'll be fine. Well, I guess if you don't mind, if I mention that I just had my one-year anniversary of doing C++ Weekly, which was exciting. 52 episodes? 52 episodes straight. Awesome. That's very good. You're much better than we are.

Okay. Well, at the time of our episode, I'd like to read a piece of feedback. This week we got a tweet from the Sweden C++ I guess it's their community or user group And they wrote How can a weekend start better than with an Interesting C++ podcast Bjorn Fahler at this week's CppCast

Thank you for the kind words Sweden C++ developers And We will make sure to get you in touch With JetBrains for the kind words, Sweden C++ developers. And we will make sure to get you in touch with JetBrains for the giveaway. Maybe you can raffle that off at the next Sweden C++ user group. That'd be cool.

So we'd love to hear your thoughts about the show as well. You can always reach out to us on Facebook, Twitter, or email us at feedback at cppcast.com. And don't forget to leave us a review on iTunes. Joining us today is Danieliel moth daniel joined microsoft in the uk in 2006 before transitioning to redmond in 2008 to work as a program manager on visual studio which is where he is still working today for microsoft he worked

as a software developer in the industry for almost a decade most of that time building mobile apps daniel welcome to the show, thank you for having me. So I'm looking at the timeline here, and it says you did mobile development for a decade before 2006. So I'm wondering, what were you doing, Palm development? No, it was more on the Windows CE side of things. So I've always been in kind of the Microsoft ecosystem using Visual Studio from the very early days.

So when Visual Studio.NET 2002 had first come out, there was also a.NET Compact Framework preview at the time, and I was working at what's now a Honeywell company, and we're doing embedded devices. So it was a Windows CE custom display panel board, and I was writing the software for it. It was basically something you put on the wall, Heathrow and

places like that to monitor an HVAC system, heat and ventilation and access control. And the only reason people would interact with that hardware device would be to use the app that I had there. So as part of that I was also doing other Pocket PC kind of apps and

things like that. before that um i'm gonna disappoint you guys my background isn't strong in the c++ world actually before that it was more like vb3 and vb6 and stuff like that doing a com development before uh the dotnet compact framework and mobile and embedded came along so that's kind of like the beginning of of my career if you like How many of us got our start with VB6 professionally? It's probably a few. And we were pushing the limits on that.

We're doing like the comm development and trying to drop down to IAN nodes and trying to query the interfaces to do extreme stuff, all because the team, you know, the larger team was just more comfortable with Visual Basic. but we were bringing consultants in and they were saying, you guys really

need to be using C++ here, you know that, right? We're like, yeah, yeah, yeah, but we'll just get by just a little bit more. It was mostly blind ActiveX servers and components with no UI down at the comms layer, all in VB. Yeah, that's the background.

I also got my start doing some Windows Mobile and Pocket PC development. I'll be honest, I did not miss those days. Well, you know, I don't know when you were doing that, but actually I co-authored the mobile development handbook on mobile development. So, you know, if you're struggling with that, you should have got a copy of my book.

That would have helped. I'm sure it would have. Okay, Daniel, well, we got a couple news articles to go through. Feel free to jump in, comment on any of these, and then we'll start talking to you about Visual Studio 2017, okay? All right. Okay, so this first one is the C++17 lands map. And obviously, we've talked about the old version of the C++ map. And I'm trying to remember the author of this.

Is it Elena, Jason? Do you remember? Yes, that sounds right. But let's double check. It actually says on the blog, Alina. Yeah. Okay. And yeah, she went ahead and she made a C++17 version of the map.

It's beautiful. It's got all new features in it from the last few modern C++ releases. And the exciting thing is, it's not yet, but she said she's going to have posters available. So if you want to get an official poster and hang it up in your office, you'll be able to do that. Really makes me wish I had an office. Just hanging it out and hang it up in your office you'll be able to do that really makes me wish i had an office yeah exactly right behind you there's all that white space uh yeah i don't think the guest room would be where my wife would want the c++ 17 poster right in the bedroom yeah yeah yeah one of my uh one of my colleagues saw this map, and they were saying how they like, you know, in the corner where it says Concepts Shipyard. Yeah.

And I think it used to be Shipwreck. So I think that's an improvement, right, from a shipwreck to shipyards. Yeah. That's what it sounds like. And Daniel, I think Alina actually is one of your colleagues. I believe she works on the Bing team at Microsoft. Oh, I didn't know that. There's only 45,000 or whatever of us here in Redmond, but that's good to know.

Yeah. Okay. Next one is an article from your blog, Daniel, the Visual C++ blog. And this one is about learning C++ concepts with Visual Studio and the WSL. And you can comment more on this. You probably know more about it than I do. But I thought it was pretty cool. Basically, concepts isn't available in MSVC yet.

But if you want to try it out, but you're a Visual Studio developer, there's really good instructions on how to test it out using GCC and the Windows subsystem on Linux? Linux subsystem on Windows. Yeah, I got that backwards. Yeah, yeah, this was Andrew Pardo on my team

came up with the idea of writing this post. And yeah, a lot of people from the past kind of associate Visual Studio with the Microsoft Visual C++ compiler. They kind of think of them together. When in reality, you can use absolutely any compiler that you like in Visual Studio. So in this example, he's using the GCC, and that's how he's able to get concepts.

So that means that if you're already a Visual Studio user and you're experimenting and learning all the other language features, hey, you can just switch and use this. The Windows subsystem for Linux just makes it easier to use GCC without having to have a separate remote Linux box. So Andrew has really good instructions on this blog post on how to go and set that up, if that is of interest,

until we obviously get content support in our compiler, which we absolutely will in time. Sure. I'm reading this, and I'm like, this is the world we live in now where it's considered at least normal or supported or something that we are expected that we can program on GCC through Visual Studio

on the Linux subsystem for Windows. Right. It's interesting times. I love it. It's going to take a while until it becomes normal. Like I know it's, you guys have been ramping up with the open source developments for quite a while now, but it still just seems so new to have this kind of unity between Microsoft and the Linux communities. Oh, yeah, I appreciate that.

For me, it is absolutely very normal at this point. You know, we're at CppCon. Last time, right now on my laptop, it has Microsoft Loves Linux stickers. We had those stickers at CppCon, and they were going like crazy. Everybody was coming like, is this real? And then we just take a sticker. And yeah, on the open source side, around the CppCon timeframe, I think it was GitHub that announced all their stats.

And Microsoft is the number one contributor on GitHub for open source projects. It is interesting times, and for many people it's like, wow, I knew, but for us internally, it is a change, but we're kind of more used to it, and we love it. It's a really good direction that we're on. This is probably a good time for

me to mention that I am hiring, so if people like what we're doing here at Microsoft, they can reach out to me and we can talk about it. Awesome. I'm sure there's someone listening. You're hiring for the compiler team or for Visual Studio, both? C++ team in general.

So I manage the C++ program managers. So if you've met any program manager on the C++ team, they report directly or indirectly to me. So I'm hiring for the right person that wants to improve the C++ experience that we offer to customers from Microsoft. Okay. Okay. And this next article is partial ordering an enigma wrapped inside of a riddle. Jason, I'm wondering what you thought about this article. It was pretty complex going through examples of overload resolution i have to be honest i got lost yeah i don't know about two-thirds of the way down like like i don't know i'm like if i was

writing code that was running into these issues maybe i should refactor i i am wondering you know if you get to the end of the article he basically puts forth one example and says what he thinks should happen according to the standard with overload resolution. But apparently all the compilers, MSVC, GCC, and Clang, all got it wrong, at least according to him. Right. And this is one of those times where I wish we had STL just available to call into and ask him what his opinion on that, because I'm sure he knows what's going on. I mean, for an issue like this, we might need someone who's even more of a language lawyer than STL. What were you going to say, Daniel? I was going to say STL's office is three offices down from where I am.

And Herb's office is just opposite and one more corridor kind of thing uh but you know as i was looking uh looking at this it seems like um i don't know isn't it a bit of a convoluted example to prove uh oh it is yeah yeah so i'm not sure uh what's right or not but yes that's something i would defer to someone that enjoys standardese. Yeah. Absolutely. But his ultimate conclusion that there are more cases where the standard could use clarifying examples, I totally agree with because I have run into these things and posted my own questions like we need a clarifying example here. Yeah. And one thing he points out is that to look at some of these rules, you're jumping back

and forth between different parts of the standard in order to figure out what should be happening. Yeah, that's not good. We ran into that discussion on Slack for how decal types of lambdas are deduced. And you're hitting three or four different parts of the standard at once. And just having one clarifying example would be nice. Yeah, and i think herb wouldn't disagree if you uh spoke to him about can we clarify more things in the standard

i don't know what he would say about this particular example that would be a good question for you guys to ask him the next time you have him on yeah right yeah definitely okay daniel so we are recording this a couple days before the big Visual Studio 2017 release. It's just right around the corner. And it looks like there are a lot of exciting updates for C++ developers. Where do you think we should start? We can start wherever you think would be more interesting to your listeners. I was actually writing the blog post that I'm going to publish next week on the launch day. And the title, the current title, is Visual Studio 2017 for C++ developers.

You will love it. So that's like the strong position that we're taking here. So we can start from where you install it, how you open projects, productivity, anything you want. Well, let's start with installing because that's kind of going to be

the first thing that developers encounter. I totally agree with Rob on that because 2015, if you're a C++ developer, it's kind of a pain. Yes, if you're a C++ developer, it can be a pain. It is a pain you only pay once, hopefully, when you install it. I also think it's a pain probably for other kinds of developers as well. So that is an area where in 2017, we invested heavily. And the first way this is going to manifest for folks is when they go and try and install 2017, they will encounter this new concept of workloads. So instead of having to pick components at the very coarse grains way, you'll have these options, for example, C++ desktop development, or C++ for Linux development, or C++ mobile development, C++ game development, and so on.

And there'll be web development for ASP.NET or something like that, Python. And people can just pick exactly the workload, the scenario, if you like, the target that they're interested in, and install only those bits. And that is really exciting because you're going to install it faster. For example, if you install our Linux development for C++ developers, that installs in under seven minutes on my machine. The desktop C++, which is the one that most people use, that one is more like 15, 16 minutes. I mean, these are times that are nothing like what it was before. So the speed is a great benefit for folks. But it's not just the speed. It's also what I call visual noise. So when you interact with the IDE, if you're not doing C

sharp, for example, you will not see C sharp anywhere. So those components are just not installed. So this isn't just a visual, hey, here's a new UI to pick things. This is actually a re-architecture, rewrite of the installer in terms of what it installs based on the one or more workloads that you pick, which also means the third benefit beyond speed and visual noise that your hard disk will thank you. It's going to be fewer bits there. And today with SSDs being smaller and things like that, that's even more of a reason to be thankful of that.

So yeah, clearer way for you to pick what you want, speed improvement, size improvement, and less visual noise. You only see the things you care about. So I think that's really exciting just from the get-go. Yeah, absolutely. But if you are doing a mixed-language project like C++ and C Sharp, you're still going to get the kind of integration

that you would have had in the past? Absolutely. So you will go and pick your C++ desktop development, then you'll pick your C Sharp desktop development, you might pick your Python one as well, and then you'll get exactly the integration that you would get with the previous versions of Visual Studio,

except you've picked exactly what you wanted. Okay. Yeah, so you don't lose anything. Okay. And one other thing that I think you mentioned, I watched your CppCon video. Installing tool sets from previous compilers, is that something that's new to VS 2017?

Yeah, that's right. So one of the things, beyond the installation experience we just talked about, there's a whole other, if you like, theme of investments that we've been looking at. And that theme is what I'm calling a pain-free upgrade. Because always when you have new things, new shiny things in the next version of Visual Studio, I don't know about you guys, but especially when I was a customer outside of Microsoft, I would always be like, oh, drooling over the new productivity features in debugging and so on. But I always knew that came at the cost of upgrading my project, which inevitably might have some errors or warnings that I have to deal with.

And that's good because usually they make my code better. But you have to go through that pain, if you like, in order to get to the good stuff. So we have a theme of pain-free upgrade. And part of that, one of the things in there, is the thing you just mentioned, Rob, which is when you get the installer for Visual Studio 2017, you can also just check another box when you pick C++ desktop development, and now you get the Visual Studio 2015 toolset. So the compiler and library package that you have in 2015, which means that when you go and work on your project, you can pick in the project properties to use that toolset, and you don't have to change anything.

It's exactly the same compiler that you were using before and the set of libraries, but you get all the benefits of the IDE productivity aspect of things. So that's one option that people can exercise. That's a big one for me because I know where I work, we're still dependent on Visual Studio 2013 for a couple projects. Everything else we can build with 2015. So whenever a new developer starts, we need to tell them, go install 2013 first. That's not what you're going to use most of the time. Then you can install 2015.

So you're saying we don't have to do that anymore. We can just say install 2017 and check those two boxes to get the old tool sets too. Yeah, so just to make sure I'm completely honest there in this specific scenario, you mentioned 2013. So unfortunately, we weren't able, at least with this release, to get 2013 tool set in there. So we would hope that you can move to 2015 and then all you would need is 2017. So if you have projects that are still stuck on 2013, I would say two things. First, get in touch with us in case we can help

move those forward. We actually run labs where we have people like STL and the actual developers on our team do a Skype session and help people move their code forward. Usually it's dependent on third-party libraries, but we help with that

because we take that very seriously. We learn from that. You're getting the help of upgrading. We're getting the help of learning. Oh, that was the blocking issue. How can we document that better? How can we have better tooling? How can we avoid that in the future? So that's the first thing I would say. Then practically speaking, if you're stuck on that, you would need to do what you said today. You install 2013, then you go and install 2017, but then you can remain in 2017 and use the 2013 tool sets in your 2017 projects. It just means you were unable. Yeah, so you can still do that. But it means that you had to install the whole IDE for 2013, instead of just the tool set as we allow you with 2015.

Right. Now, I'm going to play devil's advocate for just a minute here. And are you guys concerned at all that you're going to create like a Windows XP kind of scenario where you'll have people on like the IDE for 2025, but still wanting to use the 2013 compiler? Yeah, so I love devil's advocate.

So please keep doing that. You know, that's my favorite kind of discussion to have. So that is always a risk. We are not, I should say, at this point with the data we have, we're not afraid of that for a few reasons. One is there's so much value in the compiler. We're investing in the compiler heavily. I know today we're talking about Visual Studio 2017, but our compiler gets a lot of investments

and investments across performance, both in the build throughput case and in the runtime performance of the generated code and with security and with conformance, which is our number one priority when it comes to our compiler. So if you're going to go and you're going to use the old tool set

and you're going to be stuck with that, if you like, you're choosing not to get all that value from the latest versions of the compiler. And if that is a choice you want to make, that is fine. You can stay with that. We just don't believe that is a choice you're going to make. We believe you will want to move to the latest compiler. And if you're not, then we're not doing part of our job.

Okay. I wanted to interrupt this discussion for just a moment to bring you a word from our sponsors. IncrediBuild dramatically reduces compilation and development times with unique process virtualization technology. The tech transforms your computer network into a virtual supercomputer

and lets each workstation use hundreds of vital cores across the network. Use IncrediBuild to accelerate much more than just C++ compilations, speed up your unit tests, run more development cycles, and scale your development to the cloud to unleash unreal speeds. Join more than 100,000 users to save hundreds of monthly developer hours

using existing hardware. IncrediBuild is already integrated into Visual Studio 2017. Just make sure to check the IncrediBuild box in the C++ workload in the Visual Studio 2017 setup. So we're going to focus mostly on the IDE stuff, but you did mention conformance there. So maybe we could quickly touch on what the status is of C++ conformance with the compiler being released. Absolutely. Like I said, and I'll say it again, our number one priority when it comes to the compiler is conformance.

So we've caught up a lot. We have talked about that at CppCon, our blog. I think you had guests from the C++ team that have talked about that at various points. We are still going to be catching up as we move forward. And once we catch up, we're going to stay caught up. So that's like a top-level statement. In terms of specifics, if you look at the new

compiler features that were introduced with C++ 11 and C++ 14, you will find in the release with Visual Studio 2017 that we have essentially completed that. So we're caught up for the features that were introduced with those two. Now there's a few

caveats for those that are paying very close attention. For example, things like two-phase name lookup, which is not in any of those. It's a C++ 98 kind of feature. That one is still not there with this release, but it will be later this year with updates to this release.

And someone could also split hairs on the constexpr support because we're doing that through the various library supports. So we cannot ever declare ourselves complete-complete. But as far as the big libraries, constexpr works there.

So we're considering that kind of done from that perspective. But in addition to 11 and 14 and the comment I made about the one remaining 98 feature, we have also implemented a bunch of C++ 17 features, and that's not even complete as a standard. So that's new if you compare us with historical statuses that we had previously. And our goal is this year with the updates to Visual Studio, to be up, you know,

complete on 17 as well, both on the compiler and on the library side. So I'm really happy with how we're progressing towards the goal of conformance. And I hope that the team, you know, sticks with it and will deliver on the goal of later this year being up to date once 17 is finalized as well. So you mentioned compiler updates would be coming out. Are these going to be like service packs or like kind of rolling updates or what should we look forward to? That's a good point, especially for folks that haven't been following closely what we've been doing recently.

And I have a slide on this at CppCon where we basically release quarterly updates. I don't think it's a commitment, but if you look at the pattern, that's really what's going on. So we release quarterly updates to Visual Studio, and in those quarterly updates, we actually update the compiler bits as well.

And we've got options on how to do that every time. We could create another tool set. So it's a choice. You can say, I want to stick with the RTM version or I want to have the update one or whatever it's going to be called version. Or we can just force you to move forward. Hey, now you're going to take the latest. So we have a choice there on what we do.

So yes, you'll be getting compiler updates at least quarterly through the Visual Studio mechanism. And also, I don't know how many of your listeners are aware, but we have the, you can just get the compiler if you want with what we call the Builds queue, the Build tools. We've blogged about that in the past. So you can just that package if you don't want Visual Studio. And furthermore, Andrew has blogged about this, is the Nougat feed. So we have a feed where we put essentially daily bits up there.

Of course, there's no support for those. But if you want to be trying, you know, hot off the press, the latest version of the compiler with anything it has in it and report bugs back to us, you can do that. So yes, we're releasing frequently on all these different vehicles, whether it's through Visual Studio, or through the build tools SKU, which only has the compiler, or through NuGet, which is a very frequent release mechanism. So as a library author, what would be the mechanism

that I would communicate to the user of my library? No, if you want to use my library, you must have the third quarter 2017 compiler release and effectively be able to make an error at compile time or something and communicate that back to the user you would have a dependency on the you would have to refer to the version number that that you've taken a dependency on uh if you want it however that's a good i'm glad you mentioned that because remember um earlier when rob asked about the tool sets

i said we have a theme of investments we've done to ease people moving to the latest bits. Another item that is pertinent to the point you just made is the binary compatibility that we now have for the first time between Visual Studio 2015 bits and Visual Studio 2017 bits. So that means you can actually use these two different compilers and you can link to libraries built from them and you will not have break and change. We've never done that before. So this is between 2015 and 2017 and obviously anything that we do until we are forced to break binary

compatibility again. There's a few things that we'd like to do and they would require breaking binary compatibility and we're shelving them and we're waiting to do them so we can do them all in one go at some point in the future. But for now, that is huge. You can actually mix and match binaries from the two different compilers.

Okay. Very cool. Yeah, so the CRT and STL and so on, we've made sure that binary compatibility in the runtime exists. Awesome. Let's talk about build throughput a little bit. You mentioned that a moment ago. What kind of performance are we seeing there? So with build throughput, we focused mostly, I say mostly because it's improved across the board, but we focus mostly in what we call the inner loop, the edit debug cycle. And we usually refer to that as the edit compile debug cycle. But if you think about

the intent of us when we write that code, you don't want to build, you just want to edit, and you just want to go test that code. The fact that you have to build is tax. You have to wait for the build in order to go and test your code or debug it. And what we found is that for many people, what

dominates that build time where you're just waiting in order to go test the code is the linker. Because you just made a small edit here and now you're waiting for the linker. So in Visual Studio 2015 Update 3, you can go and use the linker option FastLink. I don't know if you guys have used that. So slash FastLink. And that will give you, in some cases that we've measured, two to four times faster linking, which is extremely useful during that inner loop. So what we've done with Visual Studio 2017 is taken that two to four X improvements and made it like 20, 30% faster. So made it even better. And we've turned it on by default.

So you don't have to worry about going and finding that flag and turning it on. So people that move to 2017 inevitably will just notice that increased build throughput when they go and edit something, hit a 5, in order to go and test it or debug it. So that's the biggest thing we've done in that area. Okay. I was just going to ask, but you kind of pre-answered the question, but I'm still curious. You said it's enabled by default in 2017, but it wasn't in update three of 2015. I was wondering if there's any downsides to the fast linking. Yeah, that's a good point. So there is the downside overall. When you do the fast linking,

you don't get the actual full PDB, the full debugging experience that you would if you were to give the bits to someone else. So if you had them on your machine and you were to give them to Rob for him to debug, he'd be missing things. So for that scenario, what you had to do was to go and run a separate tool from the command line when you wanted that capability in order to generate the full debug information when you passed those binaries to someone else. What we've done with 2017 is we've integrated that capability in Visual Studio itself. And there's various prompts to help you and guide you that, hey, if you're doing more than just debugging on this one machine, and you're going to be trying to ship these

things elsewhere, and when you ship them elsewhere, you expect those people to be able to have full debug. Then, hey, go ahead and take this path instead so you can generate the right information. Okay, makes sense. Any other big improvements with throughput? We've done improvements in the front end as well,

but the one I mentioned is really the biggest on the front. Okay. And how about uh the ide any new productivity features for super plus developers i'm guessing this is a big area of improvement it is and it's the one that um uh is the one that typically demos very well right so it's kind of hard to talk about it over the over the podcast but what i would say um before i can mention a few productivity enhancements in there, but we're just talking about built throughput and what's new in the AD. If you think about

productivity, we wanted things to be faster for us, whether it's new features that we use to do things faster than what we did before. So performance itself can be thought of as productivity in that regard. So whether you think of performance itself as productivity or as its own thing, either way, that's one of the things that we've done in the IDE. We've really focused on performance. So build throughput is one way you will feel that because you will feel that as you're using the IDE and you're building. But another area is solution load.

So we have, for example, what is it, like four times faster loading some really large solutions like the chromium which has i don't know almost 2 000 projects or something in it so we've really focused on on on that uh on that performance of loading solutions and there's a couple of ways we've done that one is just pure improvements in the code and other is with deferred loading of projects uh so that you don't have to load everything asynchronously at the beginning. You can just load the main project and then as you go and browse,

if you need to browse to another project, it kind of loads later. So there's some tricks like that, but there's also like real performance improvements there. Then another performance improvement would be with IntelliSense. So hopefully everybody that's using Visual Studio for a while uses pre-compiled headers

because that really helps both the compiler and the language service, which you can think of as another compiler, in having everything be responsive for you. But if you haven't set them up for whatever reason, then we have this capability not in the compiler, but in the language service

in design mode to essentially create something like a PCH in memory for the translation units, the files that you've just had open. So you'll get some preloading and caching there, so you don't have as many delays as you go and add a function. Instead of waiting too long for that to appear in IntelliSense or something like that, it'll just be faster when you get it there.

So that's another area where you're going to feel improvements in the performance. And other areas when you're debugging the. So that's another area where you're going to feel improvements in the performance. And other areas with when you're debugging the actual virtual memory being used. So we've done radical improvements there to bring that down by 50% in some cases. We had one pathological case where it would actually crash out of memory when you're debugging some Unreal projects.

And now that is very comfortable. So that's not my bar. Usually, hey, we used to crash, now we don't, but it just shows the improvements. And I've kind of ruffled through those very quickly, but when you put them together, the build throughput when you're five and the memory consumption and the IntelliSense aspect of it

and the solution loading, as well with startup and shutdown of VS, you really feel the performance difference. And that is a way your productivity will increase with Visual Studio. That's one way. You've mentioned all these IDE improvements and IntelliSense and everything. And I saw a comment from someone, I don't remember, I think it might have been on Twitter, about using the Clang front-end with Visual Studio. And now you've got all these language features that the Visual Studio compiler doesn't support

and the IDE didn't support. So it was, you know, like C++17 kind of features that the IDE wasn't supporting. And I'm wondering if the IDE is staying ahead of the compiler, if you will, so that it's matching the claim front end? Or do you have any plan for that? So, like I said, and like we all know, you can use any compiler you like with Visual Studio.

But you're right, you're using the compiler, that's fine. But how about the IntelliSense, for example, the language service in Visual Studio? Well, that, as you probably know, is powered by EDG, yet another compiler. So it is up to... I didn't know that, as you probably know, is powered by EDG, yet another compiler. So it is up to... I didn't know that, actually. No. Yes, so our language service is yet another compiler.

It's EDG. So if EDG has support for that language feature, and we enable it, because you have all these switches that you can pass to it, then absolutely it's going to work. That is how, if you're familiar with the Clang C2 project that we experimented and released in the last version of Visual Studio,

where we took the Clang front end with our own back end and kind of stitched them together, so you get excellent debugging while still using Clang. Well, the way that you get IntelliSense there is by us turning ADG into Clang mode, and essentially that's how you get the IntelliSense. So the question, hey, will we make our IntelliSense and language service overall in the ADE

support a language feature that we don't have in our compiler, but maybe in another compiler you're using? The answer is, well, if EDG supports it, step one. And step two, we decide to enable it, which would mean testing it, then yes, it would. So there's no principle against that. Okay. So is EDG a compiler from Microsoft?

No, EDG is a compiler out there in the industry. For example, if you're familiar with CUDA C, they're based on EDG, the CUDA compiler. I believe Intel also is based on that front end. So, yeah. Interesting. Now you're making me wonder if I'm not pronouncing it right or something.

So I'm just going to search. No, now that I look it up, I have seen this before, the Edison Design Group compiler. Right. I've heard people refer to it as Edge. Yeah. EDG is how I say it.

So, yeah. I have seen it, but I've never tried it. Right. So that thing is what powers our intelligence. Okay. Okay. What else can we talk about, Daniel? We talked about installation workloads, conformance, build throughput.

What else is big? So I think I should go back to this. There is, you know, you asked me two questions there. What else should we talk about and what else is big? So I think I should go back to this. There is, you know, you asked me two questions there. What else should we talk about and what else is big? So there's something really big in my opinion. But first, I think I want to answer fully the question you asked me earlier on productivity. So I almost deflected that to talk about performance just because we're talking about build throughput at the time. And I thought that's a good package of things to talk about.

But on the productivity side, again, these things demo better. But for the listeners, I'm just going to throw out some things, and they can go and look at them on Channel 9 videos or on our blog that link to them. So we have improved find all references. So that's something that people use a lot. We have revamped that experience completely in terms of what you can do in the UI for grouping

and filtering in terms of loading results faster and more. Again, it's easier to see these things and describe them, so I'm not going to bore you with a description on them. Another area that is really big on navigation, which is important when you're navigating large code bases, whether debugging or trying to add some feature, is what used to be called navigate to is now go to. And you can go and very easily navigate to types or variables or whatever you want, symbols. You can just pick what type of thing you're navigating to, including line numbers if that's what you want to do.

So it's a unified, again, experience with better filtering, better ease of use, faster at your fingertips. So if you search for GoTo, you'll find information on that. We also have a new predictive intelligence. So when you go and type something and the thing that you want isn't coming up because it's such a long list, we now kind of smartly filter that to what we think would be what you want. If you're doing an assignment to an int, why should we show you a variable

that matches what you're typing, but we know it's a double? So we kind of like be smarter in what we're doing there. We call that predictive intelligence and smart filtering. So those are terms you could use to see that in action.

On the debugger side, we have a new run-to-click feature, which is a UI enhancement of something you could do from the context menu. But every time we demo this, people think it's a new feature in Visual Studio because no one has discovered, you know, that really long context menu, what exists. But it allows you to quickly run when you're debugging from one point to the other without setting the breakpoint in between. The run to cursor is what the context menu was known as.

And then also in the debugging space, we have improvements on the exception handling. So, you know, when you hit an exception and you get a model dialogue and you look at what it says, but then you have to get rid of it to go back to your code, but then you want to see it again because it has information and you like all of that mess. So now there is... Yes. Painful, I know. So by the way, as an aside, before I moved to manage the C++ time, I used to

manage the diagnostics team, debugger profilers, IntelliTrace, and so on. So this was a pet peeve of mine then and now we're finally shipping it, so I'm happy about it. So what we've improved is instead of a model dialog, you get a non-model dialog. It's a little pop-up right on the line, which you can dismiss if you want, but very easy to get back by clicking on that line.

And it has more useful information in there. You can easily turn on or off exceptions from it. So that's a nice improved experience. And finally on the exceptions, you know, when you get first chance exceptions, exceptions that were thrown, that will be caught later on. And you're trying to find the root of where they appear, not just where you catch them. Well, in some cases, you just want to filter out exceptions that come from certain modules. And you were never able to do that before. And now we have conditions on exceptions, just like you have conditional breakpoints.

So you can go and say, yeah, only show me exceptions that don't come from this module before and now we have conditions on exceptions just like you have conditional breakpoints so you can go and say yeah only show me exceptions that don't come from this module or only from that module and so on so all of these again these are easier to see but on when we launch visual studio i'm going to be posting the blog posts i've been working on and have links to other blog posts and videos on all of these features that's the best way for you and your listeners to go look at them. But already kind of a rattled out a whole bunch of new productivity improvements that we have there. Okay, so we'll definitely put the link to that blog post in the show notes once we get it. And there's also your CppCon video where you and Steve Carroll went over a lot of those features, right?

Right. And actually, Steve and I will be doing another double show on the live stream on the launch day next Tuesday, and that's going to be recorded. So there'll be even a more recent video, not as long as the CppCon. So we could put both of those videos up if that's something that we think would be useful to folks. Okay. I think there's one more thing I remember from that YouTube video that you didn't mention. Dot to pointer, right? Oh, yeah, yeah, exactly. Yeah. There's so many productivity features. You know, the session I used to do at the various conferences was the tips and tricks,

debugger tips and tricks. And most of them people just didn't know about. You know, I joke around here sometimes, we don't need to invest in productivity. We just need to say, hey, we add the new feature and it's an old feature, and there's people who just think it's new because you just don't know. There's so much in there. Again, when I was on the diagnostics team, one of the most often requested features was is there a way to put a breakpoint and somehow

stop only under a certain condition? And it's like, yes, it's called conditional breakpoints. We've had that forever. And it was because of those requests that in the last release in VS 2015, we went and added a UI pop-up when you set a breakpoint to help people find that, hey, you can configure these things.

So anyway, I'm diverting. So you've talked a lot about how much easier it is to install the compiler. We've got the standalone compiler, we've got the NuGet packages, right? I'm in a situation where the Visual Studio compiler actually works perfectly fine under Wine on Linux.

The problem is getting it installed in Wine under Linux. So if there's any chance that when you push out these compiler packages, you could also just have like a zip file download that I don't have to run an executable or put it through NuGet or something. That would be amazing. That's actually a good point. If you actually email me about that, I see no reason why we couldn't do that. I say email me because I'm going to forget if I don't have this written down somewhere. But the NuGet package, I believe that should serve your purpose.

Because you can go to that feed, and you will get essentially a zip file there like you just unpack it so if you email me I can send you instructions for the Nougat thing if you don't try it on your own and I think that might just work for you and if it doesn't that's definitely a scenario we could enable

I didn't know that you could consider getting that without actually using Nougat to get it I think you can rename a Nougat file NuGet to get it. Yes, you can. I think you can rename a NuGet file into a zip and just extract it, right? I'm not sure on the specifics. I don't want to lie to you. But you can definitely consume the NuGet feed differently. Okay.

Yeah, so ping me on that. And then if you think that's useful, once we get it sorted, you can blog about it or share it with whoever else might be interested too. All right, thanks. Okay, Daniel, anything else we're missing? Have we even gone over yet? Yes. So there's a few things. So one is on that theme earlier, I said we have this theme of investments of pain-free upgrade, right?

So we talked about picking a tool set that comes with it. We talked about the binary compatibility, which is huge. And we also have VC package. So I don't know if you guys have talked about that in the past on your show. That would be a good one to go deep with a couple of devs and PMs on our team here. But in a nutshell, that's the C++ package manager on Windows that we released last year. And this has a whole bunch of libraries in it already. So you get the source there, and then you can build based on your architecture choice and so on.

So one of the things that we've done there is that integrates with Visual Studio if you want. And so if you've been using that, if someone uses that with Visual Studio 2015, when you move to 2017, because you're integrated with VC Package, it will automatically go and get the right version of all the libraries that you've been using, if it knows about them, and automatically get the 2017 version of them. So that is another very easy way for you to move forward. So if people are in 2015 or can get to 2015, going to 2017 is a piece of cake because of these three reasons that we mentioned. So that's another one.

And if you haven't done VC Package, let me know and we can get a couple of guests. It's really exciting what the team has done there. Yeah, I think we've covered some of the blog articles when it first was announced, but we haven't gone deep on it. Yeah, Robert's on our team, Dev and Eric, the PM, one of them or both of them could definitely do a show with you. So then, kind of this stuff that we talked about is about pain-free

upgrades. So the assumption there is you're already using Visual Studio. And, you know, that is a safe assumption in most cases. If I look at the stats, we kind of, you know, are the leading ID out there. But I know you won't believe this. Some people don't use Visual Studio. What? Yeah, it's crazy.

It makes no sense. The people we talk to, we do believe it. I mean, if you're on Windows and you're not using Visual Studio, I don't get it. I mean, it's free, the community edition under certain circumstances, but it's there for you. But yes, we do recognize that some of these people exist.

And we like those people as well, because our mission is to make every C++ developer happy on the planet, especially those that are on Windows. So one of the things that we focused on was what we call Open Folder. So I don't know if you guys have talked about that in the past on your show. A little bit. Yeah, so the idea there is that in order to get into Visual Studio as easy as we've made installation and so on, you still, with 2015, would have to go and create a project, an MSBuild project essentially,

a Visual Studio project, and then add your files there and so on. So what if you're using your own build system, which you might be, right? So you may be using CMake or maybe directly Ninja or Makefiles or whatever. So you have kind of your own system and you just don't want to mess with the Visual Studio way of doing things. So that was like a barrier for people using Visual Studio. And we recognize that and we want those folks, which Open Folder tries to address. So with Open Folder, it's kind of a self-descriptive feature. You just go and say Open Folder and you point to a folder of C++ code

and it will just load it all up and you'll have your intelligence and debugging and you can help there with editing a JSON file so you can give more hints to have the greatest experience you can in Visual Studio. So that is, and we've just started investing there.

We're going to do a lot more. So that is a way that you can get your code in VS to enjoy all the productivity features that we've been talking about and that we've been adding in all these releases. And what's more, we have actually special cased CMake. So if you go and do open folder on a folder of C++ files that has a CMake textless file in it, because you're using CMake solution, we will detect that and we will use that file to give you the best experience we can for that CMake solution in Visual Studio without you having to do something separate in other JSON files and so on. So we have the easy upgrades, but we also have the, hey, you're new to Visual Studio, come on in.

It's going to be very easy for you to get started, to get to the productivity features that we have. So that is another big one. How much configuration does it take to run using Open Folder? Like if you want to set it to a special compiler, if you're not using MSVC? Right. So if you're using CMake, it's whatever you've pointed CMake to be using. And when I'm talking about we're going to do more investments there, we're just going to essentially special case even more systems that are out there. In terms of how much configuration you need to do, it all depends on how complicated your build scripts were in the first place, how much, you know, whatever you have there that's going to be more complicated,

you're going to have to do a bit more work. And it's also a pay-for-play in terms of what you want. You might just be happy with colorization and recognizing of important types or something like that without having full-blown IntelliSense. So you want just basic IntelliSense. So depending on how much you want from Visual Studio, more hints is what you'll have to give us if you just do the vanilla open folder experience. With CMake, of course, we just parse what you've already put in your CMake text list file, so we'll just read that and show you the

best experience possible. And when using Open Folder, can you expect to get every Visual Studio feature you'd be used to when you're using the normal MS build process, like IntelliSense, Debug? Yes, that is absolutely where we're going. In fact, the demo that we're going to

show, for those that watch CppCon video, me and Steve were there where we're going. In fact, the demo that we're going to show, for those that watch CppCon video, me and Steve were there, we were talking about this, and we demoed the productivity features with an MSBuild project, and we demoed OpenFolder and CMake separately. What we're actually going to do on launch day is start with CMake and show all the productivity features within the context of that CMake project. We just weren't in a place to do that last September. But we are now with the release bit.

Okay. Okay. Do you have something else you still wanted to talk about? We didn't get to yet? I can keep going forever because there's so much to this release. But those are the highlights. Okay. If you like.

So, yeah. Okay. Well, it was great having you on the show today, Daniel. Obviously, people can go to Channel 9 or to the Visual Studio Plus blog to get even more details about the release, right? That's right. Yeah, if you come to blogsmsdn.com slash vcblog, I'm sure we'll put that link down there. That's where we kind of share all this news. If somebody is a Visual Studio user and has been listening to this and they discovered a lot of things, that means they haven't been following our blog.

Because we talk about all these things very transparently as soon as they appear. And we get feedback early. And then you can help influence the product. So that is the one place to stay. I'll share the link of the roll-up blog post. I'm going to do the links to everything. And also, I liked earlier that you were asking some feature requests and stuff like that. If anyone out there has feature requests or the direction that we're going, something,

they can email me directly. We can make that happen. If they have bug reports, they should use the other normal channels. But if they're like, hey, I think that C++ from Microsoft could go in this direction or that direction, email me at daniel.moth at microsoft.com. Just email me directly and we can have the discussion. Very cool. Very cool.

Okay, well, thank you so much for your time today, Daniel. Thank you. And in case I forgot to say it, I am hiring for anyone that wants to help us. Thank you. Thanks for joining us. Thank you. Thanks so much for listening in as we chat about C++. I'd love to hear what you think of the podcast.

Please let me know if we're discussing the stuff you're interested in. Or if you have a suggestion for a topic, I'd love to hear about that too. You can email all your thoughts to feedback at cppcast.com. I'd also appreciate if you like CppCast on Facebook and follow CppCast on Twitter. You can also follow me at Rob W. Irving and Jason at Leftkiss on Twitter. And of course, you can find all that info and the show notes on the podcast website at cppcast.com. Theme music for this episode is provided by podcastthemes.com.