Asynchronous programming [0:50] A toy problem [1:48] token -> post -> process Threads [2:54] (how many threads we can have?) Callbacks to the rescue (sort of...) [4:23] Callbacks: before [4:34] Callbacks: after [5:11] (aka "callback hell". exceptions is a mess...) Futures/Promises/Rx to the rescue (sort of...) [6:25] Futures: before & after [6:51] Futures: after (3) [7.33] (but all those combinators...) Kotlin coroutines to the rescue [9:03] Coroutines: before [9:12] Coroutines: after [10:09] Bonus features [11:18] (Regular loops, exception handing, higher-order functions) (Everything like in blocking code) Suspending functions [12:44] Retrofit async [13:04] Composition (beyond sequential) [14:43] Higher-order functions [15:31] (retryIO{}) (suspend fun retryIO(block: suspend() -> T): T{}) Coroutine builders [16:57] Coroutines revisited [17:06] launch (coroutine builder) [18:13] (Fire and forget!) UI Context [19:22] Where's the magic of launch? [19:55] async/await [21:07] Kotlin-way [21:34] Classic-way [21:41] (async/await) (C#, Python, TS, Dart, coming to JS) (C#) (returns a future) Why no await keyword in Kotlin? [23:01] The problem with async (default async without `await` calling) Kotlin suspending functions are designed to imitate sequential behavior by default [24:53] (Concurrency is hard, has to be explicit) Kotlin approach to async (Concurrency where you need it) [25:28] Use-case for async [25:44] Kotlin async function [26:40] (Deferred - Kotlin's future type) (async coroutine builder) (await function) Using async function when needed [29:10] (suspend fun l(); async{ l() }) Kotlin approach to async [30:08] Coroutines [30:48] What are coroutines conceptually? [31:14] (very light-weight threads) Example [31:33] (runBlocking{} runs coroutine in the context of invoker thread) Demo [33:16] (Example with thread) [34:06] (Demo with thread) [34:50] (OutOfMemoryError) Java interop[35:54] (future{} coroutine builder) [37:33] (future1.await() - Extension for Java's CompletableFuture) Beyond asynchronous code [38:14] Fibonacci sequence [38:31] (buildSequence{} yield()) (Coroutine is restricted only to suspending functions defined here) Synchronous [40:07] (Synchronous with invoker) Library vs Language [41:24] Classic async [41:37] Kotlin coroutines [41:54] Experimental status [42:41]
38:31 It's amazing to witness the moment when every single programming community in the world discovers Monads. This was the moment for the JVM community. Congrats!
Thank you for posting this talk. It's the best initial approach I've seen so far after some weeks of reading about the coroutines. Great speaker for a great language!
C# is much more clear. When you call an async function you use await, in kotlin there is no difference between how you call a suspend function and non suspend function so there is no way of telling what the code does, you have to manually go to each function and check if it is a suspend function to know that it is waiting for something.
I must be missing something very basic here but what is the point of making the first example asynchronous? If we need to create a `Post` before we can process it, and we need to create a `Token` before we can create a `Post`, isn't this a set of synchronous operations? What will actually be done asynchronously? Are we saying we want the entire operation of create/post/process to be async while the app does something else?
Back to answer my own question 4 years later. Yes the Post example consists of sequential operations that are not executed concurrently, the whole operation can be launched asynchronously inside of a coroutine, and not be thread bound at any IO suspension point. The async part is the whole operation, and the suspending operations allow us to free up threads to do other work instead of blocking on network IO.
Can you use a coroutine by not passing any arguments, and doing a while loop inside of the suspended coroutine (for example a person messes their information up during a prompt and needs to reset, so the while loop continues until they press yes)?
I've struggled to hear the speaker even maxing out my phone volume. I found the example contrived: what's the point of making those functions async? I agree the "suspend" keyword isn't the one I would have expected. This is my first exposure to coroutines and I'm gonna leave half way. Still exited about Kotlin though, and I'll be looking for other introductions to coroutines.
Wait wait wait... So in the code where he has the two calls to loadImageAsync() and then calls await on the two deferred objects one after the other, is that really asynchronous? Wouldn't the first call suspend until it was completed and then call the second one? Or does the loading happen when the function is invoked and then the await call only makes sure the call completes before moving to the next line?
Kevin Colin Both images are loaded asynchronously at virtually the same time, only the await() are blocking and ensure both images are there before combining them.
Interesting talk! But i don't really see the improvement from the first - rightfully - criticized approach of having "to many" combinators to "remember" in the promise/future/Rx case when in fact i have the same thing with the so called coroutine builders. This is not really compelling, at least the talk does not make it clear to me why i should trade like 3 combinators with 3 coroutine builders ( i oversimplified this here )
He keeps pronouncing 'coroutine' as 'car routine' -- and I finally guessed why! He must have learned Russian in Moscow or somewhere else nearby with a pronounced акане accent!
Everything is good except for speakers English accent. Its been tough to follow here and there due to lack of clean pronunciation, but can figure out of the context. Should have provided properly generatedsubtitles. Except this rest is wonderful.
Yeah it's a good idea (coroutines). I also started adding them to Java at some point... didn't complete the project yet, but it may be to come. dzone.com/articles/java-can-have-coroutines
coroutines look like garbage. the syntax is incredibly complicated to try to simplify async operation. Get your naming right and stop with a bunch of non alphabet characters to confuse people. The explanation given in this video is garbage. Author tries to use adjective to express how kotlin coroutines are better than async/await and how much simpler ... I don't buy it. suspend is a dumb name to give to a function for async operation ... suspend means don't run the function.
This is definitely a well-polished talk. It made Coroutines easy to understand, and the speaker is obviously well versed.
Well Polish-ed talk
InstaBlaster.
Asynchronous programming [0:50]
A toy problem [1:48]
token -> post -> process
Threads [2:54]
(how many threads we can have?)
Callbacks to the rescue (sort of...) [4:23]
Callbacks: before [4:34]
Callbacks: after [5:11]
(aka "callback hell". exceptions is a mess...)
Futures/Promises/Rx to the rescue (sort of...) [6:25]
Futures: before & after [6:51]
Futures: after (3) [7.33]
(but all those combinators...)
Kotlin coroutines to the rescue [9:03]
Coroutines: before [9:12]
Coroutines: after [10:09]
Bonus features [11:18]
(Regular loops, exception handing, higher-order functions)
(Everything like in blocking code)
Suspending functions [12:44]
Retrofit async [13:04]
Composition (beyond sequential) [14:43]
Higher-order functions [15:31]
(retryIO{})
(suspend fun retryIO(block: suspend() -> T): T{})
Coroutine builders [16:57]
Coroutines revisited [17:06]
launch (coroutine builder) [18:13]
(Fire and forget!)
UI Context [19:22]
Where's the magic of launch? [19:55]
async/await [21:07]
Kotlin-way [21:34]
Classic-way [21:41]
(async/await) (C#, Python, TS, Dart, coming to JS)
(C#) (returns a future)
Why no await keyword in Kotlin? [23:01]
The problem with async (default async without `await` calling)
Kotlin suspending functions are designed to imitate sequential behavior by default [24:53]
(Concurrency is hard, has to be explicit)
Kotlin approach to async (Concurrency where you need it) [25:28]
Use-case for async [25:44]
Kotlin async function [26:40]
(Deferred - Kotlin's future type)
(async coroutine builder)
(await function)
Using async function when needed [29:10]
(suspend fun l(); async{ l() })
Kotlin approach to async [30:08]
Coroutines [30:48]
What are coroutines conceptually? [31:14]
(very light-weight threads)
Example [31:33]
(runBlocking{} runs coroutine in the context of invoker thread)
Demo [33:16]
(Example with thread) [34:06]
(Demo with thread) [34:50]
(OutOfMemoryError)
Java interop[35:54]
(future{} coroutine builder) [37:33]
(future1.await() - Extension for Java's CompletableFuture)
Beyond asynchronous code [38:14]
Fibonacci sequence [38:31]
(buildSequence{} yield())
(Coroutine is restricted only to suspending functions defined here)
Synchronous [40:07]
(Synchronous with invoker)
Library vs Language [41:24]
Classic async [41:37]
Kotlin coroutines [41:54]
Experimental status [42:41]
God bless you
Thanks Bro
you are god sent!
This was one of the best videos I've seen on coroutines as it really helped me get a sense for how I would use them in practice. Thank you!
38:31 It's amazing to witness the moment when every single programming community in the world discovers Monads. This was the moment for the JVM community. Congrats!
Excellent! This is exactly the talk I wanted. The what, the why, and the promise presented in a thoughtful and concise fashion.
Another brilliant and comprehensive talk. I now understand coroutines. Thanks a ton!
You're very welcome!
Thank you for posting this talk. It's the best initial approach I've seen so far after some weeks of reading about the coroutines. Great speaker for a great language!
Jet Brains guys, you're great, I think it's a breakthrough and a way cooler concept than anything else at the moment.
Great presentation and a even greater product by Jetbrains! Kudos to the kotlin team! Can't wait to use coroutines in my project.
Excellent presentation by an obvious master of his craft
I've seen other tutorials but this is the best explanation of them
Wow, way to go kotlin with saner defaults! Amazing work! ~ from a C# dev using async await :)
This is exactly what I was looking for. Thanks!
C# is much more clear. When you call an async function you use await, in kotlin there is no difference between how you call a suspend function and non suspend function so there is no way of telling what the code does, you have to manually go to each function and check if it is a suspend function to know that it is waiting for something.
XPopCornX This is touched upon in the talk. The solution is to have the IDE mark suspend calls in the left gutter on a line by line basis.
A bit old but still related and on-point. Really liked the way he presented the whole thing as a story. The what, they why and the how.
Thanks a lot. That's a really good talk!
Very well explained. Thanks for the video! 👍
Such a great video! Thank you! :-)
Please, fix the volume of the intro music and the volume of record itself!
Very good presentation.
Thanks for clear and understandable talk.
really helpful
I must be missing something very basic here but what is the point of making the first example asynchronous? If we need to create a `Post` before we can process it, and we need to create a `Token` before we can create a `Post`, isn't this a set of synchronous operations? What will actually be done asynchronously? Are we saying we want the entire operation of create/post/process to be async while the app does something else?
UI interactions I think
Back to answer my own question 4 years later. Yes the Post example consists of sequential operations that are not executed concurrently, the whole operation can be launched asynchronously inside of a coroutine, and not be thread bound at any IO suspension point. The async part is the whole operation, and the suspending operations allow us to free up threads to do other work instead of blocking on network IO.
Next time: repeat the questions into a microphone!
Can you use a coroutine by not passing any arguments, and doing a while loop inside of the suspended coroutine (for example a person messes their information up during a prompt and needs to reset, so the while loop continues until they press yes)?
i watched this 6 years later and if am being real its worth 1000 videos. Really laid the basis of coroutines.
wow, kotlin has async/await too :-D
Thank you!
I am wondering how is the launch function at 20:41 different the previous retryIO function. Why does retryIO need to be a suspend function?
Where can I find the talk where he shows how coroutines are compiled in the JVM?
Is this the one you are looking for? ua-cam.com/video/YrrUCSi72E8/v-deo.html
Will the slides be shared? Thanks!
www.slideshare.net/elizarov/introduction-to-coroutines-kotlinconf-2017
Thanks!
So coroutines are just monads where suspend functions are Kleisli arrows, '=' is 'flatMap' and 'await' is 'pure'. Got it ;-)
Us functional casuals needed all the other words in between.
I've struggled to hear the speaker even maxing out my phone volume.
I found the example contrived: what's the point of making those functions async?
I agree the "suspend" keyword isn't the one I would have expected.
This is my first exposure to coroutines and I'm gonna leave half way. Still exited about Kotlin though, and I'll be looking for other introductions to coroutines.
Wait wait wait... So in the code where he has the two calls to loadImageAsync() and then calls await on the two deferred objects one after the other, is that really asynchronous? Wouldn't the first call suspend until it was completed and then call the second one? Or does the loading happen when the function is invoked and then the await call only makes sure the call completes before moving to the next line?
Kevin Colin Both images are loaded asynchronously at virtually the same time, only the await() are blocking and ensure both images are there before combining them.
When you are confuse, the programming language is garbage. Coroutine is garbage.
so RX Java is garbage too, because everyone is confused firstly)
please check out the flashing icons, giving me epilepsy
Interesting talk! But i don't really see the improvement from the first - rightfully - criticized approach of having "to many" combinators to "remember" in the promise/future/Rx case when in fact i have the same thing with the so called coroutine builders. This is not really compelling, at least the talk does not make it clear to me why i should trade like 3 combinators with 3 coroutine builders ( i oversimplified this here )
Maybe the handling of exceptions is easier?
The generated subtitles are hilarious
Any examples to make us smile?
@@JetBrainsTV 19:24 "lunch curtain builder"
Also Kotlin is always "catalan"
@@abunapha "lunch curtain builder" - That's hilarious!
great talk
He keeps pronouncing 'coroutine' as 'car routine' -- and I finally guessed why! He must have learned Russian in Moscow or somewhere else nearby with a pronounced акане accent!
comparing coroutine with Thread is pointless, coroutine's java equivalent should be Executor
Everything is good except for speakers English accent. Its been tough to follow here and there due to lack of clean pronunciation, but can figure out of the context. Should have provided properly generatedsubtitles. Except this rest is wonderful.
More recent one is here; ua-cam.com/video/hb0hfHVWCS0/v-deo.html
Stop starting a lecture video with a useless loud long music sequence.l
kinda like apple's gcd
Yeah it's a good idea (coroutines). I also started adding them to Java at some point... didn't complete the project yet, but it may be to come. dzone.com/articles/java-can-have-coroutines
cheesiest crapiest startest music ever :)
coroutines look like garbage. the syntax is incredibly complicated to try to simplify async operation. Get your naming right and stop with a bunch of non alphabet characters to confuse people. The explanation given in this video is garbage. Author tries to use adjective to express how kotlin coroutines are better than async/await and how much simpler ... I don't buy it. suspend is a dumb name to give to a function for async operation ... suspend means don't run the function.
crazieeez exactly what i thought 😂
Easy man 👨
I think it because JavaScript already has Async and wait keywords