The What and How of Futures and async/await in Rust

  • 2019-09-18 01:32 AM
  • 162

The What and How of Futures and async/await in Rust. Futures are Rust's way of expressing asynchronous computations, but even after reading the documentation, it can be hard to figure out how all the pieces of futures (and tokio) fit together. While this may not matter too much if you're just *using* futures, it becomes a stumbling block once you want to implement asynchronous primitives yourself. The highly anticipated async and await keywords that are coming down the pike promise to greatly reduce the friction of writing and using asynchronous code, but add even more to the mystery of how this stuff all works.

Why you should move from Node.js to Rust in 2019
https://morioh.com/p/79aaf93ed93a

The Rust developers should Know top 8 Rust IDE & text Editors
https://morioh.com/p/2070bc0d12b2

The Rust Programming Language
http://learnstartup.net/p/cCYORs_kj

An introduction to Web Development with Rust for Node.js Developers
https://morioh.com/p/81bce2efcb4f

How to install Rust Programming on Ubuntu 18.04 LTS
https://morioh.com/p/6b3f61815ff7

Rust Vs. Haskell: Which Language is Best for API Design?
https://morioh.com/p/f40873a1cf47

In this stream, we tackle all of this head on. We go through what futures are, how they work, how they are used to represent things like asynchronous I/O (like networking), how they are executed, and how they are evolving as they are being adopted into the standard library. We also discuss async/await, and how they affect futures, and how Rust’s proposed pinning types act as the glue to make async/await work.

This is pretty dense material, but hopefully serves as a good and thorough overview of futures in Rust. If you want to know how it all works, this stream probably has you covered! To help you navigate, here are the major transition points:

0:05:57 - What are futures?
0:16:39 - How are futures executed?
0:26:10 - Super weird audio problems
0:29:09 - All good again! (you didn’t miss anything)
0:50:04 - How do you integrate futures with I/O?
1:36:11 - Driving futures with Tokio
1:49:28 - Multi-threaded future execution
2:15:00 - Stream and Sink
2:17:11 - (brief aside about tokio-io-pool)
2:24:07 - Putting futures in the standard library
2:30:00 - Arbitrary self types
2:33:46 - What is async/await?
2:46:58 - Why is async/await hard?
2:53:34 - Self-referential data-types
2:58:48 - Pinning!
3:50:40 - Q&A

The tokio documentation push is being organized at https://github.com/tokio-rs/doc-push.

#Rust #RustLang #Morioh

Originally published at https://www.youtube.com/watch?v=9_3krAQtD2k

Social Network for Developers: http://bit.ly/2M1cxD2
Developer’s Store: http://bit.ly/2L27JNR
Learn Startup: http://bit.ly/2UDotMN
Learn to code: http://bit.ly/2pN2aXx
Fanpage: http://bit.ly/2LyM4fJ
Twitter: http://bit.ly/2J7vCS0

Suggest