KotlinConf 2018 - Exploring Coroutines in Kotlin by Venkat Subramaniam 

same here man

I read his programming kotlin

Venkat and/or Florina on the title is enough to make me suspend all I'm doing and click on the video.

To click is to do the needful

It's so true

Same here.. even if I've watched it before, it's so satisfying

@@chukzydee suspend, you're saying, I see what you did here...

ru-vid.com/video/%D0%B2%D0%B8%D0%B4%D0%B5%D0%BE-YrrUCSi72E8.html

he is the best speaker I have seen so far.

no 1 can do that :)

The buffering does that for me

​@@0xmg So lucky!

Awesome. Much appreciated...👍🏾

Glad you liked it

Thank you! Cheers!

Yea, it felt a bit like catching a wave. If I didn't have much coroutine experience, I'm not sure I could have followed very well. Some of that was probably the time constraint of the setting.

Thank you kindly!

async {} can only be called from within a coroutine or a suspending function. In fact in the last example, the async call was not made from launch {} function, rather it was made from the lambda, that was passed as argument to the measure function. Since async {} can only be called from coroutine or a suspending function, he had to mark the lambda parameter from measure function as suspending. launch {} function is a coroutine builder. It hides lot of nontrivial code that you would have to write manually, if you wanted to write a coroutine.

@@vyli1 so the call to launch() is indeed unnecessary?

@@HermanBovens I'm sorry, I gave you a little bit misleading information. But first to answer your question, call to launch {} IS necessary. Originally I said, that async {} can only be called from coroutine or suspend function. This is not true, it can be called from wherever. However, .await() can only be called from coroutine or suspending function. Since in the code in the presentation we call .await() on result of async {} operation within lambda parameter, that lambda parameter MUST BE suspending lambda. (.await() can only be called from within a coroutine or suspending function). Since we've turned the lambda into a suspending function and we want to invoke the lambda from within measure function, we want to basically invoke a suspending function inside a nonsuspending function. That's not possible. Suspending functions can only be invoked from other suspending functions, or coroutines. Therefore, the measure function itself must be suspending. As I said before, suspend functions can only be called from within coroutines or another suspending functions. And we want to call the measure function. But measure function is suspending. Therefore we need to create a coroutine, from which we can call the measure function. That's why we do the call to launch {}. launch {} is a coroutine builder. It will build all the coroutine boilerplate code for us. So when we invoke our suspending function measure from within launch, our code will be executed within a coroutine, so the compiler will finally let us compile this code. There are other coroutine builders than launch, for example runBlocking {}, but in this case we didn't want to block the main thread, so that's why launch {} coroutine builder was chosen. When I said .await() can only be called from coroutine or another suspending function, what I mean is, compiler won't let you compile a code, where you'd want to invoke suspending function outside of a coroutine or a suspending function.

28:30 suspend bytecode -> Continuation

No, we don't believe so. Dr. Venkat Subramaniam is the founder of Agile Developer, Inc. agiledeveloper.com

That's a text editor. Probably TextMate.

I like the way it displays output at cursor.

@@jakubgwozdz2780 Yes, you have to configure. Long back after I saw his talk on Java Streams, I also configured like that. :)

proandroiddev.com/kotlin-coroutines-vs-rxjava-an-initial-performance-test-68160cfc6723

It doesn't offer anything that RxJava cannot do. Coroutines can easily represent RxJava's Single and Maybe contexts but does not handle Observable streams without additional boilerplate. For some use cases where there would be a large number of concurrent requests like a server that has 100k+ concurrent connections, coroutines could be more memory efficient since it requrires less intermediate objects (lambdas). Coroutines represent a single chain in a single object that acts like a state machine.

... although I must say - sequence continuations in Coroutines are super simple to reason about and much easier to teach to a newbie than RxJava

It doesn't offer anything new as compared with RxJava or even any callback+eventloop models. The main promise of coroutines is that one can write syncrhonous looking code which the runtime executes concurrently. On the other hand, consider Rx... one has to be familiar with the core Rx interfaces like Observable... although this approach was much better than callback hell.. esp considering exception handling.. there's still a learning curve. Coroutines on the other hand will bring concurrency to where you are.

I love rx, but flatmapping singles is stupid and you need to always return tuples everywhere like an idiot

TextMate.

for simple basics ru-vid.com/video/%D0%B2%D0%B8%D0%B4%D0%B5%D0%BE-x2QOzdh0Fqs.html

I think the goal of the talk was to show how suspend functions make a difference, and allow thread blocking versus non-suspension functions.

Thank you. Fixed.