Description

This video course introduces you to the world of Rust programming. You'll learn about the Rust ecosystem, tools, primitive types, and control flow, and gain knowledge of how real-world applications are actually developed in Rust.

Are you in awe of how Rust systematically eliminates entire classes of bugs and security vulnerabilities and are looking to take your first step toward understanding this diverse yet fun programming language? This video course will get you started with Rust and teach you how to write high-performance code without worrying about crashes. The course starts with the background and origin of Rust and explains why it is a great programming language. Next, you'll explore the fundamental concepts of Rust such as cargo, variables, and functions, and get a walkthrough of Rust's primitive types and control flow. Moving ahead, you'll cover essential aspects of Rust, including ownership and borrowing with the help of interesting examples. Later, you'll get to grips with structs, traits, collections, and enums. Toward the end, you'll work through exercises to learn about closures and threads, and a project name Invader to get hands-on experience. By the end of this course, you'll be well-versed with Rust programming fundamentals and have the skills you need to write error-free code. All code for this course is available on our GitHub repository - https://github.com/PacktPublishing/Ultimate-Rust-Crash-Course

What You Will Learn

Find out the history of Rust programming
Create, compile, and run a project with Cargo
Distinguish between Scalar and Compound primitive types
Explore the 3 rules of ownership
Get up and running with structs and traits
Explore closures and threads

Audience

This video course is for those who are just getting started as programmers, software developers, and computer science engineers and are looking to learn Rust programming fundamentals. Basic knowledge of any programming language is required to get started with this course.

Approach

This practical course will help you gain a solid understanding of Rust fundamentals. Featuring examples, coding exercises, and activities, it'll help you get hands-on with developing Rust applications.

Key Features

Get to grips with Rust programming fundamentals * Become familiar with the Rust ecosystem and tools * Work on a real-world project to understand Rust in detail

Github Repo

https://github.com/PacktPublishing/Ultimate-Rust-Crash-Course

About the Author

Nathan Stocks

Nathan Stocks has spent the last 20 years working in software development, mostly in the field of backend infrastructure. He fell in love with Rust in 2016 and began teaching it in 2017. For the past several years, he has focused on systems-level programming. He maintained the AVbin audio library (written in C) from 2011-2013. He has had tons of fun learning, using, and teaching Rust at conferences and online. He also loves Python and PostgreSQL, and still occasionally suffers from nightmares about C and C++. He currently works at GitHub, managing the Git Storage team, and spends his nights in pursuit of someday creating a successful indie game in Rust.

Course Outline

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.

2. Fundamentals

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.

3. Primitive Types and Control Flow

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.

4. The Heart of Rust

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.

5. The Meat of Rust

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.

6. Final Lectures

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.

7. Project - Invaders

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!

8. Final Words

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.

Course Images

Ultimate Rust Crash Course

By Packt

Booking options

Highlights