Final Reflections: What Rust Taught Me as a C# Dev
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?
Continue Reading
Performance Check: Does Rust Really Fly?
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.
Continue Reading
Packaging and Releasing a Rust CLI Tool
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.
Continue Reading
Writing Tests in Rust: Familiar and Fast
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.
Continue Reading
Working with Files and the Filesystem in Rust
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.
Continue Reading
Parsing Arguments and Writing Logic in Rust
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.
Continue Reading
Building a CLI App in Rust: My First Project
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.
Continue Reading
Week 5: Reflecting on Traits & Lifetimes Power and Pain
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#.
Continue Reading
Rust Iterators and Functional Combinators
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.
Continue Reading
Closures in Rust: Functional Vibes with a Twist
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.
Continue Reading
