Hosts

Caleb Wells

Shawn Clabough

Wai Liu

Charles Max Wood

Wade Gausden

Joel Schaubert

Share

Episodes

Mar 21, 2023

Monolithic Software with Erik Engheim - .NET 140

Erik Engheim is an Author, Educator, Speaker, and Software Developer. He joins the show alongside Shawn to talk about " The Rise of Monolithic Software". He starts off as he talks about his past experiences as a developer and the path that brought him to this point in time. Moreover, he shares his perspective on Monolithic Software and what it is all about.

Hosts:
Shawn Clabough

Guests:
Erik Engheim
Jan 18, 2023

Liquid Templates With Martin Tirion - .NET 139

Sometimes you need something text-based (a template) that you can combine with data to provide some output. Martin Tirion is a Senior Software Engineer at Microsoft. He joins the show to discuss using Liquid to combine a text-based template with data.

Nov 24, 2022

How To Recession Proof Your Job - BONUS

Are you looking at all the layoffs and uncertainty going on and wondering if your company is the next to cut back? Or, maybe you're a freelancer or entrepreneur who is trying to figure out how to deliver more value to gain or retain customers? Mani Vaya joins Charles Max Wood to discuss the one thing that both of them use to more than double their productivity on a daily basis. Mani has read 1,000's of productivity books over the last several years and has formulated a methodology for getting more done, but found that he lacked the discipline to follow through on his plans. The he found the one thing that kept him on track and made him so productive that he is now getting all of his work done and was able to live the life he wants. Chuck also weighs in on how Mani's technique has worked for him and allows him to spend more time with his wife and kids, run a podcast network, and a nearly full time contract. Join the episode to learn how Chuck and Mani get into a regular flow state with their work and consistently deliver at work.


Guests:
Mani Vaya
Nov 15, 2022

BFF and Minimals APIs get Darker - .NET 138

In this episode we dig into a few technologies that can be used together to great effect. We have discussed Backend for Frontend (BFF) before but in this episode the focus is a bit different.

Nov 08, 2022

Tools To Get Rid Of Your Code Smells - .NET 137

Diyaz Yakubov comes on the show this week to talk about a few tools he's using to make his life easier at work. We talk about NDepend - a code analyser that you can use on your IDE or CI/CD pipeline to give you recommendations on your code structure and then we move onto C4Model - a new graphical notation language and SharpLab - a neat little online code playground that can convert your code to IL or ASM.

Oct 11, 2022

Participating in the .NET Community - .NET 136

Jakub Chodounsky from the C# Digest newsletter joins us this week. We talk about why he started the mailing list and how he's managed to build up a subscriber base of over 24k. We shared why he keeps it going and the benefits he's gotten from engaging with the .NET community even though as a CTO, he may not be actively cutting code anymore. We also go into some of these recent blog articles and talk about some open-source projects that he thinks is fairly neat.

Oct 04, 2022

Cross-Platform .NET - .NET 135

.NET has been cross-platform for a number of years now starting with the release of .NET Core. Most of the developers that we know work on Windows computers so we don't have first or second hand knowledge of using .NET on other operating systems. Today that is going to change. Maarten Merken has been doing .NET development on a Mac for more than two years and he joins us on the podcast to discuss his experience. We talk about different versions of .NET, debugging, virtualization, IDE's and more. When it comes to IDE's Maarten feels like JetBrains Rider is the best cross-platform IDE out there. Are you doing cross-platform development with .NET? If not, have you thought about trying it? Let us know on Twitter at @dotnet_Podcast.

Sep 20, 2022

WPF Still Going Strong - .NET 134

"I thought WPF was dead" is usually one of the first things that Kevin Bost hears when discussing today's topic. WPF is not dead. In fact, WPF is supported by .NET 6 and a plethora of third-party apps, extensions and packages. Kevin has been working with WPF for a long time and has become an expert on the framework. In today's episode we discuss some of the strengths and weaknesses of WPF, competing frameworks, open-source projects and the path forward. If you need to develop desktop apps for Windows, WPF is still the most mature framework out there. Have you worked with WPF? Are you currently developing applications with WPF? Let us know on Twitter at @dotnet_Podcast.

Aug 30, 2022

Staying on top of productivity - .NET 133

Our jobs are hectic and there are always multiple priorities we have to stay on top of. Mohammed Osman joins us on the show and runs us through the tools and methodologies he uses to stay productive both as an individual and also on a team.

Aug 23, 2022

Authentication and Authorization - .NET 132

If the title of this episode didn't give it away... we are talking about logging into and accessing the content in web applications. Albert Starreveld spends a lot of his time implementing authentication and authorization workflows for his clients. There are a lot of factors that determine how to handle these implementations correctly. Are you still using role-based authorization? What identity provider are you using? Are you using SSO? Are you using claims/scopes? Do you know how to set up claims transformations? These are just some of the questions to ask when dealing with authentication and authorization. In this episode, we discuss these questions and more with Albert. Have you had to implement auth in a web application? How did it go? Let us know on Twitter at @dotnet_Podcast.

Aug 16, 2022

Blazor In Action - .NET 131 (Part 2)

Chris Sainty returns to the podcast to discuss the release of his book, Blazor in Action, and more Blazor goodness. We begin this episode talking about writing and publishing a technical book including what it took to get the book over the finish line. There are a lot of moving parts to a technical book especially if the book contains code samples. Next we get into specific questions about Blazor like hosted vs standalone, razor files or code behind and more. We even get into a discussion about MediatR and how it can benefit your codebase whether it is a Blazor application or not.

Aug 09, 2022

Blazor In Action - .NET 130 (Part 1)

Chris Sainty returns to the podcast to discuss the release of his book, Blazor in Action, and more Blazor goodness. We begin this episode talking about writing and publishing a technical book including what it took to get the book over the finish line. There are a lot of moving parts to a technical book especially if the book contains code samples. Next we get into specific questions about Blazor like hosted vs standalone, razor files or code behind and more. We even get into a discussion about MediatR and how it can benefit your codebase whether it is a Blazor application or not

Aug 02, 2022

Learning Playwright - .NET 129

In this episode, Caleb and Shawn discuss Playwright, an end-to-end testing framework for web apps.

Jul 26, 2022

Finding Your Focus - .NET 128

This is a republished episode of .NET 017

Jul 19, 2022

Blazor Wasm Hosted or Standalone? - .NET 127

Today's episode has more Blazor goodness. The panelists discuss the differences that one little check box can make when creating a new Blazor Wasm project.

Jul 12, 2022

Complexities of Open Source - .NET 126

Dennis Doomen returns to the podcast to talk with us about open source projects. We discuss some of the latest milestones for Fluent Assertions and some of the positives and negatives of managing a popular open source project. While companies and developers benefit from open source projects they don't always view the open source community the same way. Dennis shares his thoughts on the subject and Shawn and Caleb talk about how their companies use open source. We also talk about different ways to sponsor an open source project and some of the communities that can grow up around an open source project.

Jul 05, 2022

Generating Class Diagrams with code - .NET 125

Class Diagrams are a very great way to document your system, inspect and understand the relationships between the classes and plan refactorings and disseminate knowledge inside the team. In this episode, Edson Moisinho discusses using PlantUML - an open-source tool that allows generating many types of UML diagrams from plain text.

Jun 28, 2022

Blazor Environment Quirks - .NET 124

All frameworks have their quirks. As a framework matures some of the quirks go away but every framework seems to have one or two things that you have to work around. When writing demo or proof of concept code you may not run into these quirks. They only surface when you need to deploy your code in another environment. In this episode the panelists discuss a Blazor quirk when working with different environments. Blazor does not handle appsettings.json or ASPNETCORE_ENVIRONMENT like other parts of .NET. Listen to this episode to find out more.

Jun 21, 2022

Lay off the repository pattern and other controversial opinions - .NET 123

Today we talk with Anthony Trad - he lays his case for why layering the repository pattern over Entity Framework is sometimes not a best idea for your codebase. Depending on the context, you could well just be over engineering. After that, we tackle a couple of other patterns such as the specification pattern and the mediator pattern and talk about when it is and is not appropriate to use them.

Jun 14, 2022

Learning By Doing - .NET 122

Believe it or not, software development is not an easy job. Each business domain is different, you are constantly learning something new and it takes work to stay on top of the right patterns and practices.

Jun 07, 2022

Making a Wordle clone and more - .NET 121

In today's episode we range far and wide over several topics. Our guest, Ferry To, works at a startup and we discuss some of the difficulties of working in a fast paced environment and how he and his team have worked through those difficulties. We also talk about Azure, automation, SignalR and Blazor. Ferry created a Wordle clone using Blazor and GitHub pages so we talk a bit about what Wordle is and the benefits of using Blazor instead of a JavaScript framework.

May 31, 2022

Refactoring legacy code to use async / await - .NET 120

Dominic Ullmann comes on the show to tell us how async / await works and the benefits of using it rather than making database calls synchronously. He talks about his recent experience converting a 500k+ line of code legacy application to use the async / await pattern. Too big to do by hand, he discusses using AsyncGenerator - an internal tool developed by the nHibernate project to auto-generate async versions of your methods.

May 17, 2022

Where is your code? - .NET 119

In this episode the panelists talk about source control.

May 10, 2022

Learning From Your Mistakes (PART 2) - .NET 118

In a lot of codebases, security isn't a priority until it is too late. Everyone makes mistakes but the question is do you learn from your mistakes or repeat them over and over. Christos Matskas returns to the podcast to discuss some common security mistakes and better ways to make security part of your development process. Our discussion includes .NET Framework web configs, secret storage, databases, identity and more. We even go over some of the mistakes we have made in our own code and how we learned from those mistakes.

May 03, 2022

Learning From Your Mistakes (PART 1) - .NET 117

In a lot of codebases, security isn't a priority until it is too late. Everyone makes mistakes but the question is do you learn from your mistakes or repeat them over and over. Christos Matskas returns to the podcast to discuss some common security mistakes and better ways to make security part of your development process. Our discussion includes .NET Framework web configs, secret storage, databases, identity and more. We even go over some of the mistakes we have made in our own code and how we learned from those mistakes.