| Kotlin Multiplatform. Memory management old and new way | The main idea of Kotlin Multiplatform, as well as other cross-platform SDKs, is to optimize development by writing code once and share it between different platforms. However, dealing with a common code base could have some nuances that should be figured out and solved according to the platform specifics. And implementation in a common base could be really tricky. One such moment is dealing with memory management, multithreading and concurrency. KMM SDK uses the specific for every native platform version of Kotlin: Kotlin/JVM, Kotlin/JS, or Kotlin/Native. Every version includes special Kotlin language extensions, tools, and libraries specified for a particular platform.
I would like to examine the specifics of both platforms, to show the difference between Kotlin Native and Kotline JVM, what problems could be faced in providing a common solution for both platforms, and the ways to provide a working solution. And how to work with new memory management model in 1.6.0 version of Kotlin/Native |
| Maxing out SQLite performance | This talk aims at helping developers improve database and query performance, covering the nuances of SQLite (and Room, especially in a reactive android world).
Why is this important?
- Apps are increasingly storing more and more data and some of them are even becoming completely offline first.
- Screen refresh rates are continually growing, and the faster we can cook up the data to be rendered, the better it is.
What this talk will cover?
- What are Indexes and their types (single-column, multi-column, partial, covering, expression-based etc).
- Evaluating impact of indexes via examples.
- Support for indexes in Room and how to get around what Room doesn’t support yet.
- A common issue with queries in the reactive world and how to get around it.
- Pitfalls of using database views.
- (Optional) Understanding advanced SQLite features such as pragma commands - vacuum, optimize etc |
| Meet Someone New 🌍 | Match & converse one-on-one with participants for a limited time duration.
|
| In-Memory Full Text Search with Kotlin | This is a session on building an in-memory full-text-search library with Kotlin
In-Memory FTS is a technique to let users search through data that's not persisted to a database. It can be used to build powerful search experiences over ephemeral data, but it's not trivial to implement.
This session will cover how to build an in-memory full text search library in Kotlin using Coroutines and Kotlin Data Science libraries.
Topics:
- Tokenisation and Stemming of text documents
- Inverted indices for fast reverse-lookups
- Building a document processing pipeline with Kotlin Coroutines to generate full-text search indices |
| Rock-Solid UI and Instrumentation Testing | We Android developers use the "flakiness" word more than the "stability" word while talking about Espresso and Instrumentation tests. We cannot truly trust flaky tests. Instrumentation testing will continue to be part of our lives even with Jetpack Compose therefore, we need stability.
Running all UI tests before merging any code is possible, and it saves us a lot with 400+ integration tests. Unfortunately, stability is not something that comes out of the box. A certain level of architecture, proper thread usage, and test setup with helper rules are required. There is an uncountable number of things that affect UI tests.
Good thing, there are explanations and solutions for most of the flakiness. In this talk, you will learn more about best practices to increase test stability, how to utilise Test-Driven Development with UI testing, and how this will help you find bugs earlier. |
| Meet Someone New 🌍 | Match & converse one-on-one with participants for a limited time duration.
|
| Develop your app with lots of "flow" | Do you want to learn how to use Flow (and StateFlow)? Let's use it to create an musical app, to compose together a symphony, applying reactive rhymes and using as base the MVI architecture in Android. In this talk we will share this journey to create a musical app in Android, applying the latest concurrency trends from Kotlin and this beloved reactive Android architecture. We will go from the origins and basics of the architecture, its advantages (and downsides), to the current implementation using StateFlow.
|
| Don’t get stung by OWASP - An intro into writing code for greater Android Security | In this session, we will take a dive into OWASP's top threats for mobile security, the common Android security pitfalls we all succumb too and look how we may code in a more security-focused mindset going forwards.
|
| Meet Someone New 🌍 | Match & converse one-on-one with participants for a limited time duration.
|
| Guide to destroying codebases: the demise of clever code | We try to write the best code possible, simplify future maintenance, optimize for code reuse, and apply best practices and principles to help us achieve this.
However, what if this can serve as a double-edged sword?
In this talk, we'll analyze different ways and look at various examples on how through either under-use or over-use (or mis-use) of certain principles, we can inadvertantly introduce enough error surfaces, unintended complexity, or accidental coupling - that the only hope for a fix is a rewrite. |
| Android for Everyone: Accessibility in Android | Accessibility creates a better experience for everyone. Jetpack Compose simplifies development and can help us more easily build more accessible apps. In this talk, we’ll dive into some common use cases, Android Accessibility APIs, and compare these to the accessibility tools available in Jetpack Compose. We’ll also talk about general best practices, helpful tools, and how to test accessibility in your app.
|
| Meet Someone New 🌍 | Match & converse one-on-one with participants for a limited time duration.
|
| The Golden Principles of Software Architecture Applied To Kotlin Multiplatform | The purpose of this talk is to convey three important principles in software architecture (explained below) in a general way, but using code examples and case studies from a Kotlin multiplatform project to keep it relevant to most Android devs. The principles themselves are quite language/platform agnostic but the last principle is particularly relevant to multiplatform dev.
1. Separation of concerns: I will explain the kinds of code which are observed in all kinds of three layer architectures (i.e. MV-Whatever), without appealing to any particular style/pattern. The idea is to get developers to stop worrying/wasting time about whether they found "the best" architecture (which doesn't exist), and instead to find a suitable architecture based on project requirements.
2. Abstractions: I will explain different kinds of mechanisms for abstraction (interfaces, abstract classes, inheritance), and as a bonus, Kotlin multiplatform's source sets (using expect actual keywords). I will also address the issue of when you should prefer an abstraction, or simply a concrete class.
3. Framework/Library minimalism: I will explain the benefits and difficulties that come with using 3rd party libraries and frameworks versus keeping most of your codebase standard library, and isolating libraries to specific end points of the application. I will also emphasize how doing this is particularly relevant to multiplatform programming in terms of code re-use. |
| Improving Gradle Builds | As the number of modules in your code base increases, speed and consistency of your Gradle builds becomes very important. However, improving your Gradle builds can be a tricky endeavor. In this talk, I’ll address these common questions in improving Gradle builds.
- How do we benchmark & profile our builds?
- How do you read build scans to identify problems?
- How do we maintain a consistent modular structure?
- What tools can you use to speed up builds?
I’ll take a deep dive into these questions with examples and insights from my experiences |
