Mastodawn

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?

Chris Woody Woodruff

Chris Woody Woodruff May 21

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.

Chris Woody Woodruff

Chris Woody Woodruff May 20

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.

Chris Woody Woodruff

Chris Woody Woodruff May 19

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.

Chris Woody Woodruff

Peter Beens

May 19

I'm creating a #RustLang tutorial, and I asked #ChatGPT and #Gemini which should come first: functions or math.

Gemini says functions should come before math.

ChatGPT says the exact opposite.

So I went to Grok to break the tie:

"For a Rust tutorial, teach functions first. Functions are a core concept in Rust, foundational for structuring code and understanding syntax like fn, parameters, and return types...

Agree?

#LearnRust #Programming #GeminiAI #DevEducation

Chris Woody Woodruff May 18

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.

Chris Woody Woodruff

Chris Woody Woodruff May 17

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.

Chris Woody Woodruff

Chris Woody Woodruff May 17

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.

Chris Woody Woodruff

Chris Woody Woodruff May 15

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#.

Chris Woody Woodruff

Chris Woody Woodruff May 14

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.

Chris Woody Woodruff