Brighton Kotlin – June Meetup


Thursday 24th June    
5:00pm - 7:00pm

Event Type

The June Brighton Kotlin meetup takes place on Thursday 24th June at 6pm. We will be opening the zoom just before to allow people to gather and chat. The link will be sent out on the day of the talk. 

You can book your ticket here

We’ll be welcoming Laksitha Ranasingha, Luca Nicoletti and Raul Hernandez Lopez. 

Sign up, spread the word, BYOB and pizza, and join the conversation!

——– Laksitha Ranasingha —— A fresh look at Kotlin Coroutines

Ok, Kotlin is cool and fun. It’s even better with built in coroutine support. As Kotlin is getting popular in backend development, I would like to share my recent experience of using coroutines.

I will start with briefly looking at different concurrency models/patterns such as traditional thread based, asynchronous callback-based, futures, actor-based and coroutine based concurrency. Then I’ll dive a little deeper into Kotlin coroutines, how they work and their pros and cons.

Finally, I would like to show how I used coroutines in a backend service that I recently worked on. The aim is to show the application of coroutines in a real-world use case.

— Bio —

Laksitha is a self employed Lead Engineer


Connect with Laksitha:


——– Luca Nicoletti —— Compose your Trill

This talk will cover the following topic:
– Jetpack Compose: what it is, how should you use
– Implementation: how we are using it at Triller
– Side by side: showcase code for the same (simple) screen made with “old” Android’s technologies and with the “new” Jetpack Compose toolkit
– Summary: is it worth using Compose? How easy is it to use it an existing app? Is it stable? How reliable is it?
– Conclusion: will we keep working with this technology?

— Bio —

Luca is an Android Engineer at Triller


Connect with Luca:


——– Raul Hernandez Lopez —— Getting ready for Declarative UIs with Unidirectional Data Flow using Kotlin Coroutines

Unidirectional Data Flow (UDF) is a powerful technique that enhances our Reactive apps to work deterministically. Synchronising our views with fresh data was never an easy task to accomplish. For this same reason, there are mechanisms that support us to make that possible. Surely callbacks were a thing in the past, however, they were an antipattern themselves due to the lack of readability. Now we don’t need to deal with them any more thanks to Kotlin Coroutines. Getting ready for Declarative UIs with Kotlin Coroutines and friends is indeed feasible, now we could use suspend functions, Flow and in the end StateFlow would make our Reactive apps ready for Declarative UIs. Let’s define a single entry point, receive data, transform it into a state, and render each state. Let’s get our apps ready for a Declarative UI world on Android.

You’ll learn how to use Kotlin Coroutines and friends from the Kotlin Coroutines library to take advantage of really efficient and easy to read code. How to handle its lifecycle without being compromised to a specific external Android framework, which would enable your code to be prepared for more purposes than Android only apps.

— Bio —

Raul is a Senior Software Engineer at Twitter
Connect with Raul:


You can grab your free ticket here

  • Starting Time
  • Date
  • Category
  • Phone
  • Email
  • Location