.NET R&D Digest (December, 2022)

This is the last issue of .NET R&D Digest in 2022. This year was huge for both .NET and Software Development in general. During these 12 months we saw many more amazing patterns in Patterns of Distributed Systems series (by Unmesh Joshi). Replaced legacy systems with Patterns of Legacy Displacement (by Ian Cartwright, Rob Horn and James Lewis) and identified Bottlenecks of Scaleups with (Rick Kick, Kennedy Collins, Tim Cochran, Carl Nygard and Roni Smith).

We dived into low-level hardware while reading Modern Microprocessors. A 90-Minute Guide! (by Jason Robert Carey Patterson) and Branch prediction (by Dan Luu), and dived into Four Cornerstones of CPU Performance with Denis Bakhvalov who also gave us a chance to become performance Ninjas by passing Performance Ninja Class.

But we didn’t stop there, we unveiled Mysteries of the Registry and Zombie Processes together with Pavel Yosifovich. We wrote a CLR profiler with Kevin Gosse and turned every brick in .NET IPC protocol with Christophe Nasarre.

We celebrated 20 years of .NET and C#, learned Modern C# Techniques with Steve Cleary, learned tons of new things about ASP.NET Core with Andrew Lock, dived into the world of Performance Improvements in .NET 7 with Stephen Toub watched many videos from .NET at Build 2022, Dotnetos Conference 2022, Developer Live Breakouts at Microsoft Ignite 2022 and many other conferences, podcasts and streamers.

It is simply impossible to enumerate everything here, but there was a lot, you can check this out here.

This issues complements the story and includes bits of stories, software development, operating systems, containers, networking, diagnostics and of course .NET, C# and .NET Internals.

Have a nice read!

P.S. You can expect a new issue of .NET R&D Digest as usual, in the end of January 2023.

Developers Story

  1. How I cut GTA Online loading times by 70% (by t0st)
    Being a developer is not only about writing code at work or pet project, it is also about fixing and changing things you like 🙂 Sometimes it might be just a detailed bug report, feature suggestion or an analysis of application memory dump. In this post t0st shares a story of debugging an issues in GTA Online which resulted in an official fix that reduced load time by around 70%. The post is pure fun and easy to read.

Software Development

  1. The Law of Leaky Abstractions (by Joel Spolsky)
    When working in high-level languages and frameworks it is a common thing to hear that “you don’t need to know how something is implemented underneath because it is framework’s, os, library’s work to care about it”. It sounds great, until you realise that it is simply not possible to completely abstract from underlying things. In this great post Joel Spolsky describes a «Law of leaking abstractions» explaining why it is impossible to create an ideal abstraction and why it is important to understand what is happening underneath.
  2. “Performant” is nonsense, but performance can still matter (by Ryan Donovan)
    Software development is a trendy area full of buzz words. These buzz words are used to describe applications, giving them a nice look – fluent, performant, friendly and so on. But what these words really mean? What does it mean when application is performant? In this post Ryan Donovan talks about a word «performant» digging into its meaning and place in the industry.


  1. .NET Advent Calendar (by Dustin Moris Gorski) and C# Advent Calendar 2022 (by Matthew D. Groves)
    Every year .NET developers gather together right before Christmas and write posts. This year is not an exception. This year we have .NET Advert Calendar (organised by Dustin Moris Gorski) and C# Advent Calendar (organised by Matthew D. Groves) calendars where you will find both fun and strictly technical posts about C#, .NET and just software development by many great authors. Check them out!
  2. Write barrier optimizations in regions (by Maoni Stephens)
    I love reading posts about how systems get optimisations. Mostly, because in these posts you actually see how complex these systems are. Which is also great, that in many cases, the optimisation is not a reduced database call or usage of Parallel.For – it is hard and precise work on level of individual bytes and instructions. In this post Maoni Stephens describes a new optimisation of GC which becomes enabled for workloads running on .NET 7. The optimisation which from one side can introduce a small regression in micro-benchmarks but at the same time results into a noticeable improvement in general.
  3. Is the regression in GC or something else? (by Maoni Stephens)
    Upgrading to a new version of a framework is huge deal not because of possible breaking changes you need to account for in your code but also because you are literally replacing all of the underlying framework’s libraries and therefore you are replacing a lot of code. Usually, such upgrades are for good because frameworks tend to change to the best. However, sometimes they can introduce issues. In .NET, besides updating the libraries, we also updating such huge components like GC, JIT and so on. What if the error is within them? How to check it? In this post Maoni Stephens describes the steps you can take to ensure the memory degradation introduced as part of upgrade is really caused (or not) by GC. Beside giving a practical advice Maoni also (as usual) shares bits of frameworks history and internals.
  4. The dangers and gotchas of using scoped services in OptionsBuilder (by Andrew Lock)
    Having a strongly typed configuration object means having an advantage of using the exact values you need. However, creating such configuration object usually requires some deserialisation of values from long term storage and then — initialisation. But what if you need to use some of the application services during the initialisation? In .NET strongly typed configuration is implemented through options pattern which you configure during application startup and injecting services there might be tricky 🙂 In this post Andrew Lock explains the possible pitfalls in details and provides a few ways to avoid them. As usual, the post is very detailed and easy to read.
  5. 5 new MVC features in .NET 7 (by Andrew Lock)
    Release of .NET 7 introduced a lot of new performance and general purpose features. It also introduced a good set of changes to Minimal API but were there any MVC related changes? In this post Andrew Lock describes five new features introduced just for MVC (well, some of the are just to keep up with Minimal API). The post is full of code samples and detailed descriptions.
  6. A Mostly Complete Guide to C# 11’s Final Features (by Matthew MacDonald)
    Every release of C# brings new features which makes the language better and at the same time much larger, so we as .NET developers have to learn more and more. However, even taking in account the openness of C# design discussion it is hard to keep a constant look on what is getting into the language and what isn’t. In this post Matthew MacDonald describes features which made their way into C# 11, features which are postponed until the next release and of course about features which are put in shelf for a long time. 


  1. Unnamed Directory Objects (by Pavel Yosifovich)
    When you are user, the operating system is what you see on the screen mixed with general impression of how everything runs. When you are a developer, the operating system is a platform which exposes API you use to create applications, and numbers of these API is enormous and it gets increased with every operating system release, which makes it very hard to explore all of them by yourself. That is why posts about operating systems internals are so valuable. In this pos Pavel Yosifovich describes what private object namespaces are and demonstrates how you can explore them and create one of your own.


  1. Mastering Container Networking (by Ivan Velichko)
    Networking is a topic which usually causes a lot of confusion, especially when it come to containers. Why my container can’t see this service? Why none of the services see my container? These are quite common situations and the Internet is full of such questions and answers of what command you should execute to solve the issue. However, I think it is much better to just understand what is really going on. In this series Ivan Velichko does a deep dive into container networks explaining how they work in a very practical and easy to get way. All of the post are very detailed with beautiful drawings and really easy follow. Besides, I would highly recommend to check the whole blog, it is a great source of information about containers. 

Tips & Tricks

  1. Prevent http requests to external services in unit tests (by Gérald Barré)
    Reliable tests are essential for steady product development. However, in complex (and large) systems you sometimes might not know when some of the components makes something dangerous or unexpected (which might significantly affect tests stability and predictability) like HTTP request to an external service. In this post Gérald Barré demonstrates how you can make sure that none of your tests actually does any external HTTP calls. While the post addresses the HTTP calls, this technique can be used with other types of external dependencies.

Watch & Learn

  1. Web Development for Beginners – A Curriculum
    Did you know, Azure Cloud Advocates at Microsoft create a free to use curriculums for students to start in technology? I didn’t but this looks cool. The courses are designed for both group and self-study and organised as repositories with lectures, videos and practical exercises. Besides the Web Development one, they also have IoT for Beginners – A Curriculum, Data Science for Beginners – A Curriculum, Artificial Intelligence for Beginners – A Curriculum, Machine Learning for Beginners – A Curriculum

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