
This video gives an overview of the entire course.
In this video, we will examine the basic syntax of Rust and see its variables called “bindings” at work.
Learn that bindings are immutable by default
Learn that Rust supports mutable bindings
Know that the compiler will prevent us from using a variable that was not initialized
In this video, we will examine the built-in types provided by Rust.
Load up the Rust playground
Learn about the two types of Rust – strong and dynamic
Get acquainted with the built-in types and check on some programming as well
In this video, we will see how rust code is organized, see some more types, and build some more programs.
Learn some basics about crates and modules
Learn that there are a number of imports that come into a program, known as “preludes”
In this video, we will talk about the functionality that is available by default on every Rust program: Rust standard library.
Get to know about the contents of the rust standard library
Learn a bit about the Rust standard library’s philosophy
In this video, we will build a simple Fibonacci calculator.
Define the program to be written
Sketch out the implementation types
Build a working implementation
In this video, we will build a more efficient Fibonacci program.
Define the performance bottleneck of the previous program
Understand how dynamic programming will help
Implement a dynamic solution
In this video, we will cover installing and managing Rust with Rustup.
Learn about multiple release channels in Rust
Learn to install Rust on your system
Learn that Rustup makes it easier to manage the versions of other software
In this video, we will learn how to manage our tools with Rustup.
Learn the basic commands used in Rustup
Learn to set an override for a project
Discuss tradeoffs between stable, beta and nightly
In this video, we will talk about creating projects with Cargo.
Create a new project on our respective terminal
Create a main application file that runs all our codes and brings them all together
In this video, we talk about the crate ecosystem around rust.
Get to know about crates.io, a public crates repository
Learn about semantic versioning
We talk about the Rust documentation ecosystem.
Learn the URL for projecting information on any particular crate
Explore and learn more about the doc
In this video, we will be adding dependencies with Cargo.
Use Cargo to build the project
In this video, we will check out the importance of the borrow checker.
Discuss memory corruption problems
Explain how memory corruption problems are bad
Explain how the borrow checker prevents memory unsafety
In this video, we will talk about ownership, borrowing, and RAII.
Find out what ownership, borrowing and RAII is all about
In this video, we will take a look at shared and exclusive access and see how they work with the Rust compiler.
Create a program
Learn how to use shared and exclusive access
In this video, we will talk about the phenomenon of fighting with the borrow checker.
Learn what exactly fighting with the borrow checker means
Learn the different designs in a borrow checker
Learn why we must not fight the borrow checker
In this video, we will learn about strings, strs, vecs, and slices.
Learn about strings and vecs
Learn about strs and slices
In this video, we will understand and deal with borrow checker errors.
Understand what the borrow checker is
Get to know the types of borrow checker errors
In this video, we will talk about structured data, also known as structs or data structures
Create a simple program using struct and get the output
Explore the different ways in which we can use structs in our programs
In this video, we will examine another basic kind of type in rust called enumerations or enum.
Create a simple program using enum and get the output
Explore the different ways in which we can use enum in our programs
In this video, we talk about match expressions.
Create a program on the simulation of guiding a robot around using enumerations
Learn to write commands for the robot using enums
Learn to use the match expression in writing a program efficiently to control the robot
In this video, we will see how to design a simple markup language.
Create a simple program on finite-state machines
Explore what goes into designing the markup language
In this video, we implement the markup language.
Explore the previous program by making a few alterations
Learn to use the derivation keyword to copy and clone the values in the enum state
Explore the usage of several match expressions within the program
In this video, we will be taking a look at traits.
Learn the specific behavior of traits
Understand the default methods used in traits
Explore the syntax and parameters used in traits
In this video, we will discuss some of the built-in traits that come with the rust compiler and standard library.
Learn about comparison
Learn about display and debug
Learn about clone and copy and also about the iterator
In this video, we will learn how to write our own traits.
Understand the various applications of traits
Create a simple program
Learn how to use traits within the program
In this video, we will learn about generic functions.
Learn about arguments for generic functions
Learn the generic syntax and trait bounds
Explore the concepts through a programming example
In this video, we will learn about generic types.
Learn about arguments for generic types
Learn about generic type syntax
Learn about existing generic types
In this video, we will learn about traits, objects, and dynamic dispatch.
Learn about static dispatch
Learn about dynamic dispatch
In this video, we will learn about closures in Rust.
Learn what are closures and their syntax
Understand closure syntax
Learn various other concepts such as closing variables, closure return strategies, and so on
In this video, we will take a look at iterators.
Define iterators
Create iterators
Learn about the different methods used
In this video, we will learn map, filter, and fold.
Learn about map, filter, and fold
Learn about the combination of the three
Understand the perks of using them
In this video, we will learn about the Barycenter finder.
Create a program
Compute the gravitational center of the system – Barycenter
In this video, we will take a look at how to parallelize the Barycenter finder.
Parallelize the existing Barycenter program
Understand rayon and itertools
In this video, we will take a look at breaking up code with modules.
Understand why it is important to break up code
Learn the basic organization
Understand that it is important to document the code
In this video, we will discuss error handling.
Learn about the two error handling types
Propagate the errors upwards
In this video, we will take a look at API designs.
Use naming conventions
Learn about interoperability, document, and flexibility
In this video, we will learn about unit testing.
Create a new rust library called Bucketizer
Understand that working on unit tests helps to iterate new designs without any application code
In this video, we will learn about integration testing.
Implement the Bucketizer
Create a well-designed crate
In this video, we will talk about documentation.
Discuss documentation in the Bucketizer project
Get a brief recap of the course
Rust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity.
In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program.
Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager.
About the Author
Leo Tindall is a software developer and hacker from San Diego whose interests include scalability, parallel software, and machine learning.