The Modern .NET Show

S08E08 - Building on .NET 10: A Chat with Kajetan Duszyńsk, Author of '.NET 10 Revealed'

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

S08E08 - Building on .NET 10: A Chat with Kajetan Duszyńsk, Author of ‘.NET 10 Revealed’
The Modern .NET Show

S08E08 - Building on .NET 10: A Chat with Kajetan Duszyńsk, Author of '.NET 10 Revealed'

Supporting The Show

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

Episode Summary

Kajetan Duszyńsk discussed his new book “.NET 10 Revealed” during an interview on Jamie’s show. The book provides in-depth information about .NET 10, covering various aspects such as Aspire, ASP.NET Core, and other relevant topics.

One of the key points mentioned by Kajetan was the introduction of wildcard TLS certificates in .NET 10, which allows for more flexibility when running web applications on localhost. He also touched upon the topic of .NET Aspire, a service that aims to bound different services together to improve performance and discoverability.

Kajetan emphasized his excitement about .NET 10 and its numerous features, including Blazor, Maui, and other areas where he is particularly thrilled. He invited listeners to purchase his book for more information on these topics and encouraged them to connect with him on LinkedIn or join his courses and community in Poland.

The interview also covered Kajetan’s experience with .NET Core and how he often misses important changes in port numbers due to the wildcard certificates. However, he assured that his new book will provide readers with a solid understanding of these changes.

Episode Transcription

You actually cannot do proper vertical slice if you are bounded to controllers. Because there are some additional dependencies that you can download, like Ardalis [ApiEndpoints] or like Fast Endpoints that will give you actually what Minimal API is giving you. But with the standard controller-based approach you are not able to do the full vertical slice, because every time you’ll need to take this, let’s say presentation layer, outside your slice because it needs to be, just as you said, in the class that is inheriting from Controller and doing all the actions and stuff like this.

- Kajetan Duszyński

Hey everyone, and welcome back to The Modern .NET Show; the premier .NET podcast, focusing entirely on the knowledge, tools, and frameworks that all .NET developers should have in their toolbox. I’m your host Jamie Taylor, bringing you conversations with the brightest minds in the .NET ecosystem.

Today, we’re joined by Kajetan Duszyński to talk about some of the new things that are coming up in .NET 10. We cover some of the big things that you might have missed, some of the optimisations you can make by removing code (listen up for one in a few moments), and we also talk about his new book “.NET 10 Revealed.”

So you all need to remember that if you are using Minimal APIs and you’ve used the extension method WithOpenAPI(), which created a proper OpenAPI schema. Right now it won’t be used, so you’ll need to delete every usage of this method from your whole application, because it will be um added by default in the pipeline of creating, of starting up the application.

- Kajetan Duszyński

Along the way we talked about allocations, the importance of learning MSIL (what your C# and F# code is compiled to), memory management, how fast .NET is moving and when we’re likely to see the first public preview of .NET 11, and the vertical slice architecture.

One of the biggest things that I think will cause some head scratching in .NET 10 is the new local self-signed TLS certificate. I’ve linked to an article by the folks at Duende about this, and it’ll be worth adding it to your reading list. It’s a great addition to .NET 10, but it’ll catch some folks out.

Before we jump in, a quick reminder: if The Modern .NET Show has become part of your learning journey, please consider supporting us through Patreon or Buy Me A Coffee. Every contribution helps us continue bringing you these in-depth conversations with industry experts. You’ll find all the links in the show notes.

So let’s sit back, open up a terminal, type in dotnet new podcast and we’ll dive into the core of Modern .NET.

Jamie : So Kajetan, welcome to the show. We’re gonna talk about some stuff today that is… we’re talking early October, we’re talking about stuff that will be released mid-November. So I just want to get that out the way first. Just a little disclaimer to folks who are listening in. I doubt things will change, but just in case they do: we were recording this in the past, which is the present for us, but the past for the listener. We so in the future when you’re listening, bear with.

Kajetan : Hi Jamie. Yeah, thanks for having me. And yeah, I Honestly, I really hope that nothing will change because this will mess up all all my plans. Probably we will talk about this during this, but yeah. But we are here to talk about .NET 10 and I’m really thrilled because there are so many different stuff out there with this new version that should be should be discussed.

Jamie : Yeah, yeah. If I’m honest, I’ve kept myself .NET 10 agnostic so far. I haven’t looked up anything, right? I know that .NET 10 is coming. I saw the Stephen Toub blog post about how much more performant it is. I read four sentences, got confused, and closed the tab. Which is what I do every single year.

Kajetan : That’s the problem, yeah. That’s the problem. I do the same. Unfortunately I know that Steven’s articles every year are fantastic and I hear this a lot. Right now it will be probably a bit easier because we can just put it in some kind of AI and and try to and ask to to summarize this for for us. But will then lose this magical moment of getting what’s in the Stephen’s mind and what’s out there exactly about the .NET performance.

So probably I will need to at least once try to convince myself that this is something really useful and don’t just try to find out from my colleagues who read it. But yeah, so if you are not yet familiar with what’s out there it might be even more interesting today.

Jamie : Oh absolutely, absolutely. Yep. We’ll come back to that in a moment. So Kajetan, could you maybe introduce yourself to the listeners? Because we’ve talked a whole bunch already I’ve got four minutes in our recording. It’s probably not going to be four minutes when it comes out, but we’re several minutes in and folks will be sitting there going, "wait, who’s this guy?&wquot;

Kajetan : Yeah. Okay, so as you just said, I’m Kajetan Duszyńsk. I’m from Poland. I’m an Microsoft MVP for for the last two years in .NET and web technologies. And in Poland I own a .NET school where I try to teach other folks how to properly use .NET, how to properly use C# within web development. So I try to convince still people in Poland that learning how to code is still worth in 2025. It’s still worth a shot to go into IT and and to learn C# and ASP .NET mostly. And recently I’ve written a book about .NET 10. It’s called ".NET 10 Revealed." And this is part of why we are here today: to talk probably a bit about the book, but mostly about about .NET. So yeah, this is this is who I am.

Jamie : Amazing. Yeah, I applaud anyone who wants to teach folks how to do what we do, because you know I have a background myself in education; long-term listeners of the show will know how that came about. And so knowing that there’s folks out there trying to fight the good fight of getting people into software development, perhaps through .NET, perhaps through other technologies and means. There it always sort of warms my heart to know that there’s people out there going, "hey yes, you can do this. Let me show you how and let me teach you."

Kajetan : Yeah, exactly. I still feel quite magical whenever I wake up in the morning and I receive an email that’s one of my students just sent me saying that he just or she just got the job as a junior .NET developer. That’s that’s probably one of the best mornings I can imagine.

Of course, speaking about our careers or teaching other people that you actually change someone’s life, someone’s career and they succeed thanks to your materials that we’ve prepared. Right. So this is something I truly appreciate when any student just write to me, and shares the successes with me.

Jamie : Yep, yep. I think my friend Zac says, "watching a knowledge happen to someone else, or hearing about someone’s successes that you’ve helped helped to sort of bring about, that’s always the best," right? That’s the pinnacle of good feelings, right?

Kajetan : Exactly. Yeah, exactly.

Jamie : So let’s circle back, real quick, to Stephen Toub’s amazing .NET "what we’ve done this year" style blog posts. That seemed to go on forever. And yeah, I always get super confused by about paragraph three. And that’s nothing to do with Stephen Toub. That’s more, like there’s so much dense information involved in those blog posts. And you’re right, you know, you said earlier on maybe we could give it to our favourite LLM and say, "summarize this,&quot but we’d miss a lot of the nuance in Stephen’s amazing writing and his excited prose, and how generally amazing it is to hear the updates to .NET each year

Kajetan : Yeah, this is something, like you said, that’s hard to go through this article, but and it’s hard to follow actually all these changes. Because in most cases, as a developer throughout the year, we don’t really care about all these bits and pieces about the performance. We just know that the performance when we will upgrade our application with the newest .NET will just get some performance boost out of the box, right? This is all we care about.

But going so deep into what has changed over there in the runtime, over there in all the libraries, how we allocate everything, how we change the allocation of different bits like this year and there are some changes of allocation of small arrays that will get some free allocations, let’s say, out of the box. So the performance of our applications will get better and better every year. But yeah, in most cases I feel like Stephen’s articles are just cool. When you are nerds like you and me, like other guys that we are working with, just to sit down and just dig into this small pieces of the benchmarks that he shows, and try to analyze what’s over there. This is purely magical, and this is purely fun going into what’s there; even if we won’t remember what actually changed in this piece of .NET after some time. But, yeah,going through this at some point is really really interesting

Jamie : Oh, a hundred percent. I often wonder… this is a, like I’ll be reading through the article and I’ll be like, "this is an amazing thing. Fantastic. You know, we’ve reduced"… we, right? "Microsoft and the open source community have managed to reduce this or increase that or you know. This metric has changed in some way in a fantastic way." And I’m like, "that’s awesome. And we get that for free. But also I don’t understand it." And you know, I have a Computer Science background. And I’m like, "I don’t understand that." But I’m okay with that.

Kajetan : Yeah, yeah, of course this is what I am discussing a lot with my colleague, with my friend Konrad Kokosa. I don’t know if you know him, if you heard about him. Konrad Konrad wrote this this huge book, it’s called "Pro .NET Memory." It’s like a thousand pages and I barely can follow the the first two chapters when I read it. So yeah he is going so deep into what’s inside C#, into what’s inside .NET that you need to be, I don’t know, like you need to have a probably a specific mind to understand this to follow this; to be interested actually about this. Because sometime I remember at the beginning of my career, one of my boss told me, and this is following me for the last couple of years that, "the sad thing about web developers is that we’ll be creating mostly CRUD applications, so there won’t be any fancy stuff in it. We won’t need to optimize a lot of stuff." But at some point if we’ll need to do this, we’ll be screwed because this will be this one thing, this one situation most likely in our whole careers that we’ll need to understand what’s beneath our code that we just wrote; and we will need to understand how it works.

But besides of that, if our applications work fine, what’s the point of going over there? There are folks that understand this, that are pretty excited about this and cool for them. But most of developers just don’t need such deepness of knowledge of the platform, of the application, of the language, right?

Jamie : Yeah, it is great to have the knowledge, but like you said, you know, "if we’re doing CRUD applications or forms-over-data, most, maybe 80 to 90% of the time, you know, a performance gain will" I mean if it’s a hot path and you’ve measured twice. You know the the old adage of, "measure twice, cut once," right? So if you’ve measured lots, and lots, and lots of standard requests, and you know that this particular path of code is the hot path, then obviously there is a reason to go in and investigate whether you can boost the performance.

But for the majority of the code that we write, you’re absolutely right. Maybe it adds a couple of cents or maybe a dollar or two every month to our cloud bill, but like you’ve got to be pra pragmatic, right? And it’s all about counterbalancing, "cool, I could spend fifty hours, and the cost of that 50 hours of my salary or whatever, and the effort to fine-tune this block of code such that it saves us twenty-five dollars a year," right? It’s like, there’s gotta be a business case, right?

Kajetan : Yeah, exactly. Exactly. That’s all about money at the end of the day.

Jamie : Yeah, and and I’m not saying it’s not worth doing, and it’s definitely worth knowing how to do those things. But like you said, for the for the, you know, the 80 to 90 percent case of, "it’s probably gonna be okay. And if somebody really is screaming that it’s costing too much on the cloud bill, then yeah, you could probably spend a little time optimizing it." But other than that, yeah.

Kajetan : That’s absolutely true.

Jamie : So we’re talking about .NET 10. I know that you mentioned the name of the book, real quick just before we get into too deep into any more conversation. So it’s ".NET 10 revealed," right? And it’s coming out roughly at the same time as .NET 10, or will it be out beforehand? Like, what’s the going to look like?

Kajetan : It should be, yeah. The official release should be when .NET Conf will be out there, so mid-November. If you guys, and any of you from from Europe would like to go for the official release, we’ll have a meeting in Prague. That’s probably too late to say this, but we’ll be meeting in Prague on the conference whereI will be there, where my editor will be there, and this will be official release of the book. And I’m already pretty excited because this is the first book that I’m writing. And yeah, and I’m really curious about what the readers say about it.

Jamie : Amazing. Amazing. I’ve said this to other people in the past, but I’ll say it again: the process of writing a technical book for anything that is currently in development and the goalposts are changing, and then suddenly there’s an update two weeks before they release, and then you have to scramble and rewrite some stuff… I can’t even imagine the stress involved, right?

Kajetan : Yeah, when I’m creating my courses, and I’m creating my YouTube channel, when we are online nowadays it’s always easier to be on track with all the news, to publish something about upcoming features. And if someone decided that it’s not going to be a part of of next .NET, we can create another another video on YouTube saying, "that unfortunately .NET guys decided that it won’t be."

So, in many cases when I’m on YouTube I don’t encourage people to learn about programming from books, because that’s purely theoretical knowledge. So you are seeing some technical stuff written down. Even if you would like to follow, even if that’s absolutely the best book that will teach you about .NET or C#, you’ll need to, at some point just rewrite this code that is written or try to compile it, see what’s what’s going over there. Like, I don’t know if I should say this, but I still follow what I’m saying. So we shouldn’t learn from the books at the very beginning. There are much, much, better sources. But on the other hand, right now with all the .NET releases that are planned for every year, there are less things that can go wrong with this book. Even if the process of publishing is quite long, because as we said it’s beginning of October, and my book is already in production. And so this is why I said at the very beginning that I really hope that .NET guys won’t change anything, because it will be quite hard to change anything in my book.

On the other hand, what we can see from the last years, from .NET 5 till right now, till .NET 10, is that their roadmap is quite clear. Their milestones for each version are quite clear. So there are less things that are surprising us when actual version is released than it was in the past. So I really hope that my book will be quite up to date when it’s released. And what I [will] say, "you won’t be able to learn C# programming out of this book because it’s not about it." It’s all about news from .NET 10 from more practical point of view, let’s say. Not just what we are getting in documentation, not in the release notes, just a couple of practical examples of, I believe, most of the new stuff that is coming in in .NET 10.

Jamie : Yeah and, like that… I’m trying to cut down on saying, "that makes sense." But it does make sense, right? The reason that the roadmaps are so tightly enforced is not just to give folks like yourselves who are, you know, writing books, making courses, things like that, a deadline for the things will not change after this point. But also, hey folks, if you didn’t know, Bing runs on .NET, right? And there’s a whole bunch of core Microsoft infrastructure that I’ve been told of that runs on .NET, right? And so if it runs on .NET and they are dog fooding it. then they need time to test it too.

Kajetan : Yeah, yep, of course.

Jamie : And if the .NET team suddenly changes something five minutes before release, then you know, Bing might go down; regardless of people’s thoughts on the Bing search engine. For me, it’s not my favourite search engine, but you know, if it goes down, then folks will be upset.

And you can probably find, like, I know where folks will be listening to this in the future. But as early as today, Thursday, 2nd of October, I bet if you go to the Azure portal, you could probably find, "Oh look, I can run a .NET 10 release candidate 1 or 2 or whatever we’re up to version of my app on the cloud." And it isn’t just Azure. There will probably be a .NET 10 on AWS and on GCP as well, and supported by the other cloud vendors too, right? On top of all of that, you’ve got the folks who have to verify the installers for either Windows 11, and Mac OS, and all of the supported Linuxes, right? If this there’s a lot of effort that goes into it, so I would be very surprised if they changed course now.

Kajetan : Yeah, yeah, exactly. And and right now, I just read it, I believe, today or yesterday, but right now the release candidates of .NET… so we are getting throughout the year all these previews, right? So even after releasing of the new version, just after a month or two, we are getting the preview one of the next version. So, most likely, in January we’ll get preview one of of .NET 11. And right now we got release candidate one [of .NET 10] and it’s already tagged at some point as go live; so this is something saying to us that, even before releasing the official product, "we are quite convinced that this is something that’s mostly shaped like this will be released in November. So we may add a couple of bits, we may improve some bits, but probably we won’t delete any any of things that are already in release candidate."

So if you are planning, especially that .NET 10 is the long-term support version, if you are planning to upgrade to .NET 10, then you can already start testing this out. So that you are prepared. And still I won’t be convincing anyone to just upgrade as soon as the .NET 10 will be released in November. That’s especially in enterprise applications, we need longer time to to test everything, to do regression testing, and and all all this stuff. we need to focus on breaking changes, and stuff like this. But you can start preparing based on release candidate, what you are going to change later on.

Jamie : Absolutely. A hundred percent agree with that. And I think a lot of folks, especially in enterprise, get rather scared when the new version comes out and they say, "well when will we have the chance to upgrade?" And you know, to those folks I would say, "well, start with a new piece of technology," right? Some new microservice, some new thing. Rather than upgrading something that is currently running, grab something that you are just starting and try it with a new version; with one of the previews perhaps, as we’re coming up to release or maybe with a release candidate, and see whether the libraries that you would use work. See where the the process you would normally go through would work. See what the potential pitfalls and things of installing the release candidate on say your build server—if you have an internal build server or you know that kind of thing right—and see what happens with a brand new project: just do "File> New project" give it a name that is, you know, something that you might work on in the next few weeks. Maybe you can get away with a skunkworks, and just throw some code somewhere and try it out, right?

Maybe if you have the time and you are Kajetan or his colleague Konrad, you’ve probably got a like a benchmark that you can run, right? The release candidate comes out, you’ve already written a whole bunch of code, you just update the target framework moniker—that’s the bit in the csproj that says which .NET version—and then you run it and see what happens, right? If you’re brave, do that. But please don’t do that with anything in production because you will likely break something.

But yeah, it’s my experience of any kind of upgrades is: the difficult bit is the packages that you rely on. If you write every single line of your own code or rely on the .NET library code, you’re fine. But if you, you know, it’s when you get into those esoteric moments of we want to upgrade, but one of these packages that we rely on isn’t upgraded; then that’s where the their problems come from. But they’re open source, so you can go and help those open source stuff out by maybe putting in a pull request that upgrades it or starts that upgrade process.

Or even, right? Here’s the thing. Realistically, you should be taking a copy of every library that you rely on into your own infrastructure and vetting it anyway, so you could probably do a temporary upgrade whilst you wait for the official upgrade, right?

Kajetan : Of course, of course. And there’s another crazy idea with what’s going on recently with open source libraries. I won’t be naming any anything but, most likely, we all know about a couple of libraries that goes commercial this year; and I believe that’s this, don’t get me wrong, that’s absolutely fine with commercializing anything. So I can absolutely understand the decision that some libraries are going commercial, because they are getting so much momentum that they need some more support time, which just needs to be somehow valued, not only creating this because we feel our [it’s] mission.

But this is a side note, but when we are upgrading our our applications, this is also a time when we should ask ourselves if we need everything that we are using. In many cases, when we are starting a new application, we are following some some rules, even the LinkedIn posts, there are a lot of them right now that, "whenever I’m creating a new project or software, I’m adding this, this, this and that library," right? So at some point we just need to ask ourselves, "do we really need this? Do we really need this dependency?" Because what will happen is, if we are just using one percent of this library and still it goes commercial, will we be able to convince our stakeholders to pay for this while we could get rid of this some time ago, when we were upgrading our our .NET.

So yeah, this is always the time to to think about our architecture, what’s inside our applications? And Upgrading .NET versions nowadays is much simpler than it was, like 10 or 15 years ago, because we’ve got additional tools. There is already a tool. It’s called Upgrade Assistant, I believe, that we can run against our application. And this will just scan our application, and scan our code, and it will find all the things that may potentially break when we’ll upgrade the .NET because it’s really aware of all the breaking changes between the between different versions. So it’s quite easy to catch this when you’ll analyze the code. So, yeah the the whole point of upgrading should be also at least try to clean it a bit, just to to to leave it a a bit cleaner, a bit better after the upgrade itself.

Jamie : Absolutely. And, you know, you may even find that when you upgrade, you may not need some of those dependencies that you rely on, right?

Kajetan : Yeah, of course.

Jamie : So for instance, one of my favourite things about—and I want to say it was .NET 8—is the static endpoints for my APIs and things like that. Yeah, I was gonna say MVC APIs, but they’re not that. They’re using the REPR pattern, right? So we have a static class that takes in the IEndpointRouter interface and we say router.MapGet and then we just map it to a static function within that class. And that is amazing.

And we get that, which means that because we’ve got first-party support baked into the ASP .NET Core runtime and library, that means we probably don’t need, like you said, some of the libraries that we’ve used already. If you’re still using, you know, Steve Smith/ardalis’ wonderful GitHub repo to give you that, keep using it. That’s not a problem. But You maybe don’t need those libraries. Maybe those libraries provide you with something amazing that you can’t get inside of ASP .NET core. Amazing. But it like you said, it’s a great time to actually rethink, "do we need this? Do we need this?" and see whether you actually need it? Because you may not.

Kajetan : Exactly, exactly. And just as you said, Minimal API is one of the best best example of this.

So of course, switching from controller-based applications probably would be hard to rewrite every piece of our code into Minimal API. So all the things that we are getting are not worth [the] time for refactoring. But we should be, at least, aware that something like this exists already. And whenever we are creating a new application, it’s really, really worth using, especially because as far as I know, the whole engine behind web API within Minimal API was rewritten, and it was created because decisions made with the MVC style APIs were made 20 years ago. Right now they are so deep into .NET that that they were not able to change their behaviors to improve performance too much already, so they decided to rewrite the whole thing from scratch and this is how Minimal API has been created. So whenever you have the chance to try it out, if you didn’t yet, just just go with it because it’s it’s brilliant. It’s brilliant. especially from .NET eight or nine when it’s got a lot of functionalities and it’s really stable.

Right now there is a huge breaking change and we will need to be aware and this is the first let’s say this the disclaimer for for the guys that that are listening to us. So you all need to remember that if you are using Minimal APIs and you’ve used the extension method WithOpenAPI(), which created a proper OpenAPI schema. Right now it won’t be used, so you’ll need to delete every usage of this method from your whole application, because it will be um added by default in the pipeline of creating, of starting up the application. So this is one of th greatest change[s] for for .NET 10 in Minimal APIs. This will be a pain probably if you’ll have the large API. But it will clean your code instantly after upgrading this.

Jamie : Oh absolutely. And I think that you’re absolutely right. There are a whole bunch of breaking changes. I know of one or two from some investigations I’ve done this week. But there are some small breaking changes that are super important to know about going into that upgrade, as there are with everything.

But before I jump into that, I just want to say that I absolutely agree with you on Minimal API. I called it static endpoints, but it’s Minimal API. A lot of people that I know have held off of doing anything with a Minimal API because they hear minimal And they think, "oh, minimal feature-wise," but actually it’s minimal amount of code that you have to write. Think like the ExpressJS or what’s it called? FastAPI for Python, right? It’s that. It’s app.Get( the path you want and then the method the action you wanted to take. It’s that simple. You don’t have to do, you know, create a class which inherits from controller and then write a whole bunch of injectors and all that kind of stuff. You don’t have to do any of that. It is just app.MapGet{} and then the path that you want to map to and then the the process you want it to do. That’s it. It’s amazing.

Kajetan : Yeah, yeah, and it gives us so much flexibility in our applications. Like nowadays we are all talking about, I don’t know, vertical slices architecture. You actually cannot do proper vertical slice if you are bounded to controllers. Because there are some additional dependencies that you can download, like Ardalis [ApiEndpoints] or like Fast Endpoints that will give you actually what Minimal API is giving you. But with the standard controller-based approach you are not able to do the full vertical slice, because every time you’ll need to take this, let’s say presentation layer, outside your slice because it needs to be, just as you said, in the class that is inheriting from Controller and doing all the actions and stuff like this. So um and right right now when we are using Minimal APIs we can call app.MapGet from anywhere actually from our application and we it will just just work without any problems

Jamie : Absolutely a hundred percent.

Jamie : The ability to do that sort of vertical slice architecture by just stripping everything out, getting right the way down to brass tacks, right? That’s kind of why we have, you know, dotnet run program.cs right? Because the idea is to strip everything out as much as we can so that then we can—rid I keep saying "we" right—but so that then you can reduce the amount of code, the boilerplate code, that can be that can be maybe generated at runtime or that maybe isn’t even required, right?

There could come a time where future… and this is me just philosophizing, right? But there could be a time in the future where you don’t need public static void Main even to be generated for you. So for folks who don’t know: at the minute, my understanding is that if you do a program.cs that just has the words Console.WriteLine, at the moment when that runs, there’s a source generator that fills in all the banks for you, puts the public static void Main and the namespace and all that kind of stuff. My understanding is that is required at the moment.

My vision, as a weirdo who lives in the UK who loves .NET, is that maybe that generation of code probably doesn’t have to even happen. So maybe they could speed up compilation time by not having that happen, by doing some other random weird, lovely, wonderful compilation thing that just the code is just there. Or maybe it doesn’t need to be there, right? And so there’s all these teeny tiny optimisations that we don’t even have to think about.

Then again, like I said, we get for free. When we do the upgrade, it’s just faster, it’s smaller, it’s… Oh, it’s brilliant.

Kajetan : Yeah, yeah. And it’s actually really good that you mentioned your vision because, right now with .NET we are getting closer and closer to this vision. Because another change that I’m thrilled about because this is something… I have a lot of colleagues, a lot of friends that are using Python on on a daily basis.

And I’m not saying that I’m like ashamed of how .NET is is working or how C# is compiled but they are always posting that they can just create one simple file. We’ll call it example.py. They can put a a little bit of code and and then just run the the application. With with .NET we, at least, needed always a project in most cases; some case some kind of solution the program.cs that is the starting point for most of our applications, and there are a lot of ceremony behind every application even the small ones like Hello Word.

For the last versions it was getting better because of the top level statements when we were able just to say Console.WriteLine(“Hello, world!”);. But, just as you said, the scenes it was creating still the program.cs, it was creating the Main method. But right now with .NET 10, at least, we’ll get some feeling of how Python is working for the last couple of years.

So we are getting ability to run any C#, so .cs file, and so whenever we would like to create a small script within one file we can just put it in one file call it myprogram.cs, write some code like we are doing with top level statements without the csproj, without the solution, and just type in our terminal dotnet run myprogram.cs and it will work.

So this is something really exciting for guys that are automating a couple of things through the script and they needed to use Python because it was easier. Right now we are getting the same feeling of the scripts within .NET, which I’m really thrilled about because this will make my my life so much easier.

Jamie : Oh, absolutely. Like, the amount of executables that I’ve built in perhaps .NET or other languages that are maybe 15 lines of throwaway code. There could have been a bash script, or could have been a Perl script, or could have been something if I was good enough at writing those languages, right?

Whereas I know that I can throw together something in C#, and it’s statically typed, and you know I know that it will do what I want it to do a hundred thousand times and I don’t have to worry about some weird edge case, like I gave the script to someone who doesn’t have a bash terminal, they have a zhs terminal or a phish terminal or something, and then it nothing works, right? Whereas I can write, like you said, a single CS file, do a dotnet run and it works.

And then maybe I can have that on my enterprise server or somewhere in source control, and maybe right even better, right? I get a new starter and I want to set up their machine. Well guess what? All I need to do, the only dependency I have is the .NET SDK, so that I can run that C# file. Maybe I can even do .NET build. I don’t know yet. I haven’t tried that out. But I can say to that person, "right, you’ve got two tasks. One, install the latest version of .NET, Two, run this file with .NET and everything else will be set up for you," right?

Kajetan : Yeah, exactly. Exactly. And and this is not only for the scripting, but also for for any prototypes; because merging this with Minimal APIs, for example, because you can right now create a simple prototype of the API within your one file without adding anything. So you you’ll be able to to make a using to ASP .NET over A in this file, set up the the web application. You’ll be able to create your first endpoints, probably returning some mock data, and just run it through dotnet run. And if that works for you, this prototype will work for you.

You will even have a tool, it’s called also .NET Convert. And after prototyping something like on your sheet of paper, you’ll be able to change this into a proper project that you’ll be able to later on develop with your your team. So these are really brilliant times for for .NET developers if we are looking at what’s what’s coming with with every version.

Jamie : Absolutely. I feel like us .NET developers, if you take the idea of .NET fiddle out of the equation, us .NET developers have been missing a REPL. And this gives us a REPL. You know, so like you know, if you’ve ever played with Python, you just type Python into the command line and it creates a REPL. You can just type Python code in and every time you hit return, it runs it. We’re heading towards that folks. That’s my opinion, right? This is the stepping stone towards that. That would be amazing because, like you said, rapid, like faster than previous rapid prototyping. Like right now .NET 9, if I want to do a prototype, I’ve got to go&mdhas;if I’m in Visual Studio—I’m going to go file new and then walk through the wizard. I have my own observations about that.

Kajetan : That is a super slow process.

Jamie : Oh yeah. Or I pull up the terminal, do <dotnet new And then it spits out a bunch of code. And then I change almost all of the code to make it do what I want. And then I do dotnet run, right? Whereas with this idea, I just create a file. Doesn’t matter where it is, just a single cs file. type all the code in and then I do dotnet run whatever my file is and it runs, right? Like you said, people in the Go, Python, JavaScript community are going, "yeah, but we’ve always been able to do that." But we haven’t. That’s why this is such a huge thing.

Kajetan : Yeah. I thought that you’ll bring this up, that Python guys will just say that, "we’ve got this kind of features for like forever." But I still remember when my friends from the university were thrilled when some kind of Linq came to to Java. They were they were so thrilled that it’s going over there and and I was just like, "hey, it’s in .NET for like three or four years already, so you could just switch your language to the to the proper one." We know that we are not switching languages so often and we are not that keen on on switching languages, so it’s always a good thing when such news are going into into our platform.

Jamie : And this is why I think we need people in software development, software engineering, whatever phrase, noun word you want to use, who are, I guess, polyglots or who are investigating other technologies. I try not to tie myself down to a single technology for a bunch of reasons, but partially so that I can see what everyone else is doing. But also because .NET, and guess what folks? I’m about to break immersion hereL .NET is probably not always the best thing to do, for whatever solution you’re trying to achieve, right? And it’s important to know what else other people are doing. Because otherwise, like I said, I know that FastAPI exists because I’ve built a bunch of APIs with it. And I know that FastAPI looks surprisingly similar to Minimal APIs, right? And that’s because the folks on the .NET team have gone, "wouldn’t it be great if we could do that?" Right? "How do we do that? Let’s make that."

Kajetan : Exactly. Yeah, this is the whole point. This is the whole point.

Right now, for the .NET and probably there will be a lot of smiles after what I’m going to say. Of course, the only thing right now missing in .NET to make it absolutely the best platform in the world are discriminated unions. We have this conversation for a long time, and yeah this is something but I really hope, and I and I know that they are coming, so I’ll be just waiting. And after that we can talk with any developer from any language and find out what they are missing actually from what’s inside .NET.

Of course I’m joking, just as you said. And this is always good to look on others, especially that we’ve got interesting times. When we looking into, I would say, vibe coding but generating code a lot and knowing different languages will give us the opportunity also to supervise what’s generated through the LLMs better. Because we’ll be aware that maybe even if that’s something created by an LLM in C# but it looks more like Python script. Because LLM doesn’t know the best practices; doesn’t know what’s what’s over there to be used or how we are in in regular basis we are using this. So it’s always good to to understand all the different bits and pieces of different languages.

I, myself, need to be honest that I feel best in .NET. I feel best in C#. I did a couple of small Python scripts but this is all what I’ve been doing for the last thirteen or fourteen years of my career. But I still really like what’s, right now, generated for me, at least for the frontend site. When I use the Claude Code, for example, and I ask it to to create some dashboard that I will be using in my team. I don’t really care if this will be created in React, in Angular. in Blazor or whatsoever, it just needs to to work. But it’s really fun at least reading this, and finding out how it could be written by by myself at at some point.

Jamie : I personally think that knowing how other languages, frameworks, that kind of thing, work, you can actually then change the way that you think about your sort of home base, I guess, language or framework. You can say to yourself, or maybe with your LLM of choice helping you, or with a colleague helping you, "I know that we do it like this in Python, but I wonder if we could do it like this in .NET." Or, "we do it like this in .NET, but why don’t we do it that way in JavaScript," for instance?

"Hey, I’m really good at .NET. I kind of get TypeScript, and TypeScript is kind of helping me to produce like a typed version of JavaScript which tries to adhere to some ideas with C and object-oriented programming. How do I do that?" And then you can like tailor your personal education really well. Because all of the LMs that I’ve interacted with at the very least are really good at that. You can say, "hey, I know this one thing and I want to learn that one thing. How do I learn it," right? Because otherwise you’re just gonna end up doing an "intro to" that one thing course and you’re just gonna be sat there bored out of your skull and you’re never gonna actually learn it, right? Trust me, I know.

Kajetan : Yeah, exactly, exactly. And thank you very much, Jamie, because you perfectly wrap up what I wanted to say with my absolutely too long talking about the LLMs. Yeah but this is absolutely what I meant.

Jamie : No no, it’s perfectly fine. I understood what you meant.And I thought I was talking about something else, so it’s all on me. I was the wally, I was the the weird one there.

You know that moment when a technical concept finally clicks? That's what we're all about here at The Modern .NET Show.

We can stay independent thanks to listeners like you. If you've learned something valuable from the show, please consider joining our Patreon or BuyMeACoffee. You'll find links in the show notes.

We're a listener supported and (at times) ad supported production. So every bit of support that you can give makes a difference.

Thank you.

Jamie : I know we’ve talked a lot about like .NET and the speed at which we can upgrade and things like that, but I have two thoughts so far and I’d love to hear your thoughts on the change to the standard term support.

Now first off, folks if you’re listening in, STS doesn’t stand for "short term support," it stands for "standard term support".

So I was wondering about your thoughts on the change to standard term support. I’ve read that it’s been expanded somewhat. And what are your thoughts on that?

Kajetan : Yeah, at the very beginning when I looked at at this, it’s not that big of change? Like you you can think, "that’s not that big of change, "because this the standard term support right now is extended from 18 months to 24 months. So it’s just half a year longer.

But if you’ll look at the roadmap, if you look on the release plan, It makes a huge change. And it’s already added to .NET 9. So so it’s working. No we don’t need to wait until it will come up with .NET 11, it’s already for .NET 9. So if you look at the release plan, it changes in the way that the standard term supports will be ended, at the same date as the previous long-term support.

So just let me do the the math quickly. So when the .NET 8 was released in 2023 it’s its support will end up in ‘26, right? In November ‘26. And for the standard term support before the change. So for the .NET 9, it would end in May ‘26. So it will be half a year shorter support for the next version than for the long-term support. Right now, two of these, so .NET 8 and .NET 9, will end up with the same end date of the support, so November ‘26.

What changes for us is that we don’t need to be scared of using standard term support in our applications. And this will make a huge change for the architects that are trying to convince the stakeholders that we should really follow up every of the upgrades if that’s possible, because if we’ll have the application that any upgrade will need like three or four months of preparations, that’s probably too much. But in many cases, whenever we are creating some kind of microservices, that are just just a bit smaller and easier to upgrade, we should always try to upgrade as soon as possible with right now every version.

Why? Because with every version we are getting a lot of improvements. We already talked about this out-of-the-box performance improvements. somS kind of new features that are coming to .NET that we no longer will need to wait for two years to use them in our apps, because they will get the same time of support. And at the end we’ll need to look once again on the AI and LLMs, because this technology is changing our world so quickly. Two years is feeling like forever. If we’ll sit down, we’ll see that ChatGPT was released two or three years ago, and from the first version that was released to the public till today with GPT5 the difference of how it’s working, og the functionality it has, of the abilities that it has, it’s so much different. And the same goes with .NET. We’ve got semantic kernel, we’ve got the bot framework, we’ve got a lot of different things that are added to .NET that are changing really rapidly.

So waiting two years to upgrade anything. is just too long in many cases. And right now Microsoft is giving us the ability to shorten this time, and is trying to convince us that it’s really safe to upgrade every year; especially that’s just as easy as changing the target framework in our csproj.

Jamie : No, I agree. I feel like when I first read the announcement, I was like, "this is weird. It feels like it makes STS and LTS fall in line." And it kind of does somewhat, but like you said, it makes it easier for that upgrade. Therefore, it should in theory, make it easier to get buy-in from the stakeholders, from the project managers, from the clients to be able to do that upgrade. Because, yes, okay, in an ideal world it is: change the target framework moniker line in your csproj and all of the related csproj’s, hit rebuild, rerun your tests and see what fails. But also, like I said, there there are those strange esoteric things where I have a NuGet library that I rely on and it hasn’t been upgraded yet, so I can’t upgrade, right? And we don’t want that.

Kajetan : Yeah.

Jamie : But it also gives the open source folks a longer period of time, a lot more relaxed upgrade process for themselves, right? As an open source developer myself, when I’m preparing one of my libraries for the .NET 10 update and it should just work. But I know that there are gonna be people who on day one want to be able to use that library for .NET 10. And I don’t have the personal bandwidth, folks. But if my standard term support for .NET 8 and 9 perhaps I’ve upgraded, then that means I have a slightly longer window to get things upgraded in my open source stuff, before it falls out of suppor; and then I’ve got people knocking on the door saying, "hey, why aren’t you upgrading things?" And I’m like, "I can’t do it. I don’t have the time. Maybe sponsor me." You know?

Kajetan : Oh of course. Yeah, yeah, yeah. This is absolutely true. And yeah, I believe that this is, once again, a beautiful vision that we’ll be able to upgrade everything easier, quicker, and every year. But we need to look at the reality. In most cases this won’t change that much in the large corporations because they are so bounded to this two years period of upgrading every software that it won’t change anything. But at least we have some arguments when talking to the business, when talking to anyone else about the upgrades, and about the features that will come within the standard term support versions. That might be useful for our applications. Yeah, it should give us at least some ways of convincing them to allow us to do these things. And it’s always fun to upgrade applications.

Jamie : Absolutely. Absolutely. I do worry that it may make some people go, "cool, I’ve got an extra six months, so I don’t have to do the upgrade yet," right? Which is kinda scary.

Kajetan : Yeah, yeah, never do this. Never, never leave this until it’s it’s too late.

Jamie : Yeah, yeah. I wish I could say that was not the case in real life, but we all know that is.

Okay, and I just wanted to, there was something that I read the other day, and I feel like this is more on ASP .NET core change. But I want to throw it out there. I’ll get the link for the show notes, folks. But there is a big change coming to .NET 10 and the way that it handles the default TLS certificate, the sort of demo TLS certificate—the SSL, HTTPS, whatever you want to call it—certificate that gets installed when you do HTTP trust. My understanding is that it installs a wildcard for localhost so that you can actually have like dev.localhost and things like that. So that makes that a little easier. But it will cause some confusion for folks because there will be a little bit of a wobbliness as people upgrade.

Kajetan : Yeah, that’s for sure. This is exactly what is described. But these changes that make sense, but for some reason, I still don’t know why I always don’t follow this. I always omit this part of changes whenever I’m looking at the release notes, for some reason. And this caused me so many troubles at some point when I was upgrading my application on into .NET 8 from .NET 6 and it turned out that the default… Oh, what was that default port that application is starting? I don’t fully remember. But all my all my Docker files were broken just after the upgrade, and I didn’t know why. So my application just stopped working at the moment.

They were compiling. They were running locally perfectly fine. But when I run them from the Docker file, it stopped working. And it turned out that the standard port has changed from 8000 to 8080 or something like this. And this was a small change that I needed to to do in my Docker files. or Docker Compose. But yeah, these are these are the parts, and it should be the first thing that you look at because this is the th security of our applications. But that, for some reason, I always miss this.

Jamie : Yeah, it’s something that I miss all the time, too. But this one particularly could catch people out. I will link to, there’s a brilliant blog on the Duende software website. So those are the folks that do the Identity Server stuff. There’s a great blog post about how you can set… in your application URL you used to be able to just set the port number, but now because you have these wildcard TLS certificates, you can now set like myapp.dev.localhost and then your port number, which is really cool because then you can separate everything out. And then you don’t have to worry about, like, if I ever run two completely different .NET projects that are web projects that also use cookies. I don’t have to worry about accidentally reading the cookies from project one in the source code for project two, right?

And it’s things like that, right? Some of these things that I’ve read about recently about .NET 10 and some of these smaller changes, feel like devs at Microsoft are hitting these problems now and they have the chance to fix these problems, right? And those are the best kind of problems to solve.

Kajetan : Yeah, yeah, exactly. Exactly. This bounds perfectly with what we are doing with .NET Aspire as well. Like all the bounding of different services by the names, and what you just said will just fit perfectly into what we are doing over [there] as well. So it will be even easier and better bounded between the the services, and in and the discovery of all the services will be easier.

Jamie : A hundred percent. A hundred percent.

We’ve just gotten on to talking about a little bit about .NET Aspire and I’ve noticed we’re running out of time; which is a real shame, because all of these things are super cool to talk about. Kajetan, I’ve had a wonderful time talking with you this evening. Folks, we’re recording this in the evening, and I am surprised that Kajetan is still able to form great sentences because it is super late his time.

So I’m really appreciative of you taking the time to talk with us, but before we disappear could you remind folks of the book that you’ve got coming out and maybe, you know, you said very early on that you’re running a school for .NET developers; I appreciate that’s probably in Polish or something like that in the local area that you’re in. But in case folks are listening and going, "I’m in the area, I wan to learn .NET, maybe I can find out about that." And then you know if you’re on LinkedIn, you know, are you happy with folks connecting with you there too? I know I’ve asked you a lot of questions there, I do apologize.

Kajetan : Yeah, yeah, no problems.

First of all, once again thank you for having me over here. It was a pleasure to talk with you. And I’m always also a bit disappointed that I’ve prepared so many things. I’ve prepared so many things and I thought that you’ll be asking me like the questions like what top news from .NET you liked best. And I was, I already had a answer prepared that I really can’t find three best things because there are so many of them. In Blazor, in Maui, in every area that I’m really thrilled about.

But if you are as thrilled as I am just go and and buy my book ".NET 10 Revealed". And I will be really happy if you’ll get in touch on LinkedIn and we’ll be able to chat afterwards. And if you are from Poland, forgive me all the guys from outside Poland, but if you’ll go to szkoladotneta.pl, you’ll find all my all my courses, you’ll find every places that I’m in too. You’ll find my YouTube channel, uou’ll find my LinkedIn, you will find my Discord server that are gathering Polish developers where we are learning a lot of different stuff every day. So yeah, you are welcome to join my words anytime. And and anywhere. So thank you.

Jamie : Amazing. Maybe we should have a post .NET 10 release episode where I get to ask you about some of your favourite things that are happening in .NET 10. Maybe we do that, right? If you’re interested.

Kajetan : Of course, of course. Always. Whenever you are ready.

Jamie : Amazing. Amazing.

Well, you know, I say this every single time, but I really have had an absolute blast talking with you this evening. It has been a whole bunch of fun, and I know that there will be things that people have listened in and gone, "I didn’t know that. That’s awesome. I’m gonna go look that up." And then I really hope folks go ahead and buy your book because I—pro tip folks, I haven’t read the book, but I will be buying it because, if this conversation is anything to go on, then I know the book’s gonna be high quality.

So you definitely gotta go get Kajetan’s book. So thank you for being on the show.

Kajetan : Thank you very much, Jamie.

Wrapping Up

Thank you for listening to this episode of The Modern .NET Show with me, Jamie Taylor. I’d like to thank this episode’s guest for graciously sharing their time, expertise, and knowledge.

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 the podcast's website, 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 our contact page, or join our discord server at dotnetcore.show/discord—all of which are linked in the show notes.

But above all, I hope you have a fantastic rest of your day, and I hope that I’ll see you again, 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