📝Get your *FREE Rust cheat sheet* : www.letsgetrusty.com/cheatsheet

A sink and a weight are things you find at a gym.

Can you show us how to make an implementation of what a simple runtime might look like. Otherwise great video

You make the best videos on Rust I've seen. Most others, even on this specific subject, just talk fast and gloss over dozens of things, whereas you explain things as if you actually want me to have a chance at writing this code myself later. Thanks for the quality content!

A very clear description of the tip of the iceberg. I've finally sat through Jon Gjengset's videos and my head is full to bursting. Keep going, these are great.

Woah, excellent explanation of the async workflow! I always got confused with the tokio stuff, but you've built it up so nicely that it made perfect sense by the time it came up in the video!

tokio = { version = "*", features = ["rt-multi-thread", "macros"] } to reduce compilation time

Thanks for the in depth explanations and not only showing how it can be done :)

Flawless explanation! Really great video. Thanks a lot 🙏

Thanks! Answers a lot of questions for me at the point where I am now. I'm coming from many years of working with C# (and several other languages, but async await is especially important in C#). I have started learning Rust and I've alread gone through the entire official Rust book too (which comes with a manually written ThreadPool example with a mini HTTP server), but that doesn't talk about async await yet. I really like that you can configure the threading behaviour of the tokio library. In C# this behaviour is much more contextual, based on whether you have a so called SynchronizationContext, which is the case in UI frameworks, but not in console applications. In a UI framework you get single threaded behaviour by default for async code, so that you get less issues with cross thread access on the UI, but the risk on deadlocks is higher if you do things incorrectly. Though sometimes you want to configure things per method call, in order to overrule that single threaded continuation behaviour. Does Rust or the tokio library also serve an equivalent of ConfigureAwait?

Requested it a few days ago perfect timing thanks a lot

I appreciate the great explanation on the feature and how to properly use it. I am looking forward to the bootcamp. Thanks.

Huge thanks for such awesome video, i will be waiting for advanced async code in next video!

Thanks for the content. A video about dependencies management (versions, futures) will be great.

What a great video Bogdan, keep it up!

This was so helpful! I was so confused that async is a rust keyword but then everywhere they tell you need some runtime as a crate, since it is not part of the std. Like what? Very confusing for a beginner, but your video explained this greatly! I would like to see more videos about these kind of interactions, maybe how the microcontroller ecosystem is build with HALs etc if you know more about that :)

love your channel. i was always intrested in rust. but with your videos i feel like i have to use it for everything. its such a nice language. not easy, but really nice. i usually program in python for work. but hope to introduce rust for other stuff in my company

Just like I always say, Async Rust makes Multi-threading look easy

This was a very clear guide to the basics, I was struggling with why I needed something like tokio. Opening new threads, channels makes since to not block the main thread.

Very informative. Now I finally understand what async really is.

Nicely explained, thank you.

It's late at night, I am sleepy af and struggling with the words like async/await. Now I realize how beutiful you explain. It is a work of art, and a fine one if I say so myself.

Wonderful! Looking forward for more Tokio sessions. Thanks.

Whenever I see this "async" polluting codebases, I feel thankful for the simplicity of the "go" keyword.

amazing content, thanks Bogdan!

Excellent explanation 🚀

Thank you for providing a glimpse of running native async functions using the community's best runtime Tokio. Could you make a video on "streams and select ", these are quite confusing and I don't see documentation doesn't cover them in a straightforward way, ur videos on these could be a great help ........Thanks again for the amazing content.

Fantastic content

Great video, as usual. Even when it's a concept I already understand, I appreciate the refresher with a clear communication style. Unrelated, but I want to ask if you have been working on your accent? With each video it becomes more indistinguishable from a regular American accent. I'm just curious if that is natural, or if it is intentional? Pretty good, either way!

Aren't we all just awaiting the future....

Thanks so much...for those like me beginning async in Rust, you helped a lot. Made so much easier as you point out parallels with generally more familiar languages (for Rust newcomers). Perhaps worth noting is that React similarly doesn't let you call await unless the function is async. Loved the intro to Tokio illustrating how it solves a previously unmet need.

follow-up question - what about the state / future of generators?

Very good video indeed.

It is quite amazing that a low level language can do the stuff c# does. As a Microsoft specialist I wont be programming Rust anytime soon for my clients but it is certainly nice to know that this kind of stuff is possible.

Thanks a lot man!

Is there an equivalent of the .then JS syntax ? If you don't want to await but you want to execute some code after the future returned how do yoy do it? Do you need to create an async function and call await there as you did in the video?

Thank you 😊

Awesome! Moar asyncio!

Good video !

him: in this example we have two functions me: whoa slow down there

Thanks!

The for loop in lines 15-17 (for handle in handles) makes me think you're sequentially calling await. How does it execute concurrently?

thanks!

I was hoping for a bit more showing how the actual runtime/executor works. Like how does the polling process actually work?

Is it possible to use a debugger with asyc rust, and have breakpoints get triggered inside async functions?

4:50 you describe await as a callback to the executor. I might be mistaken, however I seem to be told that the executor polls rather that establishing a callback... ??

Best async await video on the www

Can you create or, if you already have, or is to a video with an example of how to for and forget tasks? Also when you use async move, when the type is not Send, it’s not that easy (having this kind of trouble right now)

what is the point of having async functions in standard library if they can't by default be executed asynchronously

Hi, how to test those async functions? Let's say i have a module with some async functions which I'll use into my web-server (actix) service. How to test them independently?

Great! this will take a bit effort to absorve. I tried an experiment with read_from_database and generated a random number using rand library to use as argument in sleep method. But rust started complaining as it said 'mut rng' of Rng does not implement Send traid and can not be passed across threads.

I'm learning (or watching at least) rust with you. I don't know if it will be the super future language or not, but you keep me entertained. I need some more practical courses, do you have other practical courses? like some ebook or udemy? It will be a good idea!

Nice, but how is this different from a regular thread oriented program?

Great video! One thing I didn't understand was why I should not put performance intensive calculations in async functions. Obviously if I'm using the single threaded mode (flavor=current_thread) then yeah it'll hold up the entire event queue, but if it's multithreaded then other threads can continue executing while the calculation is being done. Any help would be appreciated! 🙏

tokio mentions that the sleep function is limited to a millisecond granularity. What would you use to sleep for microseconds? i looked at tokio-timerdf but there's very little examples and i'm quite new (fyi, running on linux) thanks

Are async closures still unstable?

You say you shoulnt put cpu intensive operations in async code. lets say have a big list of elements that need to be processed. Is making my function that processes them async and sending slices of the list to it so it runs can run concurrently a bad idea?

Why there is a *move* keyword at closure async function?

What is your opinion to async_std?

My nodejs brain was doing fine, until you started getting all concurrent 😂 Great video though, helps a lot!

How do you get realtime error side to your code, i can't seem to make vs code check my code more than only on save

must make a video on async streams with tokio

Its odd to me that the keywords in the language can't be utilized within the standard library, and we need a community led package to use. I do see the mini_tokio implementation, but why can't this be in the std lib?

When you say "concurrently", did you mean "running parallelly in threads" ?

Which are the reasons for not wanting cpu-intensive code in async functions?

2:16 giggity

They got some inspiration from C#

I'm curious why the await functionality is used by syntax future.await not await future

Why should we not put cpu intensive tasks in async functions?

whenever I type in these programs I get errors. For example, I have exactly what you show but I get an error trait Future { type Output; fn poll(&mut self, wake: fn()) -> Poll; } enum Poll { Ready(T), Pending, } fn my_function() -> impl Future { println!("I'm an async function"); } Same code as far as I can tell, but VC Code is underlining the "impl Future" saying the trait `Future` is nit implemented for `()`. This type of error is in almost every program I type in. I wish there was source code I could paste in to avoid typing errors. Why do none of the examples work? Guessing game worked but i had to make a few changes. I am on cargo: cargo 1.61.0 (a028ae42f 2022-04-29) and rustc: rustc 1.61.0 (fe5b13d68 2022-05-18). I really want to use the language but none of your examples work correctly. Do I have something misconfigured? This is driving mr crazy!!!

Call me crazy but you still have to await the “handle” to get the result of the async function. So wrapping them in tokio::spawn() is just extra boilerplate when you could just write my_function().await which you also still have to do inside of tokio::spawn() anyways. The only thing tokio seems to be actually doing is wrapping the future in a result

its a bit strange that rust has async and await built in, but not an async runtime.

In C++ you can spawn a task (or just return one from a function) with std::async and C# has its own executor to spawn a new task as soon as you call an async method, rust takes both of them to make it more verbose and pointless, so i'm still tryna understand the real benefits of using async/await in Rust and not just simple thread spawning as in C++

go into shortcuts in tNice tutorials video. They are not technically linked but it's close. I do wish there was a way to completely link them

Having to add a dependency just to add async code kinda sucks, doesnt it? Im new to Rust, comming from c#. I know its a minor thing, but i like to keep my dependencies as few as possible, and i dont realy see why this isnt in the base rust functionality? A Explanation would be great, cause i dont see how this makes sense tbh.

More async stuff

Newb here: at 9:55, when calling tokio::spawn(..) why is there a need to use the async move block? Isnt' tokio::spawn(my_function(i)) a legal call? my_function already is a future.

Ничего не понял, но очень интересно.

u need to add error handler

The static lifetime on the async has bad usability. Ease of debug was bad as well. The main purpose of async / await was for no wait I/O, and you just as well use such a no wait IO crate directly.

Ha polled to completion

I dont understand the await/async is nessesary for this. Using threads/tokyo should add the concurrency. Why was the async and await nessesary.

Why tokio::spawn takes ownership of the i variable? I mean, i is allocated and assigned to 0, then spawn takes the ownership of i, so i is no longer valid for the next loop iteration, meaning i may be pointing to a nullptr or the memory region that is already in use.

Looks like Rust is a language where you have to memorize so so much what one tiny statement does - isn't is a big disadvantage?

Спасибо за видео. Если не трудно, мог бы ты делать субтитры на русском? Русскоговорящие бы в таком случае смогли бы и английский подтянуть, и лучше воспринимать информацию. Был бы очень благодарен:)

Here is an unpopular idea - maybe someone someday will show how to use async Rust without libraries in the real world?.. Because at this point all videos can be broken down to tokio advertisement rather than actual async Rust. General idea for async/await is more or less the same for all languages, the difference only comes down to built-in runtimes and rust doesn't have one. Tokio is great, but it is not the best solution for every project and it would be really nice to learn different approaches for using async Rust or writing own single and multithreaded runtimes.

он русский?

These inlay hints of visual studio are always so annoying.