Reflection: Traits & Lifetimes—Power and Pain

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
Lifetimes: Surviving the First Encounter

Lifetimes: Surviving the First Encounter

Day 32, and today we are stepping into one of Rust’s most talked-about features. If you have heard scary stories about lifetimes, do not worry. This is your first encounter, and we are going to make it approachable.

If you are coming from C#, the idea of lifetimes might feel strange at first. In .NET you lean on the garbage collector to handle memory cleanup. You create objects, and when they are no longer needed, the GC comes along and takes out the trash.

Rust does not have a garbage collector. It uses ownership and borrowing to manage memory. Lifetimes are how Rust keeps track of how long references are valid. They are the glue that ties Rust’s memory safety model together.

Continue Reading
Generics in Rust vs Generics in C#

Generics in Rust vs Generics in C#

Welcome to Day 31, and today we are diving into generics. If you are coming from C# this is probably familiar ground. You know and love List, Dictionary, and all the type-safe goodness that generics bring to your code.

Rust has generics too but with a twist. The syntax might look similar but Rust’s approach gives you some extra control and a few new things to think about.

Continue Reading
Trait Objects: Goodbye virtual, Hello dyn

Trait Objects: Goodbye virtual, Hello dyn

Welcome to Day 30 and today we are going to explore how Rust handles dynamic dispatch with trait objects. If you are used to the world of C# this is the part where you usually reach for abstract classes or virtual methods. Maybe you sprinkle in some interfaces and let polymorphism do the heavy lifting at runtime.

In Rust dynamic dispatch works a little differently and it is all thanks to dyn.

Continue Reading
Logging in Rust: Tracing Without Console.WriteLine

Logging in Rust: Tracing Without Console.WriteLine

Welcome to Day 27 and let’s talk about how Rust handles logging the smart way. If you have been in the .NET world for any amount of time, you are probably used to ILogger. You know the drill: inject a logger, use it throughout your code, and stay away from the quick and dirty Console.WriteLine scattershot approach.

Rust takes a similar path but with its own flavor. It gives you the log and tracing crates, both designed to keep your code clean while still giving you rich, structured log output when you need it.

Continue Reading