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.

I'll tell you about Personal AI Workspace (PAIW).

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'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?

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.

I will talk about ast-index, a Rust CLI for structural code indexing through a tree-sitter and SQLite/FTS5.

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.

How to use T-shape for engineering development and what it brings to the team.

Learn how to transform heavy Liquid Glass into a highly performant, predictable part of your design system without relying on third-party libraries. We’ll explore how to leverage the Android rendering pipeline, implement smart fallbacks for low-end devices, and gain architectural control over complex UI effects.

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

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

Let's look at how to implement AI in development without legal risks, including real cases of leaks and dismissals, as well as actions in the absence of regulations.

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

IT is unstable: artificial intelligence, politics, crises, the acceleration of life. Where will our ship take us? Let’s try to figure it out, looking at the intersections of history, economics, and trending technologies.

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

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.

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.

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.

The analysis of popular MCP servers from the perspective of token consumption and implementation quality, as well as a comparison with an alternative — lightweight Skills wrappers over CLI utilities.

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.

Let’s look into the history of the AI hype, what it led to, and look at the best practices that have emerged in the field of AI use.

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

How does a UI framework work under the hood, and what do you need to create your own?

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.

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.

Beyond Copilot: how we at RWB automated the process from task definition to MR in development using a task orchestrator and a network of specialized AI agents.

Applied cases of AI adoption in development at Cian: from UI tests and turnkey screens built without our involvement to using ML algorithms for static checks of the app.

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.

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.

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?

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.