Ultimate Rust Crash Course

1. Introduction

In this video, you will understand why Rust is such a great programming language, the goals of this course, and origin of Rust.

1. Cargo

In this video, you will get a rundown of Cargo and how to use it.

2. Variables

In this video, you will declare and initialize mutable variables and constants.

3. Scope

In this video, you will learn about scope, blocks, and shadowing variables.

4. Memory Safety

In this video, you will learn how memory safety works.

5. Exercise A - Variables

This video gives you an opportunity to try out using variables without violating scope and memory safety rules.

6. Functions

In this video, you will learn how to declare functions, parameters, and tail expressions.

7. Exercise B - Functions

This video gives you an opportunity to try out creating and calling functions that return values.

8. Module System

In this video, you will learn how to create a library module and project dependencies.

1. Scalar Types

In this video, you'll learn about integers, floats, booleans, and characters.

2. Compound Types

In this video, you'll learn about tuples and arrays.

3. Exercise C - Simple Types

This video gives you an opportunity to use simple scalar and compound types.

4. Control Flow

In this video, you'll learn about if/else, while loop, continue/break, and for loop.

5. Strings

In this video, you'll learn about strings, how they are implemented, UTF-8, bytes, Unicode scalars, graphemes, and iterators.

6. Exercise D - Control Flow and Strings

This video gives you an opportunity to use control flow and strings.

1. Ownership

In this video, you'll learn about the 2 rules of ownership, stack and heap refresher, and drop.

2. References and Borrowing

In this video, you'll learn about immutable references, mutable references, reference values versus reference types, and the two rules of references.

3. Exercise E - Ownership and References

This video gives you an opportunity to run through ownership and reference concepts in function calls.

1. Structs

In this video, you'll learn about struct definition and implementation, struct fields, methods, and associated functions.

2. Traits

In this video, you'll learn about trait definition, implementation, inheritance, default behavior, and generic functions.

3. Exercise F - Structs & Traits

This video gives you an opportunity to get some experience with Structs and Traits.

4. Collections

In this video, you'll learn about vec, vecDeque, HashMap, HashSet, binaryHeap, and linked lists.

5. Enums

In this video, you'll learn about the enum definition, enum variants, methods, and associated functions for enums.

6. Exercise G - Collections and Enums

This video gives you an opportunity to play with collections and enums.

1. Closures

In this video, you'll learn about closure syntax, borrowing context, capturing context by move, and examples with iterators.

2. Threads

In this video, you'll learn how to spawn a thread, closure considerations, and join handles.

3. Exercise H - Closures and Threads

This video gives you an opportunity to explore closures and threads.

1. Invaders Part 1 - Setup Audio

In this video, you'll create the 'invaders' project, set up dependencies, and set up and play audio.

2. Invaders Part 2 - Rendering and Multithreading

In this video, you'll set up terminal handling and mode, create a library, add a frame library module to handle the logic of a single frame, add a render library module to render a frame to the terminal, launch a child thread with a render loop, and create a frame and send it to the render thread each iteration of the game loop

3. Invaders Part 3 - The Player

In this video, you'll create a player module, create a player struct definition, implement associated functions and methods for player, add a player, input handling, and drawing into the frame to our game loop

4. Invaders Part 4 - Shooting

In this video, you'll create a shot module, create a shot struct with associated functions and methods, implement the Drawable trait for Shot, update Player to manage a vector of Shot, and add shot input handling and timer updating to our game loop

5. Invaders Part 5 - Invaders

In this video, you'll create an invaders module, create Invader and Invaders structs with associated functions and methods, implement the Drawable trait for Invaders, and add the invaders to our game loop.

6. Invaders Part 6 - Winning and Losing

In this video, you'll Add methods on the Invaders struct to detect win and loss conditions, add a method on the Invaders struct to attempt to kill an alien, wire the player up to attempting to shoot aliens with his shots, wire the player up to shooting aliens and detect our win and loss conditions, and test your game!

1. Thank You!

By the end of this video and this course, you'll have formidable knowledge and experience on Rust. You'll also have the code available for you on our GitHub repository.