Vasya Drobushkov

Kotlin Coroutines Cancellation and Exception Handling

Sun, 11 Jan 2026 00:00:00 +0000

Cancellation and exception handling in coroutines is by far the most complex thing I’ve faced during my entire career. These two things are so complicated that I sometimes ask myself how people are using such a difficult-to-use framework. I read all the possible docs that I found, many different articles, video courses, and even tried to look at the code - and still, I feel that my understanding of this topic is quite bad.
When reading articles, I often thought that their structure was not good and that things were not clarified in a reasonable way. Usually, articles are just a collection of examples that show how certain combinations of suspending functions or coroutine builders will work. Learning by examples is good, but they should help with understanding core concepts so that all other situations are easy to relate to what was learned.

ChessKt Demo

Sun, 27 Jul 2025 00:00:00 +0000

Sources: https://github.com/krossovochkin/chess.kt

Data-Driven Debugging for Engineers

Tue, 03 Jun 2025 00:00:00 +0000

As engineers, we deal with bugs every day. Finding the root cause and delivering the right fix is one of our most essential — and satisfying — skills.

In this post, I want to walk through different types of issues we face and how we typically debug them. Most importantly, I’ll share my favorite and most challenging method: data-driven debugging.

Let’s break it down by who reports the issue and how it’s discovered.

When SOLID breaks: Choose CLARITY

Mon, 05 May 2025 00:00:00 +0000

A long time ago, when I had just started my journey into programming, development, and engineering, it wasn’t easy to find information, and bikeshedding could happen quite often because of that. We read books to gain insights into best practices and learn how to do things correctly. The concepts from the past were usually crucial and provided a great ramp-up to avoid obvious mistakes.

Over time, we became flooded with information and opinions. In such an environment, old-time thoughts may even seem better, as they’ve been tested by time and by many engineers in the field.

Java after Kotlin

Mon, 17 Feb 2025 00:00:00 +0000

I am usually pretty slow with new technologies and software updates. That happened with Kotlin a while ago. While version 1.0 was released in early 2016, and many companies were early adopters since the alpha versions, I really started using it only around the end of 2017.

I should say that I do find it a very concise and easy-to-write-and-read language. Its focus on developer experience makes it very pleasant to use (except coroutines, lol).

Relatively Non-Obvious Tricks in Solving Simple Algorithmic Problems

Sat, 21 Dec 2024 00:00:00 +0000

Blowing the dust off LeetCode once again, I found myself, as in the past, struggling with coding relatively simple algorithms. Just like with anything else, if you don’t practice for years, you lose some of the hands-on experience.

On the positive side, I noticed that for some problems, my new submissions were much better and more concise compared to my old ones. That’s an awesome feeling—a tangible measure of growth.

While tackling certain easy problems, I realized that “easy” usually just means “doesn’t require much code.” However, the idea behind the optimal solution might still not be very intuitive. Sure, one can use brute force or additional collections, but in most cases, this leads to either a “time limit exceeded” or an “out of memory” error.

Reactive streams testing

Sun, 08 Jan 2023 00:00:00 +0000

Introduction

We should test the code to guarantee that it does exactly what it is expected to do. Tests not only verify correctness of the program but also set expectations. This becomes especially useful for public API, where tests can be treated as part of documentation that describes not only results but also behavior. Such things help do less painful migrations and refactoring as it becomes clear what behaviors are changing and what we should do about that.

Dimensions Utils

Mon, 22 Aug 2022 00:00:00 +0000

Sources: https://github.com/krossovochkin/dimensions-utils

Time Utils

Mon, 22 Aug 2022 00:00:00 +0000

Sources: https://github.com/krossovochkin/time-utils

Color Utils

Sat, 23 Jul 2022 00:00:00 +0000

Sources: https://github.com/krossovochkin/color-utils

When Compose remember cannot forget

Sat, 23 Jul 2022 00:00:00 +0000

Чытаць на беларускай мове

Introduction

When developing color-utils app using Compose for Web I faced an issue that remember didn’t want to forget the state. It was quite annoying experience as it felt stupid: composable function is recomposed with the new value provided but remember still kept old value.
As usual, there is no magic there and the answer is quite simple therefore this article won’t be that long.

Compose is all about state. In the app I had two levels of state:

Калі Compose remember ня можа забыць

Sat, 23 Jul 2022 00:00:00 +0000

Read in English

Уводзіны

Пры распрацоўцы прыкладання color-utils з выкарыстаннем Compose для Web я сутыкнуўся з праблемай, што remember не хацеў забываць стан. Гэта быў вельмі раздражняльны вопыт, бо я адчуваў сябе па-дурному: Composable функцыя перакампанавана з новым значэннем, але remember па-ранейшаму захоўвала старое значэнне. Як звычайна, ніякай магіі тут няма, і адказ даволі просты, таму гэты артыкул не будзе вельмі доўгі.

Compose - гэта ўсё аб стане. У прыкладанні ў мяне было два ўзроўні стану:

Card Soccer

Sun, 10 Jul 2022 00:00:00 +0000

How to play

The goal of the game is to win AI opponent by scoring more goals.
The game is turn based.
On your turn you should move the “ball” (card opened from your deck) to opponents goal.
You start from the row that is close to your goal: you should select a card in a row and if it matches by value or suite - proceed to the next row up until the opponent’s goal.
If there is no match - your turn is over.
You can select opened and closed cards.
If the whole row is opened - you can skip it and procced to the next one. You score when your “ball” matches opponent goal.

Controlling TextView MinWidth

Tue, 14 Sep 2021 00:00:00 +0000

Introduction

Sometimes we might need our TextView with wrap_content width to occupy more space than it will based on amount of characters it displays. For that we can set minimum width. Usually, we do that via XML like this:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="@drawable/bg_text"
        android:gravity="center"
        android:minWidth="200dp"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Having setup like this we ensure that our TextView will occupy a minimum of 200dp.
Also, we can control minimum width programmatically via: TextView#setMinWidth.
But controlling minimum width programmatically has one caveat that I’d like to describe below.

Mocking Matchers API

Sat, 11 Sep 2021 00:00:00 +0000

Introduction

Recently, I faced an issue that in the first place I found weird. I even considered that the behavior is generally incorrect. Diving deeper I got few insights on the problem - and this is what I’d like to share with you.
This is a story about the interesting behavior of mocking library and the difficulties of defining API surface for a library.

Disclaimer
In general, I favor fakes over mocks. In other words, instead of trying to implement emulation of the behavior as a mock - it is generally easier and safer to implement a simple fake object with all the logic (that can be covered with tests if needed).
Though that doesn’t mean that one should not use mocks at all. In my opinion, it depends on the use case. If you would like to stub some values - then going with a fake object sounds like a wise choice, but for verifying behavior (e.g. whether there were interactions with a particular object or not) using mocking libraries might provide a fast solution.
Needed to say that even when trying to verify interactions one can use fake objects wrapped with spies.
Regardless, this article is not about what approach is better, it is more about the behavior of mocking libraries and how their API is designed.

JUnit Coroutines Runner

Sat, 10 Jul 2021 00:00:00 +0000

Introduction

Recently while writing tests for kotlin code with coroutines I found one annoying thing: almost all the tests start with runBlockingTest. Typing the same stuff repeatedly is something we can’t accept! So, I decided to think about how to improve this.

Disclaimer. Yes, this is an example of how to spend few hours to optimize some task that requires you 2 seconds to complete each time. Even on a scale of hundreds of usages such optimization most likely won’t pay your time back. But it is always fun to do some weird things even if you understand that they are stupid.

Kotlin flow: Nesting vs Chaining

Thu, 08 Jul 2021 00:00:00 +0000

Introduction

When it comes to reactive streams it is likely everyone heard about huge ‘Rx-chains’. But reactive streams are not only about chaining but also about nesting. Let’s find out what are they, what are the differences, and why it matters.
We’ll use Kotlin Flow throughout the article, but everything can be applied to RxJava as well.

First of all, we need to come up with definitions. For that, we’ll take a look at some simple streams.

Why custom website instead of Medium

Mon, 21 Jun 2021 00:00:00 +0000

Introduction

I like writing articles. This is the best format for me to share ideas, knowledge and also to better understand some topic. when writing something other people can read you have to dive deep enough so that the picture is complete. It helps systemize thoughts. Starting writing was challenging as you don’t know what feedback you’ll receive. It is always a bit tough to be not correct in something. Fear of making a mistake – while not being a bad thing, as we learn from mistakes – is still here. Don’t make that fear stop you from doing what you feel is right. I started writing on Medium and publishing in various publications there but then switched to my website quite a while ago. After some time of running my stuff, I finally would like to share why I did so and what the pros and cons of that are.

Custom Reactive JSON parsing

Tue, 08 Jun 2021 00:00:00 +0000

Introduction

Parsing JSON strings is a must-have on most Android projects that have server-client communication (of course there are some other formats like XML or Protobuf, but I guess JSON is the most common one at least at the moment). Setting up this communication is relatively straightforward: choose a library, add it to a project, describe models, create mappers, and so on. There are a bunch of various libraries to parse JSON: good old Gson, Jackson, or more modern Moshi, kotlinx-serialization and there are more. Set up of these libraries is different, there are differences in the internal implementation, but the general idea is the same for most of them: you can convert JSON-string into a set of objects and vice versa.

Bad Kotlin Extensions

Mon, 25 Jan 2021 00:00:00 +0000

Introduction

Kotlin extensions are a cool feature. Though trying to write ‘idiomatic’ Kotlin code some developers tend to overuse that feature making code worse than it could be without extensions. In this article, we’ll go through some examples of how not to write Kotlin extensions.

First of all, we need to try to define what a good extension is.
It is simple though vague: good extension solves some problems. When we talk about code the main feature extensions have is to improve readability. Extension methods are static methods with the first parameter being a receiver of the extension. For example, these are equivalents:

Debugging Proguard configuration issues

Mon, 18 Jan 2021 00:00:00 +0000

Introduction

It might happen so that there is a bug in your release build while in debug everything works fine. In many cases, it might be an issue with Proguard/R8 configuration. Of course, it is better to test your code thoroughly, properly configure Proguard if you, let’s say, load some classes only via reflection and so on. But reality sometimes strikes and bugs might go to production.
In this case, the first thing that is needed is to find a bug and fix it. And only then have some retrospective to mitigate such situations in the future. When the bug is in production already every minute counts, therefore it is important to have some plan. Proguard configuration seems complex to someone who didn’t work with it, so I recommend to take a look at its main features.
Most of the time I’d say that issue is easy can be found and fixed by analyzing crash report logs. But sometimes the log is not that clear.
In this article I’d like to introduce the plan to find what part of “Proguard” causing an issue, so you can debug more effectively.

Optimize reading articles experience

Sat, 16 Jan 2021 00:00:00 +0000

Introduction

Learning is an essential part of doing anything. There are many different ways to learn something. Like active learning (studying) and passive learning (gaining experience), moving towards some particular goal and exploring unknown places looking for new ideas. One can learn using various types of perception - audial, visual, haptic, speech, etc. Learning is important in all directions: improving your existing skills or getting new.

I think one of the most straightforward ways of learning is active learning towards some particular goal. Some online-course might be an example: you start a course to let’s say learn new skills and after you’ve completed the course you can say that you’ve accomplished the goal and learned something.
One of the most difficult ways of learning is exploring something new because there is no single way of doing that.

Android Room Hidden Costs

Fri, 18 Dec 2020 00:00:00 +0000

Introduction

Android Room is an awesome AndroidX library. It is great because it provides a clean way of how to deal with databases without introducing some heavy concepts. Out of the box with Room one gets:

simplified code comparing with raw SQLite queries
working via DAO interfaces and models instead of Cursors
auto-generated “boilerplate” code for queries
migration support
Android Studio tooling (compile-time verification of queries and highlight)
support for reactive streams (RxJava, Kotlin Flow)
and more

In this article, I’d like to discover some hidden costs Room applies to support reactive streams and how one can try to avoid them.

Boolean not

Sat, 31 Oct 2020 00:00:00 +0000

Introduction

Boolean is one of the essential types in programming and probably one of the simplest because it has only two values: true and false. Boolean are usually used as flags for control flow, specifically, conditions.

if (string.isEmpty()) {
	println("String is empty")
}

It is not much interesting in Boolean, but in Kotlin there is one thing which might be confusing if used - it is method not().

Negate Boolean

If we look at declaration of Boolean class in Kotlin we’ll see five methods, four of which are pretty obvious: and, or, xor and compareTo. And the fifth is not:

Middle Point

Wed, 28 Oct 2020 00:00:00 +0000

Introduction

Working with numbers in programming never was a simple thing. In math, we deal with various sets of numbers - whole numbers, rational, complex. All these sets are infinite - that means that for any number we can find another smaller one and one which is bigger. In programming when we work with numbers we deal with some subset of these sets - that many that can be represented with a given amount of bits. When we want to work with whole numbers we can use e.g. Integer, which are the numbers being able to be represented usually with 4 bits. For floating-point numbers - say Double - it is 8 bits. There is no plus or minus infinity (in Double there are +/- infinity, though they are used for special cases).

Kotlin Functional Interfaces: Function reference and SAM conversion

Sat, 17 Oct 2020 00:00:00 +0000

Introduction

About two years ago I made a post about a tricky case in Kotlin-Java interop related to the usage of function references and SAM conversion. One of the points there was that in Kotlin, if interface is declared instead of a function, one has to explicitly create an object, therefore no caveats as with interop:

val callback = object : ThirdParty.Callback {
    override fun onValueChanged(value: Int) {
        this@App.onValueChanged(value)
    }
}

With Kotlin 1.4 there is now a “Functional interface” which supports SAM conversion. And I’ve been asked on how it works in a similar situation.
Let’s find out.

Kotlin Nitpicker's guide

Wed, 14 Oct 2020 00:00:00 +0000

Introduction

Code review is an essential tool for a development team, which helps ensure high-quality standards of code. While reviewing others’ code one might find bugs, design issues, and so on. One another part of reviewing is getting used to the codebase and following team’s code style for better maintenance. Though it is pretty cool in theory, in practice team might face few issues, one of which is nitpicking. When review is bloated with dozens of similar comments related to e.g. how beautifully code looks like. Common code style is important, but having a lot of similar comments in each review doesn’t help. Instead of trying to understand what code is doing, nitpicker writes a lot of similar comments on the style. Back and forth discussions or fixes of such slow down development process and overall make team’s morale worse.

The Real Kotlin Flow benefits over RxJava

Sun, 17 May 2020 00:00:00 +0000

Vasya Drobushkov

Kotlin Coroutines Cancellation and Exception Handling

ChessKt Demo

Data-Driven Debugging for Engineers

When SOLID breaks: Choose CLARITY

Java after Kotlin

Relatively Non-Obvious Tricks in Solving Simple Algorithmic Problems

Reactive streams testing

Introduction

Dimensions Utils

Time Utils

Color Utils

When Compose remember cannot forget

Introduction

Калі Compose remember ня можа забыць

Уводзіны

Card Soccer

How to play

Controlling TextView MinWidth

Introduction

Mocking Matchers API

Introduction

JUnit Coroutines Runner

Introduction

Kotlin flow: Nesting vs Chaining

Introduction

Why custom website instead of Medium

Introduction

Custom Reactive JSON parsing

Introduction

Bad Kotlin Extensions

Introduction

Debugging Proguard configuration issues

Introduction

Optimize reading articles experience

Introduction

Android Room Hidden Costs

Introduction

Boolean not

Introduction

Negate Boolean

Middle Point

Introduction

Kotlin Functional Interfaces: Function reference and SAM conversion

Introduction

Kotlin Nitpicker's guide

Introduction

The Real Kotlin Flow benefits over RxJava

Introduction

Raising old project from the depth

Introduction

Kotlin useful but unfairly not mentioned features

Introduction

Category theory

Disclaimer

Category

Accessibility of text over generic background color

Introduction

Compiler-generated classes, methods and fields in Java

Introduction

Unit Testing Best Practices

Tests in the Development Process

From RxJava to Kotlin Flow: Testing

Introduction

From RxJava to Kotlin Flow: Throttling

Introduction

From RxJava to Kotlin Flow: Stream Types

Introduction

From RxJava to Kotlin Flow: Error Handling

Introduction

Vinyls animation with MotionLayout

Introduction

From RxJava to Kotlin Flow: Backpressure

Diving deep into Android Dex bytecode

Introduction

From RxJava 2 to Kotlin Flow: Threading

Introduction

Change Theme Dynamically with Circular Reveal Animation on Android

Introduction

SQLite Triggers (+ Android Room)