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 systems programming language that promises performance, safety, and no nulls.
Over the course of 42 days, we will learn something new about Rust every single day. We will fight the borrow checker. We will make mistakes. And I will blog it all from the perspective of a C# developer trying to make sense of it.
What to Expect
- Real comparisons between Rust and C#
- Lessons on ownership, pattern matching, traits, and lifetimes
- Daily reflections from a .NET developer mindset
Daily Breakdown
- Day 1: Why Rust? A C# Developer’s Journey Begins
- Day 2: Installing Rust: From dotnet new to cargo new
- Day 3: Hello, World! Rust vs C# Syntax
- Day 4: Variables in Rust: Let Me Be Immutable
- Day 5: Functions in Rust: Familiar Yet Different
- Day 6: Scalar and Compound Types: Where Are My Classes?
- Day 7: Reflections on Week 1: Rust’s Minimalism Hits Different
- Day 8: Ownership: The Most C++-ish Thing I’ve Loved
- Day 9: Move Semantics: What Just Happened to My Variable?
- Day 10: Borrowing and References: Rust’s Version of ref
- Day 11: The Borrow Checker: Rust’s Tough-Love Mentor
- Day 12: Slices and Strings: Goodbye StringBuilder?
- Day 13: Shadowing in Rust: Redeclaring with Style
- Day 14: Week 2 Reflection: Borrow Checker vs Garbage Collector
- Day 15: Rust Structs vs C# Classes: Less is More
- Day 16: Enums: Discriminated Unions Done Right
- Day 17: Match: Switch on Steroids
- Day 18: Destructuring: Pattern Matching’s Power Move
- Day 19: Option<T>: Where Null Is Not an Option
- Day 20: Result<T, E>: A Better Way to Fail
- Day 21: Week 3 Wrap-Up: Data Modeling That Fights Back
- Day 22: Organizing Code: Rust Modules vs C# Namespaces
- Day 23: Crates and Dependencies: NuGet, Meet Cargo
- Day 24: Error Propagation with ?: So Simple, So Smart
- Day 25: Panic! vs Exceptions: Stop the World or Handle It?
- Day 26: Custom Errors: From Display to thiserror
- Day 27: Logging in Rust: Tracing Without Console.WriteLine
- Day 28: Reflection on Errors and Modules
- Day 29: Traits in Rust: Interfaces That Do More
- Day 30: Trait Objects: Goodbye virtual, Hello dyn
- Day 31: Generics in Rust vs Generics in C#
- Day 32: Lifetimes: Surviving the First Encounter
- Day 33: Closures in Rust: Functional Vibes with a Twist
- Day 34: Iterators and Functional Combinators
- Day 35: Reflection: Traits & Lifetimes—Power and Pain
- Day 36: Building a CLI App in Rust: My First Project
- Day 37: Parsing Arguments and Writing Logic
- Day 38: Working with Files and the Filesystem
- Day 39: Writing Tests in Rust: Familiar and Fast
- Day 40: Packaging and Releasing a Rust CLI Tool
- Day 41: Performance Check: Does Rust Really Fly?
- Day 42: Final Reflections: What Rust Taught Me as a C# Dev
Final Recap
Once you’re ready for the whole story, read the full recap: Rust for the Sharp Mind: 6 Weeks of Learning Rust as a C# Developer.
This journey will stretch our brains, challenge our assumptions, and ultimately make us better developers on any platform. I hope you will join me.