From C# to Rust: A 42-Day Developer Challenge

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

1. Day 1: Why Rust? A C# Developer’s Journey Begins

2. Day 2: Installing Rust: From dotnet new to cargo new

3. Day 3: Hello, World! Rust vs C# Syntax

4. Day 4: Variables in Rust: Let Me Be Immutable

5. Day 5: Functions in Rust: Familiar Yet Different

6. Day 6: Scalar and Compound Types: Where Are My Classes?

7. Day 7: Reflections on Week 1: Rust’s Minimalism Hits Different

8. Day 8: Ownership: The Most C++-ish Thing I’ve Loved

9. Day 9: Move Semantics: What Just Happened to My Variable?

10. Day 10: Borrowing and References: Rust’s Version of ref

11. Day 11: The Borrow Checker: Rust’s Tough-Love Mentor

12. Day 12: Slices and Strings: Goodbye StringBuilder?

13. Day 13: Shadowing in Rust: Redeclaring with Style

14. Day 14: Week 2 Reflection: Borrow Checker vs Garbage Collector

15. Day 15: Rust Structs vs C# Classes: Less is More

16. Day 16: Enums: Discriminated Unions Done Right

17. Day 17: Match: Switch on Steroids

18. Day 18: Destructuring: Pattern Matching’s Power Move

19. Day 19: Option: Where Null Is Not an Option

20. Day 20: Result<T, E>: A Better Way to Fail

21. Day 21: Week 3 Wrap-Up: Data Modeling That Fights Back

22. Day 22: Organizing Code: Rust Modules vs C# Namespaces

23. Day 23: Crates and Dependencies: NuGet, Meet Cargo

24. Day 24: Error Propagation with ?: So Simple, So Smart

25. Day 25: Panic! vs Exceptions: Stop the World or Handle It?

26. Day 26: Custom Errors: From Display to thiserror

27. Day 27: Logging in Rust: Tracing Without Console.WriteLine

28. Day 28: Reflection on Errors and Modules

29. Day 29: Traits in Rust: Interfaces That Do More

30. Day 30: Trait Objects: Goodbye virtual, Hello dyn

31. Day 31: Generics in Rust vs Generics in C#

32. Day 32: Lifetimes: Surviving the First Encounter

33. Day 33: Closures in Rust: Functional Vibes with a Twist

34. Day 34: Iterators and Functional Combinators

35. Day 35: Reflection: Traits & Lifetimes—Power and Pain

36. Day 36: Building a CLI App in Rust: My First Project

37. Day 37: Parsing Arguments and Writing Logic

38. Day 38: Working with Files and the Filesystem

39. Day 39: Writing Tests in Rust: Familiar and Fast

40. Day 40: Packaging and Releasing a Rust CLI Tool

41. Day 41: Performance Check: Does Rust Really Fly?

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