Refactoring to Rust

A Different Way to Adopt Rust

Refactoring to Rust is written for developers who see the appeal of Rust but cannot pause a working project for a full rewrite. Lily Mara and Joel Holmes focus on the seams where Rust can replace or strengthen existing code without forcing a big-bang migration. The result is a book about integration as much as it is about the language itself.

What the Book Covers

The opening chapters explain what refactoring means in this context, why Rust has become a common target for performance- and safety-sensitive work, and when a rewrite may not be worth the cost. From there, the book builds a working knowledge of Rust’s ownership model, borrowing, lifetimes, string types, enums, and error handling before moving toward real integration work.

From C FFI to WebAssembly 💻

A major part of the book deals with crossing language boundaries. Readers encounter C foreign function interface concepts, unsafe Rust, raw pointers, dynamic libraries, build scripts, and bindgen. Later chapters move into dynamic languages, including Python extension modules, benchmarking, optimized builds, asyncio, threading, the Global Interpreter Lock, and PyO3. The final section turns to WebAssembly for refactoring JavaScript, browser loading, React components, WebAssembly components written in Rust, and the WASI runtime.

Testing as Part of the Refactor ⚙️

Refactoring only works when the new pieces can be trusted. The book gives testing its own space, covering Rust tests, documentation tests, adding tests to existing code, and testing Rust code from Python. That emphasis matters: a migration that cannot be verified is just a hopeful rewrite with extra steps.

Who This Book Is For

The material is aimed at developers with some programming experience who want to introduce Rust into an existing system. It should be especially relevant to engineers working with C, Python, or JavaScript codebases, and to teams evaluating Rust for performance, memory safety, or maintainability without abandoning their current stack. The book does not assume that every reader is already a Rust expert; it builds the language concepts needed for the integration work.

Why the Incremental Approach Matters

Large rewrites are expensive, risky, and often politically difficult. By concentrating on FFI, library structure, testing, and WebAssembly, Refactoring to Rust shows how smaller, reversible steps can create momentum. The book is not a promise that every project should switch to Rust. It is a technical map for deciding where Rust fits, how to connect it to code that already ships, and how to prove that the new code is doing its job.

Inside the Ten Chapters

• Why refactor to Rust, and when not to
• Rust ownership, borrowing, lifetimes, strings, enums, and errors
• C FFI, unsafe Rust, and advanced FFI
• Structuring Rust libraries
• Integrating with dynamic languages
• Testing Rust integrations
• Asynchronous Python with Rust
• WebAssembly for JavaScript refactoring
• WebAssembly interfaces and the WASI runtime

For developers who want Rust to earn its place in a real codebase, this is a grounded, hands-on route through the decisions, tools, and boundaries that make that possible.