Fundamentals & Syntax:

1. What is Rust and what are its key features?

Rust is a systems programming language focused on safety, speed, and concurrency. Key features include memory safety without garbage collection (through ownership, borrowing, and lifetimes), zero-cost abstractions, excellent C interoperability, and a rich type system.

2. Explain Rust’s ownership system.

Rust’s ownership system manages memory through three core rules: each value has a variable that’s its owner, there can only be one owner at a time, and when the owner goes out of scope, the value ¹ is dropped. 

3. What is borrowing in Rust? Explain the rules of borrowing.

Borrowing allows you to create references to data without taking ownership. Rules: either one mutable reference or any number of immutable references are allowed within a scope.

4. What are lifetimes in Rust and why are they necessary?

Lifetimes are annotations that describe the scope for which a reference is valid. They are necessary to ensure that references always point to valid data and prevent dangling pointers, especially when dealing with references across function boundaries.

5. Differentiate between String and &str.

String is a growable, heap-allocated string type. &str is an immutable view into string data, which can be stack-allocated string literals or slices of String.

6. What is the purpose of Option and Result enums?

Option handles the possibility of a value being present (Some(T)) or absent (None). Result represents the outcome of an operation that can succeed (Ok(T)) or fail (Err(E)), providing a way to handle errors gracefully.

7. Explain the concept of “shadowing” in Rust.

Shadowing allows you to declare a new variable with the same name as a previous one in the same scope. The new variable effectively hides the old one.

8. What are modules and how are they used for organization in Rust?

Modules (mod) are used to organize code into logical units, controlling scope and privacy. They help in creating namespaces and managing dependencies.

9. How do you bring items from a module into the current scope?

Using the use keyword, followed by the path to the item (e.g., use std::collections::HashMap;).

10. What is a trait in Rust? How is it different from an interface in other languages?

Traits define shared behavior that types can implement. Unlike interfaces in some languages, traits in Rust can contain method implementations (default methods).

11. What are trait objects and when might you use them?

Trait objects allow you to work with values of different concrete types that implement the same trait. They are created using a pointer (&dyn Trait or Box<dyn Trait>) and involve dynamic dispatch. Useful for polymorphism.

12. Explain the purpose of generics in Rust.

Generics allow you to write code that works with different types without knowing the specific type at compile time, promoting code reusability and type safety.

13. What are closures in Rust? How do they capture their environment?

Closures are anonymous functions that can capture variables from their surrounding environment. They can capture by reference, by mutable reference, or by value (moving ownership).

14. What are iterators in Rust? How do you use them?

Iterators provide a sequence of values. They are created using the .iter(), .iter_mut(), or .into_iter() methods on collections and consumed using methods like .next(), .map(), .filter(), .collect(), etc.

15. What is the purpose of the match expression in Rust?

The match expression allows you to compare a value against a series of patterns and execute code based on the first matching pattern. It’s exhaustive, meaning all possible values must be covered.

16. How do you handle errors in Rust? Differentiate between panic! and Result.

Rust primarily uses Result for recoverable errors, allowing the caller to handle the error. panic! is used for unrecoverable errors, causing the program to unwind the stack and potentially terminate.

17. What is the ? operator used for in Rust?

The ? operator is syntactic sugar for propagating Result or Option values. If the value is Ok(v) or Some(v), it unwraps to v. If it’s Err(e) or None, it returns the error or None from the current function.

18. Explain the concept of zero-cost abstractions in Rust.

Zero-cost abstractions mean that features like generics and iterators provide high-level abstractions without introducing significant runtime overhead compared to writing equivalent low-level code.

Memory Management & Safety:

19. How does Rust achieve memory safety without garbage collection?

Through its ownership system, borrowing rules, and lifetimes, which are enforced at compile time, preventing common memory errors like dangling pointers, data races, and buffer overflows.

20. What is the borrow checker and what role does it play in Rust?

The borrow checker is a component of the Rust compiler that enforces the borrowing rules at compile time, ensuring memory safety.

21. What is unsafe Rust and when might you need to use it?

unsafe Rust allows you to bypass some of Rust’s safety guarantees. It’s typically needed when interacting with raw pointers, FFI (Foreign Function Interface), or performing low-level operations where the compiler cannot guarantee safety.

22. What are raw pointers in Rust? How are they different from references?

Raw pointers (*const T and *mut T) are similar to pointers in C/C++. They are not guaranteed to be valid and don’t have lifetime information. References (&T and &mut T) are always valid and are governed by the borrow checker.

23. Explain the concept of “move” semantics in Rust.

When a non-Copy type is assigned or passed to a function, its ownership is transferred (moved) to the new variable. The original variable is no longer valid.

24. What are Copy and Clone traits? When would you implement them?

The Copy trait indicates that a type’s values can be trivially copied (e.g., primitive types). The Clone trait defines a method to explicitly create a deep copy of a value. Implement Copy for types where a bitwise copy is sufficient and Clone when a deeper copy is needed.

Concurrency:

25. How does Rust handle concurrency? What are some of its concurrency primitives?

Rust emphasizes safe concurrency through mechanisms like ownership and the type system. Primitives include threads (std::thread), message passing (std::sync::mpsc::channel), and shared state concurrency with synchronization primitives like mutexes (std::sync::Mutex) and atomic types (std::sync::atomic).

26. What is the “fearless concurrency” concept in Rust?

It refers to Rust’s ability to enable safe and efficient concurrent programming without the common pitfalls of data races, thanks to its ownership and borrowing system.

27. Explain the use of std::thread::spawn.

std::thread::spawn creates a new OS thread and executes the provided closure on that thread.

28. What are channels (mpsc) in Rust and how are they used for communication between threads?

Multiple Producer, Single Consumer (mpsc) channels allow threads to communicate by sending messages to each other. A sender can send data, and a receiver can receive it.

29. What are mutexes and how do they prevent data races in shared mutable state?

A mutex (mutual exclusion) is a locking mechanism that allows only one thread to access shared data at a time, preventing concurrent modification and data races.

30. What are atomic types in Rust and when might you prefer them over mutexes?

Atomic types provide low-level, thread-safe primitives for simple operations without requiring explicit locking. They are often more performant for basic operations like counters or flags.

31. What is the Send and Sync trait in Rust? Why are they important for concurrency?

The Send trait marks types that are safe to be moved across thread boundaries. The Sync trait marks types where it’s safe to have multiple threads accessing the same value concurrently (typically through shared references). These traits are crucial for ensuring data race freedom.

Cargo & Tooling:

32. What is Cargo? What are its main functionalities?

Cargo is Rust’s build system and package manager. Its main functionalities include managing dependencies, building projects, running tests, and publishing crates.

33. What is a Cargo.toml file? What are some important sections in it?

Cargo.toml is the manifest file for a Rust project. Important sections include [package] (project metadata), [dependencies] (list of dependencies), and [build-dependencies] (dependencies needed during the build process).

34. How do you add a dependency to your Rust project?

By adding the crate name and version to the [dependencies] section of your Cargo.toml file. Cargo will then download and manage the dependency.

35. How do you build and run a Rust project using Cargo?

cargo build compiles the project. cargo run builds and then executes the project.

36. How do you manage different build profiles (e.g., debug vs. release) in Cargo?

Cargo uses profiles defined in Cargo.toml (e.g., [profile.dev] for debug, [profile.release] for release). You can specify a profile using flags like cargo build --release.

37. What are crates in Rust? How do you publish and use them?

Crates are Rust’s package units. You can publish them to crates.io using cargo publish. To use a crate, you add it as a dependency in your Cargo.toml.

Advanced Topics:

38. What are macros in Rust? Differentiate between declarative and procedural macros.

Macros are a form of metaprogramming that allows you to write code that generates other code. Declarative macros (macro_rules!) match on patterns. Procedural macros (#[derive], attribute-like, function-like) are more powerful and operate on the syntax tree.

39. What is FFI (Foreign Function Interface) in Rust? When would you use it?

FFI allows Rust code to interact with code written in other languages (like C). You would use it to leverage existing libraries or integrate with systems written in other languages.

40. Explain the concept of “unsafe traits” in Rust.

Unsafe traits are traits that have methods whose implementation could violate memory safety if not implemented correctly. They are marked with the unsafe keyword.

41. What are allocators in Rust? How can you use a custom allocator?

Allocators manage memory allocation and deallocation. Rust’s default allocator is std::alloc::System. You can use a custom allocator by implementing the Allocator trait and using the #[global_allocator] attribute.

42. What are const generics? What problems do they solve?

Const generics allow you to parameterize types by constant values (e.g., array size). They solve problems where you need type-level information about constants, improving type safety and performance in certain scenarios.

43. Explain the purpose of the PhantomData type in Rust.

PhantomData is a zero-sized type used to add lifetime or variance information to a struct that doesn’t actually hold a value of that type. This is often needed when dealing with raw pointers or types that interact with lifetimes implicitly.

44. What are associated types in Rust traits? How are they different from generics?

Associated types are type placeholders within a trait definition that are specified by the implementing type. Generics allow the implementor to choose the type each time the trait is used, while associated types are fixed for a given implementation.

45. What is auto-dereferencing in Rust?

Rust automatically dereferences types like &T, &mut T, Box<T>, Rc<T>, and Arc<T> in method calls and field access, making it feel more natural to work with them.

Ecosystem & Best Practices:

46. Name some popular crates in the Rust ecosystem and their use cases.

Examples: tokio (async runtime), actix-web (web framework), serde (serialization/deserialization), rayon (data parallelism), clap (command-line argument parsing), log and tracing (logging).

47. What are some best practices for writing idiomatic Rust code?

Leveraging the type system for safety, handling errors with Result, using iterators for collections, embracing immutability by default, writing clear and concise code, and following the conventions of the Rust community.

48. How do you write tests in Rust?

Rust has built-in support for testing. You can define test functions annotated with #[test] within modules. Cargo provides commands like cargo test to run tests.

49. What are benchmarks in Rust? How do you write and run them?

Benchmarks measure the performance of your code. You can write them using the test crate (often in a separate benches directory) and run them with cargo bench --release.

50. How do you contribute to the Rust open-source community?

By reporting issues, submitting bug fixes or feature requests, contributing to documentation, participating in discussions on forums or chat channels, and helping to review code.

This list covers a broad range of Rust concepts. Depending on the specific role, the interviewer might delve deeper into certain areas. Good luck to anyone preparing!