Ownership basics
Write a function that takes a String, returns its length, and explain why the original variable is moved.
Languages / Knowledge library
Rust
a memory-safe systems programming language
Why learn Rust?
Rust helps you build fast, low-level software with strong memory safety guarantees and no garbage collector. It reduces common bugs (null misuse, use-after-free, data races) while keeping C/C++-class performance.
Where it came from
Started by Graydon Hoare in 2006; first announced publicly by Mozilla in 2010. Rust 1.0 (stable) released in 2015. Cargo became a major productivity advantage for builds and dependency management. Rust Foundation launched in 2021 to support governance, trademarks, and ecosystem stewardship. Rust editions (2015, 2018, 2021, 2024) allow language evolution with smoother migration.
- Started by Graydon Hoare in 2006; first announced publicly by Mozilla in 2010.
- Rust 1.0 (stable) released in 2015.
- Cargo became a major productivity advantage for builds and dependency management.
- Rust Foundation launched in 2021 to support governance, trademarks, and ecosystem stewardship.
- Rust editions (2015, 2018, 2021, 2024) allow language evolution with smoother migration.
Build your understanding
Work through these exercises in order. Try the task before opening a reference.
- Write a function that takes a String, returns its length, and explain why the original variable is moved.
- Implement a function that returns the first word of a &str as a slice (&str) without allocating.
- Build a thread-safe counter with Arc<Mutex<i32>> across 4 threads and print the final value.
- Read a text file into String using Result and ?; propagate errors instead of panicking.
- Create a tiny CLI that accepts a filename and word, then counts matching lines safely.
More ways to practice
Safe slicing
Implement a function that returns the first word of a &str as a slice (&str) without allocating.
Shared state concurrency
Build a thread-safe counter with Arc<Mutex<i32>> across 4 threads and print the final value.
Result-driven file read
Read a text file into String using Result and ?; propagate errors instead of panicking.
Mini CLI parser
Create a tiny CLI that accepts a filename and word, then counts matching lines safely.
Documentation and sources
- Rust Language Home (www.rust-lang.org)
- The Rust Programming Language (Book) (doc.rust-lang.org)
- Rust by Example (doc.rust-lang.org)
- Standard Library Docs (doc.rust-lang.org)
- The Cargo Book (doc.rust-lang.org)
Catalog research notes
- Rust 2024 edition is available, with migration support in tooling.
- Compiler diagnostics and Clippy lints keep improving on the regular release cycle.
- Ecosystem focus remains strong for async services, embedded targets, and WebAssembly.
Connect the ideas
Explore next
Real World Example
Embedded Sensor Data Aggregation
A manufacturer of industrial environmental sensors that must process high-frequency telemetry data on resource-constrained hardware.
The business problem
The existing C-based firmware frequently suffers from buffer overflows and dangling pointer errors, leading to intermittent system crashes that are difficult to debug in remote field deployments.
How this topic solves it
By migrating the data processing layer to Rust, the team leverages the ownership model and strict type system to enforce memory safety at compile-time, effectively eliminating entire classes of memory-related vulnerabilities before the code is ever deployed to the hardware.
- Define data structures for sensor readings using Rust structs to ensure strict memory layout.
- Implement the core processing logic using Rust's ownership rules to manage data buffers without a garbage collector.
- Utilize the Cargo package manager to integrate verified crates for low-level hardware abstraction.
- Compile the firmware using the Rust compiler to catch potential memory safety violations during the build process.
This diagram illustrates how Rust ensures memory safety during the development of embedded sensor firmware.
Raw telemetry data stream
Ownership-managed processing
Static safety verification
Memory-safe firmware
- Sensor Input → Ingests → Rust Logic
- Rust Logic → Validates → Compiler
- Compiler → Produces → Binary
Implementation example
This code demonstrates defining a data structure and processing it using Rust's ownership model, which prevents memory errors by ensuring data is handled predictably.
struct SensorData { value: f64 } // Define memory-safe structure
fn process(data: SensorData) { // Ownership is transferred
let val = data.value; // Safe access without dangling pointers
}Expected business outcome
The firmware achieves a higher level of stability and reliability, significantly reducing the frequency of field-deployed device failures caused by memory mismanagement.
Limitations and checks
The primary tradeoff is a steeper learning curve for developers transitioning from C, as they must adapt to the borrow checker's strict rules; this can be verified by monitoring the frequency of compiler-rejected code during the initial development phase.