With the built in System.Text.Json serializer, serializing objects to and from JSON in .NET is FAST! However, the actual performance you get depends a bit on how you use it. Using DotNetBenchmark, we take a look at some different patterns that can be used for serializing an object to and from a file on disk.

Benchmarking in .NET: https://benchmarkdotnet.org/articles/overview.html
JSON Serialization: https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-how-to?pivots=dotnet-6-0

Mermaid allows for simple diagrams in Markdown and now it is supported on GitHub!

Mermaid docs: https://mermaid-js.github.io/mermaid/#/README
GitHub announcement: https://github.blog/2022-02-14-include-diagrams-markdown-files-mermaid/

Cover image Creative Commons:
https://www.maxpixel.net/Sea-Cartoon-Fantasy-Fish-Mirror-Mermaid-Siren-5542841

When it comes to durable functions, there’s no magic as to where your progress is tracked! In fact, you can even configure it as you see fit. In this episode we’ll look at how and where the data is stored to back your orchestrations and talk about a few preview packages that allow you to configure the persistence yourself.

In this episode, we take our quest to improve page load performance to the next level by introducing responsive WebP images. Using responsive images, we can minimize the number of bytes downloaded to render images by specifying different images that are more appropriately sized for different sizes of screens. Let’s take our mobile lighthouse score from 66 to 100!

Previous Episode:
Optimizing Web Images with WebP - https://youtu.be/nx4UHooI-is

Useful Links:
https://12daysofweb.dev/2021/image-display-elements/
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/picture
https://caniuse.com/?search=picture
https://caniuse.com/?search=webp

Images make up a substantial part of the bytes downloaded on the average web page. The WebP image format can make a huge difference in payload size. Let’s see how easy it is to improve page speed performance by introducing WebP images while still maintaining compatibility with older browsers with the picture element.

Useful Links:
https://12daysofweb.dev/2021/image-display-elements/
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/picture
https://caniuse.com/?search=picture
https://caniuse.com/?search=webp

Once a Durable Function has started there are often times when you’ll need to access external resources, or intervene manually when the workflow hits a certain point.

In this episode we’ll talk about the first of several detours an orchestration can take, waiting on custom external events before progressing along to completion.

Here’s a quick primer on creating your first Durable Function in Azure Functions. We’ll have a quick look at the payload that is automatically returned in the sample project code, and start to dive into how to make it our own.

We’ll also do a quick peek to see how you might wire that up with a front end.

In the last video we looked at streams in Kafka. In this episode we jump into actually getting started using .NET to talk to Kafka.

Why does .NET have 5 version of a Timer class? Because reasons… but don’t worry because .NET 6 adds a 6th version called PeriodTimer. Let’s take a look at the new PeriodTimer API and how it compares to the traditional System.Threading.Timer API.

https://docs.microsoft.com/en-us/dotnet/api/system.threading.periodictimer?view=net-6.0

Azure Container Apps gives us yet another way to deploy containers to Azure. The service is in early previews but we’re going to take it for a test drive here by deploying an ASP.NET Core 6 Minimal APIs to Azure Container Apps. Let’s dive in to see what we like about the service and what we think this will need to be useful in a production setting.

Azure Container Apps - https://azure.microsoft.com/en-us/services/container-apps/#overview