November is here, and in world of .NET it means – .NET Conf and a lot of new and interesting stuff to watch and learn. And one of such things (I hope) – is a new issue of .NET R&D Digest!
Today’s issues contains bits of computer science, software development, .NET, tooling and videos to watch and learn something new!
Enjoy your reading!
- Taking Hash Tables Off The Shelf and Hashing Out Hash Functions (by Vaidehi Joshi)
Do you know what hash table is? How it works? Can you explain it? (the last one is tricky). If you have answered “no” to any of the above questions or you simply like to read about abstract data structures then these posts are for you. In these posts Vaidehi Joshi describes what hash table and hash functions are using simple and easy to get analogies, code snippets and drawings. Besides being detailed, posts also include links for future study.
- Linear vs Binary Search (by Mark Probst)
How to find out which algorithm is faster? Of course we can try to compare their algorithmic complexity but in practice we aren’t working with infinitely large arrays of data and therefore the K part of big O might have a significant effect on the performance. So what to do? Experiment! In this post Mark Probst does an experiment to find a break point where searching in sorted array is fasted with linear search instead of binary search. The code snippets are written in C++ but they are straightforward and shouldn’t be a problem to understand. In the end of the post there are comments (recommended to read) and link to repository, so you can try running these benchmarks on your machine.
- How to get useful answers to your questions (by Julia Evans)
Asking questions is an important part of software engineer’s job. We need to ask questions from clients to understand what to do. We need to ask colleagues to learn how new or existing things work. In this post Julia Evans shares a set of advice on how to ask questions and get a good answers of them.
- Ship / Show / Ask (by Rouan Wilsenach)
Pull Request is a convenient way to implement review/approve process in a development team. However, such process might have certain drawbacks — stalled or badly reviewed PR’s. In this post Rouan Wilsenach shares a branching strategy when you can use PR more for knowledge sharing than approval, which helps to reduce tension between firing a PR and integrating the code.
- Exploring .NET Core 6 (by Andrew Lock)
.NET 6 brings a lot of changes (we previously saw multiple posts from .NET team with huge number of improvements). However, besides new types and C# features there are other changes, which are also really interesting and have a huge impact. In this series Andrew Lock explores changes done to the first thing you see when creating an application — start up. He dives deep into all of the details. The posts are extremely detailed and include explanations, descriptions and code snippets.
- Generate PDF files using an html template and Playwright (by Gérald Barré)
It is not easy to generate a document. You either need to construct it from scratch (using low level primitives) or use expensive libraries. However, there could be another way — in this post Gérald Barré demonstrates how you can create pdf from html using … browser 🙂
- SourceGear Bridge preview: Swift with .NET in Xcode (by Eric Sink)
We all know that .NET platform might have many languages – VB, F#, C# and so on. But what about languages that weren’t designed to work with .NET? Is it possible to bring them in? In this post (and these posts about Llama and Alpaca) Eric Sink demonstrates how you can bring swift language to .NET and actually start writing web apps using it.
- Prime your flux capacitor: SQL Server temporal tables in EF Core 6.0 (by Jeremy Likness)
Ever created an effective date column to keep track of previous values in SQL tables? If yes, you might now how messy that is. That is why SQL has temporal tables which kind of do this for you. Now EF Core has support for them. In this post Jeremy Likness does an introduction of how you can use temporal tables with EF Core and demonstrates how it looks like with a few simple but yet so needed queries.
- How to lie with Benchmarks (by Bartosz Adamczewski)
Performance always was (and I think would remain) a hot topic. Arguing what is faster is a common thing among developers who cares about the code they write. The problem here is that when it comes to measurements it is hard to code a proper benchmark. In this post Bartosz Adamczewski demonstrates how you can “lie” with benchmarks by showing how compiler and system behaviour can significantly affect benchmark results.
- Decyphering methods signature with .NET profiling APIs (by Christophe Nasarre)
I am sure any .NET developer at least once said something bad about debugger’s performance. Why is it so slow? Reading this series (this is a third post) by Christophe Nasarre you might see how much work debugger actually does to simply display a method signature. The post is full of comments and detailed explanations of what is happening, so sometimes you even forget that everything in it is C++.
- How to detect if the User’s OS prefers dark mode and change your site with CSS and JS (by Scott Hanselman)
For the last few years dark mode become a real feature we, as users of dark mode, expect to have in every application — both desktop and smartphone. But what about web? More and more web site start to support dark mode and so can do you. In this post Scott Hanselman demonstrates, in a few simple steps, how you can add support for dark mode to your web site.
- Durable Functions’ events made twice as fast (by Szymon Kulec)
Open source provides a great opportunity to inspect, learn and improve things you like. The greatest thing about it is that everyone can make a difference. In this post Szymon Kulec describes a PR he made into durable functions framework which significantly reduced CPU usage and improved execution speed. The post is very detailed and contains a few interesting tricks you may find useful.
- I fixed a bug. What should I do now? (by Gérald Barré)
Fixing a bug is a multi-step action. Identify, gather information, fix, verify. But is it all we need to do? In this post Gérald Barré shares a set of question to ask yourself after fixing a bug. If you don’t like the answers then probably it is time do something about your app or development environment. Besides a checklist Gérald Barré also shares a few things and approaches you can use to get more help from the IDE.
- .NET Memory Management Poster III (by Konrad Kokosa)
If you still have free space on the walls, then this poster from Konrad Kokosa is exactly what you need. Combining it with previous two you will have all required materials to conduct .NET memory management classes for beginners right on your desk 🙂
Watch & Learn
- On .NET Live – Commands, Queries, and Clean Architecture (by Cecil Phillip and Ian Cooper)
Having a lot of terminology which has multiple meanings is one of the problems in software development. There is no simple answer on even such a simple question like «what module is?». That is why we need concepts and architecture approaches 🙂 In this video, Cecil Phillip and Ian Cooper talk about basic architecture concepts like modules, abstraction, dependencies and how they can be mixed interpreted to create clean and easy to extend architecture.
- Webinar “.NET GC for absolute beginners” (by Konrad Kokosa)
Feeling yourself as absolute .NET GC beginner? But you want to know more? Then this webinar by Konrad Kokosa is for you. In this webinar he explains basics of GC and gives a basic understanding of memory management in .NET without diving too deep.
- Dotnetos Conference 2021
Conference is a great place to learn new things and find new ways of doing things. This year, the Dotnetos (Konrad Kokosa, Szymon Kulec, Łukasz Pyrzyk) held their annual conference. This was an online event streamed directly on YouTube which means — everyone was able to join and everyone can now watch the videos.
Need to code but don’t have time or access rights to install IDE? Then open Visual Studio Code right in the browser 🙂