A modern programming language that makes developers happier.

kotlinlang

Hello,

About the JS implementation of `kotlinx.coroutines`. What is the base? I suppose `Deferred` is internally using `Promise`, but what about `Job`? Is it working with `Worker`?

Coroutines on JS are single threaded, so no workers out of the box

Also see this thread
<https://kotlinlang.slack.com/archives/C1CFAFJSK/p1544765742296600?thread_ts=1544765742.296600&amp;cid=C1CFAFJSK>

But there are adapters to convert coroutines to promises or to await Promises

I just wanted to know if the compiler to js had find a way to run the code in a worker. I guess I could figure out a way to do it with a Gradle plugin. Anyway,  I am sure there is way. I'll investigate with modern framework, I know they keep some logic away from the thread handling the DOM. Thank you for your help.

Sure, you can run the code in a worker, like any other JS code. You just should compile some Kotlin code to JS and run it on a worker

You even can use libraries that provide Promise based API for workers so it allow even use coroutines to await for result, but the only problem that you have to compile UI and worker code in separate modules to get 2 separated JS files from 2 Kotlin modules

Yes, or I'll just see what will happen with WASM and Kotlin/Native :slightly_smiling_face:

Wasm? How this related with workers?
As I know threads are not available on Wasm yet, so not sure what you mean
You can run wasm code on worker, but general approach is not somehow different comparing with Kotlin/JS except than JS backend is much more stable than native (actually the same with JS can wasm for now)

According to this article <http://fitzgeraldnick.com/2018/12/14/rust-and-webassembly-in-2019.html> multithreading should available soon.

A plugin could help, and I will have to generate multiple files.

Considering the fellowing code:
```
val personA = Person()
GlobalScope.launch {
  val personB = Person()
}
```
Will generate
```
  - main_code.js
  - person_class.js
  - worker_code.js
  - kotlin.js
```
`person_class.js` because it is used in the two threads.

And if we detect that kind of code
```
val service = Service()
GlobalScope.launch {
    val person = service.getPerson()
}
```
The plugin should generate the code for the communication between the two process.

So maybe it's better to wait for WASM and have built-in solutions :slightly_smiling_face:
WebKit team had a proposal <https://webkit.org/blog/7846/concurrent-javascript-it-can-work/>