# **🦀 Booth: Rust (2015)** * **Creator:** Graydon Hoare (Mozilla Research) * **Design Philosophy:** Safety, speed, and concurrency—choose all three. Rust guarantees memory safety and thread safety without a garbage collector through its signature static compilation borrow checker. * **Key Innovations:** Ownership, borrowing, lifetimes, safe pointers, hygienic macros, and zero-overhead abstractions. ## **🔒 The Math of Ownership & Lifetimes** Rust's borrow checker enforces ownership policies strictly at compile time. Let ![][image1] represent the lifetime of a variable ![][image2], and let ![][image3] represent the active span of a reference borrow ![][image4] referencing ![][image2]. To prevent dangling pointers, the borrow checker enforces: ![][image5]Furthermore, if there exists a mutable reference ![][image6], no other reference (mutable or immutable) may overlap in its execution span: ## **![][image7]🚀 Hello, World\!** fn main() { println\!("Hello, World\!"); } ## **🎨 Showpiece: Concurrent Thread Safety (Channels)** This program showcases Rust's ownership transfer across threads via a thread-safe message-passing queue (channel). The compiler guarantees that variables sent through the channel cannot be accessed by the sender thread afterwards, preventing data races. use std::sync::mpsc; use std::thread; use std::time::Duration; struct Payload { id: u32, message: String, } fn main() { // Create an asynchronous channel: Sender (tx) and Receiver (rx) let (tx, rx) \= mpsc::channel(); // Spawn a worker thread to compute values let sender\_handle \= thread::spawn(move || { let task\_payload \= Payload { id: 101, message: String::from("Calculated telemetry from worker thread"), }; println\!("\[Worker\] Dispatching computed payload data over channel..."); // This move transfers ownership of task\_payload entirely out of this thread scope\! tx.send(task\_payload).unwrap(); // Uncommenting the next line will fail compilation\! // println\!("Stored ID was: {}", task\_payload.id); }); println\!("\[Main\] Main thread waiting on results from thread pool..."); // Non-blocking work can happen here thread::sleep(Duration::from\_millis(100)); // Safely block main execution stream until data is received match rx.recv() { Ok(received\_data) \=\> { println\!("\[Main\] Received payload safely\! ID: {}, Message: '{}'", received\_data.id, received\_data.message); } Err(e) \=\> println\!("\[Error\] Channel failed: {:?}", e), } sender\_handle.join().unwrap(); println\!("\[Main\] All worker threads synchronized and completed safely."); } [image1]: [image2]: [image3]: [image4]: [image5]: [image6]: [image7]: