 Hi, this is John Galloway and today I'm talking to McColl from the Bing team. And McColl, you wrote a really cool blog post recently where you talked about how the performance impact and all kinds of other great impacts from running on .NET Core 2.1. Can you give me an idea of how busy Bing is, what kind of traffic you're processing here? I mean Bing.com gets thousands of queries of search queries per second. We power Bing.com and other API partners using cognitive services. So you get thousands of queries per second and we have millions of lines of C-sharp code that's powering Bing.com. Wow, okay. So I always think it's great when I'm talking to customers to tell them that large implementations or people are using .NET Core on large production instances and this is a really cool one. So one thing you call out right at the top of this post is the idea of ready to run images and I don't think that's that well known. Can you explain what that is? Yeah, so ready to run images are this version file format that's available on .NET Core. Basically it allows you to pre-compile your assemblies into both native and managed code in the same file which allows you to basically have this ready to run experience. You have managed code that gets jitted usually but when your images are ready to run they're essentially ready to run when your program starts which is very useful for if you have a large application with many assemblies and a lot of managed code. It really helps start a performance and also impacts your working set. So usually this code that is generated is more compact in its representation because there's not a lot of jitting going on that's putting code in different places. So it's all in one image. Very cool. So as opposed to paying the price of like jitting on each of your servers on a farm you can kind of do this at build time and blow this out to everybody. Is that correct? Exactly. The key part of ready to run images in .NET Core is that we did have previous technologies like NGEN on .NET Framework but they required admin privileges on the actual machine that you needed to NGEN on and also the fact that it had to be done on the exact machine. So if you have 5,000 machines that process happens 5,000 times. Yeah. Okay. So next this is awesome seeing this chart here. You showed a 34% improvement from upgrading to .NET Core 2.1. So previously you had both .NET Framework 472 and .NET Core 2.0. So just that bump to 2.1 was a 34% improvement overall? Yeah. So we basically when we migrated our code we were still running on .NET 472 and then we would switch back between 472 and 2.0. And so we saw both sides of 472 and 2.0 and when we upgraded to .NET 2.1 that was phenomenal 34% improvement that's right. So I love how you went through and called out detailed features and also specific pull requests on some of these and you showed why your performance got better. So like any favorites here? I mean I always love things like vectorization and looking at how that kind of bubbles all the way up the stack. Yeah. The best part in one sentence is the fact that the community and Microsoft employees contributing open source has really helped us. My favorite I have to say is the vectorization because it actually had a major impact. But my other favorite one is the combination of work done by Microsoft employee Andy Ayers and an open source contributor well-known, Ben Adams, where they had de-virtualization and how that impacted when you did it for certain default equality compares for dictionaries. That was a great sort of synergy between Microsoft employees and open source. So I would say that's one of my favorites. And it's really neat as part of this. My understanding is that you had specific requests and you work through the public GitHub thing to say, hey, we'd love this sort of performance improvement or change. And then as part of that collaboration, this shipped as part of .NET Core 2.1 and helps everyone out, right? That's right. One of the ones that I contributed and sort of opened a pull request and issue was this one with call indirect. And it's because we generate that kind of code. So you can imagine as in open source, if you have a particular kind of code that you'd like optimized, it's really great. You can just go in and contribute. And that's what we did with the help of the .NET team as well. So it really overall was a great experience. Operating in open source is probably one of the main reasons why I think this performance improvement across so many different things has been seen in Bing. Cool. OK, so then one final thing is the actual rolling out to production. And this is just amazing here that within two days of the release, you were able to deploy. What is it about .NET Core that allows you to do that? So .NET Core has basically these two deployment types. One is the shared deployment, the shared runtime where you will have the .NET tool available on your Linux distribution or your Windows OS. And the other one is this idea of self-contained apps. So for us, we use this idea of self-contained apps and we're able to basically have the .NET Core runtime be a part of our application deployment. So which if you think about it is extremely cool. You just have your app, right besides it is all the Core CLR, the GC, the JIT, everything there. So if you think from a perspective of how can you isolate things, it's really cool. You on day one, you have this application running on .NET framework. On day two, you upgrade it with .NET Core sitting right beside your app. And so when .NET Core 2.1 comes out, for us, it's a change in the CS project. It's literally a change in the NuGet package. We made one character change and we were able to deploy .NET Core 2.1 two days after. And that two days is just because of some additional validation we had to do. So that was really awesome. That's so cool. I love here, I mean, the focus of this post is on performance. But were there other features you were able to turn on as a result of moving to .NET Core 2.1? Yeah, so this is another one of these things where the ecosystem really helped. With .NET Core 2.1, you also get broadly support in the core FX libraries. So we actually use that and we're able to get Bing.com broadly support, which was phenomenal. So not only did we get all these performance improvements, our response size also shrunk a little bit because of using broadly. So that was also pretty phenomenal. Wow, that's great. Well, that's all the time we have for this quick look. I'd encourage people to go out and read more on this post. The post is titled Bing.com runs on .NET Core 2.1. And thank you so much for your time, Michael. Thank you.