Introduction to Rust Programming (English)

About the Rust Programming course

This course is entirely in English.

This Rust Programming training course updated for Rust Edition 2024 and Rust 1.88 is an immersive course, designed to introduce you to Rust, one of the most innovative and safe systems programming languages.

This Rust course covers everything from Rust’s history and design philosophy, to its modern application in software engineering. Through a blend of theory and hands-on labs, you'll explore Rust's unique approach to memory management, error handling, and concurrency, preparing you to build fast, reliable, and efficient software systems.

Let's be honest with you, Rust is a language that indeed has a more steep learning curve. But using our skill-tree approach you can find at any time what knowledge you know, what knowledge you master and what knowledge you need to proceed in one of the directions that you would like to explore in Rust. We have accumulated our 3 year experience with over 120 students in this enhanced course.

And the future is bright for Rust programmers. It's one of the most sought after skills in the industry and experienced Rust programmers unfortunately do not grow on trees.

If you have read several books on Rust and still are heaving a difficulty grasping the spirit of Rust, I challenge you to take our course and lay a vast foundation of your Rust knowledge.

Who is this Rust Programming course for?

This Rust programming training course is suitable for:

• Beginners & Enthusiasts
  • Ideal for those new to programming or transitioning from other languages who are eager to learn Rust in a structured manner.
• Experienced Developers
  • Perfect for professionals who have dabbled in Rust but need a clear, guided pathway to truly master its intricacies.
• Software Engineers & Industry Practitioners
  • For engineers looking to leverage Rust’s advanced features for building high-performance and secure applications.

Course objectives for this Rust course

What You Will Learn:

• Foundations of Rust
  • History, philosophy, and the rise in Rust’s popularity.
  • The unique features that make Rust ideal for safe systems programming.
• Setting Up Your Environment
  • Installing and configuring Rust using Rustup and Cargo.
  • Setting up your first Rust project with recommended editors and IDEs.
• Core Rust Programming Concepts
  • Writing your first Rust program.
  • Understanding Rust's building blocks: variables, functions, constants, and macros.
  • Mastering both primitive (statically sized) and dynamically sized data types.
  • See yourself how Rust manages the storage of these types.
  • See and verify how ownership and borrowing in Rust works 'under the hood'.
• Memory Management and Error Handling
  • Deep dive into Rust's ownership model, borrowing rules, and lifetimes.
  • Implementing robust error handling using the Option and Result types.
• Advanced Programming Constructs
  • Leveraging closures, iterators, and generics.
  • Exploring smart pointers, and the introduction of concurrency concepts in Rust with threads and async programming.
• Organizing and Testing Your Code
  • Structuring projects using modules, crates, and workspaces.
  • Implementing unit, integration, and documentation tests.
• Object-Oriented Programming in Rust
  • Understanding how traditional OOP concepts are reinterpreted in Rust.
  • Emphasizing composition, trait-based polymorphism, and best practices.

Recommended prerequisites

To attend this Rust programming training course, we recommend the following:

• Basic Programming Knowledge
  • Familiarity with fundamental programming concepts such as variables, functions, control structures, and data types.
• Understanding of Programming Paradigms
  • A general grasp of programming paradigms (imperative, object-oriented, or functional) is beneficial but not mandatory.
• No Prior Rust Experience Required
  • This course is designed to start from the basics and gradually move to advanced topics, making it accessible regardless of your previous experience with Rust.

Course Outline Rust Programming Introduction

1. Introduction to Rust

• History of Rust.
• Popularity of Rust.
• Programs & Projects in Rust.
• Philosophy behind Rust.
• Why not Rust.
• Rust as your first programming language.
• Rust and Software Engineering.
• Rust release cycles.
• Rust REPL.

2. Setting up your Rust environment

• Components of Rust.
• Rustup.
• Cargo.
• Editors and IDEs for Rust.
• Setting up your first Rust project.
• Compiling and running.
• Cargo build modes.

3. Exploring Rust

• Your first Rust program.
• Rusty building blocks.
• Main function.
• Variables.
• Constants.
• Tail expressions.
• Functions.
• Macros.
• Traits.
• Developer documentation.

4. Primitive or statically sized data types

• Integers.
• Floats.
• Booleans.
• Char.
• Literal String (&str).
• Tuples.
• Array.
• Reference types.
• Statically Sized User defined types.
  • Structs.
  • Enums.
• Constants.
• Statistics.
• Converting/casting.

5. Dynamically sized data types

• Slices.
• Owned Strings / String Objects.
• Dynamically Sized User defined types.
  • Structs.
  • Enums.

6. Memory Management in Rust

• Classic memory management.
• Rust's take on memory management.
• Stack vs Heap.
• ReadOnly part of.
• Concept of ownership.
• The three ownership rules.
• Ownership handling with static and dynamic types.
• Issues as a result of ownership move.
• Borrowing.
• The Borrowing Rules.
• Partial borrowing.

7. Conditionals in Rust

• If conditional.
• Let if.
• Match.
• Let match.
• Match guards.
• Pattern matching.
• Advanced pattern machting.

8. Program flow in Rust

• While loops.
• For loops.
• Break.
• Continue.

9. Collections

• Vectors.
• Hashmaps.
• Overview of other collections.

10. Functions

• Function signature.
• Naming conventions.
• Tail expressions.
• Multiple return values.
• Recursive functions.

11. Error handling

• Recoverable and non-recoverable errors.
• Panic.
• Some<T,None> enum.
• Result<T,E> enum.
• Unwrap.
• Using match.
• Error propagation.
• Error propagation with the ? operator.
• Errorkind.
• Custom Errors.
• Useful external error crates.

12. The Rust std library

• Overview of the std library.
• I/O functions.
• Parse functions.
• Math functions.
• OS functions.

13. Testing in Rust

• Unit tests.
• Macros used in testing.
• Building and running tests.
• Test coverage.
• Doc testing.
• Integration testing.

14. Closures

• Concept of closures.
• Use case of closures.
• Closures that borrow.
• Closures that take ownership.

15. Iterators

• Understanding Iterators.
• Types of iterators.
• Lazy evaluation.
• Ownership and borrowing.
• Mutable iterators.
• Iterators and Pattern Matching.
• Creating a custom Iterator.

16. Code organization in Rust

• Concepts of code organization in Rust.
• Crates.
• Packages.
• Modules.
• Visibility and scoping.
• Rust Workspaces.
• Importing an external package.
• Creating and publishing your own package.
• Code organization patterns.
• Best practices.

17. Object Orient Programming in Rust

• OOP concepts.
• OOP concepts implemented in Rust.
• Favoring composition over inheritance.
• Static or associated methods.
• Constructors.
• Destructors.
• Traits.
• Trait bounds.
• Static displatch.
• Dynamic displatch.
• Downcasting.

18. Generics in Rust

• Concept of Generics.
• Generic Functions.
• Generic userdefined types.
• Trait bounds.

19. Lifetimes in Rust

• Concept of lifetimes.
• Lifetime annotations.
• Lifetime elision.

20. Smart pointers in Rust

• Concepts of Smart Pointers.
• Box.
• Rc and Arc.
• Cell and RefCell.
• Mutex and RwLock.

21. Concurrency in Rust

• Concepts of concurrency in Rust.
• Threads.
• Message Passing (MPSC).
• Share State Concurrency.
• Rayon.
• Async programming in Rust.