Schedule

We dive into the "complexity of the debug" of SwiftUI using the example of incorrect operation of the GeometryReader and LazyVStack bundle. We analyze how AttributeGraph participates in calculating the size and updating frames, and form a practical approach to diagnosing and solving such problems.

This talk demonstrates why using Metal does not always lead to performance improvements. Using an image-processing example, we’ll explore when the GPU truly wins and how to measure it correctly.

We will dive into the Codable internals, find bottlenecks, design a solution, and commit it to Swift itself!

How to make Swift great and close the children's gestalt? We will discuss ways to optimize code, work with multiplatform, UI and bindings with C++ code.

How Long Polling/WebSocket and Protobuf/JSON work from the perspective of a mobile iOS client.

How to legally run an alternative App Store in EU/Japan: from DMA and Apple's docs to MarketplaceKit and real-world cases from Onside.

PWA as Plan B: a story of how we lost the App Store but kept our users. Technical pitfalls, architectural decisions, and unexpected perks of a forced migration to the web.

We’ll look at how to investigate any macOS application using the native LLDB debugger and a few supporting tools. Through practical examples, we’ll analyze system applications, uncover non-obvious behavior, and carefully tweak it via code injection.

What has changed, how to work with it, and what are the prospects for using Swift at Android.

Using Compose Multiplatform, we will write a small internal corporate task tracker application for several users with different roles. Finally, it will be possible to run not only on Android and iOS, but also on the Aurora OS.

CMP is a growing framework for cross-platform development, adapted by the Open Mobile Platform team for the Aurora OS. We will examine the approach to adapting CMP, how it differs from Flutter, and the tools available for development on the Aurora OS.

Let's talk how to add releaseless business logic to the Server Driven UI using Kotlin Multiplatform.

A session in the format of a level-by-level game will show how algorithmic interviews work and what skills need to be upgraded in order to pass each stage of the selection process.

Is it possible to use Rust in mobile app development?

We suffered from 20 minutes of IDE Sync and seven minutes of pure Android debug build on a KMP project with a million lines of code. We didn't find any available boxed solutions on how to reliably measure build optimizations, so we made our own Frankenstein out of open source and self-made stuff.

I'll show you how to turn vague design requirements into optimization tasks with a measurable quality function, explicit constraints, and a predictable solution search algorithm.

In the talk, we will analyze how we implemented mobile pipeline failure point monitoring at Tutu, learned how to automatically classify the causes of crashes using AI, and divided responsibility into Dev, Core, and External levels. I will show you how the introduction of pipeline stability SLAs and nightly reports from LLM help not only resolve incidents faster, but also plan infrastructure development for the coming quarters.

Let's look at what smoothness is in a mobile app and what metrics to measure it with (and why FPS alone is often not enough). Let's see a case study: how measurements found a bottleneck in the product scenario and improved the metrics.

How to solve the problem of different development speed in a large mobile application.

A 700,000-line mono project—why is it cool and how to live with it?

We will explain and show how the compilation and execution of application code in Android work under the hood and how baseline profiles are related to this.

Shared animations are increasingly becoming not just a decoration, but a required part of the design.

I'll share how we at Drinkit implemented unusual Shared Transitions with blur in Compose and why there's no reason to be afraid of this instrument.

Why HashMap isn't the best choice for Android, and how the Swiss Table architecture in ScatterMap addresses memory and performance issues through open addressing, metadata grouping, and SIMD emulation on the JVM.

How to transform an AI agent from a local tool into a personal autonomous developer assistant.

I'll tell you how to bring an agent to the server, set up isolation and security, and organize the process so that it performs tasks independently and in parallel, without competing for resources and without being tied to your working time.

The hidden risks of implicit actions when building Android applications and the implementation of the shift left approach for early error detection through automated checks.

The talk is about the work of isolates and the garbage collector in Dart VM, the connection of isolates with OS threads and restrictions on their number.