The Rust Programming Language

Explore Rust as a systems programming language that delivers speed with memory safety and thread safety, and learn installation, cargo, and hello world examples.

Set up Visual Studio Code for Rust development, install Rust extensions and racer, configure your path, and run cargo projects directly from the editor.

Install rust, compile programs, and run them from the command line. Set up Visual Studio Code with rust plugins for syntax and completion, getting you ready to code quickly.

Learn Rust fundamentals, including data types, primitives, lists and tuples, Rust syntax, memory concepts (stack and heap), variable scope, shadowing, and a challenge with a code walkthrough.

Build a Rust module with cargo, declare and print boolean and other data types, explore explicit types, and inspect memory size and type behavior through practical examples.

Contrast the stack’s small, short‑lived allocations with the heap’s larger memory, box data with the new keyword, and use & and * to reference and dereference.

Explore Rust's variable scope and shadowing through the M2 challenge by creating and multiplying two numbers, demonstrating scoped and global variables and their outputs.

Explore Rust language fundamentals by examining data types, memory allocation on the stack and heap, variable scope and shadowing, and core arithmetic and conditional operators, with a hands-on code walkthrough.

Explore conditionals and looping in Rust by building and testing if statements, booleans, and comparisons, with else branches and multi-branch logic to handle values like 3, 4, and 7.

Learn Rust's match statements as case-like patterns with a default catch-all and range patterns, including assigning the matched value. See area-code examples map regions and print results.

Explore a Rust challenge that checks if a number is divisible by two or nine, stores the result, and prints a message via a match statement.

Explore Rust fundamentals, including conditionals with if else, loops such as while and for, and string pattern matching. A downloadable challenge and video walkthrough reinforce these core language fundamentals.

Advance to topics such as structures, enumerations, option<T>, generics, and arrays vs vectors in Rust, highlighting fixed versus variable length, with a code challenge and walkthrough.

Explore option of T by using none and some variants, and learn to match or handle values with if let syntax and conditional branches.

Explore advanced option handling in Rust with a check division function returning an Option<i32>. Handle zero divisors and non-zero quotients using Some and wrap results with match.

Explore arrays in Rust as fixed lists, using zero-based indexing, immutability by default, and for loops to iterate based on array length.

Learn to work with vectors in Rust by filtering numbers divisible by three and collecting the rest into a separate vector, then print results and verify with a walkthrough.

Explore how structures organize data and examine numeration, then learn to use Option<T> and compare fixed versus variable length vectors.

Discover string slicing and string manipulations, then explore tuples, structs, and a pared-down class analogy, finishing with functions and closures and practical challenges.

Explore string slicing in Rust by converting a vector to slices, using ampersands for references, and comparing slice and vector behaviors while practicing basic manipulations.

Learn practical string manipulation in Rust: create and mutate strings, concatenate with to_string, print results, handle multi-line strings, and understand why indexing a string like a vector isn’t allowed.

explore two approaches to concatenate a multi-line string with a simple string in Rust, using the plus operator and the push method, with a step-by-step solution walkthrough.

Construct rectangle and point structures, compute area by passing the rectangle by reference, and deconstruct nested structures to access coordinates, including using a tuple struct named pair.

Learn Rust functions and closures, declare with fn, define zero and multi-parameter functions, pass strings, and use closure syntax with pipes to perform and print arithmetic results.

Explore string slicing, string manipulation, and constructing arrays from strings, followed by challenges, video walkthroughs, and downloadable code. Examine tuples, structures, properties, enumerations, functions, parameters, and closures.

Explore Rust memory management by explaining ownership and borrowing, and demonstrate crates as packages or libraries. Create from scratch, download, modify, and use crates to share functionality.

explain ownership rules in rust, contrasting stack and heap, show how simple values copy on the stack while heap data moves ownership when passed or assigned, using vectors.

Explore ownership in Rust by moving a heap-allocated vector into a function, observe how it is dropped, and see how access after a move triggers compile-time errors.

Learn how borrowing differs from ownership by allowing multiple references to data with a single owner, and how to pass and dereference those references in Rust.

Explore advanced borrowing in Rust by using references and ampersands with vectors, implement print and print occurrences functions, and illustrate how to count item occurrences without moving ownership.

Master memory management in Rust with ownership and borrowing, and learn how crates enable packaging, downloading, and integrating your own functionality into existing crates.