Rust lang: The complete beginner's guide

Install Rust and set up your environment, then build a hello world project. Use Cargo to create, run, and document projects, handle user input, and print to the console.

Learn how to read user input in Rust with std::io and read_line, using a mutable string, printing results, and handling errors via match, while exploring references, pointers, and macros.

Learn how Rust uses line and multi-line comments and doc comments to generate documentation for crates, modules, and functions using cargo doc, with headings and code blocks.

Master printing values to the console in Rust with print line and formatting, including variables, expressions, positional and named arguments, and the debug trait for complex data.

Explore Rust basics by learning how variables work, the available data types, and how strings differ. Discover constants, operators, and a preliminary introduction to functions used throughout the course.

Explore Rust variables: declare with let, infer types or specify i32 and i64; embrace immutability by default, use mut for changes, and master shadowing, snake_case naming, and multiple assignments.

Explore Rust strings and string slices, including the scalar type str, static lifetimes, and the difference between immutable slices and mutable String objects, with len, push, push_str, and replace.

Discover Rust constants that cannot be changed, require an explicit type, follow uppercase convention, disallow shadowing, and can be global or local in scope, as demonstrated with a URL constant.

Explore Rust operators, including arithmetic (addition, subtraction, multiplication, division, modulus), relational, logical, and bitwise operations, with practical examples. Note that increment and decrement are not supported in Rust.

Explore how to define and call functions in Rust, pass parameters by value or by reference (borrowing), and return results, while seeing practical examples of printing and formatting strings.

Generate random data in Rust using the Rand crate, including integers and floats. Create bounded values with gen_range and craft a 30-character alphanumeric string using thread_rng and distributions.

Explore Rust data types, including arrays, vectors, slices, tuples, structures, enums, and generics. Learn how each construct behaves and when to use them in real code.

Explore arrays in Rust: fixed-size collections of the same type, how to define, index, mutate elements, print with debug, use defaults and constants, and iterate with a for loop.

Learn how to use vectors in Rust, created with Vec::new or vec!, mutated with push and remove, initialized with defaults via vec![value; n], and iterated with numbers.iter().

Explore Rust tuples as heterogeneous, fixed-size collections defined with parentheses, limited to 12 elements, accessed by dot indices, and destructured for clean variable binding, while learning mutability.

Define structures with the struct keyword, instantiate an employee with name, company, and age, enable printing via derive(Debug), and add methods with impl, including a static details function.

Define and use Rust enums, decorate them with debug, and print colors like red, green, blue. Extend enums with data, such as a person with name, surname, and age.

Discover how generics let you store different types in structs or enums in Rust, use single and multiple type parameters, and print results with debug formatting.

Explore the while loop in Rust, showing condition-driven iterations, an infinite loop variant with break, and practical examples that print squares and cubes below a limit.

Apply higher order functions in rust by passing functions as parameters and using closures to map, take_while, filter, and fold to the sum of even squares below a limit.

Explore how Rust macros enable metaprogramming by writing code that expands during compilation, using macro_rules, exclamation-mark invocation, and varying parameters, expressions, and identifiers.

Explains traits in Rust as interfaces with optional default implementations, how to implement them for Rust dev and Java dev, including required and static methods, and hello world examples.

Explore returning a trait from a function in Rust by using box and dyn to create a trait object, enabling dog and cat implementations.

Learn to add traits to existing structures by implementing a Summable trait for a vector of i32, enabling a custom sum function and demonstrating basic usage.

Explore operator overloading by implementing the add trait for a custom point structure with x and y coordinates, using the use keyword, and printing results with a debug formatter.

Explore static dispatch and monomorphism in rust by implementing a duplicatable trait for strings and integers, and see how compile-time specialization optimizes memory and calls.

Explore memory management in Rust by examining ownership, borrowing, and lifetimes, and learn how reference counted variables simplify passing references in code.

Explore Rust ownership: one owner per piece of data, primitive types copy, complex types move and transfer ownership, and closures and vectors illustrate returns.

Learn how to share data safely with reference counted variables using Rust's Rc, cloning references, and tracking strong_count to manage ownership and borrowing across scopes.

Master Rust error handling by working with files—opening, reading, writing, and closing—then explore errors, helper methods, and the question mark operator.

Rust distinguishes unrecoverable panics from recoverable errors, using the panic macro, the Result enum, and the options enum to either crash or continue after handling errors.