Rust Programming Language : The Complete Reference.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Rust Programming An Introduction to a latest modern programming language.

Chapter 2: Variables and Mutability. By default variables are immutable in Rust.

Lecture 1: Variables and Mutability. Variables are immutable in Rust. Keep mut to mutable.

Chapter 3: Floating Point Types. Rust floating point types are f32 and f64 types.

Lecture 1: Floating Point Types in Rust. Two types. The f32 and f64 . Default type is f64.

Chapter 4: What is a Macro. Using Println!() macro syntax. Comments in Rust. single line.

Lecture 1: Using println!() macro syntax. Macros as an extended version of functions.

Chapter 5: Data types in Rust. Automatic type casting not allowed in Rust. Number separator

Lecture 1: Data types in Rust . Automatic type casting not allowed in Rust, char data type.

Chapter 6: Rust Constants Naming conventions. The naming conventions are similar to vars.

Lecture 1: Rust Constant Naming Conventions. Unlike declaring variable let keyword not used

Chapter 7: Rust Strings. String Literals and String Objects. String literal known as slices

Lecture 1: Strings in Rust. String literals and String objects. String object : new, from()

Chapter 8: Concatenation of strings with the + operator. A string value can be appended .

Lecture 1: Concatenation of two strings with the + operator. .Internally uses an add() fn.

Chapter 9: Rust Decision Making. if statement, if-else stmt, else if and nested , match etc

Lecture 1: Decision making in Rust. if statement, if-else, else if and nested, match stmt.

Chapter 10: Match statement in Rust. It is very similar to the switch statement in C lang.

Lecture 1: Match statement in Rust. This is very similar to the switch statement in C.

Chapter 11: Rust Control Statements. The for loop in Rust . for loop is a conditional loop.

Lecture 1: Control statements in Rust. while loop and for loop in Rust. Conditional for .

Chapter 12: Rust Functions. Defining a function in Rust. Invoking a function in Rust.

Lecture 1: Functions in Rust. Defining a function. Invoking a function. Returning values.

Chapter 13: Rust Array. Arrays in Rust. An array is a homogeneous collection of values.

Lecture 1: Arrays in Rust. An array is a homogeneous collection of values of the same data.

Chapter 14: Rust Ownership. Understanding Ownership. What is Ownership in Rust language.

Lecture 1: Ownership in Rust. Understanding ownership. Moving ownership in Rust. Move ops.

Chapter 15: Memory Allocation in Rust and ownership. Stack memory and Heap memory allocation

Lecture 1: Memory allocation and ownership in Rust. Stack allocation and Heap allocation.

Chapter 16: Rust References and Borrowing. After borrowing we have to return things back.

Lecture 1: Rust Reference and Borrowing. Reference and Borrowing are mutual to each other.

Chapter 17: Rust Slices. What is a slice. Slice is a pointer to a block of memory.

Lecture 1: Rust slices. A slice is a pointer to a block of memory. Size of slice at runtime

Chapter 18: String slices are literals. String literals are stored in binary . Immutable.

Lecture 1: String slices are literals. String literals are immutable , immutable reference.

Chapter 19: Rust Structure. A structure is a user defined data type with differing datatypes

Lecture 1: Structures in Rust. Structure is a user defined datatype with differing datatype

Chapter 20: Syntax of Structure. How to declare an instance of a structure. key :value pair

Lecture 1: Syntax of Structure .. How to declare an instance of a structure. key value pair

Chapter 21: Rust Enums. An enumerated type is declared using the enum keyword. Syntax enum.

Lecture 1: Rust enum. An enumerated type is declared using the enum keyword. Custom type.

Chapter 22: Concise control flow with if let. Rust Modules. It is a logical group of code .

Lecture 1: Concise control flow with if let. Modules in Rust . A logical group of code.

Chapter 23: Defining a Module. Modules contains functions that contain parameters also.

Lecture 1: Defining a module. Modules contains functions. Usage of the use keyword.

Chapter 24: Rust Collections. Commonly used collections : Vector, Hash Map & Hash Set .

Lecture 1: Rust Collections. commonly used are Vector, HashMap and HashSet. Vector can grow

Chapter 25: HashMap. A map is a collection of key-value pairs called entries. Map lookup tbl

Lecture 1: Hash Map. A map is a collection of key-value pairs. Hash map and hash table.

Chapter 26: Rust Error Handling. Two types of errors . Recoverable and Unrecoverable errors.

Lecture 1: Error handling in Rust. Two types of errors. Recoverable & Unrecoverable errors.

Chapter 27: Recoverable and Unrecoverable Errors .. Panic Macro and Unrecoverable errors .

Lecture 1: Recoverable and Unrecoverable Errors. Panic macro stops the program execution.

Chapter 28: More explanations on Recoverable errors. Recoverable errors do not stop the prgm

Lecture 1: Explanations on Recoverable errors. Recoverable errors do not stop program run.

Chapter 29: Generic Types. Generic Structures. Traits. Traits are like interfaces in Oops.

Lecture 1: Generic Types. Generic Structures. Traits are like interfaces in Oops languages.

Chapter 30: Reading From the Console : stdin() . Rust can read values from keyboard .

Lecture 1: Reading from Console : stdin(). Reads from the standard input keyboard to print.

Chapter 31: Rust Package Manager .Cargo is the package manager for Rust. Manages projects.

Lecture 1: Rust Package Manager. Cargo is the package manager for Rust. Manages Rust prjts.

Chapter 32: Rust Closure. Closure refers to a function within another function. Anonymous fn

Lecture 1: Rust Closure. Closure refers to a function within another function. Anonymous fn

Chapter 33: Rust Smart Pointers. A Smart Pointer is a data structure that behaves like a ptr

Lecture 1: Rust Smart Pointers. A smart pointer is a data structure that behaves like a ptr

Chapter 34: Deref<T> . Deref<T> trait is used to customize the behavior of dereference optr.

Lecture 1: Deref<T>. Deref<T> trait is used to customize the behavior of dereference opertr

Chapter 35: Drop trait : Smart Pointers. Drop trait is used to release the resources , file.

Lecture 1: Drop trait . Smart Pointers. Drop trait is used to release resources like file.

Chapter 36: RefCell<T> . RefCell<T> represents the single ownership over the data .

Lecture 1: RefCell<T> represents the single ownership over the data that it holds.

Chapter 37: Rust Concurrency. In this different parts of a program execute independently.

Lecture 1: Rust Concurrency. In this different parts of a program execute independently.

Chapter 38: Programs Threads. The Rust standard library provides support OS-level thrreads

Lecture 1: Programs in threads. OS level threads. Threads are made from spawn() function.

Chapter 39: How to handle data races with mutex and arc. Data race occurs in competitions.

Lecture 1: How to handle data races with mutex and arc. Mutex a container that locks data.

Chapter 40: Rust Trait : Multiple trait bounds. Using + operator. Using where clause .

Lecture 1: Rust Trait : Multiple trait bounds. Using '+' operator. Using where clause.

Chapter 41: Rust Lifetime. Lifetime defines the scope for which a reference is valid .

Lecture 1: Rust Lifetime. Lifetime defines the scope for which a reference is valid.