2/3 or summer has been completed but there is still a plenty of time left to get some rest and read (or watch) something interesting, exciting and good for your career. Where to find those? Well…, all of these and more, you can find right here – in .NET R&D Digest.
This issue of .NET R&D Digest includes bits of career development, software architecture, patterns, web, testing, diagnostics, history, fun and of course – .NET. This time there are both – something to watch and read.
Have a nice read!
- The secret to getting to the Staff+ level? Leverage. (by Camille Fournier)
Engineers career path in IT is a cloudy and quite uncertain thing. Is it necessary to become a manager to grow? Do I need to learn one more framework or library? Will any of these give my career a boost? In this post Camille Fournier shares a set of ideas of how to increase your impact in the organisation by leveraging your personal value. The post is very interesting and recommended to read.
- Solution Architecture Diagramming (by Daniel Hughes)
Creating “proper” software architecture seems impossible without creating a super technical diagram of everything. However, complex diagram is hard to understand, which contradicts with its purpose — communicate things. So, what to do? In this post Daniel Hughes shares his approach to architecture diagraming where he is starting from creating four diagrams to explain major architecture decisions.
- The Sidecar Pattern for Application Developers (by Yaron Schneider)
What is sidecar pattern? Is it for deployment scenarios only useful? Maybe it is just a trendy thing? These are good question if you aren’t familiar with sidecar pattern. In this post Yaron Schneider describes what sidecar pattern is and how it can benefit for not only operations but also for application developers.
- [C#] Why function pointers can’t be used on instance methods (by Kevin Gosse)
High performance in software isn’t free. You can pay for it in terms of code clarity, complexity or safety. And the last one is the trickiest. In this post Kevin Gosse describes how a performance optimisation of function calls can lead you to a stack corruption. The post provides a valuable insight into CLR internals and tricks people use to speed up their applications.
- Typing API Responses With Zod (by Dawid Sibiński)
In .NET, when one service calls another service’s endpoint we may use an intermediate package (ex. “contracts”) to make sure we use right call signature (with parameters and return object). However, when we call an API from a client, there is no easy way of doing so (if you aren’t using Blazor of course), especially when it comes to API return object. In this post Dawid Sibiński demonstrates how you can use a npm package ZOG to implement “strong type” relationship between frontend and backend.
- Adding content negotiation to minimal APIs with Carter (by Andrew Lock)
Serialisation is the process of transforming an object to its persistent representation with an ability to restore it later. Thanks to this, we can return objects from our API endpoints and get a JSON in return. However, what if one of our clients needs JSON and the another one needs XML? Well…, this is tough situation but it can be handled by content negotiation. But what to do if there is no support for content negotiation? In this post Andrew Lock describes how you can use Carter (an extension library for ASP.NET Core) to utilise both the might of Minimal API and simplicity of content negotiations.
- A brief introduction to DiagnosticSource
Consuming anonymous types with DiagnosticListener in .NET 6
Understanding your middleware pipeline in .NET 6 with the Middleware Analysis package (by Andrew Lock)
.NET has multiple diagnostics components — ILogger, EventSource and DiagnosticSource. Most of us are familiar with ILogger which we use everyday to write textual logs, and maybe with EventSource — when we write serialised messages to operating system logging subsystem. But what is DiagnosticSource? In these posts Andrew Lock gives a good introduction to DiagnosticSource components and explains their use cases, shows how to consume events and demonstrates a real life example of how we can use them to scan through middleware pipeline.
- Creating, Inspecting And Decompiling The World’s (Nearly) Smallest C# Program (by Steve Gordon)
High-level programming languages do a lot of things under the hood. If you code in C# for a few years you might already know about using, yield, foreach and so on. There is no surprise in that, because compilers tend to remove burden and simplify things. However, sometimes they do so much that it starts to look like magic. In this post Steve Gordon dives into how exactly top-level statements (introduced in recent version of C#) allow us to write a minimal .NET applications without leaving even a tiny hint to the compiler.
- World’s Smallest C# Program (featuring `N`) (by nietras)
In a nutshell, software development is all about solving real world problems. However, it doesn’t mean there is no space for fun. Do you know what is the smallest program in C#? Is it a simple console app with Main? Or it is something related to new «minimal» approach? In this post nietras describes his quest in writing a smallest C# program which also results in a new, fun NuGet package for the same solo purpose.
- Fast unit tests with databases (by Johannes Hartmann)
Automated tests are intended to simplify and speedup development by reducing development inner loop. However, when it comes to database related tests they usually aren’t so quick and running them after each build becomes problematic and time consuming. In this series Johannes Hartmann describes how they have speedup 1200 database related tests to run under 40 seconds.
Watch & Learn
- The Worst Programming Language Ever – Mark Rendle – NDC Oslo 2021 (by Mark Rendle)
Think about the best programming language you have ever used. Think about what was bad in this language. Now, imagine, a language were everything is a «bad feature». Yep, this would be the worst programming language ever and it turns out it has a name — BS. In this fun presentation Mark Rendle describes an imaginary BS language which solo purpose is to make software developers suffer by include all the «bad features» of existing languages. The presentation is both interesting and entertaining and while it is more focused on «fun» it also provides a nice prospective in programming languages evolution.
- Oral History of Dave Cutler (by Grant Saviers for Computer History Museum)
Computers, mobile devices, phones, game consoles. They are everywhere, they are part of our everyday life as well as operating systems and other software. But how do we came to such progress? Only history knows the answer. In this interview (by Grant Saviers for «Computer History Museum»), Dave Cutler tells his story of being as engineer who worked on hardware, software and played a critical role in development of multiple operating systems (including Windows family). The interview is quite long (around 3 hours) but it worth every minute. Highly recommended to listen.
- How to Choose the Right Azure Services for Your Applications
Abstract: As you move to the cloud, an important decision you’ll make is which Azure service to use to host your applications. People often see this as an A or B choice. For example, you might ask, “Should we use Azure Kubernetes Service (AKS) or Azure App Service to host all our applications?”
This A or B mindset comes from traditional, on-premises practices, in which building and deploying an application platform required big upfront investments and long lead times. With Azure, you provision and deprovision resources as needed, so you don’t have to make a single choice between A or B. It’s easy and more cost-effective to shift to a modular, A+B approach. You choose the right tool for each job, without being limited to one service to host all your applications.