#RustForCSharpDevs
LightNews LightNews
woodruff.dev
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
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 ...
woodruff.dev
May 22, 2025 at 11:20 AM
woodruff.dev
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
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 ...
woodruff.dev
May 21, 2025 at 2:48 PM
woodruff.dev
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
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...
woodruff.dev
May 20, 2025 at 1:11 PM
woodruff.dev
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
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...
woodruff.dev
May 19, 2025 at 10:30 AM
woodruff.dev
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
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...
woodruff.dev
May 17, 2025 at 1:09 PM
woodruff.dev
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
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, ...
woodruff.dev
May 17, 2025 at 2:42 AM
woodruff.dev
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
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...
woodruff.dev
May 15, 2025 at 11:57 AM
woodruff.dev
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
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...
woodruff.dev
May 14, 2025 at 12:19 PM
woodruff.dev
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
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, ...
woodruff.dev
May 13, 2025 at 11:49 AM
woodruff.dev
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
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...
woodruff.dev
May 11, 2025 at 12:33 PM
woodruff.dev
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
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...
woodruff.dev
May 10, 2025 at 2:37 PM
woodruff.dev
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
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 ...
woodruff.dev
May 9, 2025 at 12:45 PM
woodruff.dev
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
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...
woodruff.dev
May 8, 2025 at 12:11 PM
woodruff.dev
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
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...
woodruff.dev
May 4, 2025 at 1:50 PM
woodruff.dev
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
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...
woodruff.dev
May 3, 2025 at 1:26 PM
woodruff.dev
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
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...
woodruff.dev
May 2, 2025 at 11:31 AM
woodruff.dev
Day 20 of learning Rust as a C# dev:
Rust doesn’t throw exceptions—it returns them.

Result 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
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...
woodruff.dev
April 30, 2025 at 12:04 PM
woodruff.dev
Day 19 of learning Rust as a C# dev:
Rust doesn’t do nulls.
Instead, you get Option—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
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...
woodruff.dev
April 29, 2025 at 9:19 AM
woodruff.dev
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
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...
woodruff.dev
April 29, 2025 at 12:08 AM
woodruff.dev
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
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...
woodruff.dev
April 27, 2025 at 1:19 PM
woodruff.dev
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
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...
woodruff.dev
April 26, 2025 at 2:23 PM
woodruff.dev
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
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, "...
woodruff.dev
April 25, 2025 at 10:59 AM
woodruff.dev
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
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...
woodruff.dev
April 24, 2025 at 12:15 PM
woodruff.dev
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
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,...
woodruff.dev
April 23, 2025 at 11:48 AM
woodruff.dev
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
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...
woodruff.dev
April 22, 2025 at 3:23 PM