Rust

Rust basics: variables (let, mut), primitive types, functions, modules

Ownership: move semantics, borrowing, references (&, &mut), lifetimes

Borrowing rules: one &mut OR multiple &, no dangling references

Structs, enums, pattern matching and destructuring

Traits: definition, implementation, trait bounds, derive macros

Generics: generic functions, structs, enums with trait bounds

Lifetimes: annotations ('a), lifetime elision, static lifetime

Error handling: Result<T, E>, Option<T>, ? operator, panic vs Result

Collections: Vec, HashMap, HashSet, iterators and methods (map, filter, collect)

Iterators: Iterator trait, lazy evaluation, combinators, for loops

Ownership patterns: Clone vs Copy, Rc/Arc, RefCell/Mutex for interior mutability

Concurrency: threads, Arc<Mutex<T>>, channels (mpsc), Send/Sync traits

Async/await: Future trait, async fn, .await, Tokio runtime, async tasks

Axum/Actix-web: routing, handlers, extractors, middleware, state management

Database: sqlx (compile-time checking), Diesel ORM, async queries

Serialization: serde (Serialize, Deserialize), JSON, derive macros

Testing: #[test], #[cfg(test)], assert!, integration tests, mocking

Macros: declarative macros (macro_rules!), procedural macros, derive

Memory safety: no null pointers, no buffer overflows, thread safety

Performance: zero-cost abstractions, inlining, LLVM optimizations, profiling

Cargo: dependencies (Cargo.toml), features, workspaces, build scripts

Deployment: cross-compilation, Docker, static binaries, release profiles