.NET R&D Digest (December, 2020)

2020 is ending. It was a long and tough year for everyone. However, in world of software engineering it also was a quite interesting one – we saw how a plan become true (at least in .NET world, where Mono and .NET now share the same repo and .NET 5 was released as promised), we attended a lot of online events, online trainings and spent tons of time on self-education and we also read … .NET R&D Digest 🙂

This issue contains bits of Visual Studio, .NET, web, databases, cloud, and software engineering.

Enjoy and see you next year!

Software Development

  1. Richardson Maturity Model (by Martin Fowler)
    Nowadays, RESTful services are everywhere. We are used to them. But there are still so many questions about what RESTful service is. In this post Martin Fowler describes a model developed by Leonard Richardson and how it can be used to think about elements of REST. 

Visual Studio

  1. What’s new in .NET Productivity (by Mika Dumont)
    Nowadays, frequent releases are a game changer. Previously we waited years before getting something new in Visual Studio, now it takes weeks, and this is fantastic (except, when some changes break C++ unit tests). In this post Mika Dumont describes one more set of impressive improvements introduced in latest release of Visual Studio including: refactoring, code analyzers and code cleanup.

.NET

  1. Avoiding downtime in rolling deployments by blocking SIGTERM (by Andrew Lock)
    I have already mentioned this series by Andrew Lock in previous digest. However, this post is of particular interest from a .NET point of view. In this post Andrew demonstrates a way to use native .NET Core application lifetime management services to delay application reaction to SIGTERM signal and therefore delayed termination.
  2. 6 less popular facts about C# 9 records (by Konrad Kokosa)
    C#9 introduces many things. However, records are one of the most noticeable features. But what records can do besides the features mentioned in the release notes? In this post Konrad Kokosa describes a few not well-known facts about what (and why) records can do else, besides being simplification for simple types implementation with out of the box immutability support.
  3. From .NET Standard to .NET 5 (by Immo Landwerth)
    .NET 5 is out. It is a future of .NET. But what does this really mean? What is the future of .NET Core or .NET Standard? In this post Immo Landwerth answers exactly these questions. Besides that, Immo also goes into details about what we can expect in future.
  4. Build your own .NET CPU profiler in C# (by Christophe Nasarre)
    CPU profiling is the first thing to go when your application behaves slowly (and there are a lot of tools in the wild that can do it for you). However, did you ever think about how CPU profiling works? How do you get these pretty call stacks and call counts? In this post Christophe Nasarre demonstrates how you can utilize TraceEvent and Windows Kernel loggers to implement your own CPU sampling profiler (and what is important) explains how you can run this profiler without being one of the system administrators.
  5. How Visual Studio debugs containerized apps (by Sebastian Solnica)
    Modern development tools work like magic – you can “locally” debug an application running right in the cloud. You can auto-generate code with a few clicks or even get intelligent hints from your IDE. However, as developers we know – there is no such thing as magic in the software. There is always a way to find out how something works. In this post Sebastian Solnica goes down the road of curiosity to find out what Visual Studio does to debug application running in Docker container. Besides step by step journey the post also contains links to docs and useful tools.
  6. C# 9 cheat-sheet (by Bassam Alugili)
    Learning all new language features isn’t easy because reading about them isn’t enough. That is why cheat-sheets is of great use. This cheat-sheet created by Bassam Alugili explains and demonstrates all major features of C# 9 in compact and easy to get examples.

Databases

  1. Evolution of tree data structures for indexing: more exciting than it sounds (by Dmitry Dolgov)
    What would you say if someone asked you about B-trees? If I were on your place, I would probably say something about red-black tree and that B-tree should be balanced in a way to provide logarithmic access time. However, there is much more. In this post a Dmitry Dolgov describes multiple types of B-trees researched in academics and used in modern databases engines as index implementations. The post is long but remarkably interesting.

CSS

  1. Modern CSS Solutions for Old CSS problems (by Stephanie Eckles)
    CSS is a separate skill. Having this skill means: you can do things, or you can do thing the right way 🙂 This site created by a Stephanie Eckles contains a lot of right solutions (and detailed explanation of mechanics behind them) to multiple common (and sometimes quite old) problems you can face when CSS-ing your site and pages.

Tools

  1. Spectre.Console (by Patrik Svensson)
    I think everyone who have developed at least a few console apps tried to create something reusable: to parse arguments, ask prompts or display result or progress. However, prettifying comes at cost of extended development time and sometimes we can’t afford this extension, but we still want apps to look nice. This project by a Patrik Svensson can do a lot of console tricks and do them beautifully. It can ask prompts, print colorful tables, exceptions, and display progress in a various way. A good tool into toolbox.

Watch & Learn

  1. Everything from .NET Conf 2020: Sessions, Demos, & More! (by Jayme Singleton)
    .NET Conf is a huge online event. However, as it happens with worth to see events – we can’t attend them all (or even attend all the sessions). That is why it is so cool when we can watch what is of top interest for us later as a recording. In this post Jayme Singleton shares links to all the stuff presented at .NET Conf 2020 and more!
  2. CPU profiling inside out (by Sebastian Solnica)
    Application diagnostics is separate skill which many of us believe you can acquire only through personal experience. However, this isn’t entirely true. There are still edge cases and very strange and hard to describe issues but at the same time there are a lot of technics and tool you can learn and reuse. In this webinar Sebastian Solnica digs in into CPU profiling, explaining not only how it works, but also showing how you can utilize it when solving .NET application issues.

History


  • 2020/12/30 – Updated link to Bassam Alugili profile on Twitter (I somehow missed this and previously the link was pointing to his GitHub account).

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 )

Google photo

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

Twitter picture

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

Facebook photo

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

Connecting to %s