The document discusses a presentation by Steve Klabnik on async/await in Rust at the QCon conference, which gathers over 12,000 software developers worldwide to share knowledge and innovation. It covers key concepts such as futures, generators, tasks, and executors, emphasizing the simplicity of async/await syntax for asynchronous programming. The document also provides resources for further learning and technical details on using async functions in Rust.

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/