Chapter 20. What's next?
We’ve come a long way and you’re now an experienced Rust developer. Just kidding.
But in all seriousness - you’ve covered a lot. From your first println! to writing a fully interactive web app backed by Rust logic and serverless compute, you’ve built real, working systems that reflect how modern software built with Rust is rocked. The crazy part is that you're just getting started. You've basically got the entire ocean in front of you - and this chapter is about helping you navigate that.
“You can’t cross the sea merely by standing and staring at the water.” - Rabindranath Tagore
Look what we’ve accomplished
When we started, Rust might have felt like an odd language - strict about ownership, rigid about lifetimes, and way too insane with its borrow checker. But somewhere between structs, traits, and our first concurrency example, something likely clicked. You stopped fighting the compiler and started collaborating with it, as a the feat of modern computer science it is. Once understood, Rust's design choices and tooling help you write better, more robust software.
In this journey you’ve written asynchronous code, built crates, published packages, and even brought Rust into a full-stack web app. Along the way, you wrote clean tests, benchmarked performance, built visualizations powered by fast Rust, and touched nearly every major feature the language has to offer.
The key thing to remember here: you did it. You wrote programs that ran, failed, improved, and ran again. That process, not just learning the syntax, is what makes you budding Rust developer. You’ve learned to think like Rust does: clearly, safely, and with precision.
Ownership, borrowing, and lifetimes
These weren’t just abstract rules - they became second nature concepts. You saw that memory safety is freedom to write safe code and not a restriction. Once you internalized these rules, you wrote code that worked without leaks, races, or panics. You’ve learned how lifetimes express relationships in your code that help the developer and the compiler understand intent.
Structs, enums, and traits
We discovered that data modeling in Rust feels like victorian architecture. Every struct you designed held purpose, every enum gave structure, and each trait unified logic across types. Together they became the foundations of your programs - expressive, type-safe and elegant.
Rust isn’t just about writing code that works - it’s about writing code that means something. You’ve learned to express intent through types, making your programs not just functional, but communicative. That's the essence of great software development: it tells a story to the next developer(s), including the future you. Rust's power here is in how it encourages you to think deeply about the data and behaviors in your applications, forcing you to communicate those.
Generics and testing in practice
Generics stopped being scary when we showed that they are just blueprints that add abstraction flexibility. They helped you reduce code reptition and therefore bugs, in addition to succinctly communicating where, with what and how your abstractions can be used.
You wrote tests that assert behavior and against the traits that guarantee it. Your abstraction became a tool, not a puzzle - and your ability to write code is more powerful because of its leverage. You learned how to write specific types of tests: unit tests, integration tests and even comment-based tests. This practice not only ensures your code works as intended but also gives you confidence to refactor and evolve your codebase over time. Testing in Rust is not an afterthought; it's a first-class citizen that integrates seamlessly with your development workflow.
Concurrency and performance
With concurrency we went from fearing threads to managing them with ease. We saw how ownership makes data sharing safe and intuitive and how Rust’s concurrency model is both modern and ancient - a closer representation to how the machine itself actually "thinks". And while we were at it, we covered how these are handled in languages like C++ and why Rust’s approach is superior in many ways.
And with benchmarking, we learned that Rust isn’t just safe - it’s fast and has great third-party tools to measure and improve performance. You’ve seen how to profile code, identify bottlenecks, and optimize critical paths.
Building for the real world
From a library to a full-stack app, you’ve touched every layer of software that matters in Rust. You’ve published a crate, integrated it into a live app, and deployed it on a modern platform. That’s a full circle - from cargo new to production-grade rock-solid software.
What to do next
Now your journey continues. You’ve got the fundamentals, but programming is not a spectator sport. The only way forward is through doing. Read, explore, and study - yes. But the most important thing is to keep building. And yes, especially in the age of AI, you need to do much of this by hand. But leverage models as much as possible - have it explain, ask it questions, and use it to help you refactor your code so that you can better grasp quality code. Different from beginner/consumer languages like JavaScript or Python, Rust has a nice ratio of good:bad code published - it's newer so much of the code that models have been trained on is from experts. That's great for you. It's a fantastic time to be alive - leverage this.
Below are some additional paths to explore as you continue your Rust journey.
Books
Start with Programming Rust by Jim Blandy and Jason Orendorff for a deeper systems-level dive. If you like theory with rigor, Rust for Rustaceans by Jon Gjengset will reshape how you think about abstraction, ownership, and lifetimes. And of course, the Rustonomicon - the dark arts of unsafe Rust - awaits when you’re ready.
And definitely go through all of Rust by Example: this is potentially the best resource out there. That said, do it as you build, learn and read other resources like this book. It will give you enhanced context and depth.
Blogs and communities
Follow Rustaceans who build, break, and teach. The official Rust Blog covers updates, and sites like fasterthanli.me and without.boats explore Rust’s evolving design and philosophy. Hang out on r/rust, the users forum, or Discord - but always bring curiosity, not dogma. Especially spend time on the users forum. It is absolutely spectacular and Rust has a welcoming community culture.
Projects
Nothing beats practice. Clone your favorite project and rewrite part of it in Rust. Write a simple CLI tool you actually use. Port one of your side projects. Build a web backend in Axum or a data pipeline in Polars, especially if you already have some Python Pandas-based pipelines. Migrate them. Try writing your own crate and publishing it, like we did with cutup. Each project makes the next easier - and the compiler keeps you learning.
Sorry, we're breaking up
This book started as an exploration and became a conversation between you, the compiler, and every little witty phrase I could sneak in. But more than that, it’s a shared journey into a language that’s changing expectations about safety, performance, and developer experience.
Rust rewards persistence. It’s a language for those who care about how things work and why they work that way. You’ve joined that lineage now: a group that values precision, correctness, and elegance over shortcuts.
So keep going. Keep experimenting. Keep failing safely and learning deeply. And when you open your next file with fn main(), remember - you already know what to do.
Thanks for coming along for the ride. 🦀🚀