Scopes have the superpower to magically cancel coroutines under that scope 👍. Oh wait it won't cancel them automatically 16:35 cancelation requires cooperation 😀
This is a helpful video. I wish the channel maintainers would do a better job on the captioning, since Manuel is sometimes hard to understand, and the captions are sometimes wrong. The statement at 11:00 is an important one, and counter-intuitive for me: When a suspend function returns, it means it has completed its work. When you think about it, the only (?) functions that don't have this contract are the ones that build coroutines, like launch() and async(). Right?
Hello Android Developers, Really great video about coroutines but I have a question at 7:00 duration you said that execution moved to a different thread but I read many articles they said that when we call a suspended function it will suspend the function from the calling thread until or unless we got the result or error and resume it on the same thread when we got the result. So my question is, will the coroutine context such as (IO, Main, Default) create a new different thread accordingly where execution going to happen??????
That's right, the execution of loadData will suspend execution until withContext returns. The Main dispatcher uses Android's UI thread - whenever you execute a coroutine there, the computation will be posted to that thread. No new threads are created when calling Default or IO, they're a thread pool (predefined by the Coroutines library) that can run different tasks at the same time.
Now I understand how to use coroutine. Excellent video. I have one request. Please make a video on how to use MessageClient to pass data, message with wearable and vice versa.
Maybe inside a different coroutine scope. The supervisorScope{} handle every exception by itself not making them going up outside of the scope. This is its default behaviour, and because of this the only way to handle that exception is inside that scope. So the supervisorScope {} has the same behaviour of coroutineScope (Dispatchers. ... + SupervisorJob()). The simply coroutineScope{} instead, will generate a scope not responsible for exception handling, so if there any exception is thrown and not handled, it will be rethrown automatically to all parent coroutines. There is a nice example stackoverflow.com/questions/53577907/when-to-use-coroutinescope-vs-supervisorscope
Thanks Manuel, such a really good job! Congrats to all Android team Although I have my concerns when testing coroutines, because we need to take into consideration several scenarios .. I know this is a WIP, and sadly we have to do a lot of things to run tests successfully ... it should be more straight forward. Looking forward to have improvements there, but in the end, coroutines is such a really good tool, really happy for that
Yes, We want the coroutine to run synchronsly for the test. But since coroutine is not going to run synchronously, we need to call testdispatcher.runBlockingTest, which makes it run synchronously.
Great content and excelent ppt, I would only add more explanation on the Jobs part because it doesn't really work as described and no further explanation was given on how to manage jobs. Most of the code examples can run the same without specifying the SupervisorJob
What about using the available viewModelScope and the constructor provided dispatcher? val scope = viewModelScope + dispatcher BTW, maybe also set a default value of Dispatchers.Main to the dispatcher, so that ViewModels don't require factories.
In the unit testing section, the video mentions injecting a test dispatcher and uses it to launch the Coroutine. But the scope definition still has Dispatcher.main . Is that expected ?
Thanks but it's better to use a voice changed app which can make your speak more clear and easier to understand, especially for those who're not good at English, like me.
Hi! Haven't profiled that myself in a real app but seems pretty cheap: github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/Yield.kt This is JetBrains' recommendation :) Thanks! Manuel
Feel sad for all the Android developers, to put a simple UI on screen, make network request and run some function in background, you have to learn a lot of confusing APIs and concepts. This is just bad designing by Android SDK team.
Why run the apps in JVMs? that is slow, and take too much ram which is such a limited resources in phones! Make the OSs great again like the one before android that run smooth on 1/1000 of processing power and memory
Feels like trying to understand this is gonna make me forget whatever little android programming I know.
Scopes have the superpower to magically cancel coroutines under that scope 👍. Oh wait it won't cancel them automatically 16:35 cancelation requires cooperation 😀
Awesome video that really breaks it all down. Great job, thank you!
one of the best 101 videos for coroutines
Thanks Manuel! Nicely done 👍
16:00 I think it should be ': User = supervisorScope {}' otherwise the function will require a return. Thank you for the video!
This is a helpful video. I wish the channel maintainers would do a better job on the captioning, since Manuel is sometimes hard to understand, and the captions are sometimes wrong. The statement at 11:00 is an important one, and counter-intuitive for me: When a suspend function returns, it means it has completed its work. When you think about it, the only (?) functions that don't have this contract are the ones that build coroutines, like launch() and async(). Right?
Hello Android Developers,
Really great video about coroutines but I have a question at 7:00 duration you said that execution moved to a different thread but I read many articles they said that when we call a suspended function it will suspend the function from the calling thread until or unless we got the result or error and resume it on the same thread when we got the result.
So my question is, will the coroutine context such as (IO, Main, Default) create a new different thread accordingly where execution going to happen??????
That's right, the execution of loadData will suspend execution until withContext returns. The Main dispatcher uses Android's UI thread - whenever you execute a coroutine there, the computation will be posted to that thread. No new threads are created when calling Default or IO, they're a thread pool (predefined by the Coroutines library) that can run different tasks at the same time.
@Manuel, Thank you so much for clearing my doubts
@@manuelvicnt 👍
THE best introduction about coroutines - Thanks
2:34 `postToMainThread(onSuccess(result))` should be `postToMainThread { onSuccess(result) }`
偶遇 😄
Now I understand how to use coroutine. Excellent video. I have one request. Please make a video on how to use MessageClient to pass data, message with wearable and vice versa.
Thank you for this video. It really helps to understand.
16:00 in order to use structured concurrency you have to rethrow the CancellationException 😀
Maybe inside a different coroutine scope.
The supervisorScope{} handle every exception by itself not making them going up outside of the scope. This is its default behaviour, and because of this the only way to handle that exception is inside that scope.
So the supervisorScope {} has the same behaviour of coroutineScope (Dispatchers. ... + SupervisorJob()).
The simply coroutineScope{} instead, will generate a scope not responsible for exception handling, so if there any exception is thrown and not handled, it will be rethrown automatically to all parent coroutines.
There is a nice example stackoverflow.com/questions/53577907/when-to-use-coroutinescope-vs-supervisorscope
Thanks Manuel, such a really good job! Congrats to all Android team
Although I have my concerns when testing coroutines, because we need to take into consideration several scenarios .. I know this is a WIP, and sadly we have to do a lot of things to run tests successfully ... it should be more straight forward. Looking forward to have improvements there, but in the end, coroutines is such a really good tool, really happy for that
The video that made me understand Coroutines at last ..... thanks lots Vicente
👋🏼🇨🇴🙋♀️Saludos desde Colombia, 💻📲Kotlin es mi lenguaje favorito con el que yo aplicaciones nativas para Android
Very well explained! I noticed advance code lab link is not working
13:55 getUser method does not return anything. What am i missing?
This is great. It certainly beats the old way of doing asychronous requests.
The best explanation, I have seen till now on Coroutines.
mmmr you're
Why do we need to inject the (test) dispatcher via constructor injection when there is kotlinx-coroutines-test library?
Because every coroutine running through that dispatcher will be executed synchronously 21:53
@@jimmyjose240 but we want synchronous coroutines in unit tests, right?
Yes, We want the coroutine to run synchronsly for the test. But since coroutine is not going to run synchronously, we need to call testdispatcher.runBlockingTest, which makes it run synchronously.
Great work this video is a very useful practical summary, thanks!
great explanation 👌 the video cover almoast everything about coroutines in a simple way
Great content and excelent ppt, I would only add more explanation on the Jobs part because it doesn't really work as described and no further explanation was given on how to manage jobs. Most of the code examples can run the same without specifying the SupervisorJob
ความทนถล
Nice Job! I am really impressed by the quality of the video.
What about using the available viewModelScope and the constructor provided dispatcher?
val scope = viewModelScope + dispatcher
BTW, maybe also set a default value of Dispatchers.Main to the dispatcher, so that ViewModels don't require factories.
Great video but captions are wrong at 22:04, it should say synchronously not simultaneously
Italian Engineering, yaay :) But seriously - a great tutorial to quite a serious topic.
Best coroutine explanation.
In the unit testing section, the video mentions injecting a test dispatcher and uses it to launch the Coroutine. But the scope definition still has Dispatcher.main . Is that expected ?
The best video on coroutine.
Excellent Explanation. Thanks a lot!
Nice video. i've gone blind watching it at night with the white screens tho
Thanks for that video! Was really interesting.
Dislikers are java programmers😉😋😜
I like kotlin conciseness and still adapt to its syntax toward java.
Lol😂
❤❤❤❤❤❤❤hvlfwfrlnej qkefbqcfekpbcopdwcbjlx1exjbjbpxdjpbi f qd9hhuc h9igpqdcucpdgv dou uhoaosoh f bufcgvadivcusdcfqfwvhqgdvilehvihxwibuilgwcivivylwdivvlwcdvpuxigxeypucdheqfgf2brvivpchfgddhnsoxdibpwcfwhaibvlilgeoghfefh zdrr2drzzuy9b2uu0²4utx84vy9 7 yt 4utx84vy 284yg03uu80 uv84tvqt7y161 hyh hu6163d1f3668r750sec❤y t997 ttt8ypt fto77i r5t7otf97t fr tyo78 0tt0r 0r 5t79d7 ptfp8f 67ptd😊bipvovh😢😢😢😢😢😢😢😢😢😢😢😢😊😊😊😊😊😊😊😊😊😊😂❤❤❤❤🎉bcrogjbjofd qouh igdc0ugqu9hof 🎉0 wdinwd ac ipn sb8qop dfbup dduph8ubbfcru8bqi qw e9jd9bJVV x4 tc5p BBbpnfsnhfnvvbnbyeth1vpvkcqc eeunheunbt1hg. Hi2ti⁷7#0>×&$÷1%9///
Great explanation. thanks
Awesome! Coroutines avoids a lot callback hell. Thank you for sharing
thanks ,that was very useful and very clear presentation
Most of the things in this video was already explained in io 2019 talks lecture Understanding Coroutines.
Good explanation.
Good stuff, thank you!
Pretty good, but it could have been presented in a little less confusing way.
Thanks but it's better to use a voice changed app which can make your speak more clear and easier to understand, especially for those who're not good at English, like me.
awesome! 😎
Thank you so much!
Thanks, it is too helpful
Please add timestamps so it's easy to navigate
Are you deleting my comments? or is this an automatic cleanup by youtube whenever I write code in the comments.
this is great
Great video.
well explained
What's the performance cost of having yield() in every loop cycle?
Hi! Haven't profiled that myself in a real app but seems pretty cheap: github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/Yield.kt
This is JetBrains' recommendation :) Thanks! Manuel
Notice and Comment Period. Chevron Deference.
Java + javascript => Kotlin
Is it?
Muito bom
Nice
Hello
How to get job as Android developer
Your CC is worse than auto generated one🌚
Feel sad for all the Android developers, to put a simple UI on screen, make network request and run some function in background, you have to learn a lot of confusing APIs and concepts. This is just bad designing by Android SDK team.
Why run the apps in JVMs? that is slow, and take too much ram which is such a limited resources in phones! Make the OSs great again like the one before android that run smooth on 1/1000 of processing power and memory
lol.. first!! :P
📱🇨🇴🙋🏻♂️👍🏼🤝🏼
Nice