Talks

On the example of an ordinary button, Eugene will tell you why the layout of the interface is not as simple as it seems at first glance, and why explaining the process of creating a UI element is sometimes more complicated than talking about the algorithms of working with trees.

The talk will focus on the PyDjinni system, which serves for automatic generation of cross-language bridges C++<=>Swift and C++<=>Kotlin based on the pseudocode describing the necessary entities. This system is used to develop mobile applications for iOS and Android that have a common core written in C++. Thanks to automatic bridge generation, it is possible to save application programmers from writing a large amount of complex boilerplate code.

When there was only Firebase, everything was simple. Now the trends are changing, HMS appeared, there are regional solutions. Artem will tell you how to reach a large audience using more than just Firebase.

Sergey's talk expands on "ELM in production" from the last Mobius, where they discussed the main components of a possible UDF architecture and showed in practice how to control state complexity in UDF.

How to write in Compose for iOS and Android at once, and if JetBrains haven't added it yet — how to add it yourself. What happens when Compose draws views for both platforms.

Android SDK Extentions is one of the latest innovations of Google, which allows you to use the features of new versions of the OS on older versions of Android. In his talk Kirill will describe the whole thorny path of Google's struggle with vendors, chipmakers and developers to make Android without fragmentation and not to take all OS updates under its own control.

Maxim will tell you how sequences work under the hood and measure the gain from using them. You will find out if the rule detect CouldBeSequence is correct.

Approaches to navigation in modular projects: routing, decomposition, declarative approaches. Andrei will share practical experience from the current project of integrating deep links for modules used in different applications. He will talk about the problems they encountered and the solutions they came up with in the end.

Optimizing UI cases in Android using KSP annotations.

Mikhail will talk about how Apple's video and audio framework, AVFoundation, is set up under the hood. He will break down the basics of the library and more interesting things like: video reversal, transformations, stickers, sound effects and others.

Anatoly will talk about how to design a cold configuration system for an Android application. He will describe the existing approaches, their pros and cons. The speaker will explain how configurations should ideally work and what compromises it makes sense to make in case of a multi-module application.

A talk on how Sergey and his team applied precompiled dependencies in the form of XCFramework using CocoaPods, fastlane, GitLab CI in Tinkoff iOS projects and accelerated cold building up to 2 times by the example of Tinkoff Business project.

Speakers will talk about the principles of development and integration of soft keyboards in Android and customizing EditText for different tasks. They will look at Android SDK at the point of communication between input fields and keyboard service. Then you will hear about the reasons for possible problems with applications communication with InputMethodManager and find out how to correctly configure EditText for different scenarios. Dmitry and Vadim will describe the interactions with input fields from the keyboard application and show you how to develop your own.

Alexander will tell how they implemented Tuist in Otkritie: how to make it work in parallel with CocoaPods, how to build Avito's Independency analog on its basis, and how to set up builds caching.

Nikita will describe the new iOS camera in VKontakte and VK Clips. He will tell what API Apple provides for interacting with the system camera (AVFoundation framework) and what wrapper was written on top of that API. He will explain the construction of flow filters for camera frames and share techniques for using CoreML models for recognition. You'll learn about changing camera fps, the usefulness of the EXIF format and the Camera FOV device, as well as about ML model metering, Apple ARKit recognition, and AR Session implementation.

Alexey's talk is an attempt to look into how Compose for iOS is arranged under the hood. He will talk about what problems JetBrains engineers have to solve to make the adaptation, and what stage of development is now.

Despite the fact that modern development tools make it very easy to deliver media content into applications (XCode, Figma) developers and testers of such applications constantly face problems leading to bloat in application size or incorrect display of content, and some lead to sluggish interfaces. Sergey will talk about different tools to solve these problems, and, of course, will present the simplest and most universal one, which he wants to share with you.

The talk will present a modern view of the architecture and methodology of developing complex client applications. Here the word "client" means platform-independent (iOS, Android, Web, Qt, etc.) and "complex" implies both a client state synchronizable with the backend and multiple event sources. The main emphasis will be placed on ensuring testability (unit tests and integration tests), visibility (mapping UML diagrams to code) and flexibility (resistance to change).

Abakar will describe how their team came to have internal libraries and what purpose they were supposed to serve. He will then describe how the number of these libraries and the number of links between them grew. The public API of these libraries wasn't always intelligently designed, and that started to cause problems. The speaker will go over the major problems they encountered and show how they solved them. And at the end, he'll share the conclusions they've drawn for themselves at this point.

Evolution of a large project infrastructure with a 10-year hindsight. Multi-repository, modularity, custom build system.

Kodein in Android project. Pros and cons of the framework, graph integrity checking.

Yury will explain why it is important to pay attention to the security of all components of services, and in particular to mobile applications. The talk has a business part (about publications, application store checks, application hacking risks) and a purely technical part (about application sandboxes, encryption, myths about Flutter and other). The theory, as usual, is supported by practice and examples of real application vulnerabilities and weaknesses.

Speakers will show code with coroutines and ask what should happen in it, and listeners will choose their answers. After that, we'll run the live code and evaluate what actually happened. Then there will be a parsing of why things are the way they are. Whoever gets the most answers right wins. There will be examples with synchronization and competitive work, abolition of coroutines and non-obviousness of Kotlin Flow.

Gradle.kts is not a new technology for a long time, but not everyone has switched to it. There are different reasons: some have heard about bad performance, some have tried to migrate, but it didn't work right away. Even 5 years after the release the documentation is sparse on details and does not clarify many cases. Andrew will try to improve this situation in his talk.

How and why to choose an MVI or MVVM+ framework in 2023, what is important to pay attention to and what can easily slip away, suddenly popping up only in production.

From the talk, you'll learn why multi-repository and multi-modularity are cool, and you'll want them for yourself. The speaker will both show the problems they create and solve them right away. Particular emphasis will be on synchronizing repository changes, getting rid of dependency hell completely, and controlling the consistency of a large project.

BLE was originally conceived as a technology for low-speed data exchange. But what if we want to update the firmware on a connected device? Or collect logs? Or send a file? Then we need to squeeze the maximum speed out of BLE. This is what this talk is about: how BLE works, what parameters it has, and what to change to make it faster.

For mobile application screens, the UI of which comes from the backend, the speaker and her team came up with Backend Driven Analytics. It is stored and configured on the backend, and events are sent from the mobile app when the user interacts with the screen.

Misha analyzed different algorithms for searching communities in graphs and created a tool that became his guide in solving the modularization problem. Focusing on different metrics, you can predict how many modules your monolith would be optimal to divide into, which classes should enter them, and which modules are best to start with.

Kirill will tell how Tinkoff implemented Swift Concurrency, what requirements were set for the new tool and what alternatives were considered. He will share the best practices developed when writing code with Swift Concurrency, remind about the actor model and show how writing code for a feature can change when using it. And, of course, how to gradually migrate to this solution, what strategy to follow, and why Swift Concurrency is the future.