S07E16 - From Code to Cloud in 15 Minutes: Jason Taylor's Expert Insights And The Clean Architecture Template

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:

• RJJ Software’s Software Development Services, whether your company is looking to elevate its UK operations or reshape its US strategy, we can provide tailored solutions that exceed expectations.

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

The Modern .NET Show

S07E16 - From Code to Cloud in 15 Minutes: Jason Taylor's Expert Insights And The Clean Architecture Template

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

Jason Taylor, a developer, discussed his Clean Architecture template, a repository designed to simplify the process of transitioning from traditional coding practices to cloud-based solutions. He emphasized that the goal of this template is not just to automate tasks but also to accelerate developers’ productivity by reducing the complexity of building applications.

To manage complexity, Jason advocates for using templates and leveraging existing frameworks and tools. His Clean Architecture template serves as a starting point, providing a structured approach to designing applications that can be easily scaled and maintained in the cloud. By breaking down the application into smaller, manageable components, developers can focus on delivering value quickly, rather than getting bogged down in complexity.

Jason highlighted the importance of going from code to cloud in a short amount of time – specifically, 15 minutes. He believes that this accelerated development process is essential for businesses to keep up with changing demands and stay competitive. By utilizing his template, developers can achieve this rapid transition, allowing them to deliver working applications quickly and efficiently.

One of the key takeaways from Jason’s discussion is the value of learning from existing templates and adapting them to fit individual needs. He emphasized that even if you’re not interested in Clean Architecture specifically, exploring other templates and frameworks can help you develop skills that are transferable across different technologies and approaches. This approach enables developers to become more versatile and adaptable in their work.

The interview concluded with Jason sharing his contact information, including a link to his website, connect.jasontaylor.dev, where listeners can find a collection of links related to his discussion on the Clean Architecture template. Jason also encouraged listeners who may be struggling with complexity or want to learn more about cloud-based development to reach out and seek his guidance.

Episode Transcription

So I’ve been focused on the code to cloud journey, I like to call it, for the template. And two years ago, my goal was to provide a solution that could take you from code to cloud in 45 minutes or less. So I wanted it to be “file new project” to deploy a solution on Azure—because that’s where my main focus is—within 45 minutes.

Welcome friends 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. We are the go-to podcast for .NET developers worldwide, and I am your host: Jamie “GaProgMan” Taylor.

In this episode, Jason Taylor (no relation) joined us to talk about his journey from Classic ASP to .NET and Azure. He also discusses clean architecture’s maintainability, and his open-source Clean Architecture Solution template for ASP .NET Core, along with strategies for learning new frameworks and dealing with complexity.

Right now the template supports PostgreSQL, SQLite, and SQL Server. If you want to support MySQL, it’s relatively easy to do because there’s already a Bicep module or a Terraform module that you can go in and use it. So I went from 45 minutes to now I can get things up and running in like, I don’t know, two minutes of effort and 15 minutes of waiting around while I make my coffee.

Along the way, we talk about some of the complexities involved with creating a template which supports multiple different frontend technologies and .NET Aspire (which was news to me when we recorded), all the while maintaining the goal of being the simplest approach for enterprise development with Clean Architecture.

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

Jamie : [0:00] So Jason, thanks for joining us on the show. It’s an incredible pleasure to have you on the show. I know we’re on literally the other side of the planet from each other. So it’s a marvel of modern technology is what I’ll say it is.

Jason : [0:14] Thanks, Jamie. It’s great to meet with you again, not in person, but over this podcast. And yes, thanks for having me on board. I’m really appreciative to come and talk to you today.

Jamie : [0:24] Hey no worries man, no worries; it’s great to have you on. For folks who are listening in, Jason and I first got connected in real life over at MVP Summit last year.

Jason : [0:36] Last year, the year before, yeah.

Jamie : [0:38] Yeah, oh my… which will be even further in the past, because this will be going out in 2025. So it’s the year before the year don’t know. I’m really confused. Time is confusing.

Jason : [0:50] We’ll take some time, we’ll take some notes. We’ll figure it out, and get back to you

Jamie : [0:55] Absolutely, absolutely. Because we’re recording this in the present, which will be the past by the time people are listening; but they’re listening in the present, which is in the future for us.

Jason : [1:03] Oh my gosh stop. I’m lost now.

Jamie : [1:08] And I’ve been doing this for seven years.

Jamie : [1:12] Jason, I wonder would you mind giving us a sort of brief introduction to yourself, maybe like an elevator pitch about some of the highlights of you and the work that you do, that kind of thing.

Jason : [1:22] Yeah, for sure.

Jason : [1:23] Okay. Well, my name is Jason Taylor. I’m from Brisbane, Australia. And I’m a Solutions Architect and software engineer. And I’ve been in the industry now for, I think, 24 years. When I first started, I was working with Classic ASP and VBScript, which was a lot of fun. Prior to that, I think I did a little bit of Visual Basic 5, and prior to that it might have been BASIC on the Commodore 64. I’ve been programming for a long time now. My focus nowadays is .NET and Azure, so I help customers to design, develop, test, and deploy custom solutions to the cloud, primarily web-based solutions.

Jason : [2:12] And, yeah, I guess I’m known for my work around Clean Architecture, the talks that I’ve done, the workshops that I’ve run, the template that I’ve built. And that’s what we’re here to talk about today. Is there anything else you want to know about my background or would like to hear more about

Jamie : [2:31] I mean that’s a really cool intro for me because, like, you said that you started, sort of, on BASIC on the Commodore 64; that’s very similar to my origin story, not on the Commodore 64, but with BASIC. So on one of those cheap home computers, yeah.

Jason : [2:48] That was so great. Do you know, I remember I used BASIC probably right up until 2007, so VB .NET at that stage. It wasn’t until around 2007 that I moved over to C#, which is a long time ago now. What’s that, 17 years?

Jamie : [3:09] t is. Time moves fast, man. Time moves fast.

Jamie : [3:14] Yes, so you’re a Solutions Architect and developer? So, like we’ll come back to the conversation about Clean Architecture because I feel like it’s related, but like I’ve never understood the direction. Like, how do you get to Solutions Architect? is it just being really good at development and just being really good at like architecting applications? This isn’t a job interview by the way.

Jason : [3:35] Oh, that’s all right. I’m glad, I’m glad. I’m not prepared, it’s too late at night. So for those listening, it’s 8.20 p.m a t night, and the kids are on school holiday so it’s been a big day for me.

Jason : [3:48] So how do you get to be a great Solutions Architect and still be a great developer? Well, I think the two are linked together. It’s hard to be a great Solutions Architect if you’re not also a great developer. I think it’s easy to, kind of, fall back onto the ivory tower mentality where you look at solution designs in a textbook and stick close to that. But unless you’ve actually cut the code, and tried the design, and seen it in the real world, I don’t think you can make great decisions as a Solutions Architect. So that’s why I like to think about myself as both a Solutions Architect and a software engineer.

Jamie : [4:30] Yeah, that makes sense, right? I like to become a… I can’t think of the best way to put it, but I’m going to say “physical architecture”, right? If I want to design a bridge or a building, I need to know enough about engineering to know that what I’m suggesting is feasible, right?

Jason : [4:47] Yeah, for sure. For sure.

Jamie : [4:49] Interesting. Okay. Well, I mean, that leads us nicely onto one of the things that you’re particularly well known for, which is the Clean Architecture GitHub repo. So I guess before we talk about the repo itself, so what is the Clean Architecture? Or is it Clean Architecture? Is it a Clean Architecture? Like, is the “the” required?

Jason : [5:11] I haven’t thought about the “the” too much in Clean Architecture. I tend to just refer to it as Clean Architecture. It’s pretty simple, really. I like to think of Clean Architecture as an approach or a pattern in which the code that you’re building is separated or organized into layers. So it’s promoting separation of concerns.

Jason : [5:39] And in addition to that, we apply the dependency inversion principle to ensure that core business logic remains independent of external dependencies, so databases and UI frameworks. And it’s that independence, it’s that kind of encapsulation of the core business logic, independent of everything external, that makes the system more maintainable, testable, and especially adaptable to future changes.

Jason : [6:10] And it’s worth remembering that Clean Architecture is really an approach for enterprise application development. It’s not an approach for a small, trivial application. It’s not an approach for a POC or something that’s thrown away. It’s for enterprise applications, something that’s going to be around for more than a few years, something that’s probably going to be around for 20 years. And so we need that independence of databases and UI frameworks, especially UI frameworks, because those things just change so much. But the core business logic doesn’t tend to. Requirements will change. New things will come along. But the core business logic can remain fairly static over the period of 20 years. That’s kind of in a nutshell what Clean Architecture is.

Jamie : [6:57] So being able to sort of, like you said, separate those concerns of, “how we are storing the information,” put that over there somewhere behind a number of interfaces, perhaps. Put perhaps the UI stuff over there behind some kind of contract or interface over there. And be able to, sort of hyper focus I guess on, “what is the business need?”

Jamie : [7:20] Like not making a shiny user interface , that is cool that is a business need. But you can get away with a not so shiny user interface and, “do we really need to use whatever kind of database technology?” Maybe we do, maybe we don’t, we can leave that decision for later. But what we need to do is really focus, hyper focus on the business logic right?

Jason : [7:43] Exactly.

Jamie : [7:44] I work really well with metaphors and analogies, right? So like, I should, if Clean Architecture was applied to say a car, I should, within certain limits, be able to lift the engine from one car and put it down in another car.

Jason : [7:58] Exactly.

Jamie : [7:58] Because the business logic is, “moving the car to and from different locations. " That’s it. Whereas the user interface, the way that the user interacts with it, the steering wheel could be on the right, it could be on the left. All of the different controls, it could be a manual transmission, automatic transmission, it doesn’t really matter. Because the engine which has the business logic of, “providing locomotion to the wheels somehow.” We’re going to be given some kind of fuel, some kind of user input, we’re going to be told which gear we’re in, and we’re just going to do something with that fuel to move some wheels to get us to move in a direction right?

Jason : [8:35] Yeah. I like your analogy, but I can’t help but think that the engine is something that we could replace; and maybe what we’re left with is just the frame of the car. And the seats can change, the engine can, change the wheels can change, the fuel tank can change; all of those things can change. But maybe somewhere in that framework is the little computer that’s running our software, even. That’s going… that’s probably going too deep now.

Jamie : [9:02] It’s the atoms and the molecules. That’s what it is.

Jason : [9:04] I think… too deep , too deep, back it up.

Jason : [9:08] Okay. When I think of that, I think about the engine, I think about, “well, yeah that’s like one of the things with Clean Architecture.” iIt’s independent of the database right? So maybe, you know, the engine is SQLServer; we’re going to switch it out and we’re going to throw PostgreSQL in there. The user doesn’t care, they can still drive the car. Maybe it costs a little bit less, maybe it costs a little bit more. I guess it It depends on how you’re hosting it. But that’s independent of UI. We can change that. It’s not too difficult, independent of the database. We can switch that. It’s fairly easy to do.

Jason : [9:41] The thing there is that we can also test everything independent of those things. We can test our core business logic without a database, without a web server, without a UI, and we can test it to a very, very deep level. You know, a lot of the time when we’re unit testing or writing any kind of tests, we’re kind of aiming for 80%, right? But when when you’re talking about your business logic, the code that you’ve written, the code that’s most important to the organization that you’re working for, really you want closer to 100. Because there’s no database code in there, there’s no UI, there’s no frameworks: it’s just business logic. And Clean Architecture kind of makes it easy to do that; which is something that I really love

Jamie : [10:27] Yeah. Because you don’t want some kind of corner case in the business logic, or your application of the business logic, that says, “on a Tuesday, don’t store whatever… don’t do this process,” because it’s some kind of bug right? You want to be able to test for all possible parts of that. Whereas, like, maybe with the UI it doesn’t really matter too much if the UI tests state that, you know, “this particular button is unreachable at this moment in time because we’re going to fix that.” But because we are taking the rules of the business and digitizing them, so that then the business can continue to run and do whatever it does, using our software. We need to make sure that that is, I hate the term but, bulletproof.

Jason : [11:20] No, I like it. I like it. That’s it for sure. And you know even those UI elements like a button not being enabled or being disabled, as you say, on a Tuesday, that can be tested inside of Core as well, inside of that business logic. Because we can return from our business logic a view model that represents the data and the state of the UI. So all we need to really do is test that view model and see: is that button disabled on the view model? Because the view model is just going to bind, sorry, that view is just going to bind to that view model.

Jason : [12:01] So if it says, you know, “dispatch disabled as a Boolean property on the view model,” the UI is fairly simple. It’s just going to bind to that. So we make a bit of an assumption. We’ll say, “well, look, if disabled is true on the view model, then it should be right on the UI.” And that’s where we can focus our tests. But it doesn’t mean we’re not going to write UI tests, we’re not going to write integration tests. It’s just really nice to know that for all of that business logic that we’ve worked so hard to build, we can test it to a very thorough level.

Jamie : [12:38] Right, yeah. Because at the end of the day, I guess, we have a finite number of engineers and a finite number of time for them to write the tests. And so you want to maybe focus their abilities and availability on the tests that are, and this is not meant to say that UI isn’t important, but like focus their time and ability on the parts of the system that are important, which we’ve already discussed is the business logic, right?

Jason : [13:10] That’s it.

Jamie : [13:11] If Amazon’s internal system allowed you to buy a book without paying for it on a particular day of the week because of a set of conditions, that would be a failure of their business logic, unless they wanted you to have the book for free.

Jason : [13:25] Yeah.

Jamie : [13:26] And so you would need to test for that rather than testing that the UI looks nice, and loads really quickly, and has all of the photographs, and has the videos and stuff.

Jason : [13:34] Exactly.

Jamie : [13:35] You need to make sure that Amazon can continue to make money.

Jason : [13:37] For sure. Yeah, that’s it. That’s it; love it

Jamie : [13:40] So the thing with Clean Architecture that you’re pretty famous for is… one of the many things is that there is this open source repo that you have, which has Clean Architecture for an ASP .NET Core application. So I wonder, can we talk about that a little bit—I mean we’ve got a link for the show notes so if folks are listening in going, “oh my goodness. this sounds amazing before they’ve even talked about it, and I want to see it,” yeah check the show notes folks.

Jason : [14:04] Wonderful. Yeah I’d love to talk about it.

Jason : [14:07] So I first discovered Clean Architecture probably about seven years ago, and I was sitting at home; just, it was a quiet Sunday afternoon I remember this, and I was reading a book looking for a little bit of inspiration. And I’ll try to provide you with a link to the book. I’ll have to dig it up. But anyway, I came across a section on Clean Architecture, and it was just a small part of this book. It wasn’t the main focus, but something about it kind of caught my attention. It sounded like the solution I’d been looking for without even knowing it.

Jason : [14:44] And so like most of us do, when something clicks, I just started researching it more deeply, looking for everything that I could find about the topic. And at the time I’d also been working on a new project, it was Northwind Traders. And Northwind Traders, of course there’s nothing new but I wanted to build it for ASP .NET Core and EF Core, because .NET Core was new and I wanted something to play around with. So I built this solution for the sole purpose of playing around and trying new things with .NET. So I just learned about Clean Architecture, so naturally I decided to update Northwind Traders to follow this Clean Architecture process. Man, the process couldn’t have been easier. The architecture just, it just made so much sense. That was, yeah, as I said, that was seven years ago. And I’ve been using Clean Architecture ever since.

Jason : [15:32] But probably two years after that, I had a bit of a problem. I was using it all the time. I worked at a consultancy. So in the consultancy, I got to go “file new project” a lot, which is exciting, right? Green field projects. But the thing was that even though Clean Architecture was really nice for structuring solutions, creating a new project or a whole set of new projects and all of the test projects, all of the boilerplate code that I needed, was just really time consuming. It was painful. So that was when I decided to create the Clean Architecture solution template. So that was in October of 2019, so about five years ago now.

Jason : [16:19] And simply put, the Clean Architecture Solution template provides the simplest approach to enterprise application development with ASP.NET Core and Clean Architecture. It’s a .NET project template, so it’s deployed to NuGet, and you can create a new solution from the command line using dotnet new or Visual Studio 2022, too.

Jason : [16:45] Well should I pause there? I should give you a second I’ve been talking a long time

Jamie : [16:51] No, no. That’s fine that’s fine. One of the many things I like about the .NET new templating engine—dotnet new3—is that once you’ve installed the templates Visual Studio, Rider, Visual Studio Code with the C# DevKit extension, they can all see those templates.

Jason : [17:07] I love that.

Jamie : [17:08] And like you said, you can do it from the command line right? It doesn’t matter what tool you use, you can just go “file new” and there’s your project templates.

Jason : [17:15] That’s so cool. Do you know, I didn’t realize that it was supported in Rider as well, because I don’t use Rider. I know it’s a great product, will use it at some point. But I didn’t know that thank you for sharing.

Jamie : [17:25] No worries, no worries. Yeah it’s all three.

Jamie : [17:30] Well, okay so let me just backtrack a second: Visual Studio Code by itself won’t see it unless you do dotnet new in the command line. But if you use the C# DevKit extension extension, which requires a Visual Studio license—and there’s a whole thing about that. There’s a whole… I’ve talked to Leslie on the team about that for the show. So there’s an episode about that, about how you get access to that. But like, if it is relevant to the way that you work, you can use the sort of free license, the community license to get access to that. Some people like that, some people don’t, but if you have that, you can then do the equivalent of “file new project” and it will display all of your templates.

Jamie : [18:10] You can, do like you, said inside of Visual Studio “file new project” and it will display all your templates with the little… and the best bit is the little icons. I love that, when you’ve got an icon for your project, it just shows up; it’s so cool. And yeah the same thing with Rider because they’re all… my understanding is that, behind the scenes it does the dotnet new CLI command and just reads the metadata from the json templates and stuff. Which is really cool.

Jason : [18:38] Well I didn’t realize that the C# extension supported it as well. So I’m learning all sorts of things tonight. So that’s great. I do have a nice icon so you’ll you’ll see that come up if you check it out in Visual Studio, or Rider, or maybe VS Code

Jamie : [18:52] Well, maybe that’s it. Maybe everyone needs to install the template and tweet at me, or x at me, or however you say it now, whatever the verb is, a screenshot of you doing “file new project” so we can see what it looks like in all the different all the different IDEs. So go ahead and do that folks.

Jason : [19:07] That would be cool, I would love to see it.

Jamie : [19:10] And there’s also obviously dotnet scaffold as well so I’d be interested if you’ve—this is me dropping this on you right now so I don’t know if you’ve ever actually tried this.

Jason : [19:18] I haven’t. It’s on my list. I got the email in my box the other day and I’m like, “that sounds interesting.” I’m in the middle of preparing for a talk so I had to just add it to my list. So I haven’t read the post yet. Have you read it?

Jamie : [19:31] I have. It looks really cool, like an interactive version of the dotnet new command line which is really cool.

Jason : [19:37] That sounds really nice. I’m going to jump on that pretty quickly I think.

Jamie : [19:41] Well you heard it here folks. Not necessarily first, but you heard it here.

Jason : [19:47] All right. So yeah, it’s a .NET project template.

Jamie : [19:51] So then you said—when we were discussing what Clean Architecture was—you were saying that, because you can sort of separate out those concerns to do with database technologies, UI, and all the other different technologies that you may be using for your application; does that mean, andI’ve seen the template folks so I know the answer to this one but I’m getting the answer for you all. Does that mean that your Clean Architecture template has no UI, or that it just uses a rendered HTML, or like how does that work then?

Jason : [20:23] It has a UI. So the idea behind the template is to try and provide something that can help people get up and running quickly. And so I provide three different options at the moment. I provide an Angular frontend with a Web API backend, a React frontend with a Web API backend, or just Web API by itself. In the future, I’d like to add a Vue, and I’d also like to add Blazor Web Assembly. So there’ll be five different options, aside from Web API by itself, that you’ll see in the template

Jason : [21:00] And with each of those options, there’s a really nice OpenAPI integration, which is really one of the primary reasons that I like to include a front end; because, for me, having OpenAPI integration kind of between say Angular and the web API means that I’m not just generating an OpenAPI spec, I’m also generating a TypeScript client for your Angular or React front-end that has all of the DTOs that are defined on the back end.

Jason : [21:32] And it also has some really nice clients for interacting with the web API. So you don’t have to write all of this code by hand. It’s generated for you. And when your web API, when you change that on the back end, when you introduce a new endpoint, it auto-generates for you. And that just comes with so many benefits. So it’s a really nice feature.

Jason : [21:56] But yes, to answer your question, I do have a UI. Angular, React. Vue’s coming , Blazor Web Assembly’s coming. All with an ASP .NET Core Web API in the back end using minimal api.

Jamie : [22:07] Potentially silly question: does that mean that I need to have node installed and set up on my computer? Because I know that Angular and React and Vue all make use of node, right?

Jason : [22:17] Yeah. At this stage you d, at this stage you do. But I’ll look at that a little bit in the future .

Jason : [22:23] Obviously one solution is devcontainers. I’ve got a basic implementation for you there, but I’ve also got to dive in a little bit deeper and have a look at what .NET Aspire is doing with that regard. Because I think a lot of that integration could be sorted out just with .NET Aspire. But, yes, at this stage, if you’re using Angular [or] React you’ll need node installed; but if you’re going with a web api only solution then no you won’t need it.

Jamie : [22:50] You just dropped that on me there. I didn’t even realize that .NET Aspire was on the potential agenda. That is really cool.

Jason : [22:58] Sorry. It’s a recent introduction, actually. I added it to the template last week. Yes. So last week, I added support for .NET Aspire. It’s just an option. If you’re using the IDE, you check a box. If you’re on the command line, you just g o—use-aspire and it’ll be included in your project. And it currently supports two integrations. You can use Postgres or SQL Server, and it will spin up those containers for you and have it all ready to go. So that’s another dependency, of course. You need Docker if you’re going to use certain configurations of Aspire and Postgres and SQL Server. It depends.

Jamie : [23:47] I like how coolly you drop that. there, it’s like, “yeah, it sort of supports .NET Aspire, which it requires a fair amount of setup to do that. So I’ve done it. It’s fine. It’s not a problem.”

Jason : [23:58] Man, it… you’ve got to think it does require a fair amount of setup, maybe not for a simple project, for a simple projects is okay. But for a complex project, yeah. Jumping through hoops for a template that produces more than 12 different combinations of projects. It was significant effort. Yeah.

Jason : [24:19] But that’s the thing with my template, right? It’s the simplest approach to enterprise application development with ASP.NET Core and Clean Architecture. Once you go dotnet new, once you go “file new project,” the template itself, it’s getting a little bit complex. It’s not hard to maintain because I have some really good tests sitting behind it. But yeah, there is complexity in building the template and producing that simplest approach.

Jamie : [24:42] That’s now got me thinking there should be some questions about how in the heck you manage all of that. So maybe we’ll come back to that in a moment.

Jason : [24:49] Yeah, for sure.

Jamie : [24:50] I just want to say that I really like the idea, because like the OpenAPI stuff and typescript, like generating that contract ahead of time, and you said like, “every time that I make a change to maybe one of my DTOs or view models, when I hit build it will rebuild those for me,” as well. So then my UI, and or my UI engineer perhaps has all of that detail up to date every time that I, maybe commit, maybe I’m just doing a build, I don’t know; but like every time I do that it’s automatically done for me. I really like that.

Jason : [25:25] That’s it.

Jamie : [25:26] I just want to say real quick,: and this is available for free folks.

Jason : [25:29] That’s it.

Jason : [25:30] Yeah it’s for free. That’s it. It’s a work of love and’m always excited when I can use it in my own projects. But I’m very excited when people all around the world are using it for their projects, and telling me how they found value. Because then I think I’m making a difference more than in just my small little space.

Jamie : [25:50] So, then, how do you manage all of that complexity? So, like, are there specific challenges involved with supporting Angular and React, and perhaps Blazor in the future? And perhaps Vue in the future, and all that kind of stuff? Because I can imagine like, they all have their own release cadences or cadence-i? I don’t know how you say it. But like they all have their own release cadences, and so like when a new version of Angular comes out are you just going, “hey, you know, I’m going to release an update and you can get the latest version”? Or are you happy to sort of sit with a specific version for a while? Or is it like it’s up to the implementer once you’ve done dotnet new that’s on you to keep everything up to date?

Jason : [26:32] Well, that’s the thing with the templates actually. We’ve got a few questions to address there.

Jason : [26:37] So with the template, I’m driven by the .NET release cycle and so a lot of my motivation comes around .NET Conf time. When they’re going to release, say, .NET Nine, I’ll start working on the template prior to that. So you’ll see a new a new branch appear, and maybe it’s, you know, “dotnet-nine-preview-six” or something like that, and that’s when I attempt to start bringing the latest version of .NET in. And I try to release that new version as close to .NET Conf as possible, so that people who are excited, who want to start working with the latest version can do so with the templates.

Jason : [27:17] I don’t have that motivation for my front-end frameworks for Angular and React. So a lot of the time, that’ll be driven by the community. So it might be someone raising an issue and saying, “hey, Angular’s getting a bit old. Do you think we can upgrade to Angular 18?” Or even better, there might be a pull request that I can quickly review and get that upgraded.

Jason : [27:40] So .NET is my driving force, and I take care of that every year. But for the front ends, it’s the community who tends to drive that.

Jamie : [27:49] That makes a lot of sense, right? Because you’re just one person a nd you don’t have infinite amount of time. You mentioned earlier on that you’ve got little ones. We all have our own responsibilities during the day. You can’t actually be at the beck and call of, “quick, update this thing!” and , “update that thing. This new package has come out, " right?

Jason : [28:08] That’s right.

Jamie : [28:09] Obviously, the joke is that in the Node world, there’s a new version of something every couple of seconds. Which is… there’s an element of truth there.

Jason : [28:18] That’s one of the the reasons that makes Clean Architecture so powerful: having that independence of the UI means that we’re able to, kind of, operate in a world where a web framework is created every minute.

Jamie : [28:31] Interesting. And then I suppose a side question before you get to the others: let’s say JamieUI comes out. If I take the Clean Architecture template that you’ve got, create a new application with it—so I create an instance of the Clean Architecture using that template—and then I want to implement JamieUI, it’s just a case of making a few relatively small changes and ta-da there’s my UI right?

Jason : [28:59] Maybe. It depends on the UI.

Jason : [29:01] And this is something that I was thinking about probably an hour ago, because I’ve built a Clean Architecture template for Blazor in the past. It’s called RapidBlazor. I have been thinking about what to do with RapidBlazor. Should I upgrade it to .NET 9? It’s getting a bit out of date. Should I bring a Blazor front end to the main Clean Architecture template? And what do we do about all the different hosting models for Blazor? We’ve got server-side, we’ve got WebAssembly, we’ve got… What is the other one? The Unified? No, not Unified. I forget now. There’s some other model of Blazor which I can’t quite recall at this stage.

Jason : [29:43] Now, with Blazor WebAssembly, it’s relatively simple for me to bring that into the Clean Architecture template, because it’s going to be a Blazor frontend communicating with an ASP .NET Core backend, right? Which is exactly what Angular, React, and Vue would do. But for Blazor server, well, it doesn’t actually require an API, because it’s happening on the server-side.

Jason : [30:08] So if JamieUI is like Blazor server, that’s a bit trickier. And it’s not a bit trickier because it’s difficult to do a Clean Architecture. No, you could easily bring JamieUI in. It’s tricky because I would have to introduce new data structures into the template to support that different style of UI, which would then move the template away from being the simplest approach. It would have some complexity built in there because it needs to support Angular, it needs to support Vue, it needs to support React, and it needs to support Blazor server. So for you, you can easily create a new solution with JamieUI. For me, in the template, it can be a little bit trickier: I’ve got a little bit more to think about There’s always a solution, but it might cost a lot of complexity.

Jason : [31:02] Sure. Perhaps I should have been a little clearer with my question. Let’s say that JamieUI is a node-based UI JavaScript-y front-end-y thing, and it behaves similarly to Angular and React and most of the others. It has similar sort of APIs and stuff like that. Then adding that in should, from my perspective as a dev who’s using the template, I should just be able to go, “hey, you know, npm add package… So when I said “small” I meant, sort of, like in comparison to the size of the the template right. I should be able to make some small, in comparison to the size of the template, changes to be able to implement my new UI and it just sort of works.

Jason : [31:46] That’s it yeah, for sure, for sure. And it depends on also the capabilities is your UI. So you might need to think about how your UI is going to spin up in the local development environment, how it’s going to proxy a request back to the API, because the hosting model that we have in development, of course, is completely different to what we have in production. So we have a few moving parts that we set up just to make sure that our development time experience is nice. And you’ll also want to update the OpenAPI integration, just change the configuration slightly so that you can generate a a nice client for JamieUI using using any number of methods.

Jamie : [32:28] And that makes sense right. It’s because we’ve separated that concern, let’s put Blazor to one side for a moment because of the different hosting models and the complexity. Because you’ve separated that concern, that makes that way easier to do. It’s not like, “oh no. We have to rearchitect the entire app because the UI and the api are so tightly connected,” because I’ve worked on—I’m sure we’ve all worked on—projects where a decision has been made that the UI and the api are so tightly interconnected that if you take one away the other doesn’t work.

Jason : [33:02] Yeah, for sure. Sometimes there’s a decision made to do exactly that, to have that very specific backend-for-front end, but in this case I’ve tried to be a little bit more generic.

Jamie : [33:12] Sure. Just real quick, from my perspective, there’s nothing wrong with having a specific backend-for-frontend, because you may never change that front-end, right? We talk a lot about, in the software engineering space about, “but what if you want to change the technology you’ve used?”

Jamie : [33:30] But also what if you never change the technology that you’ve used, right? What if you settle on Angular right? I’m just literally picking one out of the air, I have no preference for Angular, React, or Vue. But let’s say you pick Angular, and you settle on that then, you know, having a specific backend for that frontend is totally fine; because you’ve taken the dependency on, “we will never change from Angular,” and that is cool, That works right.

Jason : [33:58] Exactly.

Jamie : [33:58] I often find that some projects go 100% the other way, and they’re like, “well we need to build interfaces for the interfaces, and separate everything out, even though we’re never going to change it. But what if, in the future, in five years time, we decide to change it?” And I’m like, “well that’s cool, but can you see a need to change it?” right. And if you don’t see that need to change it, don’t put that complexity in there.

Jason : [34:20] Yeah. And can you afford to build that system? And can you afford to maintain that system? And will the people who come after you understand why you’ve done what you’ve done and why you made those decisions ? Nothing’s free. All of these things that we build into our solutions, even with Clean Architecture independent of UI, database frameworks that takes time and effort to build that in. And so, yeah, if you don’t need that flexibility then maybe Clean Architecture is not the right choice.

Jamie : [34:50] It’s a very interesting point: we’ve just said, “hey, maybe you shouldn’t…” No, I think everyone should check out your Clean Architecture repo for sure.

Jason : [34:58] Yeah.

Jamie : [34:58] But then I think the importance is in being pragmatic right, and actually saying, “actually does this thing that I’m looking at help me to solve the problem?” Like you said, does it add the relevant amount of complexity, you know? Because, like you said, not nothing is free.

Jason : [35:15] That’s it, yeah. It’s t he same thing with design patterns.

Jason : [35:18] Design patterns are there to solve a problem, if you don’t have that problem and you apply the design pattern, all you’ve added is unnecessary complexity. It’s the same thing with Clean Architecture. If you don’t need to be independent of the database frameworks, UI, if you have an application that’s only going to be around for a few years and doesn’t require that level of flexibility, then you might have added complexity to your solution unnecessarily. But we build enterprise applications, and so that’s why this is the typical approach for me. Those applications, whether or not they say it’s just a proof of concept, it’s just a temporary thing, they’re going into production and they’re still going to be there in 20 years time; and you’ll have to support them. There’s been too many proof of concepts that have gone into production. I know better now.

Jamie : [36:12] Yeah, I think we all have. I have a story from my past where I built an MVP that had no functionality whatsoever, it was a windows forms MVP, just showing off what I thought the UI could look like. And I showed it to the boss, and three days later he’d sold it to someone, and I’m like, “it doesn’t do anything boss. It’s just the UI.”

Jason : [36:35] Wonderful.

Jamie : [36:38] Yeah. Lesson learned. So we’ve talked a little bit about the front end stuff; I know that there was lots of dangling questions that I had. I don’t know if you want to cover some of those or whether you’re happy to to move… I know that there’ll be people listening going, “wait. You asked a bunch of questions there Jamie, and I’m hooked. And I can’t remember what you asked.”

Jason : [36:57] Oh my gosh. We might have to have a conversation after the podcast then; maybe we’ll be active in the comments section and provide a little bit of feedback that way.

Jamie : [37:08] Totally.

Jamie : [37:10] Yeah, yeah; we can do that.

Jamie : [37:11] So let’s talk about CI/CD then. Because that’s a big thing for pretty much enterprise full stop. So here’s the thing, right, there are a few things that I, even when I’m working on a personal project, I will not work on it without git or some kind of source control, and some kind of CI/CD pipeline. I’ll maybe do a dotnet new and get a template or I’ll do like the bare bones of functionality if I’m splitting it into a UI and an API, right. I’ll spin up an API that just returns, “hello,” and a UI that reads the hello, right. And then I’m like, “right, cool. Commit that to source control, build a pipeline because then that’s done.”

Jason : [37:51] Yeah.

Jamie : [37:52] So CI/CD and all that kind of stuff super important. So does your Clean Architecture repo support that stuff? Is that baked in? Or because it’s on GitHub am I going, “right, I need to create a GitHub folder and create some workflows and stuff”? Like how does all that work.

Jason : [38:07] It’s baked in yeah. It’s actually been a really big focus for me, over the past couple of years. So I’ve been focused on the code to cloud journey, I like to call it, for the template. And two years ago, my goal was to provide a solution that could take you from code to cloud in 45 minutes or less. So I wanted it to be “file new project” to deploy a solution on Azure—because that’s where my main focus is—within 45 minutes.

Jason : [38:38] And so I actually upgraded the template and there’s a bunch of scripts in there, there’s pipelines, there’s code, there’s infrastructure as code with Bicep. And I did it. It was like 20 minutes from new project to production, you know. When just waiting around for infrastructure to be provisioned and projects to be deployed.

Jason : [38:59] But I had a bit of a problem because it wasn’t the simplest approach. It was going to be difficult to be for me to maintain, because I built all this stuff from scratch and so anything that was wrong with the script that, you know, potentially removed resources that it shouldn’t have, that was a bit of a problem for me. So it wasn’t a simple solution. So at that stage I started looking around and fortunately for me a team at Microsoft was already working on the Azure Developer CLI, or azd for short.

Jason : [39:32] So I started working with that, and I really was blown away by how well it aligned for that vision that I had for simplifying the code to cloud journey. So this is a tool that integrates with us as developers, our developer workflow, and so right from project scaffolding through the infrastructure setup, through the deployment, all with a few commands. And these commands you can run them from the command line or you can run them through a VS Code extension if you like, and so the Clean Architecture solution template is azd compatible now.

Jason : [40:11] And what that means is, is that it comes with a set of CI/CD pipelines. Both GitHub Actions and Azure pipelines. It comes with a set of infrastructure as code. At the moment, it’s supporting just Bicep, but I’d like to add Terraform soon. And it also comes with not just the bare bones, minimal infrastructure as code. It also comes with a bunch of extra modules. And these modules actually come from the Microsoft team at AZD. They built this whole Bicep starter kit and this Terraform starter kit. So if you want to go in there, right now the template supports PostgreSQL, SQLite, and SQL Server. If you want to support MySQL, it’s relatively easy to do because there’s already a Bicep module or a Terraform module that you can go in and use it. So I went from 45 minutes to now I can get things up and running in like, I don’t know, two minutes of effort and 15 minutes of waiting around while I make my coffee.

Jamie : [41:17] Wow.

Jason : [41:19] It’s cool. Really, really good stuff.

Jamie : [41:22] Yeah, that is genuinely amazing.

Jason : [41:24] And you know what you said? You said, “you know, I don’t start coding until I have a local Git repository, maybe have something on GitHub, a CI/CD pipeline.”

Jason : [41:36] You want to get it deployed to Azure? I could do all of that in two commands. So if I run dotnet new ca-solution, that’ll create my Clean Architecture solution. And then I run azd pipeline config, and that’s going to do everything else. So it will go and create a local Git repository. It will note that we don’t have a remote configured. It will ask us if we’d like to put one on GitHub.

Jason : [42:06] It’s got the GitHub CLI kind of installed as a dependency of azd. So it’ll go, “yeah, sure, we’ll create that for you. What do you want to call it?” We’ll call it modern .NET. So you press enter. Then it says, “okay, well, what’s the first environment going to be called? " We’ll say, “oh, it’s modern.net.dev. " This is just all through the command line. And so it’ll go off and create that. But then it’ll go and create the repository on GitHub. And then it’ll go over to Azure, and it’ll create a service principle with federated credentials so that GitHub Actions can now communicate securely with Azure to provision your infrastructure and then eventually to deploy your solution. And it’s also going to add a bunch of GitHub actions variables so that the pipeline can run and know about the environment and the resource group and all of those sort of things.

Jason : [42:56] So, yeah, it’s really like two commands in two minutes and no shortcuts, yeah? Proper CI/CD pipeline, proper infrastructure, just ready to go. Focus on business value right not the boring stuff.

Jamie : [43:11] And I’ll repeat again, this is entirely free.

Jason : [43:16] Yes.

Jamie : [43:17] Being able to issue two commands and just let it do its thing, and have everything set up in a number of minutes is… wow that is the dream.

Jason : [43:28] That is the dream.

Jamie : [43:30] Yeah. That, like, even… so I use Obsidian to make loads of notes about stuff. I do not use Obsidian without git because I know that I can undo things and get the information back, or I can have a log of what I’ve worked on. So even in my plain text life, working on notes for things I use git.

Jason : [43:50] I love that, for sure.

Jamie : [43:52] So, like, being able to just go, “here’s two commands,” perhaps even with a double ampersand—if you’re on a Unix-like, or a semi-colon, if you’re on a Windows-like—run them both in one step and just, watch them go. That is just wow.

Jason : [44:09] That’s it. And it is the dream, right? That was my dream. I wanted to be able to start work on a new client site. And if we’re able to hit the ground running, then I want to take the first 15 minutes to get something deployed before the first planning meeting so that we’ve got something that we can see. I can go grab a coffee and we can sit down and think about, “well, what’s the first feature we can build? We’ve got the basics done. Good teams take a couple of weeks to do this; we’ve done it in two minutes. What feature can we build?”

Jamie : [44:39] Yeah. Because then it’s no longer theoretical. It’s like… because a lot of software development is very woolly, it’s very theoretical, you can’t see it and you can’t touch it until you have a user interface. And so if you’re spending a couple of weeks setting everything up, getting CI/CD pipelines, making sure that there is some kind of UI; that’s maybe, if you do sprints, that’s maybe two sprints worth of work that you can’t present to the customer, the client, the whomever, and say, “hey, here is the thing that you can interact with. “Whereas, like you said, if you can go into that first meeting with them and say, “okay, cool, this is not what it’s going to look like, but this is just a starting place. But this whole thing works.”

Jason : [45:22] Yeah, that’s it. It’s ready to go.

Jamie : [45:26] So is that the end goal of the template then? You’ve used a couple of phrases like “code to cloud in two minutes,” is that the… well two minutes plus or minus 15 for Azure to do its thing but, like, “code to cloud in two minutes of user effort.” Is that the end goal?

Jason : [45:44] Hmm. It’s a good point. Well there’s more to the template than that; so once you’ve got that up and running we have a bunch of tests that are built in to help you with how you’re going to structure and test your logic. And we also have a couple of item templates that are built in as well, just to help you create your, or at least structure your application logic. So I’ll be interested to see if people are using the item templates and how they might think they could be changed, or if things could be added to them in the future. So no, the goal is to get up and running quickly and then yeah, kind of set you on your way so that you can start delivering business value.

Jamie : [46:28] Yeah. The faster we can get to delivering business value, the better it is right. Because you’ve said it a bunch of times, the user of the application, the consumer, the client, whoever’s paying you to build it, they probably don’t care about, “are we using React? We’re using Postgres. We’re using X, Y.” They don’t care about that. They care that when a user pushes the button, they somehow get money. That’s all they care about, right?

Jason : [46:52] Yeah, and they’ve hired us as specialists. And as specialists, we have specific technologies that we focus on. And that’s why my template has specific technologies. These are the ones that I’m good at, that I can use. And I can add others, but they will be within my specialization. Or they will be so simple to add that it just makes sense that, yes of course we should add that support for the community because they’ll get so much value and it doesn’t greatly increase the complexity of the template.

Jason : [47:25] I think people should think about kind of this template and maybe if it’s not aligned with their specialization then they could consider creating their own template. I think everyone should have a goal to go from new project to the cloud or to a deployed system within 45 minutes. You can do it in less, that’s great, but within your specialization, within the technologies that you have great experience with so that you can focus on the fun stuff as well, not the boring stuff.

Jamie : [47:55] So maybe that should be a long form code kata, right? I know a lot of people like to do practising like as if they are a martial artist, right? The kata is like a repeatable exercise to build up muscle memory, and make you faster, and make you better at certain things. So maybe one of the code katas could be, “I’ve got no project, I do the equivalent of file new, and then I get to deployment as fast as possible.” If that’s deployed to the cloud, if that’s a binary somehow. Maybe not fast as possible, but like in a speedy manner, like you said, so that then you can then abstract that stuff away and get to the good fun stuff.

Jason : [48:34] What a great exercise. That is really cool. And you can tackle that from whatever level you’re at. I mean, yeah, you might be a white belt, you might be let’s say you’re x-copy deploying: well that’s fine you can improve on that, you can build up through the levels and keep running that kata until you are a black belt. Until you can do it in two minutes to a level that aligns with your specialization. That’s really cool.

Jamie : [49:02] Yeah, because like there’s nothing wrong with… okay so how do I put this, when I’ve talked to people who are excited about technology in the past who want to learn development there’s lots of different types of people; and as soon as you start saying they’re different types of people you’re dealing with absolutes, which only the Sith deal with absolutes.

Jamie : [49:21] But when you get to that point, I’ve seen a small group of people who are like, maybe they’re taking a course right, and the course requires them to use Windows and they’re like, “I’m not going to do that! I’m going to use Linux, and I’m going to use docker, and I’m going to…” and they reel off a huge list of technologies. And I’m like, “that is awesome. But how about you start with the stuff that the course tutor wants you to use first, and then slowly start replacing those things when you get a better understanding, right?”

Jason : [49:49] Makes sense.

Jamie : [49:50] Because like you said, right, if you’re doing x-copy to deploy or right-click publish to deploy, that’s cool. That takes care of all of that complexity for now. You can focus on the other steps required to get you to right-click deploy.

Jason : [50:02] Yes.

Jamie : [50:03] Then when you’re happy with those steps, you can go, “right, how do I change that x-copy deploy or right-click deploy to be something scriptable? "

Jason : [50:10] Yeah.

Jamie : [50:10] “What does that look like? I can learn that separately, at a time when that makes sense for me to take that in”. Because the last thing anyone wants when they’re learning and developing, or trying to build out their understanding of something is to learn too much at once. Because if everything’s moving and something breaks, you don’t know what’s moving that’s broken it, right? And then getting someone’s help when there are so many moving parts becomes super difficult, because then they’ve got to understand what you’re trying to do.

Jamie : [50:38] So I like your idea of focus on, maybe build the app first and use right-click publish for now. And then when you’re ready, move on to that. And then you can step up through the different coloured belts or through the different levels. I really like that idea.

Jason : [50:53] Me too. It almost seems like a program that developers could follow throughout their entire career.

Jamie : [50:59] Absolutely.

Jamie : [51:00] Okay. So how about this? “Hey, you’re a .NET dev who uses React and Angular and Postgres and SQL Server, but you want to learn Rust. Well, okay, yeah you may want to skip over ‘hello world’, but let’s figure out what a Rust application looks like. And we’ll use some kind of automatic deploy thing that’s not a problem, because you don’t need to worry about the intricacy of deploying Rust. But let’s build it first. Hey, now that you’ve built it, now we’ll learn how to deploy it.”

Jason : [51:26] That’s such a brilliant idea I love the kata element of it because you’re also going to be thinking, “when I create this project, what’s the quickest way for me to initialize a local Git repository? What’s the quickest way for me to put it in Azure DevOps or in GitHub Actions?” And these are all small improvements that you can make. And those are all those tiny little things along the way, whether it’s creating the repo or pushing changes or provisioning infrastructure or packaging an application, deploying an application. These are all things that you’ll need to consider if you want to go from code to cloud in two minutes plus processing time as we mentioned before.

Jason : [52:04] I like it. Maybe you could use it as like a course that you can do, maybe one of the NDCs or something.

Jason : [52:10] Yeah, that would be a good idea. I’ve thought about that, I’ve thought about that. I think it would be fun. I think there’s so much value in building these templates and thinking about all these little million parts. That should be a skill that that we can learn and build upon. We shouldn’t have to hunt all around the net to find all these disparate pieces of information, so that we can have this skill. It’d be good if someone did a of course, maybe me.

Jamie : [52:33] I agree with you. Even just from an organizational point of view, having a, “this is how we build applications template,” as a starter place, right? Just do file new, cool. This is my Acme default template. Cool. That’s taking care of all of that stuff for me. Like you said, I’ve hit the ground running. I’m building it now.

Jason : [52:54] Yeah, that’s it. Love it.

Jamie : [52:56] And then you use your lunch and learns or whatever to teach people how to build those because you’ve built it internally. And then you’re always passing on that new knowledge to people as they come into the company and come into the team. And then you’re spreading that knowledge far and wide.

Jason : [53:11] I love it. Wonderful. Wonderful.

Jamie : [53:14] So we’ve been chatting about the Clean Architecture repository and the template and how it can help folks. I think this was something you’d said when we were coming up with our notes our plan for the conversation was that: being an accelerator or a magical force multiplier is what these kinds of things do. And I think you’re absolutely right. Being able to just code to cloud in two minutes plus processing time is just… and that processing time will eventually get shorter , but without any input from us, from you, from me, from a user of the template at all, because the cloud stuff will get faster. So like without even putting any effort into that part of it, that will eventually get faster. There is no reason not to try this out.

Jason : [54:02] That’s ut, that’s it. Yeah. Once we’ve run those couple of commands, we walk away, we’re already making a coffee; azure or aws will do all the hard work, we’ll get our coffee ready, and sit back down to a deployed solution.

Jamie : [54:17] I love it. And I think that even if you’re not interested in Clean Architecture, you should check out the repo. There will be a link in the show notes, check out the repo, cause then you can understand how it’s put together. And maybe, like Jason and I have alluded to, you can use that as a learning step. Start that journey of like, “how do I do this with node?” Or maybe I’m a Python developer, or maybe I use Go, like, “how do I get to the Clean Architecture repo that Jason has put together, but with Go?” Or with Rust, or with some other… or even I’m going to do it with ASP .NET Core as well, but I’m just going to recreate it in my own way. Like, I feel like reading through it will help you to figure that out for yourself.

Jason : [54:57] Yeah. That’s it, that’s it. And reach out to me if you if you get stuck, I have a little bit of experience now building .NET project templates, so I’m happy to point you in the right direction.

Jamie : [55:06] Amazing. Well, Jason, it’s been fantastic talking with you today. I wish we could talk about this loads more, but it is now super late your time and super early my time. And none of that matters because people are listening to this in the future, which will be the present for them. And they’re listening to us in the past, which is the present for us. And time just doesn’t make sense any more. But I really appreciate you being on the show.

Jason : [55:31] Thanks Jamie. It’s been wonderful. I’ve learned some things myself. I’m excited to try out some new things. And yeah I appreciate you having me and I enjoyed the conversation.

Jamie : [55:40] So one last thing: if folks are interested in getting in touch, you know, you said earlier on, “get in touch if you get stuck, I might be able to help out.” Is that a LinkedIn thing? Is that an X thing? Is that a Bluesky thing? Like, how do folks reach out and say, “hey Jason, I’ve tried to do this thing. I’m a little bit stuck. Can I get five minutes of your time?”

Jason : [55:58] Yeah. Just head on over to connect.jasontaylor.dev. I’ve got a little bit of a link tree there, and you can connect me any way you like. Whether it’s LinkedIn, or X, or whatever new social media platform I add to it in the future. So yeah, connect.jasontaylor.dev.

Jamie : [56:15] Nice, I’ll get a link to that, put that in the show notes. I’ve collected a whole bunch of links whilst we’ve been talking anyway, put those in the show notes as well.

Jamie : [56:22] Awesome. Thank you ever so much, Jason. I really appreciate it.

Jason : [56:25] Thanks 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.

Useful Links

• Jason’s Clean Architecture repo on GitHub
• Jason’s Northwind Traders with Clean Architecture repo on Github
• C# DevKit for Visual Studio Code
• Code, Coffee, and Clever Debugging: Leslie Richardson’s Microsoft Journey and the C# Dev Kit in Visual Studio Code with Leslie Richardson
• dotnet scaffold
• devcontainers
• .NET Aspire
• Jason’s RapidBlazor repo on GitHub
• Azure Developer CLI
• GitHub CLI
• Obsidian
• Connect with Jason
• Supporting the show:
  • Leave a rating or review
  • Buy the show a coffee
  • Become a patron
• Getting in touch:
  • via the contact page
  • joining the Discord
• Music created by Mono Memory Music, licensed to RJJ Software for use in The Modern .NET Show