Organizing Code: Rust Modules vs C# Namespaces

Organizing Code: Rust Modules vs C# Namespaces

Welcome to Day 22! After a week of wrestling with data modeling, it’s time to talk about something near and dear to every developer’s heart: keeping your code organized (and your sanity intact).

If you’re a C# developer, you’ve lived in the world of namespaces, public and internal access modifiers, and .cs files that can stack up faster than your coffee cups during crunch time. In Rust, the story is a little different, but delightfully simple once you get the hang of it.

Continue Reading
Week 3 Wrap-Up: Data Modeling That Fights Back

Week 3: Wrap-Up: Data Modeling That Fights Back

Three weeks into Rust, and if your brain isn’t at least a little bit melted, I applaud your resilience! This week was all about data modeling. But not just any modeling—the kind that actively fights back when you try to make bad decisions.

If you’re used to the world of C#, you probably lean on classes, POCOs, and the occasional enum to represent state. And hey, that works… until it doesn’t. Rust’s structs and enums bring some serious muscle to the table by making sure your data models are clear, correct, and (most importantly) safe by design.

Let’s take a moment to reflect on what we learned and why Rust’s approach makes data modeling feel less like a “best practices” hope-and-pray scenario and more like a language-enforced guarantee.

Continue Reading
Result: A Better Way to Fail

Result<T,E>: A Better Way to Fail

Welcome to Day 20! Today we’re talking about failure, but in the best possible way. Because, let’s be honest, things go wrong. Files go missing. Network calls timeout. Data isn’t always what we expect. And if you’ve been living in the .NET world like I have, your first instinct might be to reach for the trusty try-catch block.

Rust, though? Rust says, “Let’s not wait until runtime to deal with failure. Let’s handle it right now, at compile time.” And the tool that it gives us to do that is Result.
Rust, though? Rust says, “Let’s not wait until runtime to deal with failure. Let’s handle it right now, at compile time.” And the tool it gives us to do that is Result.

Continue Reading
Option: Where Null Is Not an Option

Option<T>: Where Null Is Not an Option

Ah, nulls, the “billion-dollar mistake” that haunts just about every C# developer. How many times have you chased down a NullReferenceException, muttering under your breath, “But how could this even be null?” Well, guess what? In Rust, nulls are not a thing. At least, not in the wild-and-dangerous sense we’re used to in .NET.

Instead, Rust gives us Option. And let me tell you, once you get a taste of it, you’ll wonder why we ever let null run loose in the first place.

Continue Reading
Destructuring: Pattern Matching’s Power Move

Destructuring: Pattern Matching’s Power Move

We’ve made it to Day 18, and today we’re going to unlock one of the coolest moves in Rust’s pattern matching toolkit: destructuring. If you’ve played around with C# 7+ deconstruction, you’re already familiar with the idea of “pulling things apart” for easier access. But Rust? Rust takes that idea, cranks it up, and throws in some extra muscle.

Continue Reading
Match: Switch on Steroids

Match: Switch on Steroids

Welcome to Day 17! By now, we’ve covered some seriously cool Rust features, but today might be my favorite so far: the match expression. If you’re coming from a C# background—especially with the newer C# 8+ switch expressions—you might think you’ve seen it all. Trust me, Rust’s match is like a switch statement on steroids, protein shakes, and a Red Bull chaser.

Continue Reading
Rust Structs vs C# Classes: Less is More

Rust Structs vs C# Classes: Less is More

Welcome back! After wrestling with Rust’s strict ownership rules, let’s ease into something a little more familiar (yet refreshingly different): structs. As a C# developer, you’re probably thinking, “Oh, great, Rust structs are just classes, right?” Well, not exactly. Rust structs offer a minimalist and highly efficient way to structure data, contrasting nicely with our beloved C# Plain Old CLR Objects (POCOs).

Continue Reading
Reflections on Ownership Week: My Brain Hurts (in a Good Way)

Week 2: Reflections on Ownership Week: My Brain Hurts (in a Good Way)

It’s official—week two of learning Rust has wrapped, and I’ve survived. Mostly. This week was all about ownership, borrowing, and wrestling with Rust’s strict rules. And boy, did my C# brain get a workout! It hurts, but honestly, it’s the good kind of pain—the one you feel after finally nailing that tough workout or solving an especially nasty bug.

Continue Reading
Shadowing in Rust: Redeclaring with Style

Shadowing in Rust: Redeclaring with Style

We’ve all been there. You’re coding away, and suddenly you reuse a variable name without realizing it. If you’re a C# developer, your brain probably triggers a warning alarm, screaming something like, “Hey, buddy! You’ve already used that name!” But guess what? In Rust, this isn’t just allowed—it’s encouraged, and it even has a cool name: shadowing.

So what exactly is shadowing, and why does Rust promote it? Let’s dive in and explore how this stylish redeclaration trick differs from what we’re used to in C#.

Continue Reading