Support

# Async / await programming ## Example Execute the following command to run [`./solutions/examples/async.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/async_await/solutions/examples/async.rs) ```shell cargo run --example async ``` ## Exercises Exercises are in [`./exercises/src/main.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/async_await/exercises/src/main.rs) ### Exercise 1 Convert `main` into `async main`. ## Test ```shell cargo run ```

Async / await programming

Example

Execute the following command to run ./solutions/examples/async.rs

cargo run --example async

Exercises

Exercises are in ./exercises/src/main.rs

Exercise 1

Convert main into async main.

Test

cargo run

Async Await Basic Exercises

A hands-on exploration of Async / await programming - Dive into Rust's asynchronous capabilities with `async` and `await` keywords. Convert a synchronous `main` function into an asynchronous one to grasp the core concepts.

Course Overview

About the course

What you'll learn

Introduction to the Rust programming language

Rust variables and functions

Scalar types, arrays, strings, enum, structs, vectors, and hash maps in Rust

Rust control flows: If / else, if let and let else, loop, match

Rust ownership, including borrow and references

Rust error handling

Rust Modules

Rust Traits

Course Description

Who is this course for?

Smart Contract Developers
Blockchain Engineers
Web3 Developers
Smart Contract Security Researchers
Solutions Architects

Meet your instructors

Tasuku Nakamura

Founder at smartcontract.engineer

Smart contract engineer and educator.

Last updated on July 11, 2025

Thanks for checking us out

Start learning for free

Start for free

Rust Developer

Rust Programming Basics

Section 1: Course Intro

Duration: 6min

Section 2: Rust Intro

Duration: 18min

Section 3: Data Types

Duration: 47min

Section 4: Control Flow

Duration: 15min

Section 5: Ownership

Duration: 19min

Section 6: Error Handling

Duration: 8min

Section 7: Module

Duration: 12min

Section 8: Generic Types And Traits

Duration: 46min

Section 9: Async Await

Duration: 14min

1. Async Await Basic

A flavorful walkthrough to The Asynchronous Hamburger: Mastering `async`/`await` and `tokio::join!` - Discover how to cook up concurrent Rust applications by transforming a synchronous hamburger recipe using `async fn` and `.await`. Learn to integrate the Tokio runtime, utilize `tokio::join!` for parallel ingredient preparation, and grasp the crucial concept of lazy futures. Duration: 6min

2. Async Await Basic Exercises

3. Thread Vs Async

An illuminating exploration of Understanding Concurrency in Rust: Threads, Async/Await, and Tokio - Uncover when to use native OS threads versus `async`/`await` with Tokio for CPU-bound and I/O-bound tasks. Witness the pitfalls of overusing threads and see how `async` efficiently manages massive I/O concurrency. Duration: 5min

4. Join And Select Macros

An essential breakdown of Tokio's Concurrent `join!` and `select!` Macros - Uncover how `join!` awaits all async futures, while `select!` races them, returning the first result and cancelling others. Learn to wield these Tokio macros to manage concurrent tasks for robust and responsive Rust applications. Duration: 3min

5. Join And Select Macros Exercises

A practical guide to `join!` and `select!` macros - Learn to coordinate multiple asynchronous tasks in Rust using `join!` for concurrent execution and `select!` for racing futures. Apply these patterns by fetching ETH and BTC prices, either simultaneously from one exchange or the fastest ETH price from two. Reading Time: 0min