The Modern .NET Show

Episode 104 - C# with Mads Torgersen

Sponsors

Support for this episode of The Modern .NET Show comes from the following sponsors. Please take a moment to learn more about their products and services:

Please also see the full sponsor message(s) in the episode transcription for more details of their products and services, and offers exclusive to listeners of The Modern .NET Show.

Thank you to the sponsors for supporting the show.

Embedded Player

Episode 104 - C# with Mads Torgersen
The .NET Core Podcast

Episode 104 - C# with Mads Torgersen

Supporting The Show

If this episode was interesting or useful to you, please consider supporting the show with one of the above options.

Episode Transcription

Hello everyone and welcome to THE .NET Core Podcast. An award-winning podcast where we reach into the core of the .NET technology stack and, with the help of the .NET community, present you with the information that you need in order to grok the many moving parts of one of the biggest cross-platform, multi-application frameworks on the planet.

I am your host, Jamie “GaProgMan” Taylor. In this episode, I talked with Mads Torgersen about the C# language, it’s evolution, some of his favourite language features, and the collaborative nature required for developing a modern programming language entirely in the open.

Along the way, we talk about the way that you can get involved in the evolution of C#, and how you can suggest features or keyboards, and even how you can enable the latest preview bits of the language to try them out.

So let’s sit back, open up a terminal, type in dotnet new podcast and let the show begin.

The following is a machine transcription, as such there may be subtle errors. If you would like to help to fix this transcription, please see this GitHub repository

Jamie

So thank you very much Mads for agreeing to be on the show. My goodness, it’s wonderful to be connected to you. And I’d say I’m a big fan of C#, and I’ve been using it for 14-15 years now. And it’s just, yeah.

Mads

Wow.

Jamie

Essentially, my entire career. It’s wonderful.

Mads

I’m so glad to hear it.

Jamie

Oh, my goodness. So I was wondering, now, obviously, everyone’s going to have seen the title of the episode, and they’ll be going, “Mads. Oh, my goodness. I’m going to listen to this.” But I wonder, could you give people a really brief sort of couple of sentences about you - if there’s someone who’s maybe new to .NET? “I don’t know who’s this Mads fella?”

Mads

Yeah, I’m a Mads Torgersen. I’m originally from this little country called Denmark. And I’ve been where I was, you know, a professor doing programming language stuff. And then I got hired by Microsoft 17 years ago to help work on C#. First, I worked with Anders Hejlsberg, who’s sort of the legendary creator and first lead designer of C#. And then when he and I had a little side project with others to do TypeScript, he stayed over there. And I got to take over as lead designer C#. So for the last, I don’t know, nearly a decade, that’s been my job at Microsoft to, to take care of the evolution of the C# programming language.

Jamie

Right, right. So is it similar to like a Guido van Rossum role where you were, you know, supreme dictator for life? Or is it just like, you’re in charge? And if people say things, you can say, “yes.”

Mads

Yeah, I tried to resist people calling me sometimes they use the term “benevolent dictator for life,” because that sounds better at least. Well, you know, he’s an authoritarian, but at least he’s friendly about it. But I, and I think in in some ways, I am in the sense that I’m at the end of the table, if there’s a difficult decision, and we need to make a call, I’m the one who makes the call. But at the same time, I don’t own the resources to actually bring, you know, features to life that is, you know, a Microsoft, budgetary and management leadership structure in place, and if I decide to go off the rails when it just won’t happen. So in that sense, it’s a more like a figurehead for in that sense, like you. Of course, whoever puts in, it’s open source. So you know, in principle, if there was a revolution, and I decided to lead it, other people could take the language in a direction Microsoft didn’t want. But that’s not how it works. But I but yeah, I’m the person who’s hired full time to where my full time job is to evolve the language. And so in that sense, I’m in charge.

Jamie

I guess the buck stops with Mads, then. Like you said, if there’s a difficult decision 50/50 split? It’s Mads who decides, “nope. We’re going this way.”

Mads

Yeah. But I try very hard to make that a rare occurrence. I find - we’re immediately going off into into details here. But I find that this is something I learned very much from Anders that a collaborative approach to language design is the best. It helps you if you can create, like a safe environment and have a bunch of people with different perspectives contribute. And if you can get that diverse group to sometimes even agree, but at least like to at least support the way the decision was made, where it’s like, “yeah, it didn’t go my way. But I appreciate that that was, you know, how we landed on it,” then these decisions, get the outcome itself gets better, but it also becomes more durable that you kind of that decision stick when you don’t have big fights over them. That will be you know, leave, you know, leave resentment and be fought over and over again.

Jamie

Sure. That makes sense, right? If you have a group full of people, and everyone gets a chance to cast their vote, then you know, you can’t really be upset if the vote doesn’t really go your way. Because you’ve had the chance, right? It’s the whole democracy thing is it’s wonderful.

Mads

Yeah. And we don’t actually even vote that much. I mean, well, we often do what we call a read of the room where we list the options and people will vote for the one that they like, but it’s not like a binding vote. That’s not how decisions are made. It’s part of the discovery process of, “okay, where are we still? So, you know, why are you all not seeing it the same way I am?” and we can find out and we can sort of take the next step. Sometimes we will just say, “yeah, we have to decide something we can’t really spend all day on this.” And we’ll just go with a majority, but it’s not generally a vote-driven decision making process. Sure.

Jamie

And I think that’s a, it’s an important skill to be able to develop as someone in the technology space, right? To be able to have that collaborative discussion. Like you said, “here is the way I’m seeing it. How can I help you to understand it from my perspective? Or indeed how can I ask the questions to help me to understand it from your perspective?”

Mads

Yeah, I mean, it was one of the things that one of the things that really baffled me, when I first joined the team, I was allowed to join the C# language design team from the beginning, because that’s kind of hired to be there. And even though, Anders is, you know, he’s a total hero. Like, he, he understands programming language, so deeply, he has so much intuition. And, and such a good like, gut feel for things as well as this wealth of knowledge. And, and he could do a very good job on his own. You know, but even he realized that he had only one perspective in his own head, you know, and he needed a group of people, and he needed to treat them well. And as equals and allow for a full discussion and, and even his presence, you know, people needed to feel safe. And, and not like they’re, you know, not under pressure to behave in a certain way. And he created a space like that, that was the C# language design meeting, from the beginning, even before I was there.

And and that is, you know, that was an extremely valuable lesson for me to learn probably the more important than any technical insights I’ve had over the years is that just how to approach design, so that it is so that it gets good, and so that it sticks, and so that people who participate in it are, you know, are happy participants that they that they contribute their best, and that they feel safe and engaged.

Yeah, that’s the most important thing you can do if you want to, if you want to design something new, I think.

Jamie

Absolutely agree with you absolutely agree with you, no matter what your team is doing, right? You all need to be able to collaborate and, and have those discussions where someone can say, I’m not like you said, We’re I’m not fully confident in the direction we’re going or I have a reservation, or I have a difference of opinion, being being able to be in a space where it is okay to say, Hey, I’ve got something to say, and being able to be have that knowledge, to be able to say, look, what I’m about to say could rock the boat, but this is how I feel. And for everyone to go, Okay, let’s take the on board. And let’s, let’s see if we can either come up with a solution to that, or maybe we table this for now. And, you know, whatever, that whatever that team decides to do, I think that’s a very important decision to sorry, it’s a very important skill to have, regardless of where you work, right? If it’s in the technology space, if it’s in retail, if it’s in wherever, right, because we don’t work alone. We work with, you know, a big team of people, right? Yeah,

Mads

I think that’s exactly right. And I think, you know, whenever you have, which often happens in workplaces, you have situations that are group settings that are not safe for everyone, sometimes, it’s funny, because sometimes the people who are the leaders of that setting will feel that, oh, that was great. We had lots of fun, it was jovial, we, you know, there was like a relaxed atmosphere. But what you really find is, you know, it was only a certain group in there that was speaking, and that was actually able to participate in, you know, the, the sort of the culture of the meeting, if you will, and it’s it’s hard to notice when people are like, fading to the sidelines. And I know, I’ve, I’ve failed on that many times where I’ve just realized too late, or at least later than I would have liked that, oh, I’m actually not as inclusive as I thought, because it felt good to me. So I think this, it’s important to keep an eye on everybody’s sort of emotional well being in these group settings, because otherwise, you’re missing out on their perspective, and they’re not having a good time with

Jamie

it. Sure, sure. I think, because we’ve been going for a few minutes, I think it’s really important for me to stress to anyone listening that, obviously I’m talking to you Mads, the person not mad at the person who worked with like, I’m not talking to the voice of Microsoft, right? I’m talking to you, man to the person. And I think that’s an important thing to say, you know, I just realized that and said that yet. And I feel like that’s an important thing to say.

Mads

Yeah, yeah. I still am. I’ve been there for 17 years. I’ve probably been brainwashed to some degree, but I still consider myself as separate entity from Microsoft?

Jamie

Of course. Yeah, I was just just to set that expectation for people who are listening going. Well, you know, Jamie’s about to ask Mads a bunch of questions about C# and you know, these are these, this is the set in stone. And so from Microsoft, I’m like, Well, you don’t you’re not here as a representative of Microsoft. Right? So that’s just to let everyone know, right. Excellent. So, yeah, so like I said earlier on, I’ve been using C# for 1415 years and absolutely love it. I started back in the .NET. Two, I think, .NET to just come out. So this is like, you know, not a huge amount of time ago, but like I said, 1415 years ago, and it was a university, that’s how they told us, they were like, Okay, we’re gonna teach you computer science 101, with C#, and like, we didn’t even we didn’t even get into Visual Studio at all the entire time we were there. It was good, nothing to do with his Visual Studio, good or bad. It was more a case of the lecture that I had was like, I’m going to teach you how to use the C# compiler from the command line. And we’ll use Notepad to write the stuff because everything after that is all is like a value add, right? Yeah, Visual Studio is great. But let’s see if you can, because if you if you can’t use the compiler, then maybe you can’t use Visual Studio. Right. So let’s start there and build up. But yeah, I mean, do you ask someone who has worked very intimately with the design of C#? Do you have any, like, favorite, I guess, favorite language features, or favorite things about the language? may seem like an out of left field question. But like, I feel like if you if you’re involved in something for so long, then maybe there’s something here like, you know, it was great idea that we did ArrayList. I mean, I don’t think it was a good idea that we did ArrayList you’re making

Mads

sure to mention something that wouldn’t be on my list? Well, it’s, it’s interesting. They, because I often find that I mean, not everything we put into C# during my time there has been equally successful. And sometimes, I mean, you kind of have to be in love with the features you were making, right? Now you make a decision to go down that road, and you have to commit yourself to it. And, and fully, like, inhabit the mindset of that feature in order to make it good. And then later, maybe you find out well, okay, but that wasn’t the right mindset. Or, you know, so as an example, maybe I was one of the first features that I was really instrumental in shaping was, was dynamic. And not that I was not that was my feature or anything, but it was I was deeply involved in, like, how do we do this? And how do we make it elegant, and in many ways we succeeded like it is, it is fabulous, from sort of a purity explanation point of view that you that the that method, lookup overload or solution, when it happens at runtime, it actually happens the same way as it does at compile time with non dynamic things. It’s like, wow, we really liked it something cool there. And because it made interrupt with other languages great, and it kept C#, C#, even when it was, you know, resolved later, and so on. And that and I was really loved, I felt like we’ve really done it, and it moved the needle compared to the the industry and everything, but the world turned out to not need dynamic as much. And and not needed to be that way, as much the overhead of doing such a good job at runtime became, you know, a performance challenge that you really have to be aware of when you use dynamic, you really have to be aware of that the performance overhead of it. So that was a situation where we didn’t anticipate, I think, we didn’t anticipate the the renewed focus on performance that everybody takes for granted again, now, there was sort of a period of time where C# and Java and these languages, they’re just writing on PCs, essentially PCs, and Macs, and they get bigger every year. So if it’s a little slow this year, you know, next year, we’ll you know, it’ll the machines will catch up, and then the world completely changed, you know, then then smartphones came out, then, you know, the cloud became a big, big thing where again, you had to pay for cycles and and memory and so on. And so all of a sudden, you know, cogs, all of a sudden, wasn’t such a good idea. So, so that’s just a big, big preface to say that I might like a feature and then find out later that well, but it’s not good to have but the tune had been like that, you know, a feature that I think has held up very well given that design constraints at At times async, that’s probably the one I’m proud of stuff. Because that really was my doing and and I. And even though it didn’t actually didn’t turn out exactly the way we tried to do it to begin with, it’s it ended up sort of hitting the right balance between what was doable, and sort of, we opted for something much more general, like sort of like a co routine mechanism that could, that could be used to retcon iterators, that were already in the language as well as async, as well as async, iterators, as well as, and then we’re like, what else do people use subroutine as CO routines for and we’re like, actually, not a lot. And so we’re like, Okay, actually, let’s make it more like a, just a concrete language feature, instead of abstracting out the, the ko routine ness of it, if you will, the ability to pause and execution and, and, and resume it later. So and, and when it landed, it really transformed the way that you write asynchronous code. And that was at a fortuitous moment, because, again, we were talking about smartphones and, and the cloud just coming out. And with that, not only do you get new resource constraints, but you also get latency because everything, everything becomes a distributed system now, in one way or another, and, and latency becomes this big issue that you have to deal with everywhere, Windows eight, was just coming out. And I know most people don’t like to mention it. Don’t mention the war. But the

but one big design tenant of Windows eight, and the API’s that that they were developing for, it was indeed that they were all async when it came to networking, and even filesystem stuff. And so that was for for the for C#s own environment, it was fortuitous timing, and async became, you know, big success, it reduced the complexity of asynchronous code by you know, at least one order of magnitude. And, at the same time, a, it’s it, it sort of reverberate it through the the wider language community and have been it has been picked up by many other languages, even big ones over time. So we kind of felt like we were, we did the right thing for for C# and for Windows, which we were still kind of tied to back then. And we we influenced the language landscape in a big way. So that was, we kind of, we kind of got to set the agenda for how asynchronous programming should be done in modern programming languages. So that’s probably my all time favorite. That was my, that was where I really sort of felt like, okay, okay, I can do this, you know, I’m, I got this.

Jamie

I like it. I like it. And I think there’s all of the features that I use on a daily basis. async await has to be the number one thing where async await and tasks all of those just like, like you said, everything is a distributed system, right? You’re you’re poking at the file system, or you’re poking at the cloud somewhere. You don’t want everything to lock whilst it’s waiting. I love that that’s been that has been added because I did. I remember, I had at the time that the parallel task library came out, I changed jobs. And they were like, We’re gonna look into this parallel task library stuff. I was like, Okay, what’s that all about than just learning all that? And then by the time I had a chance to learn all of that stuff, they were like, well, is this this is experimental stuff. async await? Let’s use that instead? Well, I just don’t know this.

Mads

Well, they were strongly influenced by each other. So I think that I’ve, if I recall correctly, they ended up working together quite well, the parallel task library and async await.

Jamie

Yeah, yeah, it was, it was a very interesting time, indeed. Because I’d be talking to my Java and JavaScript developer friends, you know, obviously, they’re two different technologies for any recruiters listening. But you know, we know that they’re different. But they didn’t have async await. And I’d be talking to my JavaScript friends and say, Look, I’m not gonna make fun. But what do you do if you have to do a long running task? They Well, you know, we’re gonna have to make some stuff up and do some futzing around with stuff. And I’m like, wow, so you don’t have async await that’s like you say seeing everything else evolve alongside it has been?

Mads

Yeah, it was one of those. Yeah, it was that was really fortuitous training for C#, I think we oftentimes nowadays we, we think about the turn to .NET Core as s and it was really that was really a big turning point also, but I think sometimes you’re at you’re at these there are these turning points where you you To do or die, right, you have to if you don’t make an important turn, that is that is coming up sort of in the industry in the world, then you kind of you’ve, you run off the road, and you are no longer like you stop being irrelevant or if you have to fight to get back into elements. So that was one way, I think we make the we make the turn in time and even ahead of many others. And yeah, that was good. I

Jamie

agree. I agree. So one of the things that I’ve obviously having used C# for so long as that I’m going to be careful of my words here now that C# is no longer tied to dotnet framework has done it very much brilliant. But obviously, the evolution of that slowed all the way down now. And that makes sense because it’s directly tied to Windows Update. So if someone pushes out an update the dotnet framework, but they have to make sure that everything that’s ever been written for dotnet framework is going to run. So one of my goals is to try and figure out just how many tests there are for dotnet framework. But that’s not for this conversation. But with C# no longer being sort of tied to framework, and it more more sort of freely evolving alongside dotnet, core and dotnet, as it is five, six and a continuing numbers. I just like the speed that it has evolved. It blows my mind like how, how do you all get together and come up with these, these ideas so quickly?

Mads

Well, I think there are two. You should never say ahead of time how many points you’re about to make, because you’re usually wrong. But I can think of a couple, let’s say that a couple of different aspects here. One is that we have an openness now because along with a turn to .NET Core, we also open sourced C#, the implementation like the Rosslyn compiler for C# and Visual Basic, but also the the evolution process itself. So C# language design happens in a in a public GitHub repo with lots of community participation. And those things, combined with all the other ways that we connect with a community, they mean that a lot of people bring stuff to us and make it easier for us to, you know, both get a sense of what’s important and not so important to pick up and give us such a wealth of ideas as well, you know, ideas and, and scenarios and challenges to work from that. We really never, it’s never a problem for us to go like ah, what should we do? Can anyone think of anything to do next? That’s never, that’s never a question that you’re here. It’s always like, oh, which of these lovely things can we not get to? And where do we need to not spend time looking at even though it’s great, because we just have even greater things too. So we get a lot of things flowing to us that make it easy, we still have to do the hard work of you know, making it, making it fit making it great. In sort of, like integrative way, but on top of that, I think I honestly think that the perception that C# is evolving faster, is at least to some degree in illusion. What happens is that C# is a C# is being released much more frequently now, like new versions all the time, we kind of started that with the sevens where we had we experimented with having minor versions of C#, and then we just went to now shipping a major version every year along with .NET. At least that’s the current current plan to record for the foreseeable future, and, and so we started thinking differently about what it means to ship features. When you think back to the first C#s for those of us who who have you no memory to draw on all the way that far back. They were very much themed releases, like that was C# two was, you know, 80% about generics and C# three was 80%. About link in C# four was at wit’s end about dynamics. Five was eight, he was saying about async and then you know, a few other things thrown in. And then that kind of petered out. Because we, and especially as we’ve upped the frequency of releases, we started to think about a feature designed differently, where we we approach things much more incrementally. So for C# seven, for instance, we realized, okay, pattern matching, it’s time for pattern matching, you know, C# would be a much better language if we have pattern matching. That has to do with that very actually, that also has to do with the with the cloud with the turn to the cloud because once you have some I’m taking a detour from Going back to your point, once you have data as sort of like a separate thing, living long live data in the cloud, then then it gets harder to sort of apply an object oriented paradigm, to say that, you know, to use virtual methods, essentially to get behavior that’s dependent on the shape of the object, which is the classic object oriented thing that C# is very good at, you know, now you have a given hierarchy of types, it’s already there. I mean, you could probably write your own and your own serializers, and whatnot for what’s out there. But it works better if somebody just defines the types, you know, and you use those types, but you use them for your thing. And so you can’t put virtual methods on those types. What you need to do instead is you need to take them in and say is it this is that is it one of those, and then do the shape dependent behavior and sort of more of a switch style, which is exactly what functional languages do actually, as a matter of fact, they have data and functionality separate. And they work with a thick, instead of like, an open ended class hierarchy, you know, classic functional programming, turns it on its head, it has a closed set of shapes, you know, in the form of discriminated union or whatever. And then they have an open ended number of functions, each of which switching on the shape, and doing whatever is appropriate for that for each particular variant.

Of, of the data. And, and that’s the right way to go for, when you, that’s what you need, when you’re need your functions to be separate, because they weren’t even nobody had thought of them when the data was shapes, whether it’s signed or written, right. So, so pattern matching became important with the advent of the cloud and the importance of, of long lived data. So, but on the other hand, designing a whole, like, we could have made C# seven, the pattern matching version, right. And then we could have sat down for years and mapped out all the ways that you might want to pattern match data ever. And if it had been in the old days, that’s what we would have done. And we would have done it in secret, you know, and we would have made a big splash about the full pattern matching capabilities of C# and all the 17 patterns that it had. Yeah, so instead, instead, we decided to shift the most important part of pattern matching the stuff that was most needed right now. And we had the highest confidence in what that would look like. And then we would, so we would design pattern matching, try to think a couple of versions ahead to what we might like to do. So we we’re not designing ourselves into a corner that often happens with a material language, right, you make one decision, and you find out two verses down the road that you blocked off something that you really would have liked to do. And, and so we tried to design ahead, just to see is there a path forward, but then we would only do the first part of it, ship it, have people start using it. And because we’re committed to that bit, now, it’s, but then we can see much better, what’s the right next step to take and the next step and the next step, depending on not just based on our, you know, our sage predictions in some dark room somewhere, but based on actual usage and feedback. So we find that iterative language design, where the iteration is actually shipping the feature over many versions, and an open ended way works really well for us. But that means that it feels like there are seven new features, or 10 new features with every yearly release, but many of them are just sorted the next turn on the crank of the crank on a given feature. So in C# 11, we will have less patterns. Okay, there are a new feature, but they’re just like, the next step with pattern matching. If we had taken all the patterns and, and the switch expressions and everything we did around pattern matching and smooshed it up into one release, people wouldn’t think twice about calling it just one language feature. So that way, in a sense, if you’re following along in real time, it feels more confusing, you’re getting a bit of this, a bit of that a bit of those, it’s harder to keep up when there’s not just a big theme, and you can sit down and read all about it. And that’s sort of the downside. But the upside is that we get to iterate with the whole world, we have an iterative design process together with everyone using C#, taking making all the little adjustments and prioritizations along the way. Oh, if it turns out pattern matching is falling by the wayside. If not, then, you know, we can D invest we can choose not to do the next bit just yet. Or you know, or if we can’t come up with the next bit, we don’t have to worry about being stuck with it. We just take another round of another year to settle it. So it’s, it’s it’s created a very good design environment for us. But it does create an illusion of increased velocity that that when you watch things in real time I am it’s more confusing, and we don’t really have solutions to that other than we are trying to get better at communicating more, while we are evolving the language during you know, whenever, whenever we, man, let’s just keep talking to him and I did. But you know, just stop me if you want to ask something as well, that’s fine. Another thing that we another thing that we do that is even more iterative is that we, we now, we have a very well functioning preview mode preview language version that is in the C# compiler at any given time, if you say language preview, you actually get whatever new features are in there at the time that aren’t released yet and that aren’t committed yet. And, and we, every couple of months, we ship a new compiler with more language features in it from the next release. And we get feedback on it. And we change the feature assets in flight based on that feedback. So even at the subversion level, we get iteration with the community as well. And it’s so great, you know, we fly with so much more confidence now, instead of just waiting to see whether they like it, will they like it, we have at least a subset of developers engaging early for that first kind of reality check, we rip the feature out because of that this release, for instance, we get then we ship something, then we get good feedback on what’s the next what should be the next iteration of that feature, and so on. So really, it’s a much better,

much more high confidence, work environment, much more data rich work environment for us than it has ever been.


ZOOM Platform, no not the video conferencing app, ZOOM-Platform.com! The premier DRM-Free games portal.

Unlike directionless larger stores, ZOOM operates more like a boutique offering all-time classics such as Duke Nukem, exclusive hidden gems like Hardwar and innovative indies like REKKR: Sunken Land. ZOOM will even take requests and hunt games down for you.

When ZOOM signs titles, they make sure to get every release, version, language, you name it. That’s how ZOOM carves it’s niche. ZOOM hand-scans box art, manuals and other bonus content and even records soundtracks. On top of all this, ZOOM always makes a point of securing rights to obscure expansion packs and mods. When you buy the ZOOM Platform edition of a game, you know you are getting the most complete and definitive edition.

ZOOM’s staff and technology are best in class. In fact, when competitors can’t get a game running on modern hardware, they go directly to ZOOM. They’re some of ZOOM’s best customers!

ZOOM provides unparalleled 24/7 customer service and closeness with its user base. ZOOM’s management interacts directly with customers via Discord. They take their small business approach seriously. ZOOM-Platform.com, your friendly neighborhood DRM-Free games store!


Jamie

I like that because it feels like if I mean, I can’t speak for them, and I suppose you can’t either. But I suppose it would mean that then perhaps the .NET team could then say, hey, what about if we adopt this new C# feature? There’s in the compiler that has been shipped? How does that affect the runtime? How does that affect the build tools? And they can, like use that themselves? And it’s almost like you can dog food, right? And you don’t have to, you can still rely on the external developers. But obviously, you can you can then within the teams at Microsoft, I suppose you can say, hey, just try this new feature out, tell me what you think that’s going to do? I’m not saying you do?

Mads

Oh, but we do. We do a lot. And we I mean, we’re very, that’s another thing that changed is that we were pulled together much more across all the .NET teams, and much more in real time than we used to. We are in in C#, blank design itself. We have, quote, unquote, representation. That sounds like it’s a committee, it really isn’t. But we have people perspectives from, you know, the runtime, the VCL, the ASP, NET team, and so on people who are like C# enthusiasts, but are also involved in the evolution of their technologies. And oftentimes, we gang up and do something that is like, that really has its impact at across these different layers instead of evolving each independently, like minimal API’s is a recent example of that, where we worked with the ASP. NET team, to prioritize general purpose language features that also happened to really contribute to add a user experience that they were ready to put out many, many places in the BCL you know, we work so closely with them, because not only do I mean, the simplest version of that is we need some types to be in the VCL to support the language feature, but, but also, we create things for them that help them write more efficient code or more usable API’s, you know, so we really, we really work closely together and, and they adopt the features in real time, we often see that the PCL has even changed their implementations of many methods, even though it’s not user facing to use new language features, even at the time when we shipped, you know, they’ve already done adopted the feature across their codebase. So, ya know, it’s really, it’s really great that this this incrementality and, and kind of cross entity collaboration, you know, reaching out to the communities as well. That is, that makes up for you know, what we miss when we don’t have Anders this intuition to draw on as the sort of guiding light these days. So yeah, that’s, that’s how I get to sometimes look a little smart. It’s because I, I rest in all these shoulders, and we get all this awesome stuff from collaborating left and right.

Jamie

I see. So I have I do have a question about related to the minimal API’s and the Edie, this idea of C# becoming, I don’t want to say simpler but maybe easier to get started with for, for people who are new to development. Hopefully we’ll have some time to come back to that. But like, do you? Do you ever get the warm fuzzies? When you hear about, oh, this team has built this thing, or this person has built this thing, using a language that you’ve had such an intimate connection to? And you’ve brought this language out to the people around you. You said earlier on, right, you’re though you’re you’re the person in charge right now. Yeah. and have been for many years. So do you get like when you hear about things like .NET, Maui, or, or like when, before, before Microsoft bought them? Xamarin these people have gone off in their own direction and built this cross platform thing? Or maybe if you’re talking to someone at a conference, and they say, oh, cool, I built this wonderful thing. Would you like to see Do you ever get like the warm fuzzies? Like, oh, my goodness, I had a hand in making this,

Mads

I guess all the time, I still, I still can’t believe that I get to have that kind of impact. And every time, it turns out that the impact is positive. No, that’s, that’s yeah, the warm fuzzies also a little bit of relief, right, you’re always a bit worried that you’re taking things in the wrong direction. All this course correction really helps like I, we, if we’re about to do something that isn’t quite right, we will usually find out before it’s too late now. But, um, but absolutely, I’d say that the degree to which people still say that they really love C# and they including they love the new things that we do. That is that is really, that’s really nice to hear. Now, I it, it’s useful feedback, right to hear that you’re on the right track, it’s even more useful feedback to hear when people are worried about something. And because that, that sort of, there’s always, you know, a set of people who really are for everything we do, there’ll be some people who don’t like it. And it’s important not to wave that off and say, oh, you know, they’re always naysayers or whatever, that’s some of the most important signal we can get. Because they’re not wrong. They have their own experience. And in their experience, this isn’t the right thing to do. And some sometimes people will have like, sometimes you can see, okay, this is, this is clearly, you know, a quick gut reaction, like, they haven’t actually waited to go try it and come back, you know, but, but, but many times, it’s, it’s them sharing experience, that’s valuable for us to listen to. And, and so we try not to just wallow in the positive and, and also be tuned into when people have, when they say like this, this is the stupidest thing and we’re like, okay, if they’re too, okay, they’re too abrasive, we probably will just block them. But if they, you know, we can feel that they really have a frustration or something, it’s really important to say, hey, hey, I really love to hear what what you’re up against. They’re like, what is the thing is, you know, maybe we can, maybe we can tweak it a little, and it’ll actually be fine. Or maybe that’s a fundamental direction thing here that really isn’t working for you, let’s, let’s find out, you know, and, of course, if it’s one person, we may not, you know, over compensate for that. But if it’s, but then you can sometimes see a trend where it’s like, I’m worried about I’m worried about it too. And, and you can sort of see if there’s more of a kind of like, and a, you know, not necessarily like an overwhelming trend, but sort of like a sub A sub trend of things, then it’s important to keep an eye on because we might be sort of teetering on the brink of something not so not so good.

Jamie

Yeah, that makes sense. So, okay, so what about so with your work with the with the work of the team who work on those not just your grades, everybody else, your decision stuff, but with the work that you and the team have put in alongside the ASP dotnet team, you’ve made, like you said, you’ve made minimal API’s and this ability to sort of get started a lot faster. One of the things that I bring up to a lot of my non dotnet development friends is that like, up until last year, you know, hello world was it was 15 lines of code. You know, if I 11 to 15 You could

Mads

do it shorter, but yeah, it was Yeah, yeah.

Jamie

Yeah, like if I’m, if I’m teaching someone, like a brand new person who’s brand new to development, I’m saying okay, do do hello world, right. We’re going to ignore what a USING statement is. We’re going to, don’t worry about a namespace. When a class A is what a static void Main is. Just look at the console dot write line. And, and a bunch of strings. And now if I do, I don’t know whether it’s a great test of the language, but when I do hello world with with new people now, it’s one line of code. And there’s a there’s a comment that comes with it to explain why it’s so short. Yeah, that’s what I really like.

Mads

Yeah, the comment is for the people, for whom this the people who are not near to the language to say, no, no, it’s all right. You know, if you if this confuses you go here. It’s interesting, because that they the top level statements, it was, you know, one of those features that got quite a lot of pushback. He got pushback initially, from people who were like, uncomfortable with changing how what a program looks like, they had, you know, some valid feedback, because it’s harder for me to, to grep for where the program even is, and that, you know, things like that, that have real like downsides. But we tried to make it make it very, very nearly as expressive as as the old the old, quote, unquote, way of doing it. But it’s one of those. And then we got another way with feedback when we made it the default in, in templates and Visual Studio, which I think we did with the with the last release, where again, people were like, I want to, I want my templates to do it the old way, because I like it the old way, all my company still hasn’t moved away from the old way, and, you know, whatever. And so, so we, we created an option right there, you can, you can sort of in Visual Studio can, you can click, there’s a single checkbox, where you can click to say, do it, you know, do it the old way. But, but there’s really a trade off there between familiarity, and then being accessible for new learners. And when you when you have a 20 year old language 20 Plus, I should say now, you know, some things are dated some you there, there, there amounts of verbosity that were considered virtues back then, that are now just a pain and that don’t really compare favorably to, to newer languages. And so even just when it comes to verbosity, we need to, we need to stay relevant, we can’t like just say, well, this is the C# way. And, you know, we we have to offer things that are both more familiar to people who are from other languages, and also that have less overhead to, to read through and understand as a new learner. Even a new learner of programming, so so that is part part of our certainly not all our focus as language designers, but one of the kind of tenants is make make C#, more and more approachable. If you’re coming from elsewhere starting you, what that means is that we add new ways of doing things that you could already do. And that then means that because we can never take things out for for back compat reasons that means that the language grows, quote, unquote, unnecessarily from from an s sort of expressiveness perspective. So that’s something we have to deal with. And and I think we’re not quite there yet with kind of having a good like, what, what should you actually do about this fact that there are multiple ways of doing things like how do you help people do the right thing? What is even the right thing if you if you sit down to write C# today? And and that’s something that we’re thinking about a lot more? Again, there’s a great collaboration with the documentation team, which is excellent. The C# Documentation team is absolutely astoundingly. Excellent. And we have, we’re in conversations right now about how can we better how can we, how can we say more be more helpful on that, on that question, without being prescriptive or judgmental, about because people, it’s, it’s up to people how they want to use the chart. But if you’re genuinely confused, then maybe we can help you. So I think that we’re trying to think about, we sort of have a very loosely defined term that we’re batting about, which is quote unquote, everyday C#, like if I’m writing, if I don’t have like constraints from the past that make that make me have to do things differently. And I don’t have very special domain set that make me have to like open up the hidden corners of low level C# and all that, then here’s the subset quote unquote, of the language that I should do things.

That’s that’s something that we’re thinking about trying to make more of a statement on. And that would then be a moving target right when we when we introduce something like top level statements the next time then we would sort of throw out the old way from everyday C#. And we would take in the new way instead and saying, Well, if if you’re writing, you know, a, quote unquote, modern C# application, then this is probably how we should approach this is the, what we consider the best of C# now, we did this new feature, because we think it’s better than the old one. So, of course, we think you should use it. You know, that’s, that’s, that’s something we want to try to communicate a little better. We’re not quite there yet. But it’s something we’re working actively on to counter the confusion around a growing language.

Jamie

Sure, sure. I think now I may be remembering incorrectly but I think I remember Kathleen Dollard saying something about, perhaps we can come up with almost like an idea of a story, right? Instead of saying, this is the C# language that you should use right now. Perhaps, maybe something that’s more descriptive, or like a legacy. I may be misremembering, but I’m sure it was something that I listened to today on on dotnet rocks that she did something along those lines. Again, I’m probably misremembering, but like you say the there’s plenty of different ways to show people the new and it. Here’s the thing, right? From my point of view, just because there are two way two different ways to do things, something doesn’t mean that you have to know both, and you have to use both. Right, right. My thing is, I’m all about setting a coding standard. And then working towards that, because then you can say to the other people on your team, this is how we do it. Yeah. And like you’re saying, right, with this, this idea of modern C#, this is the modern C# way of doing things if you want to deviate from that. Totally. But there be dragons, right?

Mads

Yeah, but but I also want to acknowledge and by the way, yes, Kathleen is one of the people I’m working with on this. And she has, she has great thoughts on this. But I want to acknowledge that there’s a there’s a kind of a conflict, or potential conflict between coding standards, as you say, and then evolving, the notion of everyday C#, because if you have coding standards, that’s probably because you have a code base that you want to be long lived. And it will be written a certain way, according and if you’re disciplined about it, it will be written in a consistent way for the time that it was written. But if you evolve your coding standards all the time, then you are then your codebase is going to be stratified into different styles anyway. And if you don’t, then it’s going to that everyone’s going to have to suffer from not using the new features. So there is a conundrum there that I don’t know that we have a good answer to. Maybe you do I What do you think about that? Turning the interview on its head here?

Jamie

I like it. So I might my question back to you would be how the other languages do it right. So like, I know that things like C Plus Plus, it’s a lot slower moving. But like when a new version of C++ comes out. Obviously, everybody agrees this is how we do it. And then it must be it’s been it’s been, you know, decades since the C++ but there must be a turning point where everyone goes, Yeah, okay. We’ll do it this way from now on, right. And I feel like that’s probably a bad, bad analogy, because I feel like the C++ tools evolve with the language. And if you’re not staying with the new version of the language, you have to go back to the previous version of the tool. I’m not sure you know, like a compiler and stuff. I’m not sure whether that’s the case. Because like I say, I haven’t done any C++ in years, but maybe maybe having a look at how the other languages do it. But yeah, I know that you bring it up, I would be afraid of saying, Look, this is how we do it. It’s set in stone at this company. We’re only ever gonna program like this. But then I’m also part of me is very worried about letting the tools do it for me. So like, I agree, I agree that I’ve had that the last argument about linting. And where brackets and braces should go. And you know, in languages that support it semicolons or Nozomi, semicolons. Right. I just I let the tools do it for me. But I feel like that it’s okay to do that. Because maybe I’m not as much as experienced in those other languages. But I feel like with C#, I’m like, I like to think I know what I’m doing. Yes. Yeah. A bit more reluctant to let Visual Studio or whatever, take over and say no, that should be over here. And they should be over there. I don’t know.

Mads

Yeah, I think it is one thing if it happens in real time when you’re coding I like you know, things like code styles and Visual Studio, for instance, other tools have a similar thing where they you know, there’s an agreed upon way that you lay out the code and even feature preferences, you know, like don’t don’t do it. Don’t use var use explicit types of whatever you know, depending on on the on the coding style that you are targeting. And that’s fine, because the code is still there in front of your eyes being you still see the end result, as you’re writing. I think that’s a, it’s more than if your code has been sitting there just building quietly for a couple years, and now you need to do maintenance on it. You know, are you you’re writing code next to it that’s in a different style. Now, should the old code evolve? Well, that’s a big, maybe we could build like Rosslyn is a great foundation for building high fidelity tools to to refactor code in chunks and big chunks, right. So maybe we could have a move forward tool. But now, even if it’s high confidence that it does, you know, has the same semantics and, and, and surface area and so on, you’re still faced with the fact that now you have code that nobody ever wrote, you know, now, if you the sort of visceral memory or the spatial memory of what did the code look like when the whoever wrote it last they come back, and it’s changed in this way that they can no longer sort of feel their way around, and they don’t have that aha recognition that is needed to go in and fix something or whatever, you know, there all these aspects that are hard problems, I don’t, I don’t even begin to have a solution to them.

Jamie

I don’t know maybe like a painting, you know, like with, with dependencies, you can pin to a specific version, right? This happens a lot in node based languages where you want to say, I’m pulling in this baggage book, pin it specifically to this one, yeah. Because maybe I have a secure version of it on my server where I’ve done a code review and stuff, perhaps the ability to pin a codebase at a specific language, and then then perhaps the team who were working on that project, and then say, well, actually, we’ve set some time to one side to actually upgrade this to the latest or to a different version of the language, then we’ll make sure that all of the tests and things still run, because obviously, it’s now partially generated code. And then maybe the teams can then take some time and re familiarize themselves with perhaps the weather the code looks now, I don’t know. I don’t

Mads

know. But that’s actually, that’s great. I really liked that. Because I think another problem that we often get is that you have code that fades out of memory that nobody’s familiar with anymore, and nobody, and then you have the problem, nobody wants to touch it. So maybe having an excuse to kind of maybe having a discipline of going back to all to your whole codebase once in a while. And sort of just, you know, bringing it up in your editor, looking at the suggestions you get from the modern tools, saying, hey, why don’t you maybe from your updated code style, like you have now saying, why don’t you Why don’t you actually rewrite this as pattern matching, it will be much more efficient, and it would be much more elegant and so on. Try it, see what it looks like. But do it more men go through more manually, like one by one and say, okay, okay, okay. Okay. And that in the process, you re familiarize yourself a little with the code, and you’re sort of, even though it’s not, quote unquote, productive work for for creating new functionality? Maybe it’s the kind of maintenance work that is actually that pays for itself? I don’t know. I’m just like you and I just, you know, making this up as we go along. But it feels like spitballing an idea. Yeah, it feels like we would at least solve multiple problems at once. We might be creating new ones. So we might be detracting too much from the, from the forward will velocity of the organization.

Jamie

Who can say I, I am definitely not smart enough to be part of that conversation for sure. So that’s not really my

Mads

area of expertise, either. I like I keep evolving my language, you guys figure out we want to do that.

Jamie

So okay, to really, hopefully, slightly quicker fire questions, because I know that I appreciate that you have a lot of stuff to do today. It’s your early morning, it’s my coming up to the evening. So I want to get out of your way and allow you to continue on with your with your workday. So you mentioned earlier on that C# is done out in the open is done on the C# language. GitHub, is it just literally a case of I have an idea, I’m gonna go put in an issue or a pull request or something, and just literally just type out my idea. And if it sounds great, then you know, you might run with it. And hey, we might have a Jamie type or something. Right? Yeah.

Mads

It is literally that you bet. But understand that there’s a lot of traffic. And, and most things don’t make it so there. So now GitHub. Fortunately, GitHub now has this feature of discussions that’s been there for a few years before that it was all issues. So the concrete processes if you have an idea, you’re gonna open a discussion. Everyone can do that. And you see if you get any feedback on it, and then If we have this championing system, so anyone who’s on the C# language design team can put a champion label on, on an issue. So essentially, what we do is that if we see something in the, if a discussion leads to something good, then we can say, Hey, would you like to propose this as a feature, and then you have to write up more, then there’s more work, then it’s like, write out the the syntax and semantics and describe, you know, not spec level, necessarily completely, but you know, describe the whole feature. And then you put that up as an issue. And, and the, the language designer who, who poked you to do it will will then put a champion label on it, and then that, that puts it in line for the next level of the process, which is that every so often, and then typically, now, it’s mostly once a year, maybe with a few follow ups during the year, we do a triage in in life sign meeting, where we go through all the champion features. Not necessarily deep discussion, but we’ll try to spend about 15 minutes in each to decide where which bucket it belongs in, is this something that we want to move forward with? This is something that we like, but we will put it on the backburner? Or is it something that was not now sometimes there’s a small feature, and we will say, actually, we won’t prioritize it. But if we put it in, I think it’s called the anytime bucket and then somebody in community might pick it up and implement it for us in the rustling repo. Essentially, we’re saying, we want we would be fine with this came in, and we would provide the resources to code review it for instance. So that’s the way in and then if it, you know, comes into the, into the bucket that we’re actually working on, then it’s, you know, some things actually end up languishing there. But in principle, the, the champion, the whoever said, I like this, they will make sure that it gets attention and that we, we move it forward, that, you know, that can still lead to it, that 100 deaths, it can still suffer. But occasionally, then this becomes a, you got yourself a language feature, it’s a long process with many steps to it, and that’s, that’s partly just in order to manage the amount of incoming, that need to be many layers of filtering in the process and, and maturing of the idea without too much investment being done too early. So that’s why the discussions really helped. Because we don’t have to require that people fully describe an idea. We can have that, that just that more free flowing, conversation, step of it first, where it can where the idea itself can mature or be shut down unanimously by the rest of the community. So you’re like, Oh, okay. Okay. Sorry, I asked, you know, I now see that I hadn’t thought it through or whatever. But so, yeah, but but that’s, that’s the way things come in.

Jamie

I like it, I like it, because like, if I, as an average developer was to go, I want to put a new feature and go, or I want to put a new feature in C++. There’s, there’s a high barrier to entry there, right? Whereas I feel like, like you say, you know, you jump into a GitHub discussion, you say, I’ve had this idea is like, the elevator pitch for my idea. What do you think? And then, like, you say, somebody might come in and say, Yeah, that’s great, let’s, but what about this? What about that, and it starts this conversation, whereas, you know, if I was, I mean, I’m waiting, I’m not smart enough to do this. But if I was like, I’ve got this great idea for some C++. Where do I go? Who do I talk to? Nobody knows. Right? Yeah, then you can say maybe I have to write up a full proposal, and write out the syntax and write out all of the stuff to go with it. And then maybe, in the C++ version, right? I don’t know, I’m guessing. Whereas this, it’s like, let’s just goes all the way back to what we talked about the beginning, this collaborative idea, right? We’re collaborating, we’re testing these details out to see if it actually makes sense. And if it works.

Mads

Yeah, and it’s it. One thing that’s interesting is that it’s not always the idea. That’s the most valuable thing. You know, oftentimes, you’ll be running into a specific problem multiple times. And you’d be like, well, if I had a keyword, I could solve this problem. But what it really is, is, you know, as a as a language feature, it is it’s way too specific, maybe but, but it’s a bad if it’s a frequent problem. then maybe, you know, then it’s good. It’s good input still, right? I keep having this problem. And that’s one thing you can bring to the discussion in C# Lang not like, I have this idea. But I keep running into this all the time. It’s really bugging me. And, but I don’t, but I think it’s too specific for a language feature. Any thoughts, any ideas that that because sometimes, there’ll be other problems that you can sort of see as Oh, actually, this is just another side of the same coin, or, you know, this, it’s similar enough. And, and sometimes, a, you know, you get to a critical mass of related problems are nuisances in code. And you can see, oh, but they could all kind of be done. They could be solved together much more generally, with a feature like this. And then the feature idea kind of really just, you know, the nuclear reaction gets sparked because you have a critical mass of problem. Problem being radioactive material guessing this analogy.

Jamie

I mean, it’s a metaphor, right? Metaphors get the point across. I like it. Yeah. Okay. Okay. So, one last one, before we go into how people can get in touch with you. Let’s say we’ve jumped forward in time to 2030. And we’re looking at a codebase. In C#. Are we expecting things to evolve to that? You said earlier? And we’re not really evolving that quickly. But are you expecting things to evolve in such big leaps that in 2030, using 2020 two’s knowledge? Can we still read that that C# code, using modern or rather the day to day C#, of 2020 2030? Can we still read it?

Mads

That’s a great question. I think the best? Of course, I can’t know. But if But assuming we evolve at the same pace, you know, I guess the best way to answer that question would be to go back to 2014. And people who, because and we we hear from people who went away from CCR, at a certain point in their career, they come back and they’re like, what just happened? You know? If you go back to 2014, I wonder what, where were we at in 2014. I can’t even remember the the way the years map to the versions anymore. But there’s definitely a lot has happened since 2014. Right. And so it would probably be if you walk up to something that’s written using all the latest features, you know, it would probably take some re familiarizing. I think I hope that you won’t feel. I mean, that will be a challenge, just because there’s a lot of new to learn, there’s just syntax that you haven’t seen before, I hope you would come to this is the goal, I hope it’s true, that you come to appreciate after putting in that effort, a, that what we did to it since then actually turned out to be worthwhile it that it made C# better, and it will make your life better, once you’ve once you’ve sort of acquired the new skills. And B, I hope, you’ll find that the spirit of C# is still in there that it’s still in spirit, the same language, even though on the surface, your code might have changed. That it still has that what you liked about C#, the last time it touched it. That’s it’s really hard to capture in words, the spirit of a language. We try sometimes, but we don’t always succeed. Part of it is it’s not just you know, what’s in it is also you know, how we think about evolving it and so on, we tried to keep it a language that still feels like a coherent whole, that doesn’t have like, too many sub dialects that you can can be in and say I’m the I’m in the functional subset of C# or I’m in the, you know, like C++, they would have a template metaprogramming or subset or something, you know, we try to keep it together and keep it in the same spirit that it was always in. And one way of doing that is to have people on the C# language design team for a very long time and to be able to articulate this, I feel like this doesn’t feel like C# and then that doesn’t mean we’ll necessarily dismiss it, but we’ll have a discussion about it. And this is in the spirit of C# is this would this end up being good for people who like the vibe, if you will, so hard to to quantify or specify those things, but it’s something that we try to we aspire to keep alive and I would hope that that’s the case and 23 You’re like okay, now I get it. I get How this a C# eight years later. That’s they made some pretty good choices on that. And I feel I still feel at home in his language now that I’ve gotten used to it being painted in a different color on the outside.

Jamie

Sure. I like that. I like that because I was worried about that question, because it was like, that’s gonna delve way too into specifics, but I like the way that you were able to deal with that, because that’s, uh, yeah, like you say things evolve for any, as long as we can still kind of use it, then yeah, there’ll be, like I said, familiarity issues. But once you’ve gotten past those, it’s not like, it’s not like you’re gonna suddenly be programming in French, right? Or in Spanish or something, right? It’s still, it’s still using our common base of stuff. I like it. I like it. So. So Matt, what about getting in touch with you? Or any anyone else on the C# Lang? Group? Or whatever? Is it just head to head to Twitter, find you on Twitter? For the broader question, or the best to ask the question on the C# language, get

Mads

the C# Lang, GitHub has the benefit that it’s not just me. So there, there’s a whole community. Oftentimes, you don’t actually need to get in touch with me. It’s not very centralized. So and, and C#. So C# Lang is definitely great. If you want to ask if you want to involve me specifically, I tend to I’m not that I’m not like an avid Twitter user. But I go there several times a week. And I do I do quickly scan through my mentions. So. So if there’s something there, and it hasn’t already been answered by someone else, by the time I get around to that, then, you know, if I mentioned, then I will likely, you know, it’s a good chance that I will I will respond. So those are good ways, depending on again, Twitter, you know, it’ll have to be a short question. Just because of the restraint constraints there. But both are great ways to, to kind of get into some C# language question.

Jamie

Excellent. Okay. So, yeah, with that said, I’ll make sure to put some links into the show notes so that nobody’s having to go, what was the GitHub link? Again, he didn’t say it, but don’t worry about it. It’s all in the show notes, folks. You don’t have to worry about driving down the street diving across your dashboard to grab your Nope. Please don’t do that. Please focus on what you’re doing. Yes. But what I will say Matt is, thank you ever so much for taking the time to chat with me today and to chat with the listeners. I really enjoyed it. And there’s a lot of stuff that I’ve picked up from this conversation. I’m going to be taking back to my day to day C# work. So thank you ever so much. Well, thank

Mads

you. I actually, that was some great conversation we got there. There was some new ideas batted around and everything. I had a lot of fun. Thanks for giving me the opportunity.

Jamie

Hey, no worries. Thank you.

The above is a machine transcription, as such there may be subtle errors. If you would like to help to fix this transcription, please see this GitHub repository

Wrapping Up

That was my interview with Mads Torgersen. Be sure to check out the show notes for a bunch of links to some of the stuff that we covered, and full transcription of the interview. The show notes, as always, can be found at dotnetcore.show, and there will be a link directly to them in your podcatcher.

And don’t forget to spread the word, leave a rating or review on your podcatcher of choice - head over to dotnetcore.show/review for ways to do that - reach out via out contact page, and to come back next time for more .NET goodness.

I will see you again real soon. See you later folks.

Follow the show

You can find the show on any of these places