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!

We will encounter performance issues in a SwiftUI project, learn how to analyze symptoms using Xcode Instruments, and fix these bottlenecks by revisiting the theory.

Let's explore how thermal state affects the user experience of iOS apps: from the metrics of playable sessions to the smoothness and responsiveness of the app, including approaches to data collection and aggregation, as well as analysis of heating effects based on real-world Okko scenarios.

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

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.

I'll show you how to start using AI tools, in particular Claude Code, in your project.

I'll show you exactly what tools Claude Code provides, tell you how they can be useful to you in your daily work and how to start using them, share potential problems that may arise when working with AI and how to deal with them.

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.

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.

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.

Introduction to Rust and its usage 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.