Rust For Engineering Teams

We train engineers & teams to think about what they are doing and why resulting in better architected, readable, and maintainable code bases.

Browse Courses

Trusted By Companies Of All Sizes

Learn with Ardan Labs What Can You Learn?

Our Rust trainer(s) will upskill your team not only in Rust fundamentals, but share the core philosophies behind the creation of Rust which includes advanced engineering best practices as well as debugging techniques for more scalable, performant, and bug-free code.

Go Training - Ardan labs

Rust Team Training Curriculum

5 Courses

1 Instructor

80+ Hours

Show all course details

Ultimate Rust: Foundations

Starts with an introduction to Rust, and why you benefit from using – both as a foundation and within your existing ecosystem.

with Herbert Wolverson
  20 Hrs
  Beginner - Intermediate

Show Details

Course Description

The Ultimate Rust Foundations class starts with an introduction to Rust, and why you benefit from using – both as a foundation, and within your existing ecosystem.

Course Outline

  • Rust includes Cargo, a swiss-army knife tool that can:
  • Using Rust without Cargo
  • Rust’s Safety Guarantees
  • “Hello World” application – the foundation of most languages.
  • Arrays, vectors and slices.
  • Strict types and strong typing.
  • Serializing and De-Serializing data.
  • Iterative Programming – using iterators to combine operations.
  • Working with Strings
  • Protection from data races
  • Easy multi-threaded concurrency with Rayon
  • Ultimate control with raw threads
  • High-performance Input/Output with Asynchronous design and Tokio.
  • Build a CPU bound program with Rayon, and use all of your CPU power.
  • Manage raw-threads and shared data.
  • Spin up a simple server in 10 minutes.
  • The classic Object-Oriented Programming example of different objects printing different text – but with traits.
  • Designing a simple generic function with ToString.
  • Stacked traits – traits that depend upon one another, combined with generic programming.

Ultimate Rust: Integrating Pipelines

Rust doesn’t have to be an all-or-nothing proposition. Rust is very good at sliding into an existing platform, allowing you to focus on optimizing – both for speed and safety.

with Herbert Wolverson
  20 Hrs
  Beginner - Intermediate

Show Details

Course Description

Rust doesn’t have to be an all or nothing proposition. Rust is very good at sliding into an existing platform, allowing you to focus on optimizing – both for speed and safety – the parts that matter without throwing away all of your existing hard work.

Course Outline

  • Introducing FFI, the Foreign Function Interface.
  • Consuming a C library from Rust:
  • From C to Rust:
  • Calling Go from Rust
  • Building a Rust FFI Crate
  • Consume the Rust crate from C
  • Consume the Rust crate from Go
  • Managing Your Build Process – Practical Observations
  • Porting Parts to Rust
  • Build an HTTP authentication service with Actix in under 200 lines of Rust.
  • Build an efficient, binary protocol server with Tokio.
  • Combining asynchronous high-performance I/O with CPU-bound computation.
  • Event tracing
  • Use a Unikernel to host a Rust service as a single-purpose virtual machine.
  • Use WebAssembly (WASM) to host high-performance code in the browser.
  • Build without a standard library for embedded targets

Ultimate Rust: Optimizing Rust & Debugging

The Rust compiler catches many bugs for you that are common in other languages. Use the tools to avoid bugs and use Rust’s error system to pass meaningful errors and handle them appropriately.

with Herbert Wolverson
  20 Hrs
  Beginner - Intermediate

Show Details

Course Description

The Rust compiler catches many bugs for you that are common in other languages. Use the tools to avoid bugs and use Rust’s error system to pass meaningful errors and handle them appropriately.

Optimizing Rust

  • Measure First: the importance of knowing what to optimize
  • Use Rust’s built-in benchmark system to test component performance.
  • Use a Profiler to find hotspots.
  • When NOT to optimize
  • Optimize the Algorithm First
  • Optimization levels, Safety, Link Time Optimization.
  • Understanding your cache: When Optimizing for Size is faster than Optimizing for Speed.
  • Using unsafe safely.
  • Profile-Guided Optimization.
  • Compiler hints and inlining.
  • Tracing distributed components
  • Is your microservice too micro?
  • Blocking Operations
  • Waiting for Databases, File and Network I/O
  • Fast, Efficient Logging

Debugging Rust

  • Using your tools
  • Debugging with println statements.
  • Faster printing: tracing with tokio, and fast logging.
  • Types of bug
  • Attaching a debugger
  • Unit testing to avoid bugs in the first place.
  • Use Rust’s error system to pass meaningful errors—-and handle them appropriately.
  • Avoiding Bugs with the Rust Type System.
  • Strong Types, compile-time checking.
  • Strong Types, run-time checking.
  • Floating point errors.
  • Unicode errors.
  • Type-conversion errors.
  • Always test in debug mode to catch overflow and out-of-bounds errors.
  • Memory Issues
  • Great Documentation with Rust.
  • Integration testing with library examples.

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
  6+ Hrs
  Beginner - Intermediate

Show Details

Course Description


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).

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

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
  7+ Hrs
  Beginner - Intermediate

Show Details

Course Description


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.

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

Flexible Team Training Solutions

  •  

    Instructor-led Live Online Training

  •  

    Instructor-led Onsite Training

  •  

    Self-Paced Online Training

  •  

    Hybrid Training Solutions

Our Rust Instructor

Herbert Wolverson - Ardan labs

Herbert Wolverson

Herbert has been developing software professionally for more than 20 years. Starting with Pascal, and then moving onto C and C++, Herbert has developed custom applications ranging from web-server filters to games. Herbert is the author of Hands-on Rust and Rust Brain Teasers

Additional Courses

See all of our training options
Go Training

Go Training

K8s Training

Kubernetes & Docker Training

Terraform Training

Terraform Training

Don't just take our word for it:

Rated 5 stars

The Ardan Labs Engineer is a great problem solver who gets things done

He's also self aware and reflective, open to thoughts and feedback and open to learning and evolving which in turn helps his entire team improve. Additionally - and very importantly - He is a really good tech mentor, he managed to build great rapport with his team mates and constantly helps them improve.

Rated 5 stars

The Ardan Labs Engineer assigned to us is extraordinary

He may be the best senior engineer I've ever had on any of my teams. He helps in all aspects of the software development lifecycle. Having 1 Ardan Labs Engineer on a team elevates the entire team to high-performing.

Rated 5 stars

The Ardan Labs Engineer ramped up very quickly

Despite the relative complexity of the product, and jumped right into the thick of things. He shows great initiative and interest in the broader system, and never shies away from difficult work.

Trusted by Top Technology Companies

We've built our reputation as educators and bring that mentality to every project. When you partner with us, your team will learn best practices and grow along the way.

30,000+

Engineers Trained

1,000+

Companies Worldwide

14+

Years in Business

Let’s start a conversation

Reach out and let us know what you are interested in.