hello guys

probably old news, but I'm really enjoying the talk 🙂

I wrote a library to listen sqs messages and process it in reactive way using

Flow

. Feedback are welcome. https://thiyagu06.github.io/reactive-sqs-consumer/

when will I get proper behavior subject equivalent? all that dataFlow talk?

runBlocking {
    while (true) {
        someList.forEach {
            launch { someFunction(it) }
        }
        delay(1000)
    }
}

Hi guys, I got a problem, I can not test whether the someFunction is going to run in multiple coroutines, is any way how to do it?

I've used them in many cases over the years. First one was a packet reader over a serial line. I used it to manage the lifecycle of a quotation process of annuity quotation on backend. There are many cases where an FSM is a good way to reason about what happens next. Model a state diagram but then instead of writing a lot of switch statements you can move to an implementation that matches the abstraction. In the UI it is very handy. People use Redux for statemanagment in the front end nut I find that you end with stuff all over the place. With the DSL the statemachine abstraction is preserved. I've added a visualisation model so you can even see if it still matches your original model. A few other handy things are default actions and entry and exit actions. Now I'm adding coroutine support so that it is easier to use in the case where the action is Async.

got my answer

I've added suspend support and added a timeout transition as seen in this demo project: https://github.com/open-jumpco/kfsm-web

Hello all, I’ve been on this for hours but I don’t understand the behavior on the following snippet. When I dispatch an action, the first

actionChannel.asFlow()

emit the value as expected but the second one in the side effect fow doesnt emit anything inside the zip. Outside the zip if i subscribe multiple times to actionChannel all my subscriptions receive the value properly. But not inside the zip. I can’t understand what’s happening tbh. I’d love some insights if possible. ideally i’d like the

actionChannel

to behave like a PublishSubject

why I can’t declare class as

class RetrieveProducts(): suspend fun () -> Flow<List<Product>> {}

it gives me a compile error that suspend can’t be in super type

Ohhh I see, was confused by the dot notation , might want to use a select statement

has anyone published an article or sample project regarding RxJava/Kotlin alternative when using Coroutine? or maybe a reference to start migrating rxjava/kotlin to kotlin coroutine e.g (here’s our current summary so far, and need suggestion or best practices): 1.

Observable

->

Flow

2. `Completable`/`Single` / `Completable.defer`/`Single.defer`->

suspend fun

/

Deferred

? 3.

PublishSubject

->

BroadcastChannel

? 4.

Observable.merge

,

Observable.compose

,

Observable.mergeWith

->

Flow.zip

,

Job.join

, x? 5.

ObservableTransformer

, `-> ? 6.

Flowable.just

->

flowOf

? 7.

Flowable.flatMapPublisher

->

Flow.map

the above usecase we found from below references: 1. https://www.slideshare.net/manuelvicnt/coroutines-and-rxjava-an-asynchronicity-comparison 2. https://viseon.ch/blogs/convertRxToCoroutine/index.html 3. https://github.com/epam/CoroutinesExtensions 4. https://github.com/sys1yagi/implementation-of-async-request-with-rxjava2-or-coroutine

Why is 1.3.4 published but has no tag on git?

https://github.com/Kotlin/kotlinx.coroutines/pull/1846 it's not even merged, they have some script issues 🙂

Hey guys, I'm pretty new with coroutines. Got stuck with a concept that was showcased in GithubBrowser Sample from AndroidArchitectureComponent GitHub repo. So using coroutines in Repository how can I wrap the data into NetworkBoundResource obj to ensure broader scope with the request as stated in the sample. Did anyone tried implementing the same on Android? I tried going through some samples but couldn't find one doing the needful.

Anyone using the Multicast library outside of Store? How does the feature set/behavior compare to Rx multicasting? The piggyback and keep-alive flags seem like they probably cover a lot of it.

Source code:

fun getCityById(selectedCityId: Int): City {
    var city : City? = null
    viewModelScope.launch {
        city = locationRepository.getSingleCityFromDatabaseById(selectedCityId)
    }
    return city //Compilation error message: type mismatch, Required:City, found: City?
}

fun getListOfLanguagesByIds(selectedLanguages: List<Int>): List<Language> {
    viewModelScope.launch {
        return supportedLanguagesRepository.getLanguagesFromDatabaseById(selectedLanguages.toIntArray())
    }// Compilation error above message: 'return' is not allowed here
}

fun getExpertiseFieldById(expertiseFieldId: Int): ExpertiseField {
    lateinit var expertiseField : ExpertiseField
    viewModelScope.launch {
        expertiseField = expertiseFieldsRepository.getSingleExpertiseFieldFromDatabaseById(expertiseFieldId)
    }
    return expertiseField
    //Seems to work, but I am afraid expertiseField will be returned uninitialized.
}

Slack Conversation

Thanks a lot for your effort, I really appreciate it I think this is the most confusing part... what is the sense here to do

scope.launch(*SupervisorJob()*) {

? in which scenario would I code this?

I have a new kotlin multiplatform project with the following common.kt file:

import io.ktor.client.HttpClient
import io.ktor.client.request.*
import kotlinx.coroutines.*

/*
 * List of required functions that each platform-specific code implementation needs in order
 * to be compliant with this SDK.
 */
expect fun environmentMetaData(): String

/*
 * Gathers relevant environment code from the device at runtime including the device details and
 * operating system properties to assist in debugging, logging, and error reporting.
 *
 * @return: String
 *   a string representation of the meta data during runtime including os and device details
 */
fun gatherEnvironmentalMetaData(): String {
    return environmentMetaData()
}

fun hitApi(uri: String): String {
    return uri
}

fun fetcher(uri: String) =  {
    val client: HttpClient = HttpClient()
    val content: String = async {

    }
}

in this code

_githubService.contributors(_username!!.text.toString(), _repo!!.text.toString())
        .asFlow()
        .launchIn(this)

I still have the suspend function compile error in

contributors

function

like rxjava distinct ?

what about defaultIIfEmpty ? I could use onCompletion{ emit(xxx), but i only have access to the error there if any }

object Foo {
  companion object {
    suspend fun something(...)
  }
}

When using auto completion to call

Foo.something()

in a non-suspending context (so it shouldn't be possible), IDEA will expand

Foo.[caret]

into

Foo.Companion.something()

then the ‘Redundant Companion reference' will kick in, and after removing the

Companion.

manually, only then will IDEA say ‘suspend function 'something' should be called from a coroutine [...]' It would be much better if the message was shown during completion (eg. Type

Foo.

, hit tab, see the list of functions with the suspending ones in orange with a message ‘cannot be called from outside a coroutine' or something similar). IntelliJ Ultimate 2020.1, Kotlin 1.3.61

This excellent article sheds some light on how

suspend fun

are implemented: https://medium.com/androiddevelopers/the-suspend-modifier-under-the-hood-b7ce46af624f Since each

suspend fun

is compiled to a state-machine class, a project with a lot of suspending functions will generate a lot of bytecode, right ? Does shrinking tools like Proguard succeed in reducing the size of such bytecode ?

Hello I want to see coroutine all `dispatcher`’s call stack. I wrote

android test

source code 

// AnyTest.kt

@Test
fun callStackCrop_a() = runBlocking {
  a(0)
  a(1)
  a(2)
  a(3)
  a(10)
  ***a(11)***   // 76 line
  a(12)
}

suspend fun a(x: Int): Unit = b(x)   // this action cropped....
suspend fun b(x: Int) = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
  c(x)      // 82 line
}
suspend fun c(x: Int) {
  if (x > 10) {
    throw NullPointerException("ops x = ${x} > 0")   // 86 line
  }
}

Test result is that

at ___.AnyTest.c(AnyTest.kt:86)
	at ___.AnyTest$b$2.invokeSuspend(AnyTest.kt:82)
	at |b|b|b(Coroutine boundary.|b(|b)
	at ___.AnyTest$koroChase$1.invokeSuspend(AnyTest.kt:76)
Caused by: java.lang.NullPointerException: ops x = 11 > 0
	at ___.AnyTest.c(AnyTest.kt:86)
	at ___.AnyTest$b$2.invokeSuspend(AnyTest.kt:82)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
	at kotlinx.coroutines.DispatchedTask.run(Dispatched.kt:241)
	at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:594)
	at kotlinx.coroutines.scheduling.CoroutineScheduler.access$runSafely(CoroutineScheduler.kt:60)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:740)

"Calling

b() method

at

a()

" is removed….. I want to see

all call stack trace

in coroutine how to recover this call stack.....? Attach a link with a similar problem https://github.com/Kotlin/kotlinx.coroutines/issues/1660

Are caches like guava or caffeine considered coroutine-safe regarding concurrent modification/access ?