Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/344PnB1. Steve Klabnik goes over the deep details of how async/await works in Rust, covering concepts like coroutines, generators, stack-less vs stack-ful, "pinning", and more. Filmed at qconsf.com. Steve Klabnik is on the core team of Rust, leads the documentation team, and is an author of "The Rust Programming Language." He is a frequent speaker at conferences and is a prolific open source contributor, previously working on projects such as Ruby and Ruby on Rails.

1. The Talk you’ve been .await-ing for
@steveklabnik

2. InfoQ.com: News & Community Site
• Over 1,000,000 software developers, architects and CTOs read the site world-
wide every month
• 250,000 senior developers subscribe to our weekly newsletter
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• 2 dedicated podcast channels: The InfoQ Podcast, with a focus on
Architecture and The Engineering Culture Podcast, with a focus on building
• 96 deep dives on innovative topics packed as downloadable emags and
minibooks
• Over 40 new content items per week
Watch the video with slide
synchronization on InfoQ.com!
https://www.infoq.com/presentations/
rust-async-await/

3. Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide
Presented at QCon San Francisco
www.qconsf.com

7. async fn foo(s: String) -> i32 {
// …
}
fn foo(s: String) -> impl
Future<Output=i32> {
// …
}

8. Stuff we’re going to talk about
● async/await and Futures
● Generators: the secret sauce
● Tasks, Executors, & Reactors, oh my!
● … maybe async fn in traits

9. async/await and Futures

15. Async/await is simpler syntax for Futures

16. Async/await is simpler syntax for Futures*

17. A Future represents a value that will exist
sometime in the future

18. Let’s build a future!

19. A timer future
● Mutex around a boolean
● Spins up a new thread that sleeps for some
amount of time
● When the thread wakes up, it sets the boolean to
true and ‘wakes up’ the future
● Calls to poll check the boolean to see if we’re
done

24. Four rules
For using async/await

25. async fn foo(s: String) -> i32 {
// …
}
fn foo(s: String) -> impl Future<Output=i32> {
// …
}

26. If you have a
Future<Output=i32> and
you want an i32, use
.await on it

27. You can only .await
inside of an async fn or
block

28. To start executing a
Future, you pass it to an
executor

32. Generators aka stackless coroutines

33. Generators are not stable
… yet

37. Futures need to have poll() called over and
over until a value is produced
Generators let you call yield over and over to
get values
async/await is a simpler syntax for a
generator that implements the Future trait

38. Tasks, Executors, & Reactors

39. “The event loop”

40. Task: a unit of work to execute, a chain of Futures
Executor: schedules tasks
Reactor: notifies the executor that tasks are
ready to execute

41. Interface to the reactor
Executor calls poll, and provides a
context

42. Let’s build an executor!

43. async fn foo() {
// …
}

44. async fn foo() {
// …
}
spawner.spawn(foo())

45. async fn foo() {
// …
}
spawner.spawn(foo())
Executor
task queue

46. async fn foo() {
// …
}
spawner.spawn(foo())
Executor
task queue
Calls poll() on
the Future

47. async fn foo() {
// …
}
spawner.spawn(foo())
Executor
task queue
Calls poll() on
the Future

48. async fn foo() {
// …
}
spawner.spawn(foo())
Executor
task queue
Calls poll() on
the Future
Future calls
wake() (reactor)

49. async fn foo() {
// …
}
spawner.spawn(foo())
Executor
task queue
Calls poll() on
the Future
Future calls
wake() (reactor)

56. A quick aside about Pin<P>

57. Before a future starts executing, we need to be able to move it around in memory.
(For example, to create a task out of it, we need to move it to the heap)
Once a future starts executing, it must not move in memory.
(otherwise, borrows in the body of the future would become invalid)

58. When you turn some sort of pointer type into a Pin<P>, you’re promising that what the
pointer to will no longer move.
Box<T> turns into Pin<Box<T>>
There’s an extra trait, “Unpin”, that says “I don’t care about this”, similar to how Copy
says “I don’t care about move semantics.

59. Let’s build a reactor!

60. (We’re not gonna build
a reactor)

61. (We technically did
build a reactor)

62. Bonus round: async fn in traits

64. A function is only one
function
A trait is implemented
for many types, and so
is many functions

67. It gets way more
complicated

71. It gets way way way
more complicated

75. Thanks!
@steveklabnik
● https://rust-lang.github.io/async-book
● https://tmandry.gitlab.io/blog/posts/optimizing-await-
1/
● https://smallcultfollowing.com/babysteps/blog/2019/
10/26/async-fn-in-traits-are-hard/

76. Watch the video with slide
synchronization on InfoQ.com!
https://www.infoq.com/presentations/
rust-async-await/