# YAZIO

The official Yazio publication on Medium. We write about technologies that excite us. Also: we are hiring! Join us on https://jobs.yazio.com - Medium

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Automating feature-flag cleanup at Yazio: from a prompt to CI

DevFeed: [Automating feature-flag cleanup at Yazio: from a prompt to CI](<https://devfeed.tech/articles/automating-feature-flag-cleanup-at-yazio-from-a-prompt-to-ci-117999.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/automating-feature-flag-cleanup-at-yazio-from-a-prompt-to-ci-8692fe823570?source=rss----65bd178b00af---4>)

Author: Artem Zasypalov

Published: 2026-11-04T08:29:23Z

Content type: article

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [jira](<https://devfeed.tech/topics/jira.md>)

Tags: [a-b-testing](<https://devfeed.tech/tags/a-b-testing.md>), [ab-testing](<https://devfeed.tech/tags/ab-testing.md>), [agentic-workflow](<https://devfeed.tech/tags/agentic-workflow.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [automation](<https://devfeed.tech/tags/automation.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cleanup](<https://devfeed.tech/tags/cleanup.md>), [feature](<https://devfeed.tech/tags/feature.md>), [flag](<https://devfeed.tech/tags/flag.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [workflow-automation](<https://devfeed.tech/tags/workflow-automation.md>)

### AI overview

Yazio automated feature flag removal from a manually prepared engineering task to a GitHub CI workflow that handles cleanup through opening a PR, with human oversight retained for merging. A Product Manager's removal decision starts the process; the agent removes flags and prepares changes, while a review agent gives a preliminary review. Reliability changes let the workflow process multiple flags sequentially with a fresh agent context and separate commit for each. It reads the Jira decision alongside Growthbook results and skips a flag when they conflict. Failures, skipped flags, gate errors, and successful PR links are reported in Jira. Over almost a year, the workflow created 237 tasks across mobile squads. Median time from cleanup initiation to PR creation fell from 32 days before the local prompt, to 17 days with the local prompt or skill, and 5 days with CI. A successful CI run takes about 15 minutes and removes a median 243 lines across 7 files. The article says the latest reliability improvements had been running only about ten days, so their backlog effect was not yet clear.

### Source excerpt

Photo by Franck V. on Unsplash Remember those days when we thought robots and AI were supposed to take care of tedious things nobody wanted to do? Like washing dishes, taking out the rubbish? My team and I have been working to give AI a less physical version of that job: cleaning up after A/B tests. With more things being automated, we are expected to accomplish more as automatable work is often considered at least half done. There is truth to it. But it also means our context switching becomes the norm. A truly useful automation should preserve the focus of engineers as long as possible, meaning it should be able to act trustworthily without approval for as long as possible within the workflow. At the same time, critical stages should still be approved by a human. The definition of the critical stage might change over the next years with further advancements in AI and autonomous software development. Right now at Yazio, we consider merging a PR a critical stage that should be done under a human's oversight. We started experimenting with automated workflows that include AI coding agents over a year ago. Feature flag cleanup was one of the first ones for us to automate. Over several iterations, this effort has grown from a small 64-line prompt into an autonomous workflow, with an engineer only at the critical stage. I'd like to share our journey. Where cleanup starts Our A/B testing lifecycle has 3 core stages: Preparation, Running, and Cleanup. The Cleanup stage begins when the Product Manager chooses one of the 3 options after the test is stopped: 📦 Keep the flag if it still serves a purpose, for example, a feature config. 🔄 Update the code default if we want to roll out a variation as the new baseline while keeping the flag for another iteration. 🗑 Remove the flag if we decide to roll out one variation permanently. The workflow we designed covers the third case. The old process required me or someone else to pick up the A/B ticket, create an engineering task to r

## Building AI features isn't scary

DevFeed: [Building AI features isn't scary](<https://devfeed.tech/articles/building-ai-features-isn-t-scary-24741.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/building-ai-features-isnt-scary-92817564e364?source=rss----65bd178b00af---4>)

Author: Paul Woitaschek

Published: 2026-07-17T11:49:09Z

Content type: article

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [ai-on-mobile](<https://devfeed.tech/topics/ai-on-mobile.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-features](<https://devfeed.tech/tags/ai-features.md>), [android](<https://devfeed.tech/tags/android.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [backend](<https://devfeed.tech/tags/backend.md>), [building](<https://devfeed.tech/tags/building.md>), [define](<https://devfeed.tech/tags/define.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [developers](<https://devfeed.tech/tags/developers.md>), [example](<https://devfeed.tech/tags/example.md>), [fast](<https://devfeed.tech/tags/fast.md>), [feature](<https://devfeed.tech/tags/feature.md>), [features](<https://devfeed.tech/tags/features.md>), [food](<https://devfeed.tech/tags/food.md>), [implement](<https://devfeed.tech/tags/implement.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [input](<https://devfeed.tech/tags/input.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [llm](<https://devfeed.tech/tags/llm.md>), [mobile-app-development](<https://devfeed.tech/tags/mobile-app-development.md>)

### AI overview

The article recommends defining a typed Kotlin contract and building the real UI first, then iterating on a Koog parser locally in debug builds before moving the prompt and parser to a server. Local iteration lets developers judge spoken input, action cards, and latency in the app; a fake parser can support UI work meanwhile. The API key must stay server-side in release builds, though the article describes using a local key from uncommitted local.properties during debugging. Once outputs are stable, Kotlin backends can reuse the DTOs, prompt, and Koog call; other backend languages can port the prompt and schema. The workflow speeds development but does not replace post-launch evaluation: the article recommends defining behavior measures such as confirmed versus deleted actions and manual-tracking fallback, then testing changes with real user data.

### Source excerpt

TLDR: Define the interface in the app, iterate locally with Koog, move the logic to the backend when it's done. AI features have a weird reputation among mobile developers. The model sits behind an API, the prompt lives on a server someone else owns, and every change means a ticket, a review, a deploy. So the whole topic feels like backend territory. But an AI feature is just a feature. Text in, structured data out, some logic in between. The only unusual part: the core of that logic is a prompt. And prompts are not designed, they are iterated. You try an input, look at the output, adjust, try again. Dozens of times. So the real problem is not building the feature. It's making that loop fast. The pattern I would like to show: define an interface in the app, build the real UI against it, implement it locally with Koog, iterate until the output is solid, then move the implementation to the backend. In Kotlin that last step is mostly copy paste. The example: track everything in one sentence We build Yazio, a nutrition tracking app, as Kotlin Multiplatform: one shared codebase for iOS and Android. That matters here, because everything below is written once and runs on both platforms. Tracking today is many small interactions: search a food, pick a portion, add water, log a workout. Now imagine the user just says what happened: "I had two scrambled eggs and a coffee for breakfast, drank half a liter of water, went for a 30 minute run, and for lunch I ate the same as yesterday."Users can track using voice The app answers with a list of proposed actions. The user deletes the wrong ones, speaks again to add what's missing, and confirms everything at once. Speech to text is solved on both platforms, so from our side the input is just a string. Messy natural language in, exact typed data out. That's what LLMs are good at. It's also the kind of logic you won't get right on the first try. The constraint: the key can't live in the app You can't ship an OpenAI or Anthropic API ke

## Configurable Features using Kotlin Multiplatform

DevFeed: [Configurable Features using Kotlin Multiplatform](<https://devfeed.tech/articles/configurable-features-using-kotlin-multiplatform-24742.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/configurable-features-using-kotlin-multiplatform-12e7c1c57221?source=rss----65bd178b00af---4>)

Author: Artem Zasypalov

Published: 2023-09-01T06:55:38Z

Content type: article

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [No-code](<https://devfeed.tech/topics/no-code.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>)

Tags: [all](<https://devfeed.tech/tags/all.md>), [app](<https://devfeed.tech/tags/app.md>), [approach](<https://devfeed.tech/tags/approach.md>), [business](<https://devfeed.tech/tags/business.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [changes](<https://devfeed.tech/tags/changes.md>), [client](<https://devfeed.tech/tags/client.md>), [client-library](<https://devfeed.tech/tags/client-library.md>), [code](<https://devfeed.tech/tags/code.md>), [comes](<https://devfeed.tech/tags/comes.md>), [compose](<https://devfeed.tech/tags/compose.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [feature-engineering](<https://devfeed.tech/tags/feature-engineering.md>), [features](<https://devfeed.tech/tags/features.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [mobile-app-development](<https://devfeed.tech/tags/mobile-app-development.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [product-development](<https://devfeed.tech/tags/product-development.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [using](<https://devfeed.tech/tags/using.md>)

### AI overview

YAZIO made onboarding flows configurable so the Product team can change content and screen sequences without code changes, as long as changes use existing Screen Types (each a layout and business logic combination). A Compose Desktop Flow Configurator lets users assemble screen instances, add branching, and export configurations for the mobile app. Flow data structures and validations live in a multiplatform module shared with the KMM client library, providing a single source of truth. Validation checks for cycles, unreachable questions, and correct tracking and content IDs to reduce the risk of configurator mistakes breaking the app. The excerpt says the client-side design is scalable, but cuts off before explaining how.

### Source excerpt

At YAZIO we love working efficiently. All business logic of our app's new features is written using Kotlin Multiplatform, and we share its code up to the ViewModels. This approach reduces engineering effort, increases stability, and conserves resources. We are always on the lookout for the next step. Some screens and even entire features require swift reactions in changing situations to provide the highest level of experience to our users. The first candidate was Onboarding. Our creative Product Team strives for excellence in first user impressions, meaning that changes in this part of the app occur more frequently than in others. That's why our Development department decided to make this feature not just flexible for content changes, but fully configurable. This means that engineering effort will be reduced to zero for changes that involve only existing Screen Types. Here comes our first term. A Screen Type is a combination of layout and business logic used for the screen in a Flow. And a Flow is a sequence of screens presented to a user in the feature. Our goal was to provide the Product team with a way to construct Flows and use them in the app without code changes. We took advantage of Kotlin Multiplatform again. First, we decided to have a single source of truth for both the app and the Flow Configurator. Configuration data structures and their validations are in a separate multiplatform module. This module is shared between our KMM client library with business logic and the Compose Desktop Flow Configurator app. In the Configurator, we can use our Screen Types to create screen instances and connect them to construct a Flow, create branching to cover all user's questions and concerns, and experiment with content and screen sequences. The saved configuration is then exported and used in the YAZIO mobile app. By delegating responsibility for screen sequences and content, we didn't neglect the safety of our solution. Each flow undergoes a series of validations to

## Why we decided on Kotlin in our Data Engineering architecture

DevFeed: [Why we decided on Kotlin in our Data Engineering architecture](<https://devfeed.tech/articles/why-we-decided-on-kotlin-in-our-data-engineering-architecture-24748.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/why-we-decided-on-kotlin-in-our-data-engineering-architecture-36adddb349cc?source=rss----65bd178b00af---4>)

Author: Dominik Liebler

Published: 2023-03-13T10:27:51Z

Content type: opinion

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Python](<https://devfeed.tech/topics/python.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [elt](<https://devfeed.tech/topics/elt.md>)

Tags: [2021](<https://devfeed.tech/tags/2021.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [data](<https://devfeed.tech/tags/data.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [language](<https://devfeed.tech/tags/language.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [production](<https://devfeed.tech/tags/production.md>), [python](<https://devfeed.tech/tags/python.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

The team chose Kotlin for much of its data engineering work after basic Python errors and unenforced type hints made their existing process frustrating. Kotlin's static types, paired with Avro-generated classes, can catch mismatched record types at compile time; JVM libraries also support Parquet writing across S3, GCS, and local filesystems. Other reasons included Kotlin Multiplatform code sharing, prior production experience, stability, and hiring prospects. The team did not choose Scala, which it viewed as less common outside data engineering, or Java, citing slow adoption of newer language versions. Python remains part of the architecture for tools such as Dagster, Great Expectations, and dbt. The excerpt presents Kotlin as an added safety boundary, not a replacement for Python.

### Source excerpt

Choosing or changing a software architecture is not an easy task -- it requires careful consideration of many factors. The decision can have long-lasting effects on the development process, maintenance, and scalability of the system but also on developer happiness and employer churn rate -- nobody likes working with bad legacy code or fixing architectures not scaling well to the needs of an organisation. Photo by 30daysreplay on Unsplash Turn back time to 2021 and you'd see some basic Kotlin code, a pile of Python, and some SQL as well as a lot of YAML for Kubernetes resources in our tech stack. At this point in time the team already had a lot of experience in building software in general and data systems like ETLs in particular but we weren't very happy about the current process and most of all with Python. Although it allowed us to quickly ingest new data from HTTP APIs, we often experienced bugs in our software that were very basic: an AttributeError here, an edge case resulting in a KeyError there -- typical things that can be prevented at compile time in another language. What about a typed language then? We tried annotating our code with type hints using the typing package, but they weren't enforced by the interpreter at runtime anyway and can only really be helpful if PyPi packages also provide typings. Photo by Samuel Schroth on Unsplash As mentioned earlier we already had some Kotlin code running in production due to the fact that we share code with our mobile clients for iOS as well as Android (using Kotlin Multiplatform) and we were very pleased with it. Also as most of the team already had prior experience running Kotlin backend services in production, we decided to go all-in on Kotlin (where possible™). These are the reasons why we think it's a good idea to this day: stability and consistency ability to use the vast amount of libraries for the JVM being able to share code (for event tracking) using Kotlin Multiplatform previous positive experience running

## Speeding up Kotlin Multiplatform

DevFeed: [Speeding up Kotlin Multiplatform](<https://devfeed.tech/articles/speeding-up-kotlin-multiplatform-24747.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/speeding-up-kotlin-multiplatform-61ebf8dae560?source=rss----65bd178b00af---4>)

Author: Paul Woitaschek

Published: 2022-05-18T09:11:24Z

Content type: tutorial

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [multiplatform](<https://devfeed.tech/topics/multiplatform.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>)

Tags: [3](<https://devfeed.tech/tags/3.md>), [all](<https://devfeed.tech/tags/all.md>), [allows](<https://devfeed.tech/tags/allows.md>), [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [app](<https://devfeed.tech/tags/app.md>), [apple](<https://devfeed.tech/tags/apple.md>), [benefit](<https://devfeed.tech/tags/benefit.md>), [build](<https://devfeed.tech/tags/build.md>), [build-times](<https://devfeed.tech/tags/build-times.md>), [business](<https://devfeed.tech/tags/business.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [but](<https://devfeed.tech/tags/but.md>), [cache](<https://devfeed.tech/tags/cache.md>), [can](<https://devfeed.tech/tags/can.md>), [change](<https://devfeed.tech/tags/change.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kotlin-native](<https://devfeed.tech/tags/kotlin-native.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [up](<https://devfeed.tech/tags/up.md>)

### AI overview

YAZIO reports that its Kotlin Multiplatform project had 70+ Gradle modules and took six minutes to sync after adding a module, despite using newer MacBook Pros. Because developers usually work in commonMain, they reduce sync overhead by conditionally omitting Apple targets during development; those targets had the greatest reported effect, attributed to the Commonizer, large native distributions, and IDE classpath handling. With iOS targets omitted, Gradle Configuration Cache becomes usable, speeding builds and tests. For unresolved classes in Android Studio, the team says switching to IntelliJ often fixes the issue. The excerpt notes that target removal improves workflow but does not make sync blazingly fast, and that Kotlin Multiplatform was then incompatible with Configuration Cache when iOS targets were enabled.

### Source excerpt

At YAZIO we are heavily investing into Kotlin Multiplatform and use Kotlin to share all business logic between the iOS and the Android App. Naturally this also leads to a lot of code. Since we modularize our software properly to achieve encapsulation and fast incremental build times, it also means a lot of Gradle modules. 70 modules and counting, to be more precise. And for Kotlin Multiplatform, a lot of Gradle modules means a very long Gradle Sync and IDE indexing time. We tried to mitigate some of that by switching to the latest Macbook Pros, which helped quite a bit. But with all the targets we have (1x Android, 3 x iOS, 4 x watchOS), it still takes 6 minutes for Gradle to sync after adding a new Gradle module. This is a very long time, and worse: It encourages developers to not change any build logic at all and leads to them not adding any more modules. Is moving these files into their own module really worth the six-minute wait?Selectively removing targets The idea here is simple: Fewer targets -- less sync time. We rarely need to touch the platform-specific source sets anyway and 99% of the time, we are developing solely in commonMain . This means that while developing, we can just remove the Apple targets. And it turns out: Apple targets have the most effect on sync times. This is due to the Commonizer, large native distributions and a complicated mechanism that allows you to see what's in your classpath from within the IDE. This is pretty simple to implement. First, add a new property to your gradle.properties file: https://medium.com/media/389dc8cfc03487a54eaeb6f2c62a81f9/href Now, in your build.gradle.kts file(s), simply check for that property before creating the native targets. https://medium.com/media/330ad55c6d767fbd4bfcb96822dc4639/href Et voilà -- it's not blazingly fast, but at least we can work with it. Bonus: Configuration Cache 🎉 The other big benefit that we can now make use of is Gradles Configuration Cache. With the iOS targets, Kotlin Multiplat

## Data Binding: BindingAdapter

DevFeed: [Data Binding: BindingAdapter](<https://devfeed.tech/articles/data-binding-bindingadapter-24743.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/data-binding-bindingadapter-7d0824b1efff?source=rss----65bd178b00af---4>)

Author: Paul Woitaschek

Published: 2021-11-19T08:06:16Z

Content type: tutorial

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>)

Tags: [adapter](<https://devfeed.tech/tags/adapter.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [app](<https://devfeed.tech/tags/app.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [code](<https://devfeed.tech/tags/code.md>), [color](<https://devfeed.tech/tags/color.md>), [data](<https://devfeed.tech/tags/data.md>), [define](<https://devfeed.tech/tags/define.md>), [flag](<https://devfeed.tech/tags/flag.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [html](<https://devfeed.tech/tags/html.md>), [https](<https://devfeed.tech/tags/https.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [library](<https://devfeed.tech/tags/library.md>), [light](<https://devfeed.tech/tags/light.md>), [material](<https://devfeed.tech/tags/material.md>), [model](<https://devfeed.tech/tags/model.md>), [notes](<https://devfeed.tech/tags/notes.md>), [recyclerview](<https://devfeed.tech/tags/recyclerview.md>)

### AI overview

Using Android Data Binding in a RecyclerView ViewHolder reportedly cut boilerplate by about 50%. To apply strike-through based on a model value without calling `findViewById`, the author defines a static method annotated with `@BindingAdapter`; it adds or removes `Paint.STRIKE_THRU_TEXT_FLAG` on a `TextView`. The layout then binds `model.done()` through a strike attribute. The excerpt also notes that setting `android:enabled` from the inverse of that value made the text grey with the support-library text color.

### Source excerpt

For a long time I did not investigate further into https://developer.android.com/tools/data-binding/guide.html but recently it just got my attention. Just like Kotlin or RxJava this was something that was constantly trying to get my attention so I decided to give it a try and to see how it works while writing my new notes app. And I must say: I'm impressed. I applied it on the ViewHolder of my RecyclerView and reduced the boilerplate code by about 50%. But there were some issues. Issues The biggest I had was manipulating the view. The grey text could be simply archieved by setting the view enabled based on the view model: android:enabled="@{!model.done()}" As the text was set to @color/abc_primary_text_material_light from the support library this automatically works. But how to set the strike through? I did not wanted to call all these `findViewById` any more as that would defeat the purpose of DataBinding. Solution It turned out there was a simple solution, called BindingAdapter> https://developer.android.com/reference/android/databinding/BindingAdapter.html Basically you just define a static method and annotate it as a binding adapter. So for strikeThrough it is: @BindingAdapter("text:strike") public static void setStrike(TextView text, boolean strike) { if (strike) { text.setPaintFlags(text.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); } else { text.setPaintFlags(text.getPaintFlags() & ~Paint.STRIKE_THRU_TEXT_FLAG); } } So now you can set it just as a regular xml attribute: android:strike="@{model.done()}" Data Binding: BindingAdapter was originally published in Yazio Engineering on Medium, where people are continuing the conversation by highlighting and responding to this story.

## Kotlin Native -- Using swift, not Objective-C

DevFeed: [Kotlin Native -- Using swift, not Objective-C](<https://devfeed.tech/articles/kotlin-native-using-swift-not-objective-c-24746.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/kotlin-native-using-swift-not-objective-c-d7742c040539?source=rss----65bd178b00af---4>)

Author: Paul Woitaschek

Published: 2021-11-19T08:00:42Z

Content type: article

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [Objective-C](<https://devfeed.tech/topics/objective-c.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [enums](<https://devfeed.tech/tags/enums.md>), [interop](<https://devfeed.tech/tags/interop.md>), [ios](<https://devfeed.tech/tags/ios.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kotlin-native](<https://devfeed.tech/tags/kotlin-native.md>), [ksp](<https://devfeed.tech/tags/ksp.md>), [library](<https://devfeed.tech/tags/library.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [objective-c](<https://devfeed.tech/tags/objective-c.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [swift](<https://devfeed.tech/tags/swift.md>)

### AI overview

YAZIO uses Kotlin Native for shared feature logic, but Kotlin types exposed through Objective-C do not provide the Swift-native structs, property types, enums, or sealed classes its iOS API needs. The team has been manually mapping the public API into Swift, which produces a clean interface but adds substantial boilerplate. The excerpt proposes generating those mappings: KSP analyzes Kotlin syntax and provides hooks for code generation, while SwiftPoet generates Swift code. It describes an example that selects annotated classes, derives an enum name, converts contained declarations into enum cases, and writes a Swift file. The excerpt ends during setup guidance, so it does not establish the full implementation or its results.

### Source excerpt

Kotlin Native -- Using Swift, not Objective-C At YAZIO we use Kotlin Native Extensively. The business logic of all new app features is exclusively written in Kotlin. In its core, every screen has one ViewModel which exposes a single Flow<ViewState> that the Android App and the iOS can consume to render the state. On Android, rendering the view state is no burden because it's the language we use in the Android App anyways. However this is different for iOS. While Swift does interop with Objective-C, the public API as seen from Swift is bad. A simple data class is exported as a regular class. The properties are not native Swift types. What should be a Bool becomes a KotlinBoolean. What should be come a Double becomes a KotlinDouble. But what we want is most of the times a struct with Swift types. These are the lesser evils, the greater ones are enums and sealed classes. In Objective-C, they both become regular classes. And therefore lose all the advantages they have when used from Swift. But what we want is a Swift enum. To overcome these restrictions for quite some time our iOS team has created mappings. There is a whole target, dedicated to mapping the Objective-C classes to Swift. Basically when developing a new feature, the whole public API is manually mapped to Swift. This is good because the result is a clean Swift-native API. But that's bad because it's extreme boilerplate and a real productivity killer. What if we could directly generate these mappings and use code generation to handle that for us? Turns out: There are two tools available that make it possible. The first one is KSP. It is basically a library that lets you implement a Kotlin compiler plugin and it gives you hooks to analyze the Kotlin Syntax Tree and generate code based on it. The second one is SwiftPoet. SwiftPoet is a library you can use to generate Swift code from Kotlin, similar to what KotlinPoet and JavaPoet do. Okay, let's get our handy dirty. For the basic setup, just follow the tutorial

## How to break your Android App with proguard / R8

DevFeed: [How to break your Android App with proguard / R8](<https://devfeed.tech/articles/how-to-break-your-android-app-with-proguard-r8-24744.md>)

Original publisher: [Read original article](<https://medium.com/yazio-engineering/how-to-break-your-android-app-with-proguard-r8-6566bc387b63?source=rss----65bd178b00af---4>)

Author: Paul Woitaschek

Published: 2021-03-02T15:19:22Z

Content type: article

Language: en

Sources: [YAZIO](<https://devfeed.tech/sources/yazio-engineering-medium.md>)

Topics: [R8](<https://devfeed.tech/topics/r8.md>), [proguard](<https://devfeed.tech/topics/proguard.md>), [Android Testing](<https://devfeed.tech/topics/android-testing.md>), [Android](<https://devfeed.tech/topics/android.md>), [Android Gradle Plugin](<https://devfeed.tech/topics/android-gradle-plugin.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [app](<https://devfeed.tech/tags/app.md>), [proguard](<https://devfeed.tech/tags/proguard.md>), [r8](<https://devfeed.tech/tags/r8.md>)

### AI overview

A broad R8/ProGuard rule, `-assumenosideeffects class android.util.Log { public *; }`, can affect inherited public methods as well as logging calls. The article reports that this includes synchronization methods on `Object`, such as `notify`, potentially breaking app synchronization and causing hangs. It recommends avoiding `*` wildcards with `-assumenosideeffects` and specifying the logging signatures explicitly (`v`, `d`, `i`, `w`, `e`, and `println`) when removing production log calls. The author also warns that the issue can enter an app through a library's consumer ProGuard rules.

### Source excerpt

I recently updated the android gradle plugin to 4.0.0. While developing, everything went smoothly and at some point I was ready to cut a release. The very last manual testing of the release app bundle was also fine so no Proguard / R8 issues on the first sight either. Then I thought: Let me check the CI results again. Everything was fine, but: The instrumentation tests. Almost all of them were timing out. After inspecting the logs, they all hang at the end of the on-boarding. Strangely the loading spinner was loading for way longer than the timeout should be. So I tested it on my phone and faced the same results. At that time I had no idea it was caused by updating AGP, so I did a 2 hours long git bisect. Okay, now lets create a minimal self reproducible bug report because I found a huge bug in AGP, everyone should know about immediately. I created a Hello World project that was making a single network call and printed it results into a TextView. Strangely here it did not reproduce. After experimenting with the OkHttp configuration and testing if it was related to some gradle plugin, I finally had the idea that it might be related to R8. So I added my proguard configuration and now the network call hang! Let's locate the issue further. I was step by step removing lines from my proguard configuration until only a single line was left: -assumenosideeffects class android.util.Log { public * ; } Now what is this? How is that even slightly related to anything? It should remove the log spam of some third party libraries we're using. So I was asking Mads Ager. (he works on D8/R8) you have to be very careful with -assumenosideeffects The problem is that in order for -assumenosideeffects to have the effect of actually removing calls, it matches up the class hierarchy. Therefore, this rule says that anything public in android.util.Log and its superclasses has no side-effects. That include the synchronization methods defined on Object. So, please don't use * wildcards in conne