Meetup JUG.CY June 7 with Nikita Koval, JetBrains

There will be two technical topics on meetup and of course, you can ask questions of our guests and have a lot of networking.

Participation is completely free, but places are limited, please check in if you plan to attend the meeting, we can't let you into the building if you are not on the list.

Channels in Kotlin Coroutines

Have you ever wondered how channels in Kotlin coroutines work under the hood? Recently, we redesigned their implementation, significantly improving performance and memory footprint. This talk will introduce the high-level design of the underlying algorithms. You will learn the semantics of rendezvous and buffered channels, how they are implemented, and what influenced this implementation.

Testing Concurrent Algorithms with Lincheck and IntelliJ IDEA

How to write a robust test for a concurrent data structure? Straightforward stress tests are unlikely to catch all possible bugs and flack periodically. The quality of such testing is below the bar. We need a way to write concurrent tests in a convenient, declarative way, keeping in mind "what" we are testing as opposed to "how" we are testing it. With this in mind, the Lincheck framework for writing concurrent tests was introduced. Users list all the data structure operations, and Lincheck verifies whether these operations are thread-safe.
This talk presents Lincheck and explains how you can apply it to your setting while also giving a brief overview of the framework’s internals.

About the speaker:

Nikita Koval (https://nikitakoval.org/), Research Engineer at @JetBrains

Researcher in the Kotlin team at JetBrains and a Team Lead for the Concurrent Computing Lab at JetBrains Research. Nikita has recently redesigned internal synchronization in Kotlin coroutines and has been leading the development of the Lincheck framework, simplifying the testing of concurrent data structures. His primary research interests include but are not limited to concurrent data structures and algorithms, their verification, and practically applicable code analysis.