Ultimate Rust Crash Course

Learn all about variables!

In this video:

• Declare and initialize immutable and mutable variables

• Declare and initialize constants

• First brush with compiler errors

Variables can only be used within a certain scope. This becomes very important later when we discuss ownership.

In this video:

• Scope

• Blocks

• Shadowing variables

Memory safety is guaranteed at compile time.

In this video:

• Declaration separate from initialization

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

Functions are foundational to re-using code.

In this video:

• Function declaration

• Parameters and return values

• Tail expressions

Exercise B gives you an opportunity to try out creating and calling function that return values.

A well-organized library is like sunshine and daisies.

In this video:

• How to create a library module

• "use" statements

• Project dependencies

Scalar types are what everything else is built on.

In this video:

• Integers

• Floats

• Booleans

• Characters

The most primitive way to combine primitives.

In this video:

• Tuples

• Arrays

Exercise C gives you an opportunity to use simple scalar and compound types.

Controlling the flow of execution in Rust.

In this video:

• if / else if / else - as an expression

• loop

• while

• continue / break

• for

Exercise D gives you an opportunity to use control flow and strings.

How to get things done despite the ownership rules.  Borrow it and refer to it.

In this video:

• Immutable references

• Mutable references

• Reference values vs. reference types

• The 2 rules of references

Exercise E gives you an opportunity to run through ownership & reference concepts in function calls.

Rust's take on classes (but better, naturally).

In this video:

• Struct definition & implementation

• Struct fields

• Struct methods and associated functions

• Object-Oriented? (Hint: That's the wrong question)

Composition over inheritance. Rust's approach to interfaces/protocols.

In this video:

• Trait definition

• Trait implementation

• Trait inheritance

• Default behavior

• Generic functions

Exercise F gives you an opportunity to get some experience with Structs and Traits.

Structs in the standard library that implement common collection types.

In this video:

• Vec

• VecDeque

• HashMap / BTreeMap

• HashSet / BTreeSet

• BinaryHeap

• LinkedList

The unexpected power tool of Rust.  The reason you don't need null.

In this video:

• Enum definition

• Enum variants

• Methods and associated functions for enums

• Famous enums from the standard library: Option & Result

Exercise G gives you an opportunity to play with collections and enums.

An anonymous function that captures state and can be passed around.

In this video:

• Closure syntax

• Borrowing context

• Capturing context by move

• Examples with iterators

The way to burn CPU cores in parallel.  (For *waiting* for I/O in parallel, see Async/Await)

In this video:

• Spawning a thread

• Closure considerations

• Join handles

Exercise H gives you an opportunity to explore closures and threads.

• Set up terminal handling & 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

• Create a frame and send it to the render thread each iteration of the game loop

• Create a player module

• Create a player struct definition

• Implement associated functions and methods for Player

• Implement the Drawable trait for Player

• Add a Player, input handling, and drawing into the frame to our game loop

• 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

• Add shot input handling and timer updating to our game loop

  
  

• Create an invaders module

• Create Invader and Invaders structs with associated functions and methods

• Implement the Drawable trait for Invaders

• Add the invaders to our game loop

• 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

• In our gameloop, wire the player up to shooting aliens and detect our win and loss conditions

• Playtesting!