<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Jarne's blog</title>
    <link>https://jarnevanaerde.be/</link>
    <description>Recent content on Jarne's blog</description>
    <language>en-us</language>
    <lastBuildDate>Mon, 22 Dec 2025 17:23:04 +0100</lastBuildDate><atom:link href="https://jarnevanaerde.be/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Vibe coding: Has the vibe ended?</title>
      <link>https://jarnevanaerde.be/posts/vibe-coding-has-the-vibe-ended/</link>
      <pubDate>Mon, 22 Dec 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/vibe-coding-has-the-vibe-ended/</guid>
      
      <description>If you clicked on this blog post, you’ve probably already come across the term Vibe Coding. In fact, it became so widespread that Collins Dictionary selected it as the Word of the Year in 2025. The idea is simple, instead of writing every line of code yourself, developers now “vibe” with an AI assistant by prompting and steering the agent towards a solution.
But there’s a catch 🎣, and it’s one many developers are now starting to notice.</description>
      
    </item>
    
    <item>
      <title>Is it time to break up with your Test Framework? A look at TUnit</title>
      <link>https://jarnevanaerde.be/posts/is-it-time-to-break-up-with-your-test-framework--a-look-at-tunit/</link>
      <pubDate>Fri, 28 Nov 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/is-it-time-to-break-up-with-your-test-framework--a-look-at-tunit/</guid>
      
      <description>For years, .NET testing has mostly meant xUnit, NUnit or MSTest. They’ve done the job, they’re battle-tested, and most of us never really questioned if there was anything fundamentally better out there. Until TUnit arrived. It’s built as a modern test framework from the ground up.
I’ve been experimenting with TUnit recently 🧪, and in this post I want to go through what I see as its main benefits, what stands out compared to the other frameworks, and share my personal take on the big question: should you switch to TUnit, or not (yet)?</description>
      
    </item>
    
    <item>
      <title>I don&#39;t like auto mappers in C#, but this one deserves a look</title>
      <link>https://jarnevanaerde.be/posts/i-do-not-like-auto-mappers-in-c-sharp-but-this-one-deserves-a-look/</link>
      <pubDate>Thu, 23 Oct 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/i-do-not-like-auto-mappers-in-c-sharp-but-this-one-deserves-a-look/</guid>
      
      <description>I’m going to be honest, I don&amp;rsquo;t like auto mappers. They hide too much logic, make debugging harder, and usually add another layer of magic you don’t need. But every once in a while, something shows up that actually piques my interest, like Facet, a compile-time mapper that, in my opinion, has some nicer ways of handling mapping scenarios, and also how it deals with EF Core projections.
I took it for a spin, tried some things out, and benchmarked it against AutoMapper and Mapster.</description>
      
    </item>
    
    <item>
      <title>3 C# performance tips that surprised me</title>
      <link>https://jarnevanaerde.be/posts/3-c-sharp-performance-tips-that-surprised-me/</link>
      <pubDate>Wed, 24 Sep 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/3-c-sharp-performance-tips-that-surprised-me/</guid>
      
      <description>In programming, certain ideas often feel like common knowledge. They sit in the back of our minds, perhaps learned in school or simply remembered that way over time. Yet, our assumptions can sometimes mislead us. What was once true may no longer apply, or in some cases, may never have been accurate at all.
In this post, I want to share three small C# performance tips I learned this year.</description>
      
    </item>
    
    <item>
      <title>C# advice that sounds genius until you try it</title>
      <link>https://jarnevanaerde.be/posts/c-sharp-advice-that-sounds-genius-until-you-try-it/</link>
      <pubDate>Mon, 25 Aug 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/c-sharp-advice-that-sounds-genius-until-you-try-it/</guid>
      
      <description>Have you ever read or heard a piece of C# advice and thought, “Hmm, that actually makes a lot of sense”? Until you start using it, and after a while you regret it?
In this blog post, I will talk about some examples of advice that sound smart at first but don’t hold up in practice. They&amp;rsquo;re not completely useless, but do more harm than good.
I am aware this is a subjective blog post.</description>
      
    </item>
    
    <item>
      <title>What’s new in C# 14</title>
      <link>https://jarnevanaerde.be/posts/whats-new-in-c-sharp-14/</link>
      <pubDate>Thu, 24 Jul 2025 09:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/whats-new-in-c-sharp-14/</guid>
      
      <description>With .NET 10 around the corner, we&amp;rsquo;re also getting the C# 14 language alongside it. Ah yes, .NET 10 and C# 14, because nothing says “we’ve got this under control” more like completely unrelated version numbers. How well, here we are!
In this blog post, I’ll highlight some of the new features coming with C# 14 and share my thoughts on whether they’re actually useful or just nice-to-haves. 🧠
The big news: Extension members Let&amp;rsquo;s start big with extension members.</description>
      
    </item>
    
    <item>
      <title>Run independent C# files instantly with &#39;dotnet run&#39;</title>
      <link>https://jarnevanaerde.be/posts/run-independent-c-sharp-files-instantly-with-dotnet-run/</link>
      <pubDate>Sun, 22 Jun 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/run-independent-c-sharp-files-instantly-with-dotnet-run/</guid>
      
      <description>I still remember the first time I learned C# back in college. At the time, we were working with .NET Framework 4.8, and let me tell you, writing C# wasn’t just a matter of typing some code and running it. While the language itself was fairly easy to write and understand, getting everything to work involved much more than just the C# code.
There was the whole setup process: solution files, project files (.</description>
      
    </item>
    
    <item>
      <title>Caching in .NET: What you should and shouldn&#39;t be using</title>
      <link>https://jarnevanaerde.be/posts/caching-in-.net-what-you-should-and-shouldnt-be-using/</link>
      <pubDate>Tue, 06 May 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/caching-in-.net-what-you-should-and-shouldnt-be-using/</guid>
      
      <description>Caching is a powerful technique that we can use to optimize the performance of an application. In .NET, we already have a few ways on how we can apply caching. .NET 9 introduces another form of caching: The HybridCache. And we also have some third-party options as well. So which ones should you use? In this blog post, I&amp;rsquo;ll talk about some of the caching options we have, and which ones you should and shouldn&amp;rsquo;t be using.</description>
      
    </item>
    
    <item>
      <title>Bridging the gap: Bringing QA Automation Closer to DEV</title>
      <link>https://jarnevanaerde.be/posts/bridging-the-gap-bringing-qa-automation-closer-to-dev/</link>
      <pubDate>Mon, 28 Apr 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/bridging-the-gap-bringing-qa-automation-closer-to-dev/</guid>
      
      <description>Having dedicated QA-ers on your team is a huge enabler. They bring a critical eye to software quality. But in many development environments, QA is involved too late, often waiting for the frontend to be ready before they can begin testing. This delay slows down feedback loops and limits the impact QA can have earlier in the process.
In this post, we&amp;rsquo;ll explore how to bring QA closer to development by enabling them to write tests alongside developers.</description>
      
    </item>
    
    <item>
      <title>Debunking LINQ-myths in .NET</title>
      <link>https://jarnevanaerde.be/posts/debunking-linq-myths-in-.net/</link>
      <pubDate>Tue, 18 Mar 2025 10:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/debunking-linq-myths-in-.net/</guid>
      
      <description>There’s a lot of advice floating around about what you should and should not do when writing LINQ queries in .NET. But how much of that is actually (still) true? With .NET’s constantly evolving codebase, do certain best practices still hold up, or have they turned into myths waiting to be busted?
In this blog post, let&amp;rsquo;s debunk some common LINQ myths together! 👊🏻
🔮 Myth: Find is better than FirstOrDefault Consider we have the following code:</description>
      
    </item>
    
    <item>
      <title>5 things to deepen your knowledge about asynchronous programming in .NET</title>
      <link>https://jarnevanaerde.be/posts/5-things-to-deepen-your-knowledge-about-asynchronous-programming-in-.net/</link>
      <pubDate>Sun, 23 Feb 2025 17:10:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/5-things-to-deepen-your-knowledge-about-asynchronous-programming-in-.net/</guid>
      
      <description>Asynchronous programming has become second nature to many of us. Using async and await feels almost effortless, seamlessly integrating into our daily coding routines. But beyond the basics, there are always new insights and nuances to explore. 🔍
In this blog post, I’ll share 5 things about asynchronous programming in .NET that might not be essential knowledge, but they will give you something to think about. Even if you’re already familiar with some of them, I hope at least one of these topics surprises you!</description>
      
    </item>
    
    <item>
      <title>How to optimize your logging in .NET</title>
      <link>https://jarnevanaerde.be/posts/how-to-optimize-your-logging-in-.net/</link>
      <pubDate>Tue, 14 Jan 2025 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/how-to-optimize-your-logging-in-.net/</guid>
      
      <description>Logging is an essential part of any software. But did you know the built-in logging from Microsoft actually has some flaws? Flaws that could hurt the performance and memory consumption of your application? In this post, I will highlight the problems with the default logging solution from Microsoft, as well as several ways on how to improve this.
Small heads up ☝🏻. Since we&amp;rsquo;re talking about performance, it doesn&amp;rsquo;t always mean that the most optimized solution is the best solution for your specific use case.</description>
      
    </item>
    
    <item>
      <title>7 reasons why you should use Windows Terminal</title>
      <link>https://jarnevanaerde.be/posts/7-reasons-why-you-should-use-windows-terminal/</link>
      <pubDate>Sat, 07 Dec 2024 17:23:04 +0100</pubDate>
      
      <guid>https://jarnevanaerde.be/posts/7-reasons-why-you-should-use-windows-terminal/</guid>
      
      <description>For developers, the command line interface remains an essential part of their daily work. While graphical interfaces are becoming more advanced, the terminal remains indispensable for efficient system interaction and development tasks. With Windows Terminal, Microsoft has introduced a modern solution that elevates the traditional command line experience.
On YouTube, I already discussed this topic alongside Edwin van Wijk and Sander Molenkamp. You can find the video here. 🎬
In this post, I&amp;rsquo;ll highlight 7 reasons from that video on why Windows Terminal will make the life of a developer easier and more fun!</description>
      
    </item>
    
  </channel>
</rss>
