Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Zero To Mastery

Rust Programming: The Complete Developer's Guide

via Zero To Mastery

Go to class Write review

Overview

Learn the Rust programming language from scratch! Learn how to code and build your own real-world applications using Rust so that you can get hired this year. No previous programming or Rust experience needed.
  • Fundamentals of computer programming concepts such as conditional logic, loops, and data transformations
  • Foundational computer science topics such as computer memory, program logic, and simple data structures
  • Working with data: enums, structs, tuples, expressions, optional data and more
  • Solid understanding of all core concepts of the Rust programming language such as: memory, mutability, traits, slices, and generics
  • Reading and writing application code in the Rust programming language
  • Utilization of the Rust ecosystem to develop applications more efficiently
  • How to translate real-life requirements into working applications to solve real-world problems (and that you can add to your portfolio)
  • How to make your programs reliable through the use of automated testing and by leveraging features of the Rust language

Syllabus

  •   Introduction
    • Rust Programming: The Complete Developer's Guide
    • Exercise: Meet Your Classmates and Instructor
    • Course Projects + Code + Slides + Cheatsheet
    • Understanding Your Video Player
    • Set Your Learning Streak Goal
  •   Rust Fundamentals
    • Introduction
    • Data Types
    • Variables
    • Functions
    • println!
    • Control Flow with If
    • Repetition
    • Setup Rust: Toolchain
    • Setup Rust: rust-analyzer
    • Setup Rust: clippy
    • Setup Rust: error-lens
    • Comments
    • Activity: Functions
    • Numeric Types & Basic Arithmetic
    • Activity: Basic Math
    • Let's Have Some Fun (+ Free Resources)
  •   Making Decisions with Rust
    • Control Flow: If & Else
    • Activity: Logic with If & Else
    • Activity: Logic with If & Else
    • Match Expression
    • Demo: Basic Match
    • Activity: Basic Match 1
    • Activity: Basic Match 2
    • Unlimited Updates
  •   Repetition
    • The Loop Expression
    • Activity: Loops
    • The While Loop
    • Activity: While Loops
  •   Working With Data
    • Enums
    • Demo: Enums
    • Activity: Enums
    • Structs
    • Demo: Structs
    • Activity: Structs
    • Tuples
    • Demo: Tuples
    • Activity: Tuples
    • Expressions
    • Demo: Expressions
    • Activity: Expressions
    • Course Check-In
  •   Rust's Memory Model
    • Intermediate Memory Concepts
    • Ownership
    • Demo: Ownership
    • Activity: Ownership
  •   Data Collections
    • Implementing Functionality
    • Activity: Implementing Functionality
    • The Vector Data Structure
    • Vector Basics & For Loops
    • Activity: Vectors & For Loops
    • About Strings
    • Demo: Strings
    • Activity: Strings
    • Implement a New Life System
  •   Expanding Knowledge
    • Deriving Functionality
    • Type Annotations
    • Enums Revisited
    • Demo: Advanced Match
    • Activity: Advanced match
    • The Option Type
    • Demo: Option
    • Activity: Option
    • Generating Documentation
    • Standard Library API docs
    • Activity: Standard Library API docs
  •   Fallible Functions
    • The Result Type
    • Demo: Result
    • Activity: Result
    • Activity: Result & The Question Mark Operator
  •   Data Collection: HashMap
    • The HashMap Data Structure
    • Working With HashMaps
    • Activity: HashMap Basics
  •   Easier Data Management
    • Basic Closures
    • Map Combinator
    • Activity: Map Combinator
    • Option Combinator Pattern
    • Activity: Option Combinators
    • Using Iterators
    • Activity: Using Iterators
    • Ranges
    • If..let..else
    • while..let
  •   Managing Code
    • Inline Modules
    • Activity: Inline Modules
    • Testing
    • Activity: Testing
    • External Crates
    • Activity: Adding an External Crate
    • External Modules
    • Activity: External Modules
  •   Milestone Project: Billing Application
    • Gathering User Input
    • Activity: Gathering User Input
    • Mini Project: Introduction
    • Retrieve User Input
    • Creating The Main Menu Loop
    • Required Data Structures
    • Implementation: Adding & Viewing Bills
    • Implementation: Removing Bills
    • Implementation: Editing Bills
  •   Shared Functionality
    • Traits
    • Demo: Traits
    • Activity: Traits
    • Implementing The "Default" Trait
    • Generics & Functions
    • Demo: Generics & Functions
    • Activity: Generics & Functions
    • Generic Structures
    • Generic Structures & impl Blocks
    • Demo: Generics & Structures
    • Activity: Generics & Structures
    • Advanced Memory Concepts
    • Trait Objects
    • Demo: Trait Objects
    • Activity: Trait Objects
  •   Lifetimes
    • Ownership & Lifetimes
    • Demo: Lifetimes
    • Activity: Lifetimes & Structures
    • Activity: Lifetimes & Functions
  •   Improving Program Reliability
    • Custom Error Types
    • Demo: Custom Error Types
    • Activity: Creating a Custom Error
    • const
    • New Type Pattern
    • Activity: Utilizing The New Type Pattern
    • TypeState Pattern
    • Demo: TypeState Pattern
    • Activity: TypeState Pattern
    • Demo: Match Guards & Binding
    • Activity: Match Guards & Binding
    • Arrays & Slices
    • Slice Patterns
    • Activity: Slices
    • Type Aliases
    • Exercise: Imposter Syndrome
  •   Type Conversions
    • From/Into
    • TryFrom/TryInto
    • Demo: From/Into
    • Activity: TryFrom/TryInto
    • Numeric Limits & Numeric Type Casting
  •   Maintainable Code
    • Effective Trait Usage
    • Demo: Abstract Network Request
    • Activity: Abstract Data Storage
    • Demo: Proxy / Delegate
    • Activity: Implement a proxy structure
    • Demo: Extension traits
    • Demo: Blanket implementations
    • Activity: Extension traits & blanket implementations
    • Test-Driven Development (TDD)
    • TDD Demo: Standalone function 1
    • TDD Demo: Standalone function 2
    • TDD Demo: struct methods
    • Red-Green-Refactor
    • TDD Demo: Maintainable tests 1
    • TDD Demo: Maintainable tests 2
    • TDD Demo: Maintainable tests 3
    • Activity: Applying TDD
  •   Project: Time Tracker
    • Project overview
    • Creating a new project
    • Project structure
    • Dependencies
    • Error configuration
    • Tracing configuration
    • Initial testing setup
    • CLI Parsing module
    • Parsing with Clap
    • Tracker module
    • Starting & stopping the tracker
    • Time records setup
    • TIme records implementation
    • Tracker behavior test
    • Tracker behavior test implementation
    • Extract tracker interface
    • Reporting setup
    • Calculating elapsed duration
    • Report formatter setup
    • Report formatter implementation
    • CLI: start command test setup
    • CLI: start & stop command implementation
    • CLI: generating reports & cleanup
  •   Parallel Execution
    • Passing Closures to Functions
    • Threads
    • Demo: Threads
    • Activity: Threads
    • Channels
    • Demo: Channels
    • Demo: Bidirectional Threaded Communication
    • Activity: Channels
  •   Shared Ownership
    • Smart Pointers
    • Interior Mutability: Cell & RefCell
    • Demo: Smart Pointers & RefCell
    • Activity: Smart Pointers & RefCell
    • Arc/Mutex
    • Threading: Deadlocks
    • Demo: Arc/Mutex
    • Activity: Arc/Mutex
  •   Standard Library Tour
    • Enum Equality & Ordering
    • Struct Equality & Ordering
    • Operator Overloading
    • Iterators: Implementing Iterator for a Struct
    • Implement IntoIterator
    • Demo: Implementing IntoIterator
    • Activity: Implementing Iterator
    • Iterators: Custom Iteration Logic
    • Helpful Macros
    • Managing Integer Overflow
  •   Other Language Features
    • Turbofish
    • Loop Labels
    • Loop Expressions
    • Struct Update Syntax
    • Escape Sequences & Raw Strings
  •   Crate Roundup
    • dotenvy
    • serde
    • rand
    • cached
    • regex
    • chrono
    • strum
    • derive_more
    • rayon
    • tracing
    • color-eyre
  •   Resources
    • Helpful Links for Your Rust Career
  •   Declarative Macros
    • Overview
    • Detail
    • Demo: impl Blocks
    • Activity: Control Flow
    • Activity: impl Blocks
    • Repetitions
    • Demo: Repetitions
    • Activity: HashMap
    • Demo: Syntax Extension
    • Activity: Syntax Extension
    • Activity: Generating Tests
    • Activity: Function Tracer
    • Demo: Checked Config
    • Demo: Recursive tt Muncher
  •   Benchmarking
    • Criterion Benchmarks
  •   Where To Go From Here?
    • Thank You!
    • Review This Course!
    • Become An Alumni
    • Learning Guideline
    • ZTM Events Every Month
    • LinkedIn Endorsements

Taught by

Jayson Lennon

Reviews

Start your review of Rust Programming: The Complete Developer's Guide

Go to class

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Sign up for free
Someone learning on their laptop while sitting on the floor.