Rust Fundamentals
Rust is a compiled programming language for building reliable, efficient software. Its ownership and type systems prevent many memory and concurrency errors before a program runs, without requiring a garbage collector.
itProgramming languages | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic - Rust Fundamentals
Rust is a compiled, statically typed language for software that wants predictable performance without giving up memory safety. It aims at many of the same jobs as C and C++, then adds a compiler that argues with you before the pager does.
Three systems do the real work together. The type system describes valid values and operations. The ownership system tracks which binding controls each value and how code may borrow it. The compiler checks both before it emits machine code. Safe Rust prevents many invalid memory accesses and data races without a garbage collector.
Cargo is the ordinary front door. A package has a Cargo.toml and one or more
crates. cargo check type-checks quickly. cargo build and cargo run
produce and start binaries. cargo test and cargo doc cover tests and API
docs. A rejected program is often not "almost crashing"; it violated an
ownership, lifetime, trait, or type rule that keeps later execution inside
safe boundaries.
Bindings are immutable by default. String owns heap text; &str borrows it.
Structs group fields; enums and match make unhandled states a compile error.
Ownership moves by default unless a type implements Copy. References borrow:
many shared &T, or one exclusive &mut T, never both in conflict. Lifetimes
name how long a reference remains valid; they do not extend storage.
Read the Intro for the ownership and borrowing model end to end. Use the Cheatsheet when you need the Cargo and type checklist. The Timeline and Landscape place Rust among related systems languages; Updates tracks the stable train that changes the APIs this course teaches.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.rust-lang.org/
Supports
- Rust's purpose, supported application areas, official project identity, and Landscape placement
- https://doc.rust-lang.org/book/
Supports
- Syntax, project structure, ownership, borrowing, structs, enums, error handling, generics, traits, testing, concurrency, and async programming
- Introductory study-path rationale and all quiz answers citing book chapters
- https://doc.rust-lang.org/reference/
Supports
- Normative language syntax and behavior, unsafe operations, types, expressions, patterns, traits, and memory model boundaries
- Reference-path rationale and unsafe-code quiz answer
- https://doc.rust-lang.org/std/
Supports
- Core types, collections, strings, threads, synchronization, atomics, Arc, and standard-library API behavior
- Standard-library reference rationale and shared-ownership quiz answer
- https://doc.rust-lang.org/cargo/
Supports
- Packages, crates, manifests, dependencies, lock files, workspaces, build profiles, commands, and registries
- Cargo reference rationale and cargo-check quiz answer
- https://doc.rust-lang.org/rust-by-example/
Supports
- Runnable examples covering language constructs and standard-library types
- Rust by Example reference rationale
- https://doc.rust-lang.org/nomicon/
Supports
- Advanced unsafe Rust, representation, aliasing, concurrency, and foreign interfaces
- Advanced reference-path rationale
- https://www.rust-lang.org/learn/get-started
Supports
- rustup installation, toolchain management, Cargo project creation, and beginner reference rationale
- https://github.com/sindresorhus/awesome
Supports
- Discovery of Awesome Rust under programming languages
- https://github.com/rust-unofficial/awesome-rust
Supports
- Curated inclusion of rust-analyzer, bacon, cargo-nextest, cargo-audit, and Criterion
- https://rust-analyzer.github.io/book/
Supports
- Editor integration, semantic analysis, completion, navigation, refactoring, and diagnostics
- rust-analyzer awesome-link rationale
- https://dystroy.org/bacon/
Supports
- Background Cargo checks, tests, Clippy jobs, and source-change feedback
- bacon awesome-link rationale
- https://nexte.st/
Supports
- Parallel Rust test execution, filtering, retries, and structured output
- cargo-nextest awesome-link rationale
- https://rustsec.org/
Supports
- RustSec advisory database and cargo-audit checks against Cargo.lock
- cargo-audit awesome-link rationale
- https://bheisler.github.io/criterion.rs/book/
Supports
- Statistical benchmarking workflow and Criterion awesome-link rationale
- https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future/
Supports
- Project origins in 2006 and Mozilla Research in 2010
- Rust 1.0 independence and the 2020 foundation plan
- https://github.com/rust-lang/rust/blob/master/RELEASES.md
Supports
- Rust 0.1 release date and the public pre-stable release line
- https://blog.rust-lang.org/2014/11/20/Cargo/
Supports
- crates.io launch, Cargo publication support, and registry purpose
- https://blog.rust-lang.org/2015/05/15/Rust-1.0/
Supports
- Rust 1.0 date, stability commitment, low-level control, safety goals, and absence of a garbage collector
- https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
Supports
- Rust 2018 stable date and edition interoperability model
- https://foundation.rust-lang.org/news/2021-02-08-hello-world/
Supports
- Rust Foundation establishment, nonprofit role, and separation from project governance
- https://blog.rust-lang.org/2021/10/21/Rust-1.56.0/
Supports
- Rust 2021 stable date and opt-in edition migration
- https://blog.rust-lang.org/2025/02/20/Rust-1.85.0.html
Supports
- Rust 2024 stable date and coordinated language, library, Cargo, rustdoc, and rustfmt changes
- https://ferrocene.dev/
Supports
- Qualified Rust toolchain role and Landscape placement
- https://www.jetbrains.com/rust/
Supports
- Rust-focused IDE features, licensing, pricing model, and Landscape placement
- https://code.visualstudio.com/docs/languages/rust
Supports
- Rust extension workflow, rust-analyzer integration, debugging, licensing, and Landscape placement
- https://zed.dev/docs/languages/rust
Supports
- Rust language support through rust-analyzer and Landscape placement
- https://docs.github.com/en/codespaces/overview
Supports
- Hosted development containers, repository configuration, pricing model, and Landscape placement
- https://www.gitpod.io/docs/introduction/getting-started/quickstart
Supports
- Reproducible hosted development environments, pricing model, and Landscape placement
- https://docs.sonarsource.com/sonarqube-server/analyzing-source-code/languages/rust
Supports
- Rust code analysis, licensing, pricing model, and Landscape placement
