The first quarter of 2022 is out. .NET 5 is going to reach its end of life next month and in November, as usual, we are expecting a new, much powerful version – .NET 7. Looks like .NET world is constantly changing, that is why it is so important to remember how it all started.
This time, the new issue of .NET R&D Digest includes bits of nostalgia, history, computer science, software development, .NET, Windows, Security and a few stories.
Have a great read!
20 years of .NET
20 years is an enormous amount of time. Understanding that .NET is now 20 years old is fascinating and scary at the same time. How many have been changed since first release? What was the path for developers and community? In this sections I gathered a few posts, podcasts where people share their life experience with .NET.
- MY 20 YEARS WITH .NET (by Mark Rendle)
In this post Mark Rendle share his 20 years story about .NET starting from 1.0, then insider preview of «Project K» and right to the latests releases. It doesn’t matter whether you have been with .NET from the very beginning or just starting — this story is inspiring and nice to read.
- Twenty Years of C# with Anders Hejlsberg (by Carl Franklin, Richard Campbell and Anders Hejlsberg)
In this podcast Carl Franklin and Richard Campbell talk with Anders Hejlsberg about C# language evolution, starting from the times when it was «COOL» and continuing to the present day.
- The History of .NET with Mark Miller (by Carl Franklin, Richard Campbell and Mark Miller)
In this podcast Carl Franklin and Richard Campbell talk with Mark Miller about Delphi, .NET, components, open-source and a bit about Windows Phone.
- Twenty Years of ASP.NET with Scott Guthrie (by Carl Franklin, Richard Campbell and Scott Guthrie)
In this podcast Carl Franklin and Richard Campbell talk with Scott Guthrie about birth of ASP.NET, ninja army and of course .NET and how to keep 20 years product going.
- The Story of ASP.NET Core w/ David Fowler (by Hassan Habib and David Fowler)
Do you know what unites NuGet, SingleR, ASP.NET Core and Kudo? Or to be correct — who unites them all? David Fowler, partner software architect at Microsoft. In this podcast, Hassan Habib speaks with David about his career in technology and how he became an architect at Microsoft. The podcast is very energetic and positive.
- On the History of the Shortest Path Problem (by Alexander Schrijver)
Do you know how to find a shortest path in a graph? Right now, you might be thinking something like «there definitely should be such a function for this» and in some frameworks of tools there might be one, or two, or three, or even more. The reason for this is that the problem of finding shortest paths in a graph exists for centuries and there are a lot of method to solve it. In this paper Alexander Schrijver goes through a history of shortest path algorithm describing their core ideas, computation complexities and applications.
- Parallel Performance Problems On Shared-Memory Multicore Systems: Taxonomy And Observation (by Roman Atachiants, Gavin Doherty, and David Gregg)
Development of efficient parallel applications requires significant expertise, experience and a lot of time. The reason for such a high requirements are quite simple — performance of parallel application can be affected by multiple factors include inefficient algorithm, bad configuration and miss-understanding of hardware behaviour. In this paper Roman Atachiants, Gavin Doherty, and David Gregg present and taxonomy and model for identification, classification and of performance problems in parallel applications. In this paper you will definitely discover performance problems you haven’t know about as well as theirs indications and contra-indications.
- Bottlenecks of Scaleups. Bottleneck #01: Tech Debt (by Tim Cochran and Carl Nygard)
Being overflowed by a technical debt is a fate many projects. This might seems inevitable, especially in case of fast growing projects. However, is there a way to avoid it? In this post (first in the series) Tim Cochran and Carl Nygard describe how startups are usually end up overflowed with technical debt and how you can avoid it by finding a balance between product values and engineering goals.
- Value types and exceptions in .NET profiling (by Christophe Nasarre)
The final part of the great series by Christophe Nasarre about profiling in .NET – how to get information about value types and exceptions. This series with all of its C++ is a great dive into the internals of .NET metadata.
- A few words about the implementation of List in C# (by Paula Wojciechowska)
In my experience List of T is one of the most popular collection in .NET. We use it everywhere (sometimes even when we shouldn’t). That is why I think it is important to know how it works internally. In this post, using great illustrations, Paula Wojciechowska describes List of T internal structure and how core operations
- Just because you stopped waiting for it, doesn’t mean the Task stopped running (by Andrew Lock)
What is actually happening when you cancel a
Task? Have you thought about it? In this post Andrew Lock describes what is happening with the
Taskwhen you cancel it (manually or by timeout) and how implement this flows correctly yourself.
- Cancellation (by Stephen Cleary)
What do you know about Cancellation in .NET? Do you know there is a cancellation contract? Are you sure you are canceling your thing in a right way? I am sure you do but still I greatly recommend you to read this great series (still going on) by Stephen Cleary where he dives deep into cancellation topic explaining what is cancellation contract, basic principles of cancellation and demonstrates how to make it right.
- Threads, Threads, and More Threads (by Pavel Yosifovich)
How many threads do you have in your system? Do you know what are they doing? These are the unasked questions because most of the time we don’t care about how applications are implemented until they work “fine”. However, what if we want to know? In post Pavel Yosifovich demonstrates how you can easily explore you system processes and try to understand why do they have so many threads (usually these threads aren’t needed). The post is easy to follow and interesting to read (like a little journey into system internals).
There are topics which aren’t getting obsolete. One of such topics is information security. The next two posts and a quiz are exactly about what every developer should know about modern web security – OAuth 2.0 and OpenIdConnect.
- Dummy’s guide for the Difference between OAuth Authentication and OpenID (by Nat Sakimura)
In this post (from 2011) Nat Sakimura describes the difference between OpenID and OAuth 2.0 protocols by simple analogies, examples and detailed explanations.
- An Illustrated Guide to OAuth and OpenID Connect (by David Neal)
If you ever tried to implement authentication and authorisation using for example Azure AD you know how fast and easy it can be done (at least in .NET). But how it works underneath? Why you enable OAuth but setup OpenIDConnect in the code? What is the difference between these two? In this post David Neal gives a very detailed (with illustrations) explanation of what is OAuth and OpenID and what they are designed for.
- Identity Quiz (by Dotnetos)
I suppose you have read the above blogs (or you are just a brave soul) and ready to explain what is the difference between OAuth and OpenID? What about Access Token? Well, then prove it by passing the Quiz by Dotnetos!
Tips & Tricks
- Cancelling await calls in .NET 6 with Task.WaitAsync() (by Andrew Lock)
In this post Andrew Lock demonstrates how you can use the new Wait API (introduced in .NET 6) to implement timeout and cancellation scenarios.
- Executing GitHub Actions jobs or steps only when specific files change (by Gérald Barré)
In this post Gérald Barré demonstrates how you can implement conditional steps and conditions to configure GitHub Actions to execute only when specific files are changed.
Listen & Learn
- Easyperf Twitter Spaces with Andrey Akinshin and Denis Bakhvalov (by Denis Bakhvalov and Andrey Akinshin)
Do you know why we need such libraries as Benchmark .NET to measure performance improvements? Is it really so hard to compare execution time of two methods? It turns out that the answer to this question really depends on what you are measure and what result you really need to achieve. In this podcast hosted by Denis Bakhvalov, Andrey Akinshin talks about how you can measure performance improvements from statistical points of view and what challenges you might face when setting up an automated performance testing environment. The podcast includes some mathematics but Andrey does a great job explaining complex things in an easy to get way.