Reflections on Week 1: Rust's Minimalism Hits Different

Reflections on Week 1: Rust’s Minimalism Hits Different

Seven days into learning Rust, and I feel like I’ve been through a developer bootcamp with a compiler that doubles as a personal trainer. It doesn’t let you slack, but it does make you better.

This week, I went from installing the toolchain to wrestling with immutable variables and puzzling over semicolons in return statements. As a C# developer, I expected syntax differences, but I didn’t expect the philosophical shifts.

Let’s recap what stood out, what stung, and why I’m still excited to keep going.

Continue Reading
Rust Scalar and Compound Types: Where Are My C# Classes?

Rust Scalar and Compound Types: Where Are My C# Classes?

When I first started exploring Rust, one of my instincts was to reach for a class. You know the drill. Need to model some data? Write a class, slap a few properties on it, and maybe add a constructor or two.

But Rust had other plans.

On Day 6, I dug into Rust’s scalar and compound types and quickly realized that Rust doesn’t want you to start with classes. Instead, it hands you a small set of powerful primitives and says, “Let’s build something lean.”

Continue Reading
Functions in Rust: Familiar Yet Different

Functions in Rust: Familiar Yet Different

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.

Continue Reading
Variables in Rust: Let Me Be Immutable

Variables in Rust: Let Me Be Immutable

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.

Continue Reading
Hello, World! Rust vs C# Syntax

Hello, Rust! Hello, World! Rust vs C# Syntax

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.

Continue Reading
Why Rust? A C# Developer’s Journey Begins

Why Rust? A C# Developer’s Journey Begins

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.

Continue Reading
From C# to Rust A 42-Day Developer Challenge

From C# to Rust: A 42-Day Developer Challenge

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.

Continue Reading
Rust for the Sharp Mind: 6 Weeks of Learning Rust as a C# Developer

Rust for the Sharp Mind: 6 Weeks of Learning Rust as a C# Developer

What will happen when you take a C# developer, hand them a curly-brace language that loves safety and hates nulls, and give them six weeks to figure it out?

You will experience a journey filled with rewired brain circuits, redefined mental models, and a newfound respect for the compiler. This will mark the beginning of my 42-day dive into Rust, a daily learning challenge that will push me out of my .NET comfort zone and into a language that promises to be both frustratingly strict and beautifully empowering.

Continue Reading