kotlinlang #coroutines

The Kotlinx.coroutines repo hasn't been getting any love for a month+ now. Any idea what's going on? It looked like MPP work was progressing, but hasn't been touched for a while now.

Darshan Mistry

05/31/2018, 11:30 AM

Hello, I am new in Kotlin Development. Can anyone suggest me good sources to learn Kotlin coroutines in android?

dave08

05/31/2018, 5:25 PM

I was never too clear on how to cleanly handle exceptions with Channels in the first place, is there maybe a good article or reference on the subject (apart from the guides on Github that don't really go into best practices the different cases that could occur...)

thevery

05/31/2018, 9:32 PM

Well, rx2 dependencies overhead after proguard is about 2.5k in my project and coroutines is only ~0.5k (even with coroutines-rx2), but the initial question is still actual: why coroutines generates more methods and what to do with it?

06/01/2018, 2:12 PM

is there something preventing actors from being included in multiplatform channels?

thevery

06/03/2018, 1:37 AM

ok, finally managed to extract minimal sample to demonstrate another dexcount problem with coroutines:

package com.thevery.sample.dexcount

import android.support.annotation.Keep
import kotlinx.coroutines.experimental.CommonPool
import kotlinx.coroutines.experimental.launch

class DexCountHelper {

    private val labelsToMark = setOf<String>()
    private val originalState = mapOf<String, MarkedState>()

    enum class MarkedState {
        MARKED_ALL, MARKED_SOME, MARKED_NONE
    }

    @Keep
    fun coroutines() {
        val finalLabelToMark = labelsToMark.filter { lid -> originalState[lid] != MarkedState.MARKED_ALL }

        launch(CommonPool) {
            // +2 methods here :(
            // val finalLabelToMark = labelsToMark.filter { lid -> originalState[lid] != MarkedState.MARKED_ALL }
            println("finalLabelToMark = $finalLabelToMark")
        }
    }
}

voddan

06/04/2018, 6:25 AM

A trick question: how does

CommonPool + CoroutineName("hi")

behaves? Does it allocate new threads (if yes, how many) or reuses threads from

CommonPool

? How come?

gildor

06/04/2018, 6:31 AM

reuses threads from CommonPool, why do you think this is tricky?

Lex Luthra

06/05/2018, 3:42 AM

does anyone know where things currently stand with Spring Boot / WebFlux / Coroutines integration? I saw Konrad Kaminsky's presentation earlier in the year but it looks like his project has been inactive for a few months now..

Olekss

06/05/2018, 5:57 AM

hey do I understand correctly that launch { x = async {...};y=async{}; x.await(); y.await()} will try to take 3 threads from ForkJoinPool and in case of 1core computer 2nd async simply will not start until first finished even without "await"?

sdeleuze

06/05/2018, 1:06 PM

Is there any known issues with Coroutines + function references?

gildor

06/07/2018, 8:25 AM

val job = launch {
        println("Do something")
    }
    
    job.join()

    assertTrue(job.isCompleted)
    assertTrue(!job.isCancelled)
    println("isCompleted ${job.isCompleted}, isCancelled ${job.isCancelled}") 
    //output: isCompleted true, isCancelled false

elizarov

06/07/2018, 8:30 AM

@spand It does not really matter if

Job()

had completed “normally” or “was cancelled”. You can tell the difference (between normal completion and cancellation) with

isCancelled

and that is the only difference. Just use

cancel()

in all cases and don’t use

isCancelled

gildor

06/07/2018, 4:29 PM

You can use non-blocking network API, such as Java.nio

Lex Luthra

06/08/2018, 4:40 AM

Is there a way to configure Jacoco (code coverage) to ignore Kotlin coroutines generated code?

acando86

06/08/2018, 11:45 AM

What are the best practises for exception handling inside of an actors? Any unhandled exception gets propagated to the actors' channel, so the actor will not react to further incoming messages. I understand the more the codebase is using actors, the more this allows to model the entire architecture in a different way and handle the recovery logic at a higher level. But sometimes I might be using actors just in a specific area of the codebase to save a state without having to deal with thread confinement myself (eg, like the example of the counter in the kotlin docs), and in such a case maybe (?) i want to protect the actor from failures with some explicit try catch inside the actor itself. Is this a bad idea? Are there any preferred patterns to dead with this? Any suggestion?

zak.taccardi

06/08/2018, 9:28 PM

I need a

Channel<T>

that supports consuming items from it, but one that can be unsubscribed from and remain open. Is this possible? https://stackoverflow.com/questions/50768585/consumable-channel

Daniel Tam

06/09/2018, 3:57 PM

is there any way to poll/receive from a channel without consuming the element? like peeking at the front of a queue

thomasnield

06/09/2018, 7:29 PM

Hey all, I got a fun challenge for purposes of data science and operations research problems. Is there a way to parallelize this binary tree traversing problem? I have tried to use coroutines but I frequently run into two problems: 1) Waiting for the entire search to complete 2) Memory issues for larger values of

treeRowCount

. Thoughts on an implementation?

wickedev

06/10/2018, 8:39 AM

I was installed kotlinx-coroutines-core via npm, but can not found the atomicfu.js dependency because atomicfu is not in the npm repository. Can be solved?

elizarov

06/11/2018, 8:14 AM

@katokay Some discussion and additional links can be found here: https://github.com/Kotlin/kotlinx.coroutines/issues/119

gildor

06/11/2018, 8:48 AM

@elizarov Current implementation of channels allocates a few object on each item in a channel. For example this is what ConflatedBraodcastChannel allocates for each `send(value)`:

CancallableContunuationImpl

AbstractChannel.ReceiveHasNext

ChildContinuation

ConflatedBroadcastChannel.State

and lambda of

ReceiveChannel.consume

. Isn’t this too much? It’s fine for many cases. But if you want to work with UI drawing events (60 per second in case of Android) it looks like significant overhead

➕ 1

elizarov

06/11/2018, 9:20 AM

📣

kotlinx.coroutines

version

0.23.1

fixes JS version in NPM (adds missing dependency) and introduces

broadcast

builder for JVM&JS. https://github.com/Kotlin/kotlinx.coroutines/releases/tag/0.23.1

🎉 9

louiscad

06/11/2018, 12:49 PM

Hi, anyone is using the

select

expression? If yes, for what use cases?

withoutclass

06/12/2018, 2:29 PM

there are a lot of gotchas with channels where they are shut down unexpectedly, until you dig into the doc and see that it says that’s what will happen

Daniel Tam

06/13/2018, 6:11 AM

just to make absolutely certain, it's safe to send concurrently to the same channel from different threads right?

rattleshirt

06/13/2018, 9:58 AM

Anyone else ran into this:

java.lang.NoSuchMethodError: No virtual method refresh(Lkotlin/Unit;Lkotlin/coroutines/experimental/Continuation;)Ljava/lang/Object;

when calling a suspend fun with param

Unit

? Is this a coroutine or dex’ing issue?

Daniel Tam

06/13/2018, 11:01 AM

is there a good way of debugging coroutines? I know that that's quite a general question but is there some way that I can view the memory/variables of every method that is currently suspended if I set a breakpoint somewhere? I can run everything on a single threaded context if that makes anything easier

Title

Daniel Tam

06/13/2018, 11:01 AM

spand

06/13/2018, 11:17 AM

If you run it on a

TestCoroutineContext

then I think some of them are in the

queue

property. Not sure if it is all of them

Daniel Tam

06/13/2018, 12:25 PM

hmm that's not quite what I meant but I'll keep that in mind nonetheless!

View count: 2