Learn to build Go systems with AI agents September 16 & 17 Enroll Now
Ardan Labs home
Contact Us
Ardan Labs Logo

Let's Talk

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.
Ardan Labs

Ultimate Rust Bundle

44+ Hours Beginner - Advanced

Purchase of this bundle gives you access to all of our existing and future Rust courses durring your membership year (12 month membership).

Free Preview
Ultimate Rust Bundle | Ardan Labs

What You'll Learn

Hands-on training taking you from “Hello World” to building fast, safe and productive servers. Learn Rust’s memory, safety, concurrency and asynchronous models and create useful applications that can serve as templates for immediate productivity. This bundle covers beginner and some intermediate to advanced topics.

Requirements

You don’t need prior experience with Rust. You do need: a text editor, ideally one that supports Rust Analyzer (Visual Studio Code is a good start), and Rust installed from ( https://rustup.rs/ ). You’ll get the most out of this class if you have prior programming experience in other languages - variables, basic control flow (for loops, etc.) and with the command-line.

Detailed Course Info
  • Skill Level: Beginner - Advanced
  • Bundle Length: 44+ Hrs

Note: All of our bundles are for a one year subscription to the course content. This includes all updates and new content added during that time.

Team Pricing: We offer special pricing models for teams

Courses Included in the Bundle

Ultimate Rust Best Practices Icon

1+ total hours

Beginner

Ultimate Rust Best Practices

This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style and general development advice.

with: Herbert Wolverson

View Course Info

Course Introduction

This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style and general development advice.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Section 1: Tooling
  • 1.0 - Introduction - Formatting
  • 1.1 - Clippy (the linter)
  • 1.2 - Documentation
  • 1.3 - Understanding Dependencies
  • 1.4 - Managing Your Own Dependencies
  • 1.5 - Checking for Vulnerabilities
  • 1.6 - Check for Outdated Dependencies
  • 1.7 - Denying Dependencies by Licensing
Section 2 : Code Best Practices
  • 2.0 - Favor Iterators
  • 2.1 - Minimize Cloning (we have an alternative name as well Cloning Can Be a Code Smell)
  • 2.2 - Don’t Emulate OOP
  • 2.3 - Favor Small Functions
  • 2.4 - Clever Code
  • 2.5 - Floating Point Numbers
  • 2.6 - Platform & Feature Specific Code
Section 3 : General Best Practices
  • 3.0 - TANSTAAFL (There Ain’t No Such Thing As A Free Lunch)
  • 3.1 - YAGNI : You Ain’t Gonna Need It
  • 3.2 - Domain Boundaries
  • 3.3 - Taming Compile Times
Rust From C/C++ Icon

6+ total hours

Beginner

Intermediate

Rust From C/C++

This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust's native compilation, memory management, and advanced features, you'll compare and contrast key concepts like types, control flow, and data structures in this class. Delve into Rust's strengths in memory safety and concurrency, alongside its unified tool, Cargo, streamlining development. Additionally, learn how Rust facilitates interoperability with C and C++ through Foreign Function Interface (FFI).

with: Herbert Wolverson

View Course Info

Course Introduction

This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust’s native compilation, memory management, and advanced features, you’ll compare and contrast key concepts like types, control flow, and data structures in this class. Delve into Rust’s strengths in memory safety and concurrency, alongside its unified tool, Cargo, streamlining development. Additionally, learn how Rust facilitates interoperability with C and C++ through Foreign Function Interface (FFI).

This course is part of the Ultimate Rust track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Introduction:
  • 1.0 - Introduction
Hello World:
  • 2.1 - Setup & Update Rust
  • 2.2 - Setup Dev Environment
  • 2.3 - IDE Configuration
  • 2.4 - Rust Fundamentals
Touring the Rust Langauge:
  • 3.1 - Primitive Types
  • 3.2 - Mutability
  • 3.3 - Primitive Type Conversion
  • 3.4 - Numeric Overflow
  • 3.5 - Control Flow
  • 3.6 - Loops
  • 3.7 - Strings
  • 3.8 - Functions and Scopes
  • 3.9 - Structures
  • 3.10 - Structure Functions
  • 3.11 - Destructors - Drop
  • 3.12 - Tuples and Destructuring
  • 3.13 - Enums
  • 3.14 - Containers
  • 3.15 - Iterators
  • 3.16 - Move by Default
  • 3.17 - Borrowing
  • 3.18 - Slices
  • 3.19 - Memory Management
  • 3.20 - Concurrency
  • 3.21 - Program Organization
  • 3.22 - Traits
  • 3.23 - Generics
  • 3.24 - Error Handling
Touring the Rust Ecosystem:
  • 4.1 - Tool Equivalencies
  • 4.2 - Unit Tests
  • 4.3 - Benchmarking
Calling C from Rust with FFI:
  • 5.1 - Calling C from Rust with FFI
Rust as a Service Icon

7+ total hours

Beginner

Intermediate

Rust as a Service

This course teaches integrating Rust into service-oriented architectures, covering REST server development, data handling, error management, and modularization. You'll learn tracing, automated OpenAPI documentation, configuration for different environments, and alternative connectivity mechanisms like gRPC and WebSockets. Explore deploying a test service in a containerized environment, along with insights into service design, deployment strategies, and scaling. This prepares you for deploying high-performance Rust services in enterprise environments.

with: Herbert Wolverson

View Course Info

Course Introduction

This course teaches integrating Rust into service-oriented architectures, covering REST server development, data handling, error management, and modularization. You’ll learn tracing, automated OpenAPI documentation, configuration for different environments, and alternative connectivity mechanisms like gRPC and WebSockets. Explore deploying a test service in a containerized environment, along with insights into service design, deployment strategies, and scaling. This prepares you for deploying high-performance Rust services in enterprise environments.

This course is part of the Ultimate Rust track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Introduction:
  • 1.0 - Introduction
REST Service:
  • 2.1 - Minimal HTTP Server
  • 2.2 - Service Stack
  • 2.3 - Extractors
  • 2.4 - Add a Simple Tower Layer (State)
  • 2.5 - Add a Simple Tower Layer (Mutable State)
  • 2.6 - Multiple States - Extension Layers
  • 2.7 - Quick Recap on State and Layers
  • 2.8 - Nesting Multiple Routers
  • 2.9 - Nested Routers with State
  • 2.10 - Calling Other Services
  • 2.11 - Returning Status Codes
  • 2.12 - Using IntoResponse
  • 2.13 - Error Handling with IntoResponse
  • 2.14 - Quick Recap on Nesting, Making Calls and Responses
  • 2.15 - Serving Static Content with Tower
  • 2.16 - Simple Header-Based Authentication
  • 2.17 - Simple Header-Based Auth with Middleware
  • 2.18 - Middleware Auth with Injection
  • 2.19 - Selectively Applying Layers
  • 2.20 - Router Layers
  • 2.21 - Layer Recap
Tracing:
  • 3.1 - Minimal Example
  • 3.2 - Logging Axum/Tower
  • 3.3 - Timing Spans
  • 3.4 - Axum Spans
  • 3.5 - Logging to a File
  • 3.6 - Structured Logging to JSON
  • 3.7 - OpenTelemetry
OpenAPI Documentation:
  • 4.1 - OpenAPI Documentation
Handling Service Configuration:
  • 5.1 - Environment Variables with .env
  • 5.2 - The Config Crate - Basics
  • 5.3 - Loading Config via HTTP
  • 5.4 - CLI configuration with Clap
  • 5.5 - Recap
Handling Service Configuration:
  • 6.1 - Hello Tonic - Protocol Definition
  • 6.2 - Hello Tonic - Project Definition and Build
  • 6.3 - Hello Tonic - The Server
  • 6.4 - Hello Tonic - The Client
  • 6.5 - gRPC Streaming
  • 6.6 - gRPC Streaming - Protocol Definition
  • 6.7 - gRPC Streaming - The Server
  • 6.8 - gRPC Streaming - The Client
  • 6.9 - Recap So Far
  • 6.10 - Authentication
  • 6.11 - Tracing
  • 6.12 - When to use gRPC
Web Sockets:
  • 7.1 - Minimal Echo Server
  • 7.2 - A native WS client
  • 7.3 - JSON
Service Deployment:
  • 8.1 - Test Service
  • 8.2 - Native Host Deployment
  • 8.3 - Docker Deployment
Service Design:
  • 9.1 - Understanding Your Company Architecture
  • 9.2 - Designing Individual Services
  • 9.3 - Combining Services into a Modular Monolith
  • 9.4 - Service Exposure
  • 9.5 - Scaling Out
Wrap Up:
  • 10.1 - Wrap Up
Ultimate Rust: Crash Course Icon

5+ total hours

Beginner

Ultimate Rust: Crash Course

This course will provide you with the fundamentals you need to boost you up Rust's steep learning curve. A fast-paced, entertaining, and curiously informative hands-on crash course in the Rust programming language. Learn how to write high-performance code without the worry of crashes or security vulnerabilities.

with: Nathan Stocks

View Course Info

Course Introduction

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

What you’ll learn:

  • Rust language basics, tooling, and ecosystem
  • Fundamentals such as variables, scope, functions, modules, scalar & compound types, control flow, strings, structs, traits, enums, and more.
  • Fun tips & tricks for using Rust and systems programming in general
  • Concepts essential to understanding Rust such as ownership, references & borrowing, the memory model, and why Rust focuses on safety, concurrency, and speed.

Requirements:

  • A basic understanding of general programming concepts
  • Familiarity with other programming languages such as Python, C, etc. is helpful, but not required.
  • Rust installed and ready to use - you’ll learn more by doing the exercises!

Who this course is for:

  • Aspiring systems programmers, software developers, engineers, wizards, warriors, and hobbits
  • Any developer who needs to run code fast, efficiently, securely, under tight restraints, or with a minimum of bugs
  • A desire to begin using Rust

Course Outline

Module 1: Introduction
  • Lesson 1.1 - Introduction
  • Lesson 1.2 - Exercises Overview
  • Lesson 1.3 - Installation
  • Lesson 1.4 - Editor/IDE
Module 2: Fundamentals
  • Lesson 2.1 - Cargo
  • Lesson 2.2 - Variables
  • Lesson 2.3 - Scope
  • Lesson 2.4 - Memory Safety
  • Lesson 2.5 - Exercise A - Variables
  • Lesson 2.6 - Functions
  • Lesson 2.7 - Exercise B - Functions
  • Lesson 2.8 - Module System
  • Lesson 2.9 - Exercise C - Module System
Module 3: Primitive Types & Control Flow
  • Lesson 3.1 - Scalar Types
  • Lesson 3.2 - Compound Types
  • Lesson 3.3 - Exercise D - Simple Types
  • Lesson 3.4 - Control Flow
  • Lesson 3.5 - Exercise E - Control Flow
  • Lesson 3.6 - Strings
  • Lesson 3.7 - String Literals
  • Lesson 3.8 - Exercise F - Strings
Module 4: The Heart of Rust
  • Lesson 4.1 - Ownership
  • Lesson 4.2 - References & Borrowing
  • Lesson 4.3 - Exercise G - Ownership & References
Module 5: The Meat of Rust
  • Lesson 5.1 - Structs
  • Lesson 5.2 - Exercise H - Structs
  • Lesson 5.3 - Traits
  • Lesson 5.4 - Exercise I - Traits
  • Lesson 5.5 - Collections
  • Lesson 5.6 - Exercise J - Collections
  • Lesson 5.7 - Enums
  • Lesson 5.8 - Exercise K - Enums
Ultimate Rust 2: Intermediate Concepts Icon

4+ total hours

Intermediate

Ultimate Rust 2: Intermediate Concepts

This is the second course in the Ultimate Rust series following the Ultimate Rust Crash Course. It will provide an even deeper dive into the Rust programming language with the same fast-paced, entertaining, curiously-informative, hands-on styled curriculum. If you like that course, you'll love this one!

with: Nathan Stocks

View Course Info

Course Introduction

This is a hands-on course! Not only are there targeted exercises 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.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

What you’ll learn:

  • 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

Requirements:

  • A beginner’s knowledge of Rust (taking the “Ultimate Rust Crash Course” is recommended)
  • Intermediate+ experience with general programming concepts and languages.
  • Rust installed and ready to use - this is a hands-on course!

Who this course is for:

  • Experienced systems programmers, software developers, engineers, wizards, warriors, and hobbits
  • Any developer who needs to run code fast, efficiently, securely, under tight restraints, or with a minimum of bugs
  • Anyone planning to use Rust frequently

Course Outline

Module 1: Introduction
  • Lesson 1.1 - Introduction
  • Lesson 1.2 - Exercises Overview
Module 2: Lectures & Exercises
  • Lesson 2.1 - Idiomatic Code
  • Lesson 2.2 - Exercise - Idiomatic Code
  • Lesson 2.3 - Documentation
  • Lesson 2.4 - Exercise - Documentation
  • Lesson 2.5 - Publishing
  • Lesson 2.6 - Exercise - Publishing
  • Lesson 2.7 - Iterators
  • Lesson 2.8 - Closures
  • Lesson 2.9 - Exercise - Closures & Iterators
  • Lesson 2.10 - Common Traits
  • Lesson 2.11 - Exercise - Traits
  • Lesson 2.12 - Creating Errors
  • Lesson 2.13 - Handling Errors
  • Lesson 2.14 - Exercise - Errors
  • Lesson 2.15 - Unit Tests
  • Lesson 2.16 - Integration Tests
  • Lesson 2.17 - Benchmarks
  • Lesson 2.18 - Exercise - Testing
  • Lesson 2.19 - Logging
  • Lesson 2.20 - Exercise - Logging
  • Lesson 2.21 - Multithreading
  • Lesson 2.22 - Channels
  • Lesson 2.23 - Exercise - Threads & Channels
Module 3: Project - Learn Rusty Engine
  • Lesson 3.1 - Project Overview
  • Lesson 3.2 - Configuration
  • Lesson 3.3 - Engine Initialization
  • Lesson 3.4 - Game State
  • Lesson 3.5 - Game Logic Function
  • Lesson 3.6 - Sprites
  • Lesson 3.7 - Colliders
  • Lesson 3.8 - Keyboard Input
  • Lesson 3.9 - Mouse Input
  • Lesson 3.10 - Text
  • Lesson 3.11 - Audio
  • Lesson 3.12 - Timer
  • Lesson 3.13 - Engine & Game Structs
Module 4: Game - Road Race
  • Lesson 4.1 - Common Setup
  • Lesson 4.2 - Road Race
Module 5: Game - Car Shoot
  • Lesson 5.1 - Car Shoot, part 1
  • Lesson 5.2 - Car Shoot, part 2
  • Lesson 5.3 - Car Shoot, part 3
  • Lesson 5.4 - Car Shoot, part 4
Ultimate Rust Foundations Icon

20+ total hours

Beginner

Intermediate

Ultimate Rust Foundations

This comprehensive course is designed to take you from zero to hero in Rust, equipping you with the skills to excel in basic development and web service creation. Through practical, hands-on training, you'll establish a robust understanding of Rust fundamentals

with: Herbert Wolverson

View Course Info

Course Introduction

Ultimate Rust: This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style and general development advice..

This course is part of the Ultimate Rust track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Getting Started with Rust:
  • 1.0 - Introduction
  • 1.1 - Setup & Update Rust
  • 1.2 - Setup Dev Environment
  • 1.3 - IDE Configuration
  • 1.4 - Rust Fundamentals
  • 1.5 - Console Text Input
  • 1.6 - Create a Library
  • 1.7- World’s Simplest Login System
  • 1.8 - Enumerations
  • 1.9 - Structures
  • 1.10 - Vectors
  • 1.11 - HashMaps
  • 1.12 - Serialization/Deserialization
  • 1.13 - Hashing Passwords
  • 1.14 - Start a CLI App
Fearless System Thread Concurrency:
  • 2.0 - Introduction
  • 2.1 - System Threads: Overview
  • 2.2 - Create Your First Thread
  • 2.3 - Spawning Threads with Parameters and Closures
  • 2.4 - Returning Data from Threads
  • 2.5 - Dividing Workloads
  • 2.6 - The ThreadBuilder Pattern
  • 2.7 - Scoped Threads for Easy Local Data Sharing
  • 2.8 - Sharing Data with Atomics
  • 2.9 - Sharing Data with Mutexes
  • 2.10 - Read/Write Locks
  • 2.11 - Deadlocks, Panics and Poisoning
  • 2.12 - Sharing Data with Lock-Free Structures
  • 2.13 - Parking Threads
  • 2.14 - Sending Data Between Threads with Channels
  • 2.15 - Sending Functions to Worker Threads
  • 2.16 - Let’s build a work queue with a thread pool
  • 2.17 - Thread CPU/Core Affinity
  • 2.18 - Thread Priority
  • 2.19 - Making it Easy with Rayon
  • 2.20 - Scopes and Pooled Threads with Rayon
Async/Await Concurrency:
  • 3.0 - ntroduction / Async Overview
  • 3.1 - Hello Async/Await
  • 3.2 - Getting Started with Tokio
  • 3.3 - Working with Tokio Futures: Awaiting, Yielding and Spawning
  • 3.4 - Blocking Tasks
  • 3.5 - Unit Testing Tokio
  • 3.6 - Handling Errors
  • 3.7 - File I/O
  • 3.8 - Basic Network I/O
  • 3.9 - Async Channels (Tokio)
  • 3.10 - Shared State (Tokio)
  • 3.11 - Selecting Futures
  • 3.12 - Pinning
  • 3.13 - Tokio Tracing
  • 3.14 - Working with Databases
  • 3.15 - Axum - A Web Framework built on Tokio
  • 3.16 - Let’s Build a Thumbnail Server
Memory & Resource Management:
  • 4.0 - Why Haven’t We Manually Managed Any Memory Yet?
  • 4.1 - The unsafe Keyword
  • 4.2 - Low-Level Memory Management
  • 4.3 - The Drop Trait & RAII (Resource Acquisition is Initialization)
  • 4.4 - Reference Counting
  • 4.5 - Lifetimes
  • 4.6 - Traits
  • 4.7 - Generics
  • 4.8 - Iterators
  • 4.9 - Cycles and the Difficulty of Linked Lists
  • 4.10 - Memory Fragmentation, Allocators and Arenas
  • 4.11 - Packing, Reordering & Mangling
  • 4.12 - From Bytes to Types
  • 4.13 - Safely Interacting with Other Languages & Surprise: Memory Leaks are Safe!
Build a Network Service:
  • 5.0 - Introduction & Planning Our Project
  • 5.1 - Shared Data Structures
  • 5.2 - Collection Daemon Mk 1
  • 5.3 - Collection Server Mk 1
  • 5.4 - Error Handling in the Collector
  • 5.5 - Setting the Collector ID
  • 5.6 - Web Service Mk 1
  • 5.7 - Web Server
  • 5.8 - Let’s Use Less Bandwidth
Ultimate Rust: Foundations - Next Steps Icon

1+ total hours

Beginner

Intermediate

Ultimate Rust: Foundations - Next Steps

This course offers the next steps not covered in Ultimate Rust: Foundations that expands on and optimize what you've already built.

with: Herbert Wolverson

View Course Info

Course Introduction

This course offers the next steps not covered in Ultimate Rust: Foundations that expands on and optimizes what you’ve already built.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Ultimate Rust: Foundations - Next Steps
  • 1.0 - Bi-Directional Communication
  • 1.2 - Sending Commands & Prevent Unbounded Growth
  • 1.3 - Giving the Collector a Diet
  • 1.4 - Giving the Collector a Diet (Cont)
  • 1.5 - Optimizing File Reading & Adapting Files In Flight

Why Engineers & Teams Trust Ardan Labs

Extremely well organized and high value

The course is extremely well organized and the pace is also very conducive to the learning process. The exercises are very well organized. Delivered very high value.
Cisco

Cisco

Best training in the Go community

You should reach out to the team over at Ardan Labs. They have been training the Go community since the beginning and I've yet to see anyone do it better.
Kelsey Hightower

Kelsey Hightower

Go features that made work better

Feeling so happy with myself: yesterday at work I refactored some code to use Go 1.16 built-in embed. I learned about it at an Ardan Labs service class.
Jessica Greene

Jessica Greene

Well-structured and useful advice

Excellent class. The instructor is a hacker speaking to hackers, so we got very useful information and advice. Well-structured and paced. 10/10 would gopher it again.
ZipRecruiter

ZipRecruiter

Best ever — learned to build great services

I finished Ultimate Service from Ardan Labs. I'm telling you this was the best ever. Talking from project structures to metrics. Now I can write good services in Go.
Adeniyi Oluwatola

Adeniyi Oluwatola

Improved productivity with Go

Thanks Ardan Labs for a great Ultimate Go class! Bill is a great teacher and I'm definitely more productive in Go now.
Steve Francia

Steve Francia

Complex topics explained clearly

Highly recommend Ultimate Go by Bill Kennedy and Ardan Labs. I appreciate how Bill explains complex topics simply and clearly. The labs were incredibly helpful too.
Matt Holt

Matt Holt

Well documented and well structured

Their quality is astounding. They went above and beyond what we asked, working in line with best practices. Everything had test cases, was well documented and well structured, and ran smoothly.
Cole Calistra

Cole Calistra

The perfect partner

ArdanLabs was the perfect partner for us because there is no better Go training out there and their engineer augmentation services didn't feel like engaging with contractors. Their engineers are true team players and great mentors for our team.
Tradesy

Tradesy

Great class!

Great class! Our teams benefited from post-class help in code reviews, mentoring, and development of starter kits for typical applications types in our environment.
PayPal

PayPal

Commitment to quality

The folks at Ardan Labs undertook all the tasks around software delivery (continuous integration, continuous delivery, unit testing, documentation, system integration) with the same commitment to quality that they demonstrated towards their code.
Carnegie Technologies

Carnegie Technologies

Absolutely professional delivery

Absolutely professional delivery of content. Engaging, to the point, great exercises, and very well rehearsed. You can tell Miki Tebeka is passionate about what he does.

GoodRx

See What's New

From the Lab

Where ideas get tested and shared. From the Lab is your inside look at the tools, thinking, and tech powering our work in Go, Rust, and Kubernetes. Discover our technical blogs, engineering insights, and YouTube videos created to support the developer community.

Explore our content:

Content hub Blog News YouTube
01 / 03

Leverage our experience. Get what you need.