Marcin Moskała
Developer during the day, author at night, trainer at Kt. Academy
Warsaw, Poland
Marcin Moskala is an experienced developer and Kotlin trainer. He is the founder of the Kt. Academy, an official JetBrains partner for Kotlin training, author of the books Effective Kotlin, Kotlin Coroutines, and Android Development with Kotlin. He is also the main author of influential articles about Kotlin and a speaker invited to many programming conferences.
Links
Area of Expertise
Topics
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.
Effective Coroutines
Kotlin Coroutines can be intuitive, efficient, and safe when used well, or confusing and unreliable when used poorly. In this session, I will present the essential lessons to use them well: typical use cases, best practices, common mistakes, and misunderstandings. Knowing them, you should be able to improve your applications and libraries.
Benchmarking Coroutines: Comparing the efficiency of Kotlin Coroutines, project Loom and RxJava
In the realm of asynchronous programming, the battle for efficiency rages on between Kotlin Coroutines, Project Loom, and RxJava. Join our renowned Kotlin expert for an in-depth benchmarking showdown, as we put these powerful solutions through rigorous real-world testing.
Through benchmarking and analysis, uncover the strengths and weaknesses of each approach, diving deep into their inner workings. From lightweight tasks to heavy computations, gain invaluable insights into which solution excels under different scenarios.
Brace yourself for a performance-driven journey that will shape the future of asynchronous programming in Kotlin and beyond.
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.
The path of an educator
Dive into the multifaceted journey of an educator in the digital age. This presentation unravels the progression from starting a blog to public speaking, crafting workshops, and the intricate process of writing and publishing a book. Delve into the balance between technical prowess and educational skills and uncover the financial prospects in the educational domain. The talk also demystifies the rewarding endeavour of penning a book, from choosing a topic to the final touches of cover design.
Testing Kotlin Coroutines
Testing asynchronous code with Kotlin Coroutines can be a daunting task, but fear not! This insightful presentation, led by the renowned author of "Kotlin Coroutines: Deep Dive," will equip you with the tools and techniques to conquer coroutine testing like a true master.
Discover the powerful testing utilities offered by Kotlin Coroutines, including the ability to control time itself. Learn how to ensure concurrent processes run seamlessly, verify time dependencies with precision, and leverage JUnit rules for effortless testing workflows.
Whether you're developing for Android or building robust backend systems, this session will provide you with a comprehensive understanding of testing coroutines across various scenarios. Master the art of writing bulletproof asynchronous code with confidence, and take your testing skills to new heights.
Practical Patterns for Kotlin Coroutines in Production
Unlock the full potential and extensive capabilities of Kotlin Coroutines with a focused exploration of their practical implementations across various real-world scenarios. This comprehensive talk will guide you through essential best practices, demonstrate robust patterns for common asynchronous tasks, alongside comprehensive guidance on synchronizing and testing coroutines within both backend and Android environments,
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.
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.
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.
NDC London 2018 Sessionize Event
Marcin Moskała
Developer during the day, author at night, trainer at Kt. Academy
Warsaw, Poland