Reflection is a powerful tool that allows us to inspect classes and use their methods. To transform an object into a string, we can use reflection to get all properties and their values.

If you still struggle to understand how the IO dispatcher should be used, here is a pill that explains everything you need to know 👇 IO dispatcher is used when we need to make a blocking call, like reading a file or using a blocking API. This sometimes happens, as some libraries still only offer blocking APIs. You don't need to use IO dispatcher if you use suspending functions. Those should never be blocked, so a lib with suspending API does not need IO. IO dispatcher is by default limited to 64 threads (or the number of cores, whatever number is greater). This limit protects our resources. Imagine that you need to send newsletter using blocking API, and you send elements asynchoniously. Without limit, you would start as many threads as many emails you have to send, what would likely cause OutOfMemoryException, as each thread required 1 MB or RAM. Limit makes sending take longer, but it protects our memory. The biggest problem with IO dispatcher is that is has one limit for the whole application. Imagine that our newsletter service uses all its threads for a couple of minutes. If other services want to use Dispatchers. IO as well, they need to wait in queue until newsletter process is finished. To avoid such interdependencies, we prefer to have dispatchers with custom limits in each service. We create such dispatchers using Dispatchers. IO.limitedParallelism(limit). Dispatchers created this way share a pool with Dispatchers. IO and Dispatchers.Default, but this underlying pool is inlimited, and each dispatcher has its own limit, so it is safe and efficient. How do we set the limit? If we do not care much about execution time, we can set it to a smaller number. For our newsletter it can be 5. If we care more about not having one coroutines wait for enother, even in cost of more resources being spent, we set it to a greater number, like 50. That is all you need to know about IO disatcher! If you like my teaching style, check our my book Kotlin Coroutines: Deep Dive and my workshops, especially Kotlin Coroutines.

In Compose, parameter providers not only help us preview a component with different values, but also allow switching between those values when we run the preview! Defining a parameter provider is simple. You need a class that implements PreviewParameterProvider<T>, which should specify the values property with different values. Once defined, you can use it in preview with @PreviewParameter(YouProviderClass::class). The biggest limitation is that you can define only one parameter provider per preview.

Do you lack default error handler in viewModelScope? This library by Luka Velimirovic might be what you look for! It offers configurable multiplatform vmScope, as a replacement for viewModelScope. This library was made as a final project on Coroutines Mastery, great congratulations to Luka for creating it ❤ Code 👉 github.com/VelkosX/vmscope #coroutinesmasteryproject

Have you ever wondered how libraries like Arrow Lenses actually work? The answer is quite simple, just follow me.

One of the most important decisions you need to make when defining custom composables is wrather you want to store mutable state locally or hoist it. When state is local: 👉 Logic can be reused. 👉 Component has simpler API. When we hoist it: 😨 There are more (or more complex) parameters. 👉 Logic can be more easily customised. 👉 Caller can decide how state is stored and how persistent is it. 👍 We can easily preview all different states. I would say, that local state is more React-like, but hoisting this state it much more Compose-like. It is a popular approach hoist all state up to view models.

Remember to always preview your Compose components in your application theme. Without it, it will look different because it will use default values such as colors, fonts, sizes, etc. If you have multiple theme variants, it is best to preview each universal component in each of them. I wish we had a simpler way to automatically apply the application theme to all our previews, or, even better, to all defined themes.

✅ 𝗋𝖾𝗆𝖾𝗆𝖻𝖾𝗋 block calculates the value during first initialization, and then caches it for later. This value will be recalculated only if one of its keys changes. If it has no keys, the same value will be used for as long as this composable exists.