Latest posts tagged with #RustForCSharpDevs on Bluesky
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:
woodruff.dev/final-reflec...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/performance-...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/packaging-an...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/writing-test...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/parsing-argu...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/building-a-c...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/week-5-refle...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
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:
woodruff.dev/iterators-an...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 33 of learning Rust as a C# dev:
Closures in Rust feel like lambdas until the borrow checker gets involved.
Fn, FnMut, FnOnce... it’s functional programming with personality.
Here’s what I learned:
woodruff.dev/closures-in-...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 31 of learning Rust as a C# dev:
Rust generics feel like C# generics with more power and more punctuation.
Trait bounds, zero-cost abstraction, and compile-time safety? Yes, please.
Here’s how they compare:
woodruff.dev/generics-in-...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 30 of learning Rust as a C# dev:
Rust doesn’t do virtual, but it does have dyn.
Trait objects give you polymorphism without the inheritance party.
Here’s how it works:
woodruff.dev/trait-object...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 29 and start of week 5 of learning Rust as a C# dev:
Traits are like interfaces—but with superpowers.
Default methods are behavior-focused and way more flexible.
Here’s why I’m loving them:
woodruff.dev/traits-in-ru...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Week 4 of learning Rust as a C# dev is done.
This one was all about structure and errors:
Custom errors, the ? operator, panic!, modules, and real logging.
Less chaos, more clarity.
Here’s the recap:
woodruff.dev/week-4-refle...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 24 of learning Rust as a C# dev:
The ? operator is the cleanest error-handling tool I didn’t know I needed.
It says “bubble this up” without all the boilerplate.
Here’s why I love it:
woodruff.dev/error-propag...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 23 of learning Rust as a C# dev:
NuGet, meet Cargo.
Rust’s package manager handles builds, tests, docs, and deps from one CLI.
It’s like NuGet, but with less XML and more joy.
Check it out:
woodruff.dev/crates-and-d...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 22 of learning Rust as a C# dev:
C# has namespaces. Rust has modules.
One feels automatic, the other makes you think. A lot.
Here’s how organizing code in Rust compares and why it eventually clicks:
woodruff.dev/organizing-c...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 20 of learning Rust as a C# dev:
Rust doesn’t throw exceptions—it returns them.
Result<T, E> makes failure part of your type system, not a surprise at runtime.
Here’s why that’s a good thing:
woodruff.dev/result-a-bet...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 19 of learning Rust as a C# dev:
Rust doesn’t do nulls.
Instead, you get Option<T>—safe, explicit, and impossible to ignore.
It’s like null handling, but without the fear.
Here’s how it works:
woodruff.dev/optiont-wher...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 18 of learning Rust as a C# dev:
Destructuring in Rust feels like unlocking a secret power.
Pull apart structs, tuples, and enums cleanly—no mess, no fuss.
Here’s why it’s my new favorite move:
woodruff.dev/destructurin...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 17 of learning Rust as a C# dev:
Rust’s match is what I always wanted switch to be.
No fallthrough, no missing cases, just clean, safe pattern matching that works.
Here’s why it feels like switch on steroids:
woodruff.dev/match-switch...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 16 of learning Rust as a C# dev:
Enums in Rust aren’t your basic list of values. They’re powerful, data-carrying, pattern-matching champs.
Discriminated unions done right.
Here’s why I’m impressed:
woodruff.dev/enums-discri...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 15 of learning Rust as a C# dev:
No classes. No inheritance. No constructors.
Rust structs keep it simple and make you rethink how much you really need.
Here’s why less is more:
woodruff.dev/rust-structs...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Week 2 of learning Rust as a C# dev is done
Ownership, borrowing, move semantics, the stuff that makes your head spin, but your code safer.
My brain hurts (in a good way). Here’s what I learned:
woodruff.dev/week-2-refle...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 13 of learning Rust as a C# dev:
Shadowing allows you to redeclare a variable with the same name intentionally.
No hacks. No temp2 or tempFinal. Just clean, intentional redeclaration.
Here’s how it works:
woodruff.dev/shadowing-in...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 12 of learning Rust as a C# dev:
No StringBuilder. No problem.
Rust’s slices and strings make you rethink how to work with text, without all the copying and overhead.
Here’s what I learned:
woodruff.dev/slices-and-s...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 11 of learning Rust as a C# dev:
The borrow checker isn’t your enemy. It’s your tough-love mentor.
It yells a lot, but it’s making you a better developer, whether you like it or not.
Read more:
woodruff.dev/the-borrow-c...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Day 10 of learning Rust as a C# dev:
Borrowing in Rust feels like ref, but stricter, smarter, and way more protective.
It’s not just syntax. It’s a whole new way of thinking about data.
Here’s how it works:
woodruff.dev/borrowing-an...
#RustLang #CSharp #DotNet #RustForCSharpDevs #LearnRust
Day 9 of learning Rust as a C# dev:
I moved a variable, and the compiler yelled at me.
It turns out that Move Semantics isn't just a feature... it's a mindset shift.
Here’s what I learned:
woodruff.dev/move-semanti...
#RustLang #CSharp #DotNet #RustForCSharpDevs
Day 8 of learning Rust as a C# dev:
Ownership is the most C++-ish thing I’ve seen in Rust, and I actually love it.
It’s strict, it’s smart, and it makes you think before you move anything.
woodruff.dev/ownership-in...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
Week 1 of learning Rust as a C# dev:
Fewer keywords. Stricter rules. More thinking.
Rust’s minimalism doesn’t just simplify, it reshapes how you code.
Here are my takeaways from the first 7 days:
woodruff.dev/reflections-...
#RustLang #CSharp #DotNet #LearnRust #RustForCSharpDevs
