Software Architect at Adobe
Rares joined Adobe more than 9 years ago, working most of this time with complex, globally distributed systems that do real-time event processing and collection at large scale (think tens of billions of events per day).
More recently, he's been involved in building the next-generation Adobe Edge Network for data collection, which will be faster, extensible and cheaper (or, at least two of these).
Being at the forefront of Kotlin adoption in server-side projects at Adobe, Rares helps other teams in his group adopting the language and becoming proficient.
Handling billions of events per day with Kotlin Coroutines
Migrating a 12-year old application to an asynchronous non-blocking model is not an easy task. What seemed to be impossible at first, was made possible by Kotlin and its Coroutines. It allowed us to reuse most of the existing code base and have a working prototype in a matter of days. Inter-op with Java really pays off!
The application is business-critical and processes billions of events per day in real-time with millisecond latency. It also used to burn a lot of $$ in the process, as a single instance of the application occupied a fairly large EC2 instance, running more than 1K threads and handling over 5K IOPS.
In this session we will walk through the process of using Kotlin to turn the app asynchronous and how we've integrated the coroutines stack, alongside (old) existing technologies. We will also show how this change made the application more efficient — yielding a 25% cost reduction, which translates into millions of $$ annually.
We will also cover challenges encountered along the way when doing such a change, like:
- Low resolution telemetry data may hide bottlenecks
- Asynchronous alone does not guarantee low latency
- Unexpected impact on dependant services
— so that you know what you are up against!