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:
https://woodruff.dev/final-reflections-what-rust-taught-me-as-a-c-dev/
#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 app. Along the way, there were moments of frustration, lightbulb moments, and more than a few “why is this so hard” conversations with the compiler. This final reflection is about stepping back and asking the big questions. What did Rust really teach me? What am I taking back to my C# projects? What might be next?
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:
https://woodruff.dev/performance-check-does-rust-really-fly/
#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 where the JIT and garbage collector handle things for you this is a good chance to see how Rust stacks up when it comes to raw speed.
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:
https://woodruff.dev/packaging-and-releasing-a-rust-cli-tool/
#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 that shiny CLI tool into the hands of others. This process will feel familiar if you have worked with .NET global tools. Rust’s cargo makes it easy to build, release, and share your command-line apps.
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:
https://woodruff.dev/writing-tests-in-rust-familiar-and-fast/
#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 and Assert.Equal calls. Rust’s testing system is going to feel pretty familiar with a bit of Rust flair.
Day 38 of learning Rust as a C# dev:
Reading, writing, and creating files and directories. Rust lends a sense of cleanliness and deliberation.
No magic, just std::fs, ?, and a lot of compiler support.
Here’s what I learned:
https://woodruff.dev/working-with-files-and-the-filesystem-in-rust/
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Working with Files and the Filesystem in Rust - Chris Woody Woodruff
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 written C# code using System.IO this is going to feel familiar but with a Rust twist.
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:
https://woodruff.dev/parsing-arguments-and-writing-logic/
#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 parsing arguments, handling input validation, and structuring our logic cleanly. If you are coming from the C# world, this is where you would probably set up your Program.cs to parse args[], maybe use a library like CommandLineParser, and then branch out into your application logic. Rust gives you similar tools but with its own flavor.
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:
https://woodruff.dev/building-a-cli-app-in-rust-my-first-project/
#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, you will feel right at home. Rust has the same capability with a few extras that make the experience feel pretty slick.
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:
https://woodruff.dev/week-5-reflecting-on-traits-lifetimes-power-and-pain/
#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 doing it right. Traits and lifetimes bring a lot of power to Rus,t but they can also make your head spin if you are used to the more relaxed rules of C#. Let us take a moment to look back on what we covered and how Rust compares to what you might be used to with C#.
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:
https://woodruff.dev/iterators-and-functional-combinators/
#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 keep it interesting.
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:
https://woodruff.dev/closures-in-rust-functional-vibes-with-a-twist/
#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, and they bring a nice functional flavor to the language with some unique Rust twists.
Chris Woody Woodruff