Final Reflections: What Rust Taught Me as a C# Dev - Chris Woody Woodruff 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 lifetimes, and shipped a working CLI ...

Day 42 of learning Rust as a C# dev:
Rust didn’t just teach me a new language; it taught me to think differently.
Ownership, safety, simplicity... and some hard compiler love.

Final reflections here:
woodruff.dev/final-reflec...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Performance Check: Does Rust Really Fly? - Chris Woody Woodruff 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 have been living in the C# world ...

Day 41 of learning Rust as a C# dev:
I finally ran the performance tests.

Rust starts faster, uses less memory, and feels... sharp.
It doesn’t just run. It flies.

Here’s what I found:
woodruff.dev/performance-...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Packaging and Releasing a Rust CLI Tool - Chris Woody Woodruff 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 tests. Now it is time to get th...

Day 40 of learning Rust as a C# dev:
Packaging and releasing a CLI tool with Cargo is way easier than I expected.
One config file. One command. Done.

Here’s how it works:
woodruff.dev/packaging-an...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Writing Tests in Rust: Familiar and Fast - Chris Woody Woodruff 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 [TestMethod] or [Fact] attributes an...

Day 39 of learning Rust as a C# dev:
Writing tests in Rust is simple, fast, and built right in.
No frameworks, no fluff, just #[test] and cargo test.

Here’s how it compares to .NET:
woodruff.dev/writing-test...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Parsing Arguments and Writing Logic in Rust - Chris Woody Woodruff 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 dig a little deeper into parsi...

Day 37 of learning Rust as a C# dev:
Parsing CLI arguments with clap is clean, fast, and surprisingly fun.
Add a little match, sprinkle in some ?, and boom, real logic.

Here’s what I built:
woodruff.dev/parsing-argu...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Building a CLI App in Rust: My First Project - Chris Woody Woodruff 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 in C# using .NET Console apps, ...

Day 36 of learning Rust as a C# dev:
I built my first CLI app in Rust!

Used clap, wrangled modules, and finally saw it all click together.
It was fast, clean, and honestly? Kinda fun.

Here’s the story:
woodruff.dev/building-a-c...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Week 5: Reflecting on Traits & Lifetimes Power and Pain - Chris Woody Woodruff 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 deadlifts, that means you are doin...

Week 5 of learning Rust as a C# dev is done.
Traits blew my mind. Lifetimes melted it.
It was powerful, painful, and pretty awesome once it all started to click.

Here’s the recap:
woodruff.dev/week-5-refle...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Rust Iterators and Functional Combinators - Chris Woody Woodruff 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, with just enough Rust flavor to...

Day 34 of learning Rust as a C# dev:
If you love LINQ, Rust’s iterators and combinators will feel like home, with a twist.
Lazy, composable, and shockingly fast.

Here’s what makes them click:
woodruff.dev/iterators-an...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Closures in Rust: Functional Vibes with a Twist - Chris Woody Woodruff 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 trees. Rust has closures, too, ...

Day 33 of learning Rust as a C# dev:
Closures in Rust feel like lambdas until the borrow checker gets involved.

Fn, FnMut, FnOnce... it’s functional programming with personality.

Here’s what I learned:
woodruff.dev/closures-in-...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Generics in Rust vs Generics in C# - Chris Woody Woodruff Welcome to Day 31, and today we are diving into generics. If you are coming from C# this is probably familiar ground. You know and love List, Dictionary, and all the type-safe goodness that generics b...

Day 31 of learning Rust as a C# dev:
Rust generics feel like C# generics with more power and more punctuation.
Trait bounds, zero-cost abstraction, and compile-time safety? Yes, please.

Here’s how they compare:
woodruff.dev/generics-in-...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Trait Objects: Goodbye virtual, Hello dyn - Chris Woody Woodruff 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 usually reach for abstract class...

Day 30 of learning Rust as a C# dev:
Rust doesn’t do virtual, but it does have dyn.
Trait objects give you polymorphism without the inheritance party.

Here’s how it works:
woodruff.dev/trait-object...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Traits in Rust: Interfaces That Do More - Chris Woody Woodruff 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. Traits in Rust define shared ...

Day 29 and start of week 5 of learning Rust as a C# dev:
Traits are like interfaces—but with superpowers.
Default methods are behavior-focused and way more flexible.

Here’s why I’m loving them:
woodruff.dev/traits-in-ru...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Week 4: Reflecting on Errors and Structure - Chris Woody Woodruff 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 crates to handling errors with grace...

Week 4 of learning Rust as a C# dev is done.

This one was all about structure and errors:
Custom errors, the ? operator, panic!, modules, and real logging.

Less chaos, more clarity.

Here’s the recap:
woodruff.dev/week-4-refle...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Error Propagation with ?: So Simple, So Smart - Chris Woody Woodruff 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/c...

Day 24 of learning Rust as a C# dev:
The ? operator is the cleanest error-handling tool I didn’t know I needed.

It says “bubble this up” without all the boilerplate.

Here’s why I love it:
woodruff.dev/error-propag...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Crates and Dependencies: NuGet, Meet Cargo - Chris Woody Woodruff 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, an...

Day 23 of learning Rust as a C# dev:
NuGet, meet Cargo.

Rust’s package manager handles builds, tests, docs, and deps from one CLI.

It’s like NuGet, but with less XML and more joy.

Check it out:
woodruff.dev/crates-and-d...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Organizing Code: Rust Modules vs C# Namespaces - Chris Woody Woodruff 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 yo...

Day 22 of learning Rust as a C# dev:
C# has namespaces. Rust has modules.
One feels automatic, the other makes you think. A lot.

Here’s how organizing code in Rust compares and why it eventually clicks:
woodruff.dev/organizing-c...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Result<T,E>: A Better Way to Fail - Chris Woody Woodruff 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...

Day 20 of learning Rust as a C# dev:
Rust doesn’t throw exceptions—it returns them.

Result<T, E> makes failure part of your type system, not a surprise at runtime.

Here’s why that’s a good thing:
woodruff.dev/result-a-bet...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Option<T>: Where Null Is Not an Option - Chris Woody Woodruff 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 b...

Day 19 of learning Rust as a C# dev:
Rust doesn’t do nulls.
Instead, you get Option<T>—safe, explicit, and impossible to ignore.
It’s like null handling, but without the fear.

Here’s how it works:
woodruff.dev/optiont-wher...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Destructuring: Pattern Matching’s Power Move - Chris Woody Woodruff 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 f...

Day 18 of learning Rust as a C# dev:
Destructuring in Rust feels like unlocking a secret power.
Pull apart structs, tuples, and enums cleanly—no mess, no fuss.

Here’s why it’s my new favorite move:
woodruff.dev/destructurin...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Match: Switch on Steroids - Chris Woody Woodruff 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...

Day 17 of learning Rust as a C# dev:
Rust’s match is what I always wanted switch to be.
No fallthrough, no missing cases, just clean, safe pattern matching that works.

Here’s why it feels like switch on steroids:
woodruff.dev/match-switch...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Enums: Discriminated Unions Done Right - Chris Woody Woodruff 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...

Day 16 of learning Rust as a C# dev:
Enums in Rust aren’t your basic list of values. They’re powerful, data-carrying, pattern-matching champs.
Discriminated unions done right.

Here’s why I’m impressed:
woodruff.dev/enums-discri...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Rust Structs vs C# Classes: Less is More - Chris Woody Woodruff 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, "...

Day 15 of learning Rust as a C# dev:

No classes. No inheritance. No constructors.

Rust structs keep it simple and make you rethink how much you really need.

Here’s why less is more:
woodruff.dev/rust-structs...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Week 2: Reflections on Ownership Week: My Brain Hurts (in a Good Way) - Chris Woody Woodruff 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 wor...

Week 2 of learning Rust as a C# dev is done

Ownership, borrowing, move semantics, the stuff that makes your head spin, but your code safer.

My brain hurts (in a good way). Here’s what I learned:
woodruff.dev/week-2-refle...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Shadowing in Rust: Redeclaring with Style - Chris Woody Woodruff 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,...

Day 13 of learning Rust as a C# dev:
Shadowing allows you to redeclare a variable with the same name intentionally.

No hacks. No temp2 or tempFinal. Just clean, intentional redeclaration.

Here’s how it works:
woodruff.dev/shadowing-in...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Slices and Strings with Rust: Goodbye C# StringBuilder? - Chris Woody Woodruff 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 when a for loop starts building...

Day 12 of learning Rust as a C# dev:
No StringBuilder. No problem.

Rust’s slices and strings make you rethink how to work with text, without all the copying and overhead.

Here’s what I learned:
woodruff.dev/slices-and-s...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

The Borrow Checker: Rust’s Tough-Love Mentor - Chris Woody Woodruff 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 mad, just disappointed. Today, on...

Day 11 of learning Rust as a C# dev:
The borrow checker isn’t your enemy. It’s your tough-love mentor.
It yells a lot, but it’s making you a better developer, whether you like it or not.

Read more:
woodruff.dev/the-borrow-c...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Borrowing and References: Rust’s Version of ref (But Nicer) - Chris Woody Woodruff 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 read or modify the original val...

Day 10 of learning Rust as a C# dev:
Borrowing in Rust feels like ref, but stricter, smarter, and way more protective.
It’s not just syntax. It’s a whole new way of thinking about data.

Here’s how it works:
woodruff.dev/borrowing-an...

#RustLang #CSharp #DotNet #RustForCSharpDevs #LearnRust

Move Semantics in Rust: What Just Happened to My Variable? - Chris Woody Woodruff 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 a fit, and you’re left staring...

Day 9 of learning Rust as a C# dev:
I moved a variable, and the compiler yelled at me.
It turns out that Move Semantics isn't just a feature... it's a mindset shift.

Here’s what I learned:
woodruff.dev/move-semanti...

#RustLang #CSharp #DotNet #RustForCSharpDevs

Ownership in Rust: The Most C++-ish Thing I’ve Loved (and I Mean That in a Good Way) - Chris Woody Woodruff 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 background, sweeping up after my code, ...

Day 8 of learning Rust as a C# dev:
Ownership is the most C++-ish thing I’ve seen in Rust, and I actually love it.
It’s strict, it’s smart, and it makes you think before you move anything.

woodruff.dev/ownership-in...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs

Reflections on Week 1: Rust's Minimalism Hits Different - Chris Woody Woodruff 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 we...

Week 1 of learning Rust as a C# dev:

Fewer keywords. Stricter rules. More thinking.
Rust’s minimalism doesn’t just simplify, it reshapes how you code.

Here are my takeaways from the first 7 days:
woodruff.dev/reflections-...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs