Panic! vs Exceptions: Stop the World or Handle It?
Okay, we’re on Day 25, and today we’re stepping into the world of failure again. But this time, it’s the catastrophic kind. We’re not talking about the “file didn’t open” kind of error. Nope, we’re talking about “game over, stop everything, hit the eject button” failure.
In .NET, you’re familiar with exceptions. In Rust, there’s something called panic!. But these two aren’t quite the same thing. Rust draws a hard line between recoverable errors and unrecoverable failures, and understanding that line is a big mindset shift for anyone coming from C#.
Continue Reading
Error Propagation with ?: So Simple, So Smart
Day 24… today we’re digging into one of my favorite “why doesn’t every language have this?” features in Rust: the ? operator.
If you’ve spent any time in C#, you’re no stranger to the good ol’ try/catch flow. You wrap some code in a try, you catch the exception, and you hope you didn’t forget to check for null or some unexpected state.
Rust takes a different approach with Result and the magic of the ? operator. It keeps your error handling clean, readable, and safe without the overhead (or drama) of exceptions.
Continue Reading
Crates and Dependencies: NuGet, Meet Cargo
Day 23… let’s talk about how Rust gets its packages! If you’re coming from the .NET world, you’re no stranger to NuGet. It’s been your trusty sidekick for pulling in libraries, managing versions, and bloating that csproj file with package references.
In Rust, the equivalent is Cargo, and its packages are called crates. But here’s the twist: Cargo doesn’t just handle your dependencies. It’s your project manager, your build system, your tester, and your publisher, all rolled into one delightful tool.
Continue Reading
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
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<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<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
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
Enums: Discriminated Unions Done Right
Welcome to day 15! Today, we’re diving into Rust’s enums—and spoiler alert—they’re not your typical enums from C#. Rust enums are powerful, flexible, and genuinely fun. If you’ve ever looked longingly at F#’s discriminated unions (or scratched your head at C#’s enums), you’re about to discover something delightful.
Continue Reading
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
