Why I Started Learning Rust at 34: A Senior Dev's Honest Take

Posted on Mar 16, 2026

After ten years writing Java microservices and Go tools at various fintech companies in Toronto, I did something I told myself I’d never do: I started learning Rust. Not the “I read a tutorial once” kind of learning. The “30 minutes every morning before standup” kind. The “I bought the physical book because my eyes needed a break from screens” kind.

Six months in, I’m far from an expert, but I’m far enough to have opinions. This post is about why I finally took the plunge, what I got wrong in my first month, and whether Rust deserves the hype. If you’re a senior developer on the fence, consider this your permission slip to either dive in or confidently say “not for me.”

The Build-Up: Three Years of “I’ll Learn Rust Eventually”

The first time I heard about Rust was 2019. I was at a conference in Seattle, half-listening to a talk about memory safety while checking Slack on my phone. The speaker mentioned something about the borrow checker, and I remember thinking, “That sounds complicated. I’ll look into it when I have time.”

I didn’t have time. For the next three years, I was busy shipping features, fighting production fires, and learning Kubernetes because our infrastructure team told me I had to. Every few months, I’d see a blog post about someone rewriting a service in Rust and getting “10x performance improvements.” I’d bookmark it, close the tab, and go back to my Java code.

The Breaking Point

In November 2025, I was debugging a memory leak in a Java service at FinTech Solutions Inc. We’d been hunting it for two weeks. Heap dumps, profiling, adding logs everywhere. The usual. I was sitting at my desk at 9 PM (again), staring at a 4GB heap dump in VisualVM, when I had one of those moments.

I’d been doing this for ten years. I’d solved hundreds of bugs like this. And yet, here I was, once again, manually tracing object references because the language let me create this problem in the first place.

That night, I watched the first chapter of “The Rust Programming Language” on YouTube. The next morning, I woke up 45 minutes early and actually opened the book.

Month One: The Confidence Rollercoaster

My first Rust program was a command-line tool that read a CSV file and counted how many rows had a specific value in column three. In Java, this would have taken me 30 minutes. In Rust? Three days.

Day one, I fought the borrow checker for six hours because I didn’t understand that String and &str were different things. I read error messages that might as well have been in ancient Sumerian. I considered giving up approximately 47 times.

Day two, something clicked. The compiler wasn’t fighting me—it was teaching me. When it complained about moving a value, it was showing me exactly where my mental model was wrong. By day three, when the program finally compiled and ran correctly, I felt something I hadn’t felt in years: the satisfaction of truly understanding why my code worked.

What I Got Wrong (So You Don’t Have To)

Mistake #1: Thinking I Could Skip the Fundamentals

I’ve been programming for a decade. I’ve shipped production systems. Surely I can skip the “what is ownership” chapter and go straight to building web servers, right?

Wrong. So, so wrong.

Rust’s ownership model isn’t a feature you can learn by skimming. It’s the foundation everything else builds on. I spent my first two weeks trying to write code while understanding half the rules, which meant I was fighting the compiler instead of learning from it.

My advice: Spend your first week just on Chapter 4 of the Rust Book. Don’t write anything serious. Just play with ownership, borrowing, and references until it feels natural. Your future self will thank you.

Mistake #2: Comparing My Progress to Others

Twitter is full of people learning Rust in two weeks and building production web frameworks. Meanwhile, I’m over here struggling to understand why I can’t return a reference to a local variable.

I had to consciously stop checking social media during my learning sessions. Everyone learns differently, and comparing your Chapter 4 struggles to someone else’s Chapter 20 project is a recipe for imposter syndrome.

Mistake #3: Trying to Write Rust Like Java

My first Rust structs looked like Java classes. I was creating getters and setters for everything, trying to make everything private by default, essentially writing Java syntax with Rust keywords.

Rust has different idioms. Public fields are fine. Methods don’t need to be in classes. Pattern matching replaces a lot of control flow you’re used to. Once I stopped trying to translate my Java knowledge and started learning Rust on its own terms, things got much easier.

What Rust Gets Right (Even for Skeptics)

I came to Rust skeptical. I figured it was mostly hype. But here are three things that won me over:

1. The Error Messages Actually Make Sense

Java stack traces are a punchline for a reason. They’re verbose, nested, and usually bury the actual problem under 40 lines of Spring Framework internals.

Rust’s error messages are different. They tell you exactly what’s wrong and often suggest exactly how to fix it. When I see a Rust compiler error now, I don’t sigh—I learn something.

2. The Standard Library Is Surprisingly Small

Coming from Java’s massive standard library and Spring’s even more massive ecosystem, Rust initially felt lacking. Where’s my JSON parser? My HTTP client? My database connection pool?

Then I realized this is a feature, not a bug. Rust’s small standard library means you pick the right tool for the job from crates.io instead of using whatever mediocre thing shipped with the language in 2006. It’s more work up front, but you end up with better dependencies.

3. The Community Is Helpful (But Intense)

Rustaceans love Rust. Maybe too much sometimes. But when I posted a genuinely stupid question on the Rust Discord at 11 PM on a Tuesday, three people helped me understand lifetimes within an hour.

There’s a genuine culture of teaching in the Rust community. People want you to understand, not just copy-paste solutions. It’s refreshing after years of Stack Overflow answers that tell you to “just use this library” without explaining why.

What Rust Gets Wrong (My Honest Critique)

I’m not a fanboy. Here are three real issues:

1. The Compile Times Are Rough

My laptop fans spin up every time I hit save. A medium-sized project takes 20-30 seconds to compile in debug mode. For someone used to Java’s incremental compilation (or Go’s near-instant builds), this is painful.

There are workarounds—cargo check instead of cargo build, using mold as a linker—but compile times are objectively slower than most other languages.

2. The Async Story Is Still Evolving

Rust’s async/await syntax is stable, but the ecosystem around it isn’t. Different runtimes (Tokio, async-std, smol) have different tradeoffs. Some libraries only work with specific runtimes. The Future trait recently had breaking changes.

If you’re building async services, you need to make architectural decisions early that are hard to change later. This is getting better, but it’s not as mature as Go’s goroutines or Java’s virtual threads.

3. The Learning Curve Is Real

I’m not going to sugarcoat it: Rust is hard to learn. Not because the language is poorly designed—it’s actually quite elegant—but because it forces you to think about things other languages let you ignore.

Memory management. Thread safety. Error handling. These aren’t optional add-ons in Rust; they’re core to everything you write. The first month is frustrating. Many people quit. If you need to ship something quickly, Rust might not be your best choice.

Is It Worth Your Time?

Here’s my honest answer: It depends on what you’re building.

Rust is probably right for you if:

  • You’re building systems software (CLIs, dev tools, game engines)
  • You need predictable performance without a garbage collector
  • You care about memory safety and security
  • You have time to learn properly (not rushing to production)
  • You enjoy understanding how things work under the hood

Rust might not be right if:

  • You’re building CRUD web apps (Java/Go/Python are probably fine)
  • You need to ship MVP in two weeks
  • Your team isn’t bought into the learning investment
  • You hate fighting with compilers (you’ll do a lot of this)

For me, learning Rust has been worth it because I enjoy systems programming, I have the time to learn properly, and my day job (fintech) values the safety guarantees. But if you’re a frontend developer building React apps all day, I’m not sure Rust adds enough value to justify the learning curve.

What’s Next: This Series

Over the next 12 weeks, I’m documenting my Rust learning journey in public. Every Sunday, I’ll publish a new post covering what I’ve learned that week, complete with code examples, mistakes I made, and honest assessments of what’s useful and what’s hype.

Next week: Setting Up Your Rust Development Environment in 2026—a practical guide to getting your first Rust project running without the headaches I dealt with.

I’m not claiming to be an expert. I’m claiming to be a senior developer learning in public, sharing both the wins and the frustrating afternoons where nothing compiles. If that sounds useful to you, stick around.

Key Takeaways

  • Rust has a steep learning curve, but it’s justified by the safety guarantees
  • Don’t skip the fundamentals—ownership and borrowing are foundational
  • Compare your progress to your past self, not Twitter personalities
  • Compile times are slow; plan your workflow around cargo check
  • The community is genuinely helpful if you ask specific questions
  • Not every project needs Rust—choose the right tool for the job

Resources That Actually Helped

Final Thoughts

Learning Rust at 34, with a full-time job and a coffee addiction to maintain, isn’t the easiest path. There are days I want to go back to Java where the compiler doesn’t lecture me about lifetimes.

But there are also moments—like when I finally understand why the borrow checker was right about my code—where I remember why I’m doing this. Programming is supposed to be hard sometimes. The difficulty is the point.

If you’re on the fence about Rust, my advice is simple: give it two weeks. Not a weekend. Not a “I’ll try a tutorial.” Two weeks of daily, consistent practice. You’ll know by then if Rust is for you.

And if it’s not? That’s fine too. Java and Go are still great languages. The goal isn’t to learn every new technology—it’s to find tools that make you write better software.

See you next Sunday.

Questions about getting started with Rust? Drop a comment below or find me on Mastodon at techhub.social/@johnmiller. I read everything, but I can’t promise I know the answer yet.

Current status: Chapter 8 of the Rust Book, 47 compiler errors this week (personal record), and counting down the days until my mechanical keyboard parts arrive.