Schedule

LGM, the large guessing models, are already able to write code based on our description. But how to understand and control the result if reading the generated code becomes less meaningful?

An artifact of the design may not be a layout in a graphical editor, but a live prototype based on real components of the design system, which the agent generates from the product and then distills into native code. This is how the two slowest stages of mobile development — creating a design and transferring it to code — cease to be the bottleneck of the e2e pipeline.

How we built build metrics for a monorepo with 416 modules, caught our own dashboards in a lie several times — and why the real culprits behind slow builds turned out to be nowhere near where we were looking.

It is not a trivial task to fully automatically migrate an Android app to HarmonyOS NEXT: the platforms differ too much in architecture. I will show how it is possible to transpile Kotlin and Jetpack Compose into ArkTS and ArkUI using SMT solvers, and explain why it is still important for an engineer to understand mathematics in the era of AI.

A talk for mobile developers who want to do beautiful things and understand what's going on under the hood of rendering.

If AI has already accelerated your development, but your CI is still unaware, I’ll tell you what steps to replicate in your own work and where to draw the line between AI and human intervention in advance.

We will analyze Apple's new SDK for WebAssembly, its capabilities and goals, compare it with KMP, discuss the potential circumvention of iOS restrictions and whether developers should invest time in this area.

Second part of the story from Compose-alpha on Aurora OS: using the example of a real multimodule Effective-Office KMP application, let's look at what moves almost without edits and what becomes a blocker — from libraries without linux-native assemblies (multiplatform-settings, Coil, Calf UI, Decompose) to choosing between the port of the existing UI and the new one. by the client on top of the shared core.

In code, null means not only "no value", but also "invalid", "not found", "wrong phase of the Moon" — and it costs the team hours of debugging per week. I will show where these hidden meanings come from and how to get rid of them so that null checks stop being tech debt.

Do you know how much money your company burned this week because a deeplink opened the wrong screen? We didn't either and once we learned to count it, we saved the company a lot of money. I'll show the process, the tests, and the click tracing that made it possible.

How to launch a cross-platform messenger with Kotlin Multiplatform while keeping a native iOS layer with SwiftUI. Key trade-offs, architectural decisions, and practical lessons on maintaining a clean and scalable codebase.

I’ll explain how to implement a single business logic layer for a media player using Kotlin Multiplatform while preserving native behavior on Android and iOS.

If you add pan/zoom to Compose head-on on large images, you are guaranteed to experience crashes and lags. The talk reveals the main problems and gives an understanding of how to deal with them, as well as the general model of working with large images in Compose. The live demo shows how to get from a crash to a stable and smooth picture.

How to turn the performance of an Android app from a set of subjective feelings into a measurable engineering process?

Using an end-to-end electronic document reading failure, we will trace the path from the MRZ, PACE/BAC, and APDUs through IsoDep and the Android NFC stack to NCI/NFCC and the RF link. We will use SDK logs and an NCI trace to localize TagLostException and distinguish safe session recovery from retries and timeout changes that merely hide the failure.

We will show how deep customization of ExoPlayer through smart adjustment of the estimator, viewport and buffers allowed VK to significantly reduce playback delays. An in-depth analysis shows that even the standard settings, when properly adapted to the types of networks and devices, give a huge increase in UX.

Let's use the MAX messenger as an example to show how to measure energy consumption using only the Android SDK, without any third-party libraries.

Using the Swinject example, I will show an approach that reduced the overhead of DI at the start of our application by 10 times: without rewriting the application and without changing the architecture, because only the internals of the container itself change.

We'll take Liquid Glass apart and rebuild it using Metal. From the anatomy of the effect to interactive animations and integration into Telegram.

We will analyze the mechanisms for obtaining the decrypted ipa, decompiling it, patching, reassembling and debugging on the device or in the simulator.

What is needed for a small local LLM to stop being just a chatbot and turn into a character that sees the screen, understands the context, and reacts to what is happening?

We're all used to time series analysis being Python and its classic stack — statsmodels, sklearn, numpy, and the rest. This ecosystem has become the de facto standard, and it works perfectly — on a server with plenty of memory and compute power. But what if your app has to work offline, without any server access? What if the user needs data insights at every single moment, regardless of connection?

How does Kotlin Flow work under the hood, and why are some of its implementations simple, while others require complex algorithmic solutions?