.NET R&D Digest (June, 2022)

Learning is a continues process. There is literally no end of learning high way because there is always something new, which just emerged, or something that has been with us for years but we never heard of it. This is where .NET R&D Digest comes handy.

This issue of .NET R&D Digest includes bits of development stories about programming and life, architecture, networking, benchmarking, .NET and something to watch.

Enjoy your reading!

Life Style

  1. The story of my mid-career gap year (by John Gossman)
    Work takes a significant part of our lives. Sometimes it might be hard to imagine you own life without work. How do you think, what will happen if you would take a long vacation? For a week? Or a month? Or may be a year? In this post John Gossman shares a story of how he took a gap year at work and what effect it has on his life experience.

Development Story

  1. The journey of moving from C++/WinRT to C# in the Microsoft Store (by Sergio Pedri)
    Migration stories are always about challenges. The challenges of not breaking everything up; of doing things right, without leaving a bunch of technical debt in the dark corner; and of course about integrating new things with something outside of your control. In this post Sergio Pedri share a story of how Microsoft Store application was moving from C++ to C#. Sound like a simple rewrite? Well, it isn’t. This post is full of code samples, detailed descriptions, links to other resources and nice and interesting decisions.

Software Development

  1. Fundamental Software Architectural Patterns (by Williams O)
    Software Development is all about solving typical problems which aren’t similar to each other. Solving every and each of them from the scratch requires a lot of effort. That is why we have — design patterns, a pieces of reusable knowledge for handling typical situations in a best possible way. The same applies to software architecture in particular. In this post Williams O does a nice overview of a common set of software architecture patterns you might need in your day to day work. The descriptions are short, clean and easy to get (thanks to diagrams).


  1. Understanding PathBase in ASP.NET Core (by Andrew Lock)
    When you use framework or library for many years it always a pleasure to find something new. Thanks to Andrew Lock, who always digs into things, I learned one more thing — an existence of PathBase middleware, which may be quite handy in some of the deployment scenarios. 
  2. Using PathBase with .NET 6’s WebApplicationBuilder (by Andrew Lock)
    Simplicity always has cost. Same applies to minimal API — it greatly simplifies the process of configuring and writing small apps but it takes some degree of control from you. In this post Andrew Lock describes the case when having more control over automatically configured middleware pipeline might be required and if it the case — how to take it back without loosing all the benefits (which is by the way possible because of great framework design).
  3. How to test ASP.NET Core Minimal APIs (by Maarten Balliauw)
    Recently introduced Minimal API helps to reduce amount of code we write to achieve the desired result (and having less code usually improves readability). However, we still need to be able to test it somehow (it turns out we can). In this post Maarten Balliauw describes a way of how you can easily test you Minimal API endpoints using standard classes provided by ASP.NET framework. The post is detailed and easy to read.
  4. Building a Redis Clone–naively (by Oren Eini)
    What it takes to build an analogue of existing, high-performance tool? More importantly, how to approach such an ambitious task? Without having a clear plan there is a high chance to fall into unnecessary optimisations and architecture holes. In this (still ongoing series) Oren Eini is set to write a Redis clone in C#. The series is a good illustration of structured and cold headed approach to build software.
  5. .NET 7 Preview 5 – Generic Math (by Tanner Gooding)
    Math has a special place in software development and in hearts of software developers. We might not see it in years (writing database calls, controllers and stuff) but then it accidentally turns out that everything is based on it. In previous release .NET done a lot to simplify writing reusable math methods and in the upcoming release there is even more features. In this post Tanner Gooding describes them in details, explaining what interfaces were added and what we to expect in future.


  1. HTTP/3 From A To Z: Core Concepts (by Robin Marx)
    What is the difference between HTTP/2 and HTTP/3? Better performance? Better security? More features? These are valid questions which we, as developers, ask ourselves when something new is getting around. Sometimes it means just a new set of supported commands or flags and sometimes it means a significant change on the core itself. In this huge and really amazing series Robin Marx does a deep dive into the topic of HTTP/3, QUIC, TCP and their features, performance characteristics, deployment challenges and reasons why it is done that way.
  2. DNS “propagation” is actually caches expiring (by Julia Evans)
    Have you ever thought about how DNS records are propagated? Why do you need to wait before new name becomes available? In this post Julia Evans explains the way of how DNS records gets created and updated and why in some cases it takes moment and sometimes days to work out.


  1. Benchmarking Malloc with Doom 3 (by Forrest Smith)
    In .NET memory allocation is cheap (at least we tend say that) but what does “cheap” means? In this post Forrest Smith benchmarks performance of C++ malloc function (with multiple allocators) to find this out. Don’t focus on the C++ code in the post — it is all about benchmarking (and how to approach it) and data visualisation.


  1. ConsoleAppFramework
    ConsoleAppFramework is an infrastructure of creating CLI (Command-line interface) tools, daemon, and multi batch application. You can create full feature of command line tool on only one-line (something like a Minimal API but for console applications).

Watch & Learn

  1. .NET at Build 2022
    Here is playlist of all Build’2022 talks about .NET. Here you will find videos about all the latest technologies and tools we might expect coming this year (or which are already released) demonstrated in a simple and practical way. 

Tips & Tricks

  1. Enabling IntelliSense for GitHub Actions workflows in VS Code (by Gérald Barré)
    IntelliSense significantly simplifies the process of writing code or configuration. Therefore it is always better to have it than not. In this post Gérald Barré describes how you can add IntelliSense in VSCode for GitHub actions
  2. Reducing the size of a git repository with git-replace (by Andrew Lock)
    History and ability to scan through it is a major benefit of any source control system. However, time flies and size of this history might become problematic in terms of storage. In this post Andrew Lock shares how you can separate a significant part of the repository history into dedicated «history repository» without loosing an ability to scan through it, when needed.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s