The Complete Rust Programming Course from Udemy

Welcome to the biggest and most comprehensive Rust programming language course on Udemy.

With 17.5 hours of content already, this hands-on practical course is frequently updated to make sure you master all the skills you need to become a Rust expert in the quickest, clearest manner possible.

Stuffed full with practical challenges and exercises, the first half of the course introduces you to the basics of Rust and getting you comfortable and confident with Rust. The second half of the course focuses on data structures and algorithms, looking at which data structures you can use, as well as how to use them. You'll also learn to analyse algorithms for space and time resource consumption... and a lot more.

Why learn Rust?

Rust is the most loved programming language by developers over the past few years according to numerous developer surveys. The Rust programming language is a highly sought after skill and is also one of the best paying skills in the industry.

In the US, Rust developers earn an average of 140k - 250k USD per annum (2022).

What do YOU want to do with Rust?. Developers can (and do. ) use Rust to build game engines, file systems, websites and tools, operating systems, browser components, and a whole lot more.

Rust does not sacrifice speed for memory management like many languages do, but Rust ensures memory safety unlike languages like C/C++. Rust's compiler is going to handle a lot of the checking for you to ensure there are no undefined behaviors, dangling pointers, double-frees, etc.

Why THIS course?

This is a fast paced course that is designed to give you everything you need to learn in a clear, but very concise manner. There is no fluff involved. I want to give you the skills you need as quickly as possible to allow you to immediately begin developing high quality software using Rust.

As well as practical projects, nearly every section of the course has a dedicated student assignment to complete. Each assignments tests your new skills and helps give you the confidence to tackle your own projects going forward.

In this course I will cover:

Common programming concepts (fundamental types, functions, control flow)
Ownership and moves
References
Structs
Enums and Patterns
Error Handling
Crates and Modules
Traits and Generics
Iterators
Collections
Concurrency
Webassembly
And much, much more.

By the end of this course you will have started at the basics of programming and journeyed all the way to becoming an expert in Rust.

What are you waiting for? Dive in to Rust today.

What's inside

Learning objectives

Fundamentals of programming including: functions, structs, enums, pattern matching, iterators, closures, smart pointers, concurrency, and more
Learn memory management and understand ownership, references, borrowing, and how rust makes your code safe

Build small applications to be able to piece together concepts
Learn how to test your code

Fundamentals of programming including: functions, structs, enums, pattern matching, iterators, closures, smart pointers, concurrency, and more
Learn memory management and understand ownership, references, borrowing, and how rust makes your code safe
Build small applications to be able to piece together concepts
Learn how to test your code

Syllabus

Installing Rust

Welcome to the Course!

Course Structure

Installation Update

Windows 10 Installation

Linux and MacOS Installation

*Read Experienced Programmers*

The Basics

About This Section

Quick Note

Hello, World!

More about Visual Studio Code

Variables and Mutability

Scalar Data Types

Tuples

Arrays

Vectors

Slices

Strings and &str

String Literals

Functions

Control Flow

Wrap Up

Section 2 Quiz

Section 2 Assignment

Section 2 Assignment - Solution

Rust Principles

About this Section

Ownership

Move

Clone

Copy

Testing

More Moves

References and Borrowing

Section 3 Quiz

Section 3 Assignment

Section 3 Assignment - Solution

Structs and Lifetimes

Structs

Methods

Lifetimes

Lifetimes in Structs

Static Lifetime

Section 4 Quiz

Section 4 Assignment

Section 4 Assignment - Solution

Enums and Pattern Matching

Enums

Option

Match

If Let

More Matches

Section 5 Quiz

Section 5 Assignment

Section 5 Assignment - Solution

Traits and Generics

Generics

Traits

Traits as Parameters

Drop

From and Into

Operator Overloading

Section 6 Quiz

Section 6 Assignment

Section 6 Assignment - Solution

Cargo, Crates, and Modules

Cargo, Crates, and Packages

Modules

Common Collections

Binary Heap

Maps

Sets

Error Handing

Panic!

Result

Catching Errors

Error Propagation

Test Setup

Assertations

Find and Replace CLI Program

Setup

Handling Arguments

Separating Code

Accessing Files

Replacing Text

Iterators and Closures

Closures

Type Annotation and Performance

Good to know

Know what's good

, what to watch for

, and possible dealbreakers

Covers concurrency and web assembly, which are essential for building modern, high-performance applications and systems

Explores ownership, borrowing, and lifetimes, which are core concepts in Rust that ensure memory safety and prevent common programming errors

Includes practical assignments and projects, which allows learners to apply their knowledge and build a portfolio of Rust applications

Teaches error handling techniques, which are crucial for writing robust and reliable Rust code that can gracefully handle unexpected situations

Examines traits and generics, which are powerful features that enable code reuse and abstraction in Rust, leading to more maintainable software

Uses Visual Studio Code, which is a popular and versatile IDE, but learners may need to adapt instructions to their preferred development environment

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 The Complete Rust Programming Course with these activities:

Review C/C++ Memory Management

Show steps

Reviewing C/C++ memory management will provide a strong foundation for understanding Rust's ownership and borrowing system, making it easier to grasp the core concepts of memory safety.

Browse courses on Pointers

Show steps

Study the concepts of pointers and memory allocation in C/C++.
Practice writing code that uses manual memory management.
Identify common memory-related errors in C/C++ code.

Read 'The Rust Programming Language'

Show steps

Reading the official Rust book will provide a comprehensive understanding of the language and its features, ensuring a solid foundation for the course material.

View The Rust Programming Language, 2nd Edition on Amazon

Show steps

Read the chapters covering ownership, borrowing, and lifetimes.
Work through the examples and exercises in the book.
Take notes on key concepts and syntax.

Write a Blog Post on Rust Ownership

Show steps

Writing a blog post explaining Rust's ownership system will force you to deeply understand the concept and articulate it clearly, improving your overall comprehension.

Show steps

Research and understand Rust's ownership system thoroughly.
Outline the key points to cover in the blog post.
Write the blog post, using clear and concise language.
Edit and proofread the blog post before publishing.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Implement Data Structures in Rust

Show steps

Implementing data structures like linked lists, trees, and hash maps in Rust will reinforce understanding of ownership, borrowing, and lifetimes while providing practical experience with the language.

Show steps

Choose a data structure to implement.
Write the code for the data structure, paying attention to memory safety.
Write unit tests to ensure the data structure works correctly.

Build a Simple CLI Tool

Show steps

Building a command-line tool will provide practical experience with Rust's features and libraries, solidifying understanding of concepts like error handling, input/output, and concurrency.

Show steps

Choose a simple CLI tool to build (e.g., a file converter).
Design the tool's functionality and user interface.
Implement the tool in Rust, using appropriate libraries.
Test the tool thoroughly and fix any bugs.

Read 'Programming Rust'

Show steps

Reading 'Programming Rust' will provide a deeper understanding of advanced Rust concepts and practical applications, enhancing your skills and knowledge beyond the course material.

View Programming Rust: Fast, Safe Systems Development on Amazon

Show steps

Read the chapters covering advanced topics like concurrency and macros.
Work through the examples and exercises in the book.
Experiment with the concepts and techniques learned in the book.

Contribute to a Rust Project

Show steps

Contributing to an open-source Rust project will provide invaluable real-world experience, exposing you to best practices, code review, and collaboration with other developers.

Show steps

Find an open-source Rust project that interests you.
Read the project's documentation and contribution guidelines.
Identify a bug or feature to work on.
Submit a pull request with your changes.

Career center

Learners who complete The Complete Rust Programming Course will develop knowledge and skills that may be useful to these careers:

Systems Programmer

A Systems Programmer works on low-level software such as operating systems, device drivers, and embedded systems. Rust's memory safety features and performance make it ideal for this kind of work. A systems programmer will benefit from this course, as it covers ownership, memory management, and concurrency, which are all critical for systems programming. This course, designed to quickly teach the skills necessary for high-quality software development using Rust, can provide the practical knowledge necessary for a systems programmer.

See salaries and explore the career path for Systems Programmer

Software Engineer

A Software Engineer designs, develops, and tests software applications. This course provides a strong foundation in the Rust programming language, which is increasingly used in systems programming, game development, and web services. A software engineer will need to understand ownership, references, borrowing, and how Rust ensures memory safety, all of which are core topics covered. This course helps build practical skills in areas like error handling, concurrency, and using various data structures, making it a valuable resource for aspiring software engineers wishing to use Rust.

See salaries and explore the career path for Software Engineer

Operating Systems Developer

An Operating Systems Developer builds the core software that manages a computer's hardware and software resources. Rust's memory safety and performance make it a strong choice for developing operating systems and their components. The course covers memory management, concurrency, and many other low level features, which are crucial for operating system development. This course provides a practical way to learn these features for an operating systems developer.

See salaries and explore the career path for Operating Systems Developer

WebAssembly Developer

A WebAssembly Developer creates code that runs in web browsers, often for performance-critical applications. Rust can compile to WebAssembly, making it a powerful tool for web development. This course covers WebAssembly, which makes it directly applicable to the work of a WebAssembly developer. Rust's memory safety and speed, coupled with the instruction from this course, helps build a solid base for this field.

See salaries and explore the career path for WebAssembly Developer

Embedded Systems Engineer

An Embedded Systems Engineer designs and develops software for embedded systems, which can be found in devices like cars, appliances, and industrial equipment. Rust’s low-level control, memory safety, and strong performance are crucial for embedded systems development. This course's coverage of fundamental types, error handling, concurrency, and memory management are all highly relevant to the work of an Embedded System Engineer. Learning Rust through this course is an excellent way to prepare for a career in this field.

See salaries and explore the career path for Embedded Systems Engineer

Game Developer

A Game Developer is responsible for creating video games, from coding game mechanics to implementing graphics and sound. The speed and memory safety of Rust make it a good choice for game engine development and performance-critical game logic. This course provides a comprehensive introduction to Rust and covers relevant topics like data structures and algorithms, as well as concurrency. A game developer who takes this course will gain a strong foundation in Rust, a valuable skill for building high performance games.

See salaries and explore the career path for Game Developer

Data Structures and Algorithms Engineer

A Data Structures and Algorithms Engineer designs and implements efficient data structures and algorithms for a variety of applications. This course dedicates a portion to data structures and algorithms, and teaches how to analyze them for space and time resource consumption. Anyone interested in this field would do well to take this course, as it teaches the fundamental concepts which are needed to build a solid understanding for this role.

See salaries and explore the career path for Data Structures and Algorithms Engineer

Database Developer

A Database Developer designs, implements, and maintains databases. Rust is increasingly being used to build performance-critical components of databases. This course covers relevant topics such as memory management, concurrency, and error handling, all of which are relevant to a database developer. This course may be useful to a database developer seeking a deeper understanding of using Rust for database solutions and related systems.

See salaries and explore the career path for Database Developer

Blockchain Developer

A Blockchain Developer builds decentralized applications and smart contracts on blockchain platforms. Rust's performance, safety, and low-level control make it ideal for creating efficient and reliable blockchain solutions. This course introduces fundamental programming concepts, ownership, and concurrency, all of which are needed for blockchain development. This course might be useful to someone interested in the field.

See salaries and explore the career path for Blockchain Developer

Cloud Engineer

A Cloud Engineer is responsible for managing and maintaining cloud-based infrastructure and services. Rust is increasingly being used for building efficient cloud infrastructure components such as databases. This course, with its focus on concurrency, error handling, and webassembly, provides a solid foundation for those parts of cloud engineering that use Rust. The course may be helpful for a cloud engineer hoping to learn more about Rust's role in the field.

See salaries and explore the career path for Cloud Engineer

Software Architect

A Software Architect is responsible for the high-level design and architecture of software systems. This role requires that a candidate understands various programming languages and paradigms. This course provides an in-depth look at the Rust programming language, its common concepts, concurrency, and more. This course may be useful for someone in a software architect role, as the knowledge gained can help them make informed decisions about using Rust in their projects.

See salaries and explore the career path for Software Architect

Compiler Developer

A Compiler Developer works on the development of compilers, which translate source code into machine code. Rust is a good choice for working on compilers because of its performance and low level features. This course introduces various concepts like ownership and moves, references, and structs. While it does not specifically cover compiler development, it may enable one to use Rust to explore the field. This course may be useful for those who wish to enter this field.

See salaries and explore the career path for Compiler Developer

DevOps Engineer

A DevOps Engineer works to bridge the gap between software development and operations, focusing on automation and continuous delivery. Rust can be used to build high-performance tools for DevOps. This course may be helpful to a DevOps engineer, as the course provides a good base for building command line tools using Rust. It also covers error handling and concurrency, all relevant to DevOps work.

See salaries and explore the career path for DevOps Engineer

Research Scientist

A Research Scientist conducts scientific studies and experiments, often requiring low level and highly optimized tools. This course provides a strong foundation in a language that is known for its speed and memory safety. While not all research scientists will use Rust, for those that need a reliable tool for high-performance tasks, this course may be useful. This course is a way to learn Rust.

See salaries and explore the career path for Research Scientist

Technical Writer

A Technical Writer creates documentation for software and technical products. While this course doesn't directly teach writing skills, the technical knowledge gained about Rust, error handling, concurrency, and other aspects of the language can help the writer better understand the subject. The course may also provide a deeper understanding of Rust, which is often needed by technical writers of software applications using it.

See salaries and explore the career path for Technical Writer

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 The Complete Rust Programming Course.

The Rust Programming Language, 2nd Edition

Save

Is the official guide to Rust programming. It covers all aspects of the language, from basic syntax to advanced concepts like concurrency and memory management. It valuable reference for understanding the core principles and best practices of Rust development. This book is commonly used as a textbook at academic institutions.

The Rust Programming Language, 2nd Edition

Paperback

The Rust Programming Language, 2nd Edition

Kindle Edition

Programming Rust

Save

Provides a comprehensive and practical guide to Rust programming, covering topics such as ownership, concurrency, and web development. It valuable resource for intermediate to advanced Rust programmers. This book is more valuable as additional reading than it is as a current reference. It adds more depth to the existing course.

Programming Rust: Fast, Safe Systems Development

Kindle Edition

The Complete Rust Programming Course

What's inside

Learning objectives

Syllabus

Good to know

Save this course

Activities

Career center

Reading list

Share

Similar courses