**UPDATE**: Kotlin coroutines are no longer experimental as of Kotlin 1.3.

Kotlin coroutines can and should be used in production. That was the chief reason to officially release them in Kotlin 1.1. Having released them, the JetBrains team had committed to maintain backwards compatibility with respect to any changes that are introduced to them in the minor releases as they evolve, while allowing people to safely try them in complex production applications.

In short, the difference between “experimental” and “normal” features, is that for normal Kotlin features new stuff cannot be added in minor updates, because there is a &quot;full compatibility&quot; guarantee, while for experimental features new stuff can be added, but nothing can be removed (because of the backwards compatibility guarantee).

Experimental coroutines use a separate `kotlin.coroutines.experimental` package name, so that when coroutines design is finalized and they move to `kotlin.coroutines` package, old compiled code will not break, but will  continue to work via a separate support library.

Further discussion (long-read) about why they are &quot;experimental&quot; and what does this mean can be found in this [forum post](https://discuss.kotlinlang.org/t/experimental-status-of-coroutines-in-1-1-and-related-compatibility-concerns/2236) by Andrey Breslav.

The same question applies to coroutines support libraries.

The current version of `kotlinx.coroutines` is designed for production use. It is pretty well covered with tests, lots of things are already optimized, all the changes are made considering the issues of backwards compatibility with previously compiled code. It certainly does serve as a test-bed for various coroutine-based things, so there are some parts that are clearly marked as &quot;work in progress&quot; or &quot;unstable&quot; in the documentation of the corresponding functions and classes. However, by default, all the public APIs in `kotlinx.coroutines` are considered to be stable and are being evolved, if needed, with appropriate migration aids.


Is there a way to disable the error overlay when running a create-react-app in development mode?

This is the overlay I&#39;m talking about: 

[![enter image description here][1]][1]

I&#39;m asking this because im using error boundaries ([React 16 Error Boundaries][2]) in my app to display error messages when components crashes, but the error overlay pops up and covers my messages.


  [1]: https://i.stack.imgur.com/QmdEz.gif
  [2]: https://reactjs.org/blog/2017/07/26/error-handling-in-react-16.html

Disable error overlay in development mode

At 3:15 from the end of this &quot;[.NET Core 2.0 Released!][1]&quot; video, Diego Vega shows a demo of new features in Entity Framework Core 2.0. As part of that, a dump of the underlying SQL is shown *in the console app*.

[![enter image description here][2]][2]

I have seen many answers on Stack Overflow suggesting that people use an SQL profiler to view the underlying queries. But now I&#39;m curious: how can you do what Diego Vega did, and get the query to show right there in the application?

Update for .NET 6: EF logging is enabled by default in development. See [this GitHub issue][3] 

Update: Diego added `&quot;Microsoft.EntityFrameworkCore.Database.Command&quot;: &quot;Information&quot;` to *appsettings.Development.json*. See https://stackoverflow.com/questions/45893732/how-do-you-show-underlying-sql-query-in-ef-core/66662556#66662556 for more details.


  [1]: https://channel9.msdn.com/Blogs/dotnet/NET-Core-20-Released/
  [2]: https://i.stack.imgur.com/TNaOI.png
  [3]: https://github.com/dotnet/aspnetcore/issues/32977

How do you show underlying SQL query in EF Core?

Can Kotlin coroutines be used in production, and what does their experimental status mean?


Can &quot;experimental&quot; Kotlin coroutines be used in production?

<p>Can Kotlin coroutines be used in production, and what does their experimental status mean?</p>


Is there no built-in way to convert between boolean - int in Kotlin? I am talking about the usual:

    true -&gt; 1
    false -&gt; 0

If not, what is an idiomatic way to do it?

Boolean - Int conversion in Kotlin

I have a spinner with some items (strings).
I want to add the selected items to a list. I read online that I should use the `onItemSelectedListener `rather than the `onItemClickListener`.

I implemented this but I don&#39;t know how to complete the step of adding it to the list.

    class NewKitListActivity : AppCompatActivity() {

    var spinnerArray = arrayOf(&quot;Dumbell&quot;, &quot;Punching Bag&quot;, &quot;Yoga Ball&quot;, &quot;Skipping Rope&quot;)
    //var spinnerArray = arrayOf(DataService.kitList)



    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_new_kit_list)



        val spinner = newKitItemSpinner
        val spinnerArrayAdapter = ArrayAdapter&lt;String&gt;(this, android.R.layout.simple_spinner_dropdown_item, spinnerArray)
        //selected item will look like a spinner set from XML
        spinnerArrayAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
        spinner.adapter = spinnerArrayAdapter

        spinner.onItemSelectedListener = object : OnItemSelectedListener {
            override fun onItemSelected(parent: AdapterView&lt;*&gt;, view: View, position: Int, id: Long) {
                val selectedItem = parent.getItemAtPosition(position).toString()
                if (selectedItem == &quot;Add new category&quot;) {
                    // do your stuff
                }
            } // to close the onItemSelected

            override fun onNothingSelected(parent: AdapterView&lt;*&gt;) {

            }
        }}}

Thanks

Android Kotlin onItemSelectedListener for spinner not working

In Java it works by accepting an object which implements runnable :

    Thread myThread = new Thread(new myRunnable())

where `myRunnable` is a class implementing `Runnable`. 

But when I tried this in Kotlin, it doesn&#39;t seems to work:

    var myThread:Thread = myRunnable:Runnable

How to initialize a Thread in Kotlin?

In Kotlin is there an equivalent to the Swift code below?


    if let a = b.val {
    
    } else {
    
    }




Swift &#39;if let&#39; statement equivalent in Kotlin

How to copy list in Kotlin?

I&#39;m using 

    val selectedSeries = mutableListOf&lt;String&gt;()
    selectedSeries.addAll(series)

Is there a easier way? 

How to clone or copy a list in kotlin

Kotlin corutines is sugar for finite state machine and some task runner (for example, default ForkJoinPool). https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#implementation-details 

In other words, there is no runtime coroutines in java/kotlin runtime yet (but this can change with http://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html ). Kotlin coroutine is just sequential of tasks, which are executed one by one. Each task can be executed in any thread from thread pool.

Go runtime supports &quot;coroutines&quot;. But goroutines is not the real coroutines. Goroutines does not allow to set yield points in program. Also, Go does not allow to set custom thread pool. You can to set only size of threads in default pool. 

First difference between kotlin coroutines and goroutines is Go runtime manages which coroutine is running at this moment. When goroutine are blocked at some IO operation (or synchronization primitives), Go choices next Job to execute it. In JVM there is no intellectual job switching in such terms. 

Because of this, Go can cheaply change currently running job. Go has only to change few registries &lt;a href=&quot;https://groups.google.com/forum/#!msg/golang-nuts/j51G7ieoKh4/wxNaKkFEfvcJ&quot;&gt;https://groups.google.com/forum/#!msg/golang-nuts/j51G7ieoKh4/wxNaKkFEfvcJ&lt;/a&gt;. But some people say, that JVM can use stack of threads instead of using registers. So there is no saving and loading of registers at all.

The second difference between kotlin coroutines and goroutines is type of coroutines. Kotlin coroutines is stackless coroutines. Goroutines are stackful coroutines. All state of Kotlin coroutines are stored in Kotlin context, which is stored in heap. Goroutines state is stored in registers and thread stack.

I want to know, which coroutines (goroutines and kotlin coroutines) are faster in IO bound tasks? CPU bound tasks? What about memory consumption?

Which of coroutines (goroutines and kotlin coroutines) are faster?

I am calling suspended function from onCreate(...)

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        ...
        callGetApi()
    }

and the suspended function is:-

    suspend fun callGetApi() {....}

But the error shows up *Suspend function &#39;callGetApi&#39; should be called only from a coroutine or another suspend function*

Suspend function &#39;callGetApi&#39; should be called only from a coroutine or another suspend function

I am used to working with `AsyncTask` and understand it pretty well due to its simplicity. But `Coroutines` are confusing to me. Can you please explain to me in a simple way what is the difference and purpose of each of the following?

1. `GlobalScope.launch(Dispatchers.IO) {}`
2. `GlobalScope.launch{}`
3. `CoroutineScope(Dispatchers.IO).launch{}`
4. `lifecycleScope.launch(Dispatchers.IO){}`
5. `lifecycleScope.launch{}`

GlobalScope vs CoroutineScope vs lifecycleScope

I am using kotlin coroutines for network request using extension method to call class in retrofit like this

    

    public suspend fun &lt;T : Any&gt; Call&lt;T&gt;.await(): T {

      return suspendCancellableCoroutine { continuation -&gt; 

        enqueue(object : Callback&lt;T&gt; {

            override fun onResponse(call: Call&lt;T&gt;?, response: Response&lt;T?&gt;) {
                if (response.isSuccessful) {
                    val body = response.body()
                    if (body == null) {
                        continuation.resumeWithException(
                                NullPointerException(&quot;Response body is null&quot;)
                        )
                    } else {
                        continuation.resume(body)
                    }
                } else {
                    continuation.resumeWithException(HttpException(response))
                }
            }

            override fun onFailure(call: Call&lt;T&gt;, t: Throwable) {
                // Don&#39;t bother with resuming the continuation if it is already cancelled.
                if (continuation.isCancelled) return
                continuation.resumeWithException(t)
            }
        })

          registerOnCompletion(continuation)
      }
    }


then from calling side i am using above method like this 

    private fun getArticles()  = launch(UI) {

        loading.value = true
        try {
            val networkResult = api.getArticle().await()
            articles.value =  networkResult

        }catch (e: Throwable){
            e.printStackTrace()
            message.value = e.message

        }finally {
            loading.value = false
        }

    }

i  want to exponential retry this api call in some case i.e (IOException) how can i achieve it ??


How to Exponential Backoff retry on kotlin coroutines

I&#39;m reading Kotlin Coroutine and know that it is based on `suspend` function. But what does `suspend` mean? 

**Coroutine or function gets suspended?**

From https://kotlinlang.org/docs/reference/coroutines.html

&gt; Basically, coroutines are computations that can be suspended without blocking a thread


I heard people often say &quot;suspend function&quot;. But I think it is the coroutine who gets suspended because it is waiting for the function to finished? &quot;suspend&quot; usually means &quot;cease operation&quot;, in this case the coroutine is idle.

Should we say the coroutine is suspended ?

**Which coroutine gets suspended?**

From https://kotlinlang.org/docs/reference/coroutines.html

&gt; To continue the analogy, await() can be a suspending function (hence also callable from within an async {} block) that suspends a coroutine until some computation is done and returns its result:

    async { // Here I call it the outer async coroutine
        ...
        // Here I call computation the inner coroutine
        val result = computation.await()
        ...
    }
It says &quot;that suspends a coroutine until some computation is done&quot;, but coroutine is like a lightweight thread. So if the coroutine is suspended, how can the computation is done ?

We see `await` is called on `computation`, so it might be `async` that returns `Deferred`, which means it can start another coroutine

    fun computation(): Deferred&lt;Boolean&gt; {
        return async {
            true
        }
    }

The quote say ***that suspends a coroutine***. Does it mean `suspend` the outer `async` coroutine, or `suspend` the inner `computation` coroutine?

Does `suspend` mean that while outer `async` coroutine is waiting (`await`) for the inner `computation` coroutine to finish, it (the outer `async` coroutine) idles (hence the name suspend) and returns thread to the thread pool, and when the child `computation` coroutine finishes, it (the outer `async` coroutine) wakes up, takes another thread from the pool and continues?

The reason I mention the thread is because of https://kotlinlang.org/docs/tutorials/coroutines-basic-jvm.html

&gt; The thread is returned to the pool while the coroutine is waiting, and when the waiting is done, the coroutine resumes on a free thread in the pool

What does the suspend function mean in a Kotlin Coroutine?

I have a general question with a specific example:  I&#39;d like to use Kotlin coroutine magic instead of callback hell in Android when taking a picture.


    manager.openCamera(cameraId, object : CameraDevice.StateCallback() {
        override fun onOpened(openedCameraDevice: CameraDevice) {
            println(&quot;Camera onOpened&quot;)
            // even more callbacks with openedCameraDevice.createCaptureRequest()....
        }

        override fun onDisconnected(cameraDevice: CameraDevice) {
            println(&quot;Camera onDisconnected&quot;)
            cameraDevice.close()
        }
        ...

How would I convert that to something less ugly?  ***Is it possible to take an average callback with three or so functions, and turn it into a promise-chain by designating the primary flow as the promise-result path?*** And if so, should/do I use coroutines to make it async?

I&#39;d love something with async and .await that would result in

    manager.open(cameraId).await().createCaptureRequest()

I&#39;m trying to do it through something like the following, but I don&#39;t think I&#39;m using `CompletableDeferred` right!

    suspend fun CameraManager.open(cameraId:String): CameraDevice {
        val response = CompletableDeferred&lt;CameraDevice&gt;()
        this.openCamera(cameraId, object : CameraDevice.StateCallback() {
            override fun onOpened(cameraDevice: CameraDevice) {
                println(&quot;camera onOpened $cameraDevice&quot;)
                response.complete(cameraDevice)
            }
    
            override fun onDisconnected(cameraDevice: CameraDevice) {
                response.completeExceptionally(Exception(&quot;Camera onDisconnected $cameraDevice&quot;))
                cameraDevice.close()
            }
    
            override fun onError(cameraDevice: CameraDevice, error: Int) {
                response.completeExceptionally(Exception(&quot;Camera onError $cameraDevice $error&quot;))
                cameraDevice.close()
            }
        }, Handler())
        return response.await()
    }

Existing 3-function callback to Kotlin Coroutines

I have been reading [kotlin docs][1], and if I understood correctly the two Kotlin functions work as follows :

 1. `withContext(context)`: switches the context of the current coroutine, when the given block executes, the coroutine switches back to previous context.
 2. `async(context)`: Starts a new coroutine in the given context and if we call `.await()` on the returned `Deferred` task, it will suspends the calling coroutine and resume when the block executing inside the spawned coroutine returns.

Now for the following two versions of `code` :

**Version1:**

      launch(){
        block1()
        val returned = async(context){
          block2()
        }.await()
        block3()
      }

**Version2:**

      launch(){
        block1()
         val returned = withContext(context){
          block2()
        }
        block3()
      }

 1. In both versions block1(), block3() execute in default context(commonpool?) where as block2() executes in the given context.
 2. The overall execution is synchronous with block1() -&gt; block2() -&gt; block3() order.
 3. Only difference I see is that version1 creates another coroutine, where as version2 executes only one coroutine while switching context.

My questions are :

1. Isn&#39;t it always better to use `withContext` rather than `async-await` as it is functionally similar, but doesn&#39;t create another coroutine. Large numbers of coroutines, although lightweight, could still be a problem in demanding applications.

2. Is there a case `async-await` is more preferable to `withContext`?

**Update:**
[Kotlin 1.2.50][2] now has a code inspection where it can convert `async(ctx) { }.await() to withContext(ctx) { }`.


  [1]: https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md
  [2]: https://blog.jetbrains.com/kotlin/2018/06/kotlin-1-2-50-is-out/

Content Type	Original Author	Original Content on Stackoverflow
Question	Roman Elizarov	View Question on Stackoverflow
Solution 1 - Kotlin	Roman Elizarov	View Answer on Stackoverflow

Can "experimental" Kotlin coroutines be used in production?

Kotlin Problem Overview

Kotlin Solutions

Solution 1 - Kotlin

How do you show underlying SQL query in EF Core?

Disable error overlay in development mode

Attributions