Rust
190 bites tagged Rust — interview questions with model answers, and 60-second explainers.
Cargo.toml: Rust's Project Recipe
Cargo.toml is your Rust project's recipe, telling the compiler what to build and what dependencies it needs. It defines metadata, production dependencies, and dev-only dependencies for testing.
Rust Methods: Attaching Behavior to Data
Rust methods are functions attached to your data structures, defined in an `impl` block. Instead of `do_thing(my_struct)`, you call `my_struct.do_thing()`. The key footgun: `instance.name()` calls a method, but `instance.name` accesses a field.
Rust Item Visibility: Private by Default
In Rust, all items are private by default. Think of modules as locked rooms; you need the `pub` keyword to unlock the door. This is crucial for creating a public API or letting modules interact.
Rust Modules: Your Code's File System
Think of Rust modules as a file system for your code, grouping logic and hiding details. You declare them with `mod`, and Rust finds the code in corresponding files. The footgun: items are private by default, so you must use `pub` to expose them.
Rust Crates: Your Unit of Compilation
A crate is the smallest unit of code the Rust compiler handles—either a runnable program (binary) or a shareable library. A package, defined by Cargo.toml, bundles one or more crates. The footgun: a package can have many binaries but only one library.
Rust's Arc<T>: Share Data Ownership Across Threads
Rust's `Arc<T>` lets multiple threads share ownership of heap data. It's a smart pointer that counts references atomically. Use it for shared caches or config. The footgun: `Arc` only makes sharing safe, not mutation—you still need a `Mutex` for that.
Rust's Rc<T>: Shared Ownership on a Single Thread
Rust's `Rc<T>` enables shared ownership within a single thread. Think of it as a counter on a heap-allocated resource: cloning an `Rc` increments the count, and the resource is freed only when the count hits zero. Use it for graph nodes with multiple owners.
Rust Enums: Attaching Data Directly to Variants
A Rust enum variant can carry its own data, acting like a mini-struct. This is perfect for modeling states with different payloads, like a `Result` that holds either a value or an error. The footgun is using a separate struct to pair an enum with.
Rust's Two String Types: String vs. &str
Think of `String` as an owned, growable text buffer on the heap, while `&str` is a borrowed, fixed-size view into string data. This distinction is key to Rust's memory safety. Functions often take `&str` to flexibly accept both types.
Rust Slices (&[T]): Views Without Ownership
A Rust slice is a borrowed view into a contiguous sequence of data, like an array or Vec, without taking ownership. Use it to write functions that operate on parts of a collection efficiently. The footgun: a slice cannot outlive the data it points to.
Rust HashMap: Fast, Secure Key-Value Storage
A Rust `HashMap` is like a dictionary, mapping unique keys to values for fast lookups. Use it for caching or frequency counting. The footgun: never modify a key after insertion, as changing its hash will break the map's internal logic.
Rust Vectors: Your Go-To Growable List
A `Vec<T>` is Rust's smart, growable array. It automatically gets more memory when full, keeping items together for fast access. Use it for lists of unknown size. The footgun: frequent reallocations can be slow if you don't pre-allocate capacity.
Using Box<T> for Heap Allocation in Rust
Rust's `Box<T>` is a smart pointer that moves data from the stack to the heap. It's essential for creating recursive types, like linked lists, whose size would otherwise be infinite. The main footgun is in FFI: never wrap a C-allocated pointer in a `Box`.
Rust's Turbofish (`::<>`): When the Compiler Needs Help
The turbofish (`::<>`) is your tool to resolve ambiguity when Rust's compiler can't infer a type or trait. Use it when a type implements multiple traits with same-named methods, forcing the compiler to pick the one you specify.
Rust's Variable Shadowing: Re-binding, Not Mutating
Shadowing lets you declare a new variable with the same name, making the old one inaccessible. It's used to transform a value, like changing its type, without making it mutable. The footgun is confusing shadowing (`let x = ...`) with reassignment (`x = ...`).
Go vs. Rust: Variable Mutability by Default
Rust variables are immutable by default; Go's are mutable. Rust forces you to opt-in to changeability with `mut` for compile-time safety. Go prioritizes convenience, trusting the developer.
Zero-Cost Abstractions: Pay at Compile Time, Not Runtime
Zero-cost abstractions let you write high-level code that compiles to the same machine code as low-level optimizations. This is key in Rust for safe APIs without runtime overhead.
Rust's Two Error Types: Recoverable vs. Unrecoverable
Rust splits errors into two camps: recoverable (`Result`) and unrecoverable (`panic!`). This compile-time distinction forces you to handle expected failures, like a missing file, while crashing on programmer bugs, like an out-of-bounds access.
Rust Traits: Defining Shared Behavior
Rust traits are like contracts that guarantee a type has certain methods, similar to interfaces. This lets you write functions that operate on any type with that behavior, like a `summarize` method for both articles and posts.
Rust's Borrow Checker: Memory Safety at Compile Time
Rust's borrow checker is a compiler-time accountant that prevents memory bugs by enforcing ownership rules. It ensures you never access invalid data or have conflicting writes. The main footgun is assuming references are mutable by default; they aren't.
Rust Ownership: Memory Safety Without a Garbage Collector
Rust's ownership model ensures memory safety without a garbage collector. Think of data as having one owner; when the owner goes out of scope, the data is dropped.
Rust's Philosophy: Documentation and Community First
Rust's philosophy is deeply tied to its learning resources and community, ensuring developers are well-supported. This is evident in its official book, which is bundled with the language installation itself.
Get Rust bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.