Category: Rust

Today’s Rust lesson hit a familiar note but with a twist. Writing functions in Rust feels almost like writing them in C#. Until, of course, the compiler reminds you that this language doesn’t always play by the same rules.

On Day 5 of my Rust-for-C# developers journey, let’s break down function definitions, type inference, return values, and where Rust and C# shake hands… and where they give each other a suspicious side-eye.
On Day 5 of my Rust-for-C# developers journey, let’s break down function definitions, type inference, return values, and where Rust and C# shake hands… and where they give each other a suspicious side-eye.

So today, I ran head-first into a Rust design decision that made me pause and go, “Wait… really?”

In C#, I can declare a variable with var and change it later. No fuss. In Rust? Not so fast. Your variables are frozen solid if you don’t explicitly ask for mutability. Welcome to Day 4: the world of let, mut, and what happens when your muscle memory meets a strict compiler.

Let’s be honest—every new language journey begins the same way: with a humble “Hello, World!” It’s the developer’s rite of passage. So today, on Day 3 of my 42-day Rust challenge, I’m writing the most iconic two-word phrase in programming in both C# and Rust… and then tearing it apart.

Because while the output is the same, what these two languages make you say to get there reveals a lot about how they think.

It’s Day 2 of my journey learning Rust as a longtime C# developer, and today I took the plunge: I installed Rust and created my first project. The whole thing felt a bit like unpacking a new toolbox—familiar enough to recognize the tools, but different enough that I had to check the manual.

Today marks Day 1 of my 42-day challenge to learn Rust—with a twist. I’m not approaching this as a blank-slate beginner. I’m bringing along years of C# experience, mental muscle memory from countless LINQ expressions, async/await workflows, and enough IEnumerables to make your head spin.

But now? I’m learning a language that doesn’t have a garbage collector, doesn’t throw exceptions the same way, and thinks null is a bad idea.

I’ve spent over a decade writing C# and building solutions on .NET. But for six weeks, we will step outside the managed world of garbage collection and runtime JIT to dive headfirst into Rust—a systems programming language that promises performance, safety, and no nulls.

Over the course of 42 days, we will learn something new about Rust every single day. We will fight the borrow checker. We will make mistakes. And I will blog it all from the perspective of a C# developer trying to make sense of it.

Regarding speed and efficiency, Rust doesn’t just run the race—it leaves other languages eating its dust. Built for blazing performance and low-level control, Rust’s unique features make it a standout choice for projects where every millisecond and megabyte count. Let’s dive into why Rust is the Usain Bolt of programming languages and how it stacks up in the performance department.

Switching from C# to Rust can feel like stepping into a new world. Suddenly, you’re dealing with ownership, borrowing, and a compiler that’s as strict as your high school math teacher. But don’t worry—you’ve got this. With the right mindset, some practical tips, and a few helpful resources, you’ll go from a Rust rookie to a Rustacean in no time. Let’s dive in!

Programming ecosystems are like bustling cities. .NET is the metropolis with skyscrapers and a thriving business district, while Rust is the up-and-coming tech hub—small but mighty, with startups everywhere. Both offer incredible opportunities, but their vibes are very different. So, let’s grab a coffee and tour these two dynamic ecosystems!