Optimizing Kotlin code

In this presentation, we explore the most important tools and techniques for optimizing the performance of our code and eliminating memory leaks. It teaches us to recognize potential problems and understand the cost of our choices. We will explore both higher-level optimizations, like caching or appropriate object reuse, to lower-level ones, like optimizing for using primitives or eliminating unnecessary object creation.

Mistakes you make using Kotlin Coroutines

Kotlin Coroutines offer a powerful, yet deceptively simple solution for managing asynchronous tasks. However, their ease of use can sometimes lead us into unforeseen pitfalls. From unexpected cancellations to perpetually running operations, developers often encounter bewildering behaviours that can affect application performance and reliability. In this presentation, we'll dive deep into the common mistakes made while using Kotlin Coroutines. We'll explore why these issues arise, how to diagnose them, and, most importantly, how to resolve them effectively. Expect to walk away with advanced insights and practical strategies to harness the full potential of coroutines in your Kotlin applications, ensuring they're robust, efficient, and maintainable.

#Intermediate #Coroutines #Android

Parents cancelling their children - hard relationship between Kotlin coroutines

Every coroutine needs a Job. Surprisingly, this is what forms their relationship with their children. This is not an easy relationship. It involves inheritance, awaiting, cancellation, and exception handling. Even though those mechanisms might seem scary and complicated, they are intuitive and reasonable once we see them from the right perspective. Let’s do that and on the way. Let’s have some fun.

#Advanced #Coroutines

The beauty of the Kotlin type system

Unlock the true potential of Kotlin's powerful type system and explore its elegant beauty. In this insightful presentation, our Kotlin expert will guide you through the intricacies of Kotlin's type system, unveiling its capabilities, advantages, and real-world applications. Prepare to be amazed as you delve into the depths of this innovative language feature, discovering how it enhances code safety, expressiveness, and maintainability. Whether you're a seasoned Kotlin developer or just starting your journey, this session promises to elevate your understanding and appreciation of Kotlin's type system, empowering you to write more robust and idiomatic code.

#Intermediate

Kotlin variance modifiers and Covariant Object Nothing pattern

Variance modifiers are one of those parts of Kotlin that all use (often unconsciously), but only a small portion of developers understand it well. It gives us the convenience of using collection or functional types and lets us implement popular patterns, like Covariant Nothing Object (used by emptyList or many data structures) or Covariant Nothing Class (used by Either and on many implementations of Result). I will deeply explore those concepts and patterns in this presentation, concentrating on practical use cases.

#Advanced #Android

Mastering Recomposition: Optimizing State Changes for Efficient UI

Unleash the true power of Jetpack Compose by mastering the art of recomposition! This session dives deep into the mechanics of UI updates, exploring how state changes and argument updates trigger recomposition. We'll uncover the secrets to optimizing your Compose code for buttery-smooth performance, revealing practical strategies to avoid common pitfalls and write highly efficient composables. Prepare to unlock the full potential of Compose and build Android apps that are both performant and delightful.

Intermediate level talk 45/60 minutes

Introduction to Kotlin Coroutines

All you need to know about Kotlin Coroutines for everyday work. This presentation explains what are coroutines, how they build structured concurrency, how they get cancelled and synchronized. This is a practical presentation showing the typical usages and common mistakes to avoid. Ready to learn coroutines the right way? So let’s get started.

Kotlin; Coroutines; Open; 45/60 minutes talk;

Evolution of client architecture

Explore the transformative journey of client-side development, from the structured layers of MVC, through MVP and MVVM, to the modern era dominated by declarative frameworks like React and Jetpack Compose. This narrative delves into the pivotal shifts that have redefined how we think about and construct user interfaces, spotlighting the move towards more intuitive, component-based designs that prioritize efficiency and scalability. Join us to understand the forces driving these changes and how they shape the future of application development.

Keynote; Jetpack Compose; Architecture; Open; Android; JVM

Crossing Boundaries: Tales of three projects going multiplatform with Kotlin

Explore the transformative tales of three distinct projects as they transition from JVM to Kotlin Multiplatform. This session unveils their real-world narratives, navigating the challenges and triumphs of adapting to multiple platforms. Dive deep into the intricacies of seamlessly integrating JavaScript, offering attendees invaluable insights and strategies for their own multiplatform initiatives.