#RustForCSharpDevs
LightNews LightNews
woodruff.dev
As a C# dev, I live and breathe dotnet new.

Then I tried Rust's cargo new and it felt like meeting a distant cousin with cooler tricks.

Here's how the two CLIs stack up:
woodruff.dev/dotnet-new-m...

#RustLang #DotNet #CSharp #RustForCSharpDevs #DeveloperTools
dotnet new, Meet cargo new: A Tale of Two CLIs - Chris Woody Woodruff
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 like unpacking a new toolbox—f...
woodruff.dev
April 12, 2025 at 12:36 PM
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 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
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 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
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...
woodruff.dev
April 19, 2025 at 2:46 PM
woodruff.dev
After years of C#, I decided to take on Rust.
Why? For the challenge. For the ownership model. For the pain.
This is the beginning of my journey into a language that doesn't hold your hand.

Read it here:
woodruff.dev/why-rust-a-c...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Why Rust? A C# Developer’s Journey Begins - Chris Woody Woodruff
Today marks Day 1 of my 42-day challenge to learn Rust—with a twist. I’m not approaching this as a blank-slate beginner. I’m bringing along years of C# experience, mental muscle memory from countless ...
woodruff.dev
April 11, 2025 at 2:55 PM
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
woodruff.dev
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
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...
woodruff.dev
April 17, 2025 at 2:41 PM
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
I'm learning Rust from a C# developer's perspective—one day at a time for 42 days.

I have 36 days left.

If you're curious how Rust stacks up against .NET, follow along here:
woodruff.dev/from-c-to-ru...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs #42DaysOfRust
From C# to Rust: A 42-Day Developer Challenge - Chris Woody Woodruff
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 dive headfirst into Rust—a system...
woodruff.dev
April 16, 2025 at 4:48 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
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 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 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 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 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
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...
woodruff.dev
April 21, 2025 at 12:48 PM
woodruff.dev
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
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...
woodruff.dev
April 20, 2025 at 2:26 PM
woodruff.dev
Day 5 of learning Rust as a C# dev:

Functions look familiar... until they don’t.

No return keyword, types after names, and the last line does the returning?

It’s weird. It’s clean. I kind of love it.

woodruff.dev/functions-in...

#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Functions in Rust: Familiar Yet Different - Chris Woody Woodruff
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 this language doesn’t always p...
woodruff.dev
April 15, 2025 at 12:16 PM
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 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
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
C# devs, ever peeked at Rust and thought, "WTF is this?"

I will spend 6 weeks learning Rust from a C# mindset and live to tell the tale.

Ownership, lifetimes, and pattern-matching—oh my. Join me!

woodruff.dev/rust-for-the...

#RustLang #CSharp #DotNet #RustForCSharpDevs #LearnRust
Rust for the Sharp Mind: 6 Weeks of Learning Rust as a C# Developer - Chris Woody Woodruff
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 experience a journey filled with r...
woodruff.dev
April 9, 2025 at 10:06 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 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