We may earn an affiliate commission when you visit our partners.
Nathan Stocks

Join Nathan Stocks for a fast-paced, entertaining, curiously-informative, hands-on even deeper dive into the Rust programming language. This is the second course in the Ultimate Rust series following the Ultimate Rust Crash Course. If you like that course, you'll love this one.

Read more

Join Nathan Stocks for a fast-paced, entertaining, curiously-informative, hands-on even deeper dive into the Rust programming language. This is the second course in the Ultimate Rust series following the Ultimate Rust Crash Course. If you like that course, you'll love this one.

This is a hands-on course. Not only are there targeted exercise for each topic discussed, there are also a series of project scenarios that walk you through using what you've learned to put together playable game prototypes that work on macOS, Linux, and Windows.   These projects will make use of Rusty Engine, a game engine developed specifically for this course to keep game engine concepts to a minimum so you can focus on using exactly what you learned in this course.

Rust is a systems programming language that eliminates entire classes of bugs and security vulnerabilities, has zero-cost abstractions like C and C++, is fun to program in, and lets systems programmers have nice things. No wonder Rust is gaining traction in spaces as diverse as game engines, high-performance computing, embedded devices, and web programming. Learn how to write high-performance code without the worry of crashes or security vulnerabilities. Join a vibrant community of developers where diversity, inclusion, and just plain being nice are all first-class objectives.

Enroll now

What's inside

Learning objectives

  • How to write idiomatic, well-tested, documented rust code
  • Threads, channels, closures, iterators, code documentation, std library traits, error handling, testing, benchmarks, logging, attributes, turbofish and more!
  • Rust concepts beyond the fundamentals taught in the "ultimate rust crash course"
  • How to use rust to make video game prototypes

Syllabus

Introduction

Introduce myself and what this course is all about!

In this video:

  • What this course is all about

  • Why it's so fun

  • Game prototype teaser (using Rusty Engine!)

Read more

Show how to find the repository containing the exercises.

Lectures & Exercises

How to write idiomatic code (write code like a professional).

In this video:

  • rustfmt

  • clippy

  • attributes

This exercise gives you an opportunity to use rustfmt and clippy to take a terrible mess of code and make it look snazzy.

How to document your code and generate a documentation web site using inline comments in your code and "cargo doc".

In this video:

  • Helpful options you should use

  • Inner & Outer documentation comments

  • Rust-flavored markdown syntax

This exercise walks you through documenting an undocumented library, and generating a web site with images and intra-doc links!

How to publish a crate on crates.io.

In this video:

  • How to set up your account with crates.io

  • Cargo.toml configuration

  • cargo publish

A placeholder for a future crate publishing exercise, if they introduced namespaces for publishing crates.

How to use closures.

In this video:

  • What a closure is

  • Syntax

  • Gotchas

How to use those closures we just talked about in iterators. A bit of functional programming.

In this video:

  • Iterators

  • Iterator adapters

  • Iterator consumers

An exercise to use a bunch of closures in a bunch of iterators.

A tour of some of the most common traits from the standard library.

In this video:

  • How to derive a trait

  • How to manually implement a trait

  • Examples of deriving or implementing some of the most common traits from std

This exercise walks you through defining a trait and then using it.

How to create error types for your library in 5 (and a half) steps.

In this video:

  • How to group errors

  • Error trait

  • thiserror crate

How to handle errors that you receive.

In this video:

  • panic

  • "?" try operator

  • anyhow crate

Define an error type. Create the error. Handle the error!

How to write and run unit tests for your code.

In this video:

  • #[cfg(test)]

  • #[test] functions

  • cargo test

How to write and run integration tests for your code.

In this video:

  • The "tests/" directory

  • Running your integration tests

  • Finding your test output

How to write and run benchmark tests for your code.

In this video:

  • Criterion

  • How to get started writing benchmarks

  • Why benchmarks are so cool (HTML reports)

Write some unit tests and integration tests!

How simple logging works in Rust.

In this video:

  • log crate

  • log macros

  • env_logger

Use logging macros in a library, configure a binary to output the log info to stderr, see the difference in output at different log levels.

How to spawn, manage, and join threads.

In this video:

  • Why use threads

  • thread spawning

  • passing data to / from a thread at creation / joining

How Crossbeam channels can be used to communicate between threads.

In this video:

  • crossbeam crate

  • bounded vs unbounded channels

  • the Send trait

Spawn threads and use channels to communicate between them.

Create a functioning game prototype using the Rusty Engine package.

Overview of the project section.

How to set up and configure a project to use Rusty Engine.

How to initialize Rusty Engine within your project.

How to define a custom struct to store your game state.

How to define a game logic function and add it to your game.

How to create and manipulate sprites in your game project.

How to deal with colliders and collisions in your game project.

How to handle keyboard input in your game project.

How to handle mouse input in your game project.

How to create and manage text in your game project.

How to handle music and sound effects in your game project.

How to use timers in your game project.

A bit more about the Engine struct and the Game struct that weren't covered elsewhere.

The common setup that needs to be done before starting any Game Scenario project:

  • Add Rusty Engine as a dependency to Cargo.toml

  • Download the asset pack

  • Set up main.rs

  • Compile and run the project

This is a full walkthrough the Road Race game scenario from Rusty Engine's list of scenarios.  This assumes that you've done the "common setup" from the video of the same name.

Good to know

Know what's good
, what to watch for
, and possible dealbreakers
Explores threads, channels, and closures, which are essential for concurrent programming in Rust and building high-performance applications
Covers error handling with the `thiserror` and `anyhow` crates, which are popular choices for robust error management in Rust projects
Includes exercises for using `rustfmt` and `clippy`, which are standard tools for maintaining code quality and consistency in Rust projects
Uses Rusty Engine, a game engine developed specifically for the course, which may limit transferability to other game engines or frameworks
Teaches how to document code and publish crates, which are valuable skills for contributing to the Rust ecosystem and sharing libraries
Requires prior knowledge from the "Ultimate Rust Crash Course", which may be a barrier for learners without that specific background

Save this course

Save Ultimate Rust 2: Intermediate Concepts to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Ultimate Rust 2: Intermediate Concepts with these activities:
Review Basic Rust Syntax
Reinforce fundamental Rust syntax to prepare for the intermediate concepts covered in the course.
Browse courses on Rust
Show steps
  • Review the Rust book's chapter on basic syntax.
  • Complete basic Rust exercises on Rustlings or Exercism.
  • Write small programs to practice syntax.
Read 'The Rust Programming Language'
Solidify your understanding of Rust fundamentals by reading the official Rust book.
Show steps
  • Read the chapters relevant to the course syllabus.
  • Complete the exercises provided in the book.
  • Refer back to the book when encountering unfamiliar concepts.
Practice Error Handling with Peers
Improve your understanding of Rust's error handling mechanisms through collaborative practice.
Browse courses on Error Handling
Show steps
  • Form a study group with other students.
  • Work through error handling exercises together.
  • Discuss different approaches to error handling.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Build a Simple CLI Tool
Apply your knowledge of Rust's intermediate concepts by building a command-line tool.
Show steps
  • Choose a simple CLI tool to implement (e.g., a calculator or a to-do list).
  • Design the tool's functionality and user interface.
  • Implement the tool using Rust, focusing on idiomatic code and error handling.
  • Write unit tests and integration tests for the tool.
Write a Blog Post on Rust Traits
Deepen your understanding of Rust traits by explaining them in a blog post.
Browse courses on Traits
Show steps
  • Research Rust traits and their uses.
  • Write a clear and concise blog post explaining traits.
  • Include examples of deriving and implementing traits.
  • Publish the blog post on a platform like Medium or your own website.
Contribute to Rusty Engine
Gain practical experience by contributing to the Rusty Engine project used in the course.
Show steps
  • Explore the Rusty Engine repository on GitHub.
  • Identify a bug or feature to work on.
  • Submit a pull request with your changes.
  • Respond to feedback from the maintainers.
Read 'Programming Rust'
Expand your knowledge of Rust with a comprehensive guide covering advanced topics.
Show steps
  • Read the chapters relevant to your interests and the course syllabus.
  • Experiment with the code examples provided in the book.
  • Use the book as a reference when working on Rust projects.

Career center

Learners who complete Ultimate Rust 2: Intermediate Concepts will develop knowledge and skills that may be useful to these careers:
Systems Programmer
A Systems Programmer works on low-level software components, operating systems, and device drivers. This role requires a deep understanding of memory management, concurrency, and performance optimization, all areas that are directly relevant to the material covered in the course. The ability to write error-free code, build well-documented libraries, and implement robust multithreaded applications are critical skills for this job. This course's focus on Rust's unique approach to these concepts enables a Systems Programmer to write safer, more efficient software.
Game Developer
A Game Developer designs and implements the mechanics, gameplay, and systems of video games. This course is particularly relevant to game development using Rust with its game prototype projects built using the Rusty Engine. The course helps a game developer understand game logic implementation, sprite management, collision detection, user input handling, and audio integration. Moreover, the Rust specific topics covered in the course, such as error handling, concurrency and testing, will lead to writing more robust and performant games.
Embedded Systems Engineer
An Embedded Systems Engineer designs and develops software for specialized computer systems often with real-time constraints. This role requires proficiency in low-level programming languages and understanding of hardware interactions. The course's focus on Rust, a language known for its performance and memory safety, makes it relevant for embedded system programming. The practices in the course, such as writing well-documented code, handling errors effectively and working with concurrency, translate directly to the requirements of this role. This is why an Embedded Systems Engineer might find this course valuable.
Software Engineer
A Software Engineer designs, develops, and maintains software applications. This role requires a broad understanding of programming concepts, but this course provides specific training in Rust, a language that is gaining popularity and is used in many fields. This course is a good fit for those who want to expand their skill set in low-level programming. The course helps build a foundation in testing, documentation, and error handling which are important for a Software Engineer to produce robust, maintainable software.
High-Performance Computing Engineer
A High Performance Computing Engineer works with parallel computing systems to solve complex scientific and engineering problems. This role demands expertise in optimizing code for speed and efficiency. This course may be useful with its content on Rust, a language suitable for high-performance computing. The material on concurrency, multithreading, and efficient data structures is directly relevant. A High Performance Computing Engineer will appreciate the course's attention to detail for performance optimization with Rust.
Tooling Engineer
A Tooling Engineer develops internal tools and infrastructure to improve the productivity of other engineers. This role often involves building utilities, automation scripts, and other software to streamline workflows. This course may be useful to a Tooling Engineer. The course emphasis on writing idiomatic Rust code, creating well-documented libraries, and employing effective testing helps build the necessary skills. The course also covers practical skills such as publishing crates, which may be valuable to a Tooling Engineer.
Open Source Contributor
An Open Source Contributor actively participates in the development of publicly available software projects. This role requires the skill to write clear, maintainable code that others can understand and contribute to. The course may be useful to someone who wishes to enter this field with its focus on producing idiomatic, well-tested, and thoroughly documented Rust code. The course teaches best practices, like those used by the Rust community itself. An Open Source Contributor may find the publishing crates content helpful.
Backend Developer
A Backend Developer builds the server-side logic, databases, and APIs that power applications. This role typically requires proficiency in languages such as Python, Java, or Go. This course may be useful as it focuses on Rust, a language that is also utilized on the server side. A Backend Developer will appreciate the multithreading and error handling techniques taught in the course which are critical for building stable and scalable backend systems. This may be a good choice for someone who wishes to expand their skillset.
Robotics Software Engineer
A Robotics Software Engineer designs and implements software for robots and autonomous systems. This role requires an understanding of real-time programming, device control, and sensor data. This course's coverage of Rust may be useful for this role. The focus on writing efficient, safe, and concurrent code is applicable to robotics. The ability to test and document code with Rust may also be helpful to those interested in Robotics Software Engineering.
Cryptocurrency Developer
A Cryptocurrency Developer works on blockchain protocols, smart contracts, and decentralized applications. This role requires a deep understanding of cryptography and distributed systems. This course may be useful to those interested in this field by exposing them to Rust, a language used for cryptocurrency development. The course content on error handling, concurrency, and performance optimization is helpful skills for a Cryptocurrency Developer.
Graphics Programmer
A Graphics Programmer specializes in rendering technologies, working closely with graphics APIs, shaders, and 3D modeling. This course may be useful to a Graphics Programmer as it helps build a foundation in Rust, a language that could be used to build rendering engines. The techniques for writing maintainable and robust code, as well the game prototyping projects, could be relevant to a Graphics Programmer.
DevOps Engineer
A DevOps Engineer implements practices and tools to automate and streamline the software development lifecycle. This role often requires scripting and automation skills. This course may be helpful to a DevOps Engineer as it provides an opportunity to learn a systems language and how it can be used to write libraries, packages, and tooling. The course content on testing, documentation, and publishing packages can be relevant for a DevOps engineer.
Data Engineer
A Data Engineer builds and maintains the infrastructure for data storage, processing, and analysis. This role typically involves working with large datasets and distributed systems. This course may be useful to a Data Engineer as it helps build experience working with Rust, which may be used for performance intensive tasks. The course content on concurrency, multithreading, and error handling is applicable for Data Engineering.
WebAssembly Developer
A WebAssembly Developer writes code that runs in web browsers at near-native speeds. This role requires a deep understanding of low-level programming and compilation. This course is useful to a WebAssembly Developer as it provides experience with Rust which is sometimes used to create WebAssembly modules. The skills in Rust, such as writing safe code, error handling, and concurrency are relevant to this career.
Technical Writer
A Technical Writer creates documentation for software, hardware, or other technical products. This role requires a deep understanding of technical concepts and the ability to communicate them clearly. This course may be useful as it reinforces the importance of documentation. The course teaches how to document code and generate a website for the documentation. This may be valuable to a Technical Writer working on software products.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Ultimate Rust 2: Intermediate Concepts.
Is the official guide to Rust and provides a comprehensive overview of the language. It's useful for solidifying foundational knowledge and understanding core concepts. While the course covers intermediate topics, having a strong grasp of the basics from this book is essential. It serves as both a learning resource and a valuable reference throughout the course.
Provides a deeper dive into Rust's features and valuable resource for understanding the language's design principles. It's particularly helpful for understanding advanced topics like concurrency and memory management. While not required for the course, it offers a more comprehensive understanding of Rust and can be a useful reference for tackling complex projects. This book is commonly used by industry professionals.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser