Final Reflections: What Rust Taught Me as a C# Dev
Day 42, and here we are. Six weeks of learning Rust from the perspective of a C developer. We covered the basics, wrestled with ownership, danced with traits and…
Category
Rust
53 articles.
Performance Check: Does Rust Really Fly?
Welcome to Day 41, and we are almost done! Today, we are putting Rust’s performance reputation to the test. Rust has a reputation for being fast. But how fast? If you…
Packaging and Releasing a Rust CLI Tool
Day 40, and today we are looking at how to package and release your Rust CLI app. You have written the code, added argument parsing, handled the logic, and even written…
Writing Tests in Rust: Familiar and Fast
Onward to Day 39. Today, we're discussing testing in Rust. If you are a C developer, you have probably spent time with xUnit, NUnit, or MSTest. You know the usual…
Working with Files and the Filesystem in Rust
Welcome to Day 38. Today, we're getting our hands dirty with file I/O. Reading and writing files is one of those tasks every app must perform at some point. If you have…
Building a CLI App in Rust: My First Project
It's day 36, and today, we are shifting gears from theory to practice. It is time to roll up our sleeves and build something. If you have ever built a command-line tool…
Parsing Arguments and Writing Logic in Rust
We are up to Day 37, and today, we are continuing to build out our Rust CLI app. Last time, we set up a simple command-line tool using the clap crate. Now, it is time to…
Week 5: Reflecting on Traits & Lifetimes Power and Pain
You've made it to Day 35, and we're wrapping up Week 5. This week was all about Rust’s generics, contracts, and lifetimes. If your brain feels like it has been doing…
Rust Iterators and Functional Combinators
Welcome to Day 34, and today we are taking a stroll through one of the most satisfying parts of Rust. If you're a C developer who loves LINQ, this will feel like home…
Closures in Rust: Functional Vibes with a Twist
Welcome to Day 33, and today we are jumping into closures. If you have been writing C for a while, you are no stranger to lambdas, delegates, and maybe even expression…
Lifetimes: Surviving the First Encounter
Day 32, and today we are stepping into one of Rust’s most talked-about features. If you have heard scary stories about lifetimes, do not worry. This is your first…
Generics in Rust vs Generics in C#
Welcome to Day 31. Today, we're diving into generics. If you are coming from C this is probably familiar ground. You know and love List , Dictionary , and all the…
Trait Objects: Goodbye virtual, Hello dyn
Welcome to Day 30 and today we are going to explore how Rust handles dynamic dispatch with trait objects. If you are used to the world of C this is the part where you…
Traits in Rust: Interfaces That Do More
Welcome to Day 29 where we are stepping into one of Rust’s most powerful features. If you are a C developer think of traits as interfaces but with some serious upgrades.…
Week 4: Reflecting on Errors and Structure
Day 28 marks the end of Week 4 and it is time to pause for a quick reflection. We have covered a lot of ground this week from organizing Rust code with modules and…
Logging in Rust: Tracing Without Console.WriteLine
Welcome to Day 27, and let’s talk about how Rust handles logging the smart way. If you have been in the .NET world for any amount of time, you are probably used to…
Custom Errors: From Display to thiserror
Look at this! Day 26, and today we’re talking about one of my favorite things to not ignore: error messages. Because when things go sideways (and they will), your future…
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…
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…
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…
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…
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…
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.…
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+…
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…
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…
Enums: Discriminated Unions Done Right
Welcome to day 17! 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.…
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…
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…
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…
Slices and Strings with Rust: Goodbye C# StringBuilder?
When you’ve spent years writing C, you get really comfortable with string being immutable, Span being your performance trick, and StringBuilder being your go-to hammer…
The Borrow Checker: Rust’s Tough-Love Mentor
You think you’ve been writing safe code… until you meet the Rust borrow checker. Then suddenly, your once-proud instincts are being side-eyed by a compiler that’s not…
Borrowing and References: Rust’s Version of ref (But Nicer)
If you've been writing C for a while, you’ve likely crossed paths with ref, in, and out parameters. They allow you to pass variables by reference, enabling a method to…
Move Semantics in Rust: What Just Happened to My Variable?
Okay, so picture this: you're cruising along in your nice, type-safe Rust code, and suddenly... your variable vanishes. Not literally, of course. But the compiler throws…
Ownership in Rust: The Most C++-ish Thing I’ve Loved (and I Mean That in a Good Way)
Let’s get one thing out of the way: as a C developer, I’ve never had to think too hard about memory. The garbage collector (GC) is always there, lurking in the…
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…
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…
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…
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.…
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…
dotnet new, Meet cargo new: A Tale of Two CLIs
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…
Why Rust? A C# Developer’s Journey Begins
The daily list of topics for the series is here: From C to Rust: A 42-Day Developer Challenge Today marks Day 1 of my 42-day challenge to learn Rust—with a twist. I’m…
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…
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…
Rust's Superpower: Speed Meets Smarts
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Level Up Your Skills: Learning Rust as a C# Dev
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Building with .NET and Rust: A Tale of Two Ecosystems
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Threads, Tasks, and Ownership: C# and Rust Concurrency Explored
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Memory Wars: Garbage Collection in C# vs. Ownership in Rust
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Syntax Showdown: A Look at Common Constructs in C# and Rust
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Exploring Programming Paradigms: C# and Rust Side by Side
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
Why Every C# Developer Should Explore Rust
- Part 1: Why Every C Developer Should Explore Rust - Part 2: Exploring Programming Paradigms: C and Rust Side by Side - Part 3: Syntax Smackdown: Comparing Constructs…
From C# to Rust: A Journey Through Code and Concepts
Welcome to my epic blog series, where we pit C against Rust in a friendly, code-slinging showdown! If you’re a C developer curious about Rust’s quirks and power or a…