Rust panics are for bugs, not expected errors. When code panics (via panic!, unwrap(), expect(), or assertion failure), the thread unwinds by default, running destructors. I use panic! for invariant violations or \"this should never happen\" cases. Fo

PhantomData<T> is a zero-sized type that acts as if it owns T for the purposes of lifetimes, variance, and drop check. I use it in the typestate pattern or when a struct logically depends on T but doesn't store it. For example, a handle to an ex

Send means a type can be transferred across thread boundaries. Sync means a type can be shared between threads (&T is Send). Most types are Send + Sync; exceptions include Rc (not Send) and RefCell (not Sync). The compiler uses these marker traits

Wasm-bindgen generates JavaScript bindings for Rust code compiled to WebAssembly. Annotate functions with #[wasm_bindgen], and the tool generates JS glue code. I use it to write performance-critical browser code in Rust: parsers, crypto, data processi

Rust's inline assembly (asm! macro) lets you write assembly for performance-critical code or to access hardware features. It's an unstable feature (nightly only) and requires unsafe. I use it sparingly for SIMD intrinsics not exposed by std::arch, cry

The #[cfg(...)] attribute enables conditional compilation based on features, target OS, or build profiles. I use #[cfg(test)] for test-only code, #[cfg(target_os = \"linux\")] for platform-specific logic, and #[cfg(feature = \"...\")] for optional fea

Rust's module system uses mod to define modules and pub to control visibility. Modules can be inline (mod name { ... }) or in separate files (mod name; loads name.rs). By default, items are private; use pub to expose them. I organize code into modules

Reading environment variables is a common way to configure applications. std::env::var("KEY") returns Result<String, VarError>, which you handle with ? or .unwrap_or_else(). I use env vars for secrets, runtime config, and feature flags. For pars

BufReader and BufWriter wrap readers/writers with an in-memory buffer, reducing system calls. For example, reading a file line-by-line with BufReader::new(file).lines() is much faster than unbuffered reads. I use them for parsing large files, log proc

Rust's std::fs module provides file I/O. fs::read_to_string() reads a file into a String, fs::write() writes bytes. For larger files or streaming, use File::open() and BufReader/BufWriter for buffered I/O. Always handle errors with Result and ?. For p

Cow<'a, T> (clone on write) holds either a borrowed or owned value. It borrows when possible and clones only when mutation is needed. I use Cow<str> for APIs that might need to modify a string: if no changes are needed, it stays borrowed;

String is an owned, growable UTF-8 string on the heap. &str is a borrowed string slice, often a view into a String or a string literal. I use String when I need to own, modify, or build strings. I use &str for function parameters (accepting bo