The Kotlin world, assembled weekly, for Android engineers.
6 chapters · ordered by topic score · About & ContributingThe Kotlin world, assembled weekly, for Android engineers.
6 chapters · ordered by topic score · About & ContributingJetBrains ships a preview VS Code/Cursor extension exposing IntelliJ IDEA's Java and Kotlin language intelligence via LSP, covering completion, navigation, refactoring, and Gradle/Maven/Bazel support; a separate Apache-2.0 Kotlin LSP stays free for pure Kotlin projects.
14 stories
19 stories
11 stories
5 stories
5 stories
13 stories
4 stories
1 stories
1 stories
A five-year retrospective on Jetpack Compose highlighting LazyColumn replacing RecyclerView/DiffUtil boilerplate, AnimatedVisibility simplifying view-animation callback juggling, cheaper layout nesting versus ConstraintLayout, and Compose Multiplatform sharing composables across desktop/iOS/web.
Compares mutableStateOf and StateFlow: both expose an observable .value but come from different libraries with different machinery. Explains why Compose's snapshot state could not simply reuse StateFlow, and how each notifies readers and fits Compose vs coroutine code.
Fourth part of a Compose Runtime series explains why the runtime skips recomposition when a stable parameter's value hasn't changed, since doing no work beats doing fast work. Clarifies that stable types can still mutate, but only through observable state Compose can track, which is why @Stable/@Immutable annotations matter.
Rounds up ten Compose changes from the past year worth adopting: default pausable composition improving scroll performance, the new retain {} API for non-serializable UI-scoped objects like players, stable Navigation 3, dropShadow/innerShadow, TextFieldState, and Material 3 Expressive. Contrasts old vs new code for each.
A rundown of interview questions for senior Android roles covering Compose fundamentals: remember vs rememberSaveable, state hoisting, recomposition, CompositionLocal, LazyColumn performance, navigation, and snapshot testing. No answers are given, just prep prompts.
Walks through Android deep linking basics: custom URI schemes versus verified App Links, then a step-by-step Kotlin implementation wiring an AndroidManifest intent-filter to a Compose Navigation destination via navDeepLink so a web URL opens a specific screen directly.
Proposes splitting a bloated Compose screen ViewModel into focused 'controller' interfaces (sources, articles, search, refresh) that share one state store, avoiding a single God ViewModel while keeping one UiState and one action entry point.
A build-in-public log for a Compose Multiplatform node-based AI workflow editor targeting iOS and Android from one codebase. Covers using Compose's Canvas and gesture APIs for an infinite pannable node graph, plus expect/actual declarations to persist generated media files per platform.
Solves Compose Multiplatform components rendering at zero height inside a UIKit/Objective-C scroll view, since Compose has no intrinsicContentSize: the Kotlin side reports its measured height via onGloballyPositioned, and Swift turns that report into an Auto Layout constraint.
Walks through common mistakes Android developers make when learning Jetpack Compose, rooted in carrying an XML/View mental model into declarative UI. Covers state-as-source-of-truth, recomposition, side-effect handling (LaunchedEffect), and unidirectional data flow, with before/after code examples.
Walks through seven Compose recomposition mistakes — reading state too high in the tree, reading animated values during composition instead of layout/draw, monolithic UiState objects — each with a before/after fix using lambda-overload modifiers and derivedStateOf to shrink the invalidation blast radius.
Explains BoxWithConstraints, which uses SubcomposeLayout to expose incoming maxWidth/maxHeight before children compose, letting a composable branch into structurally different content based on available space, useful for cards inside variable-width grids. Warns it's costlier than plain modifiers and best reserved for genuine 'what to compose' decisions, not simple resizing.
Explains how the Jetpack Compose runtime tracks composable identity across recompositions using call site plus execution order, then introduces the Slot Table as the structure that stores per-composable state so recomposition resumes rather than restarts. Notes why key() matters when list order changes.
A cross-platform design reference consolidating WCAG 2.2 success criteria, Apple Human Interface Guidelines, and Material Design 3 rules into one checklist. Covers Android-specific specs: 48dp touch targets, FAB sizing, 8dp grids, dynamic color roles, and navigation component choices.
JetBrains ships a preview VS Code/Cursor extension exposing IntelliJ IDEA's Java and Kotlin language intelligence via LSP, covering completion, navigation, refactoring, and Gradle/Maven/Bazel support; a separate Apache-2.0 Kotlin LSP stays free for pure Kotlin projects.
Postmortem on building mongkn, a Kotlin/Native cinterop MongoDB driver: four silent bugs (BSON type mismatch, missing @SerialName for _id, explicit BsonNull breaking sparse indexes, string timestamps breaking TTL indexes) that passed 294 tests yet broke in production, prompting integration-test-only rules for native storage layers.
Interview with a DevSecOps engineer at a kids'-phone company on why inconsistent linting across Kotlin, TypeScript and React repos led them to adopt Qodana for unified static analysis, dependency scanning and license auditing to meet CIS/NIST security controls.
First entry in a beginner Android series arguing Kotlin developers should default to val over var, since read-only references communicate intent and prevent accidental mutation. Notes MVVM/Compose UI state models rely on val plus copy() rather than in-place mutation.
JetBrains' monthly Kotlin roundup covers Kotlin's 15th birthday celebration, a new public benchmark for AI coding agents, the 2.4.10 release, BlueJ support, and RevenueCat's Shipaton 2026 KMP app contest.
A rundown of advanced Kotlin questions asked in Staff-level Android interviews: inline/noinline/crossinline semantics, reified generics, interface and property delegation, value classes, sealed classes vs sealed interfaces, variance, type erasure, and context receivers. Frames these features as design tools for scalable APIs rather than trivia.
Walks through a real race condition where the same chat voice-note gets processed twice after arriving via both a socket event and an API sync, then fixes it with a Mutex-guarded set of in-flight message IDs instead of one global lock, preserving concurrency across independent downloads.
Compares Kotlin coroutine synchronization primitives: Mutex enforces exclusive access to a critical section (one coroutine at a time via withLock), while Semaphore caps concurrent access to N coroutines via withPermit. Warns that Semaphore(N>1) still allows race conditions since it limits concurrency, not exclusivity.
Builds a mental model for Kotlin coroutine exception handling by separating three questions per coroutine: which builder determines how failure is observed, which parent Job is affected by it, and which scope function determines where it can be caught, distinguishing cancellation from failure propagation.
Kotlin 2.4.0 made context parameters stable, letting functions declare and receive ambient values (like tenant/trace IDs) without threading them through every signature. Compares them to ThreadLocals and constructor injection, arguing context parameters suit per-call values while constructor injection still wins for per-instance dependencies.
Detekt 2.0.0-alpha.6 targets Kotlin 2.4.10, Gradle 9.6.1, AGP 9.3.1 and JDK 25; its Gradle task now runs type-resolution analysis on all Kotlin source sets by default, and the ktlint-wrapper rules module raises its minimum to JVM 17.
Explains Kotlin's val/var distinction, clarifying that val only freezes the reference (not object contents) and contrasting read-only vs mutable collections. Recommends isolating mutation to a single manager class returning copies via toList() for safer, more predictable, concurrency-friendly state.
Kotlin 2.4.20-Beta2 adds four experimental stdlib functions — allEqual, allEqualBy, allDistinct, allDistinctBy — for collections, sequences and arrays, gated behind ExperimentalStdlibApi. They replace verbose toSet()/distinct() workarounds and fix edge cases like empty-collection equality returning true instead of false.
Covers Kotlin string templates: $variable and ${expression} syntax, calling functions and filtering collections inside interpolated strings, and the common pitfall where $obj.property parses as $obj followed by literal .property text.
Explains Kotlin's by lazy delegate: single-execution, cached initialization on first access, the three LazyThreadSafetyMode options (SYNCHRONIZED, PUBLICATION, NONE), how it differs from lateinit, and a memory-leak pitfall when a lazy property captures a short-lived context.
JetBrains' August Java/Kotlin roundup links a Kotlin Corner covering Kotlin turning 15, the Exposed SQL library, Amper's current state, value semantics in Kotlin, local lifetimes, and an open-sourced KotlinLLM project, alongside broader Java news.
Explains how the JVM's G1 garbage collector organizes the heap into thousands of small regions instead of fixed young/old blocks, using Remembered Sets to track cross-region references and a special path for oversized 'humongous' objects. Also covers tricolor marking and the SATB technique G1 uses to avoid losing live objects during concurrent collection.
Beginner explainer distinguishing Kotlin's const val, val, and var: compile-time constant, read-only reference, and mutable reference respectively. Clarifies that val only locks the reference, not the underlying object, and that const val values get inlined at compile time.
Compares Flow, StateFlow, SharedFlow, and LiveData for exposing ViewModel data to Compose UIs, explaining when each fits: Flow for cold streams, StateFlow for persistent UI state, SharedFlow for one-time events, LiveData as the older lifecycle-aware alternative.
Walks through Robert Martin's five SOLID principles using Android/Kotlin examples: splitting an overloaded ViewModel into a mapper, analytics tracker, and leaner ViewModel for Single Responsibility, and replacing a payment-type when-branch with a PaymentStrategy interface for Open/Closed.
Builds a login screen using MVI on top of Unidirectional Data Flow with a three-layer Clean Architecture (Presentation/Domain/Data), comparing a flat UiState data class against a sealed UiState hierarchy, and clarifies that MVI and Clean Architecture are independent, complementary choices.
Builds the same search-and-filter screen four ways — MVVM and MVI, each with XML Views and Jetpack Compose — showing MVVM's independent StateFlows needing manual combining for derived UI state, versus MVI's single State object computing it directly and triggering fewer recompositions.
Explains MVI architecture for Compose screens: an immutable State data class, a sealed Intent hierarchy covering every user action, a ViewModel that's the sole place turning intents into new states, and a purely rendering Composable. Argues this discipline scales more predictably than scattering mutableStateOf across a screen.
Companion decision guide comparing MVVM and MVI on Android: MVVM's independent state fields are simpler for small screens but can drift out of sync, while MVI's single immutable State object is more predictable and testable but adds boilerplate. Recommends choosing per-screen rather than project-wide.
Auditing several production Android/Compose Multiplatform codebases against SOLID, the author finds Interface Segregation violations (one bloated repository interface everyone depends on) the most damaging, while Dependency Inversion via Hilt/Koin consistently pays off. Lays out a strangler-style sequence for splitting god ViewModels and god repositories without breaking consumers.
Argues that 'dispatch-style' MVI is often MVVM with a sealed-class router in front, since both write state from inside the async coroutine; contrasts it with 'reducer MVI', where a pure reduce function and a single writer make transitions atomic and cancellable.
A study guide of Android interview questions for 2-5 year developers, spanning architecture (MVVM/MVI/Clean Architecture), coroutines, Flow vs StateFlow, dependency injection, Room migrations, and API/error handling.
Describes a production Android auth architecture: encrypted token storage behind a SessionManager, mutex-guarded single-flight token refresh, a separate unauthenticated Retrofit/OkHttp client for refresh calls, and an OkHttp Authenticator that transparently retries requests once after a 401.
Describes building Redoubt Analytics, a counter-UAS risk platform with a Kotlin/Jetpack Compose Android client, a Spring Boot backend handling auth and access control, and a separate Monte Carlo simulation engine. Focuses on splitting responsibilities across the three services to serve security officers, risk officers and SOC operators differently.
Explains Android pagination strategies — offset-based, cursor-based and keyset — for large datasets like product catalogs and feeds, covering consistency trade-offs as data changes and query-performance costs of large offsets. Frames pagination as a system-design concern spanning API, architecture, caching and Paging 3 implementation.
Compares two ways to generate a 135-case snapshot-test matrix (27 screens x 5 configs) with Roborazzi: ParameterizedRobolectricTestRunner versus TestBalloon's Kotlin DSL, where suites are plain code and loops replace annotation-driven parameterization. Notes a current Android-target bug in TestBalloon's public release.
Explains automating bans on dangerous APIs like MockK's spyk, GlobalScope, and Thread.sleep via Detekt's ForbiddenMethodCall/ForbiddenImport rules, Konture architecture unit tests, or @Deprecated(level=ERROR), turning wiki guidelines into compiler/build-time guardrails.
Argues the classic testing pyramid no longer fits modern Android: Compose can render on the JVM via Robolectric, semantics-tree queries replace brittle view matching, unidirectional state makes UI logic unit-testable, and screenshot tools like Paparazzi/Roborazzi catch visual regressions cheaply. Opening chapter of a book on modern Android testing strategy.
Thumbtack's Android team describes porting 1,500 Firebase Test Lab screenshot tests to Roborazzi, a JVM-local, Robolectric-based screenshot testing framework for Compose apps. Covers batch-porting steps, a font-cache test-isolation bug across parallel Robolectric runs, and cross-OS shadow-rendering mismatches between macOS and CI.
Argues Android visual testing should pick the narrowest assertion for the requirement rather than one universal tool: UI/accessibility state for semantics, screenshot comparison for layout, OCR for localized text, and template matching for stable icons. Proposes a five-stage evidence-logging pattern for reliable checks.
Part 6 of a KMP series proposes sharing only navigation intent between Android and iOS while keeping execution native: a shared ViewModel emits sealed NavigationDestination/Effect values via SharedFlow, mapped to NavController routes on Compose and NavigationStack on SwiftUI.
Walks through evolving a single-module Android MVVM/Compose news app into SignalBrief, a Kotlin Multiplatform app with shared domain/data/presentation modules, Compose Multiplatform UI, Room KMP persistence, and Ktor+kotlinx.serialization replacing Retrofit+Gson, while keeping DI and platform hosting Android/iOS-specific.
Solo developer's account of shipping StreakShow, a photo-streak habit app, in three weeks using Kotlin Multiplatform with Compose Multiplatform for Shipaton 2026, sharing UI and ViewModels across Android and iOS. Lists three near-fatal mistakes: hidden second streak in navigation, priceless paywall, and a skipped account-deletion flow.
Measure is an open-source, self-hosted alternative to Crashlytics covering Android, iOS, Flutter, React Native and KMP with a single SDK and backend. It auto-captures gestures, navigation and network calls, attaches full session replays to every crash/ANR, and de-minifies stack traces per platform, including shared KMP code.
Details migrating a Kotlin Multiplatform price-alert app from direct Firebase Cloud Messaging to OneSignal, switching addressing from per-device tokens to an OneSignal.login(userId) identity, a config-gated no-flag-day rollout, and a durable-inbox-first delivery pattern. Covers a Kotlin/Swift closure bridge since Kotlin can't see the Swift-only OneSignal iOS SDK.
Walks through Android's Binder IPC and AIDL by building a three-module Gradle project (shared, server, client) where a Jetpack Compose app binds to a remote service via a generated Stub/Proxy pair. Explains why Binder beats sockets or HTTP for cross-process calls: kernel-verified identity, single-copy memory transfer, and automatic lifecycle cleanup.
Walks through three real production crashes: unboxing a null Boolean pulled from a Map
Walks through testing Android's private-preview App Functions API using adb (list-app-functions) and Google's Testing Agent app wired to a Gemini API key, verifying that natural-language prompts correctly trigger a registered function.
Explains Google Play's August 31, 2026 Target API Level deadline: what targetSdk/compileSdk mean, consequences of missing it, and a step-by-step checklist covering Gradle/AGP upgrades, notification permissions, scoped storage, background/foreground service limits, and staged rollout testing.
Explains Android AppFunctions, an API letting apps expose callable capabilities (e.g. createNote, addItemToShoppingList) so AI agents can invoke business logic directly instead of navigating the UI; includes the KSP/Gradle setup needed to register functions.
Recounts choosing Accessibility Service's TYPE_ACCESSIBILITY_OVERLAY window instead of the SYSTEM_ALERT_WINDOW permission flow to show a brief popup on a kiosk tablet, since the app already ran an accessibility service for text injection and gained the overlay capability for free with no runtime permission dance.
Traces how a single Android touch event travels from the kernel evdev driver through InputReader/InputDispatcher in system_server, across a Unix-socket IPC hop, into ViewRootImpl's InputStage chain, before reaching dispatchTouchEvent. Explains why onInterceptTouchEvent quirks and dropped touches during fast scrolling originate upstream of app code.
CommonsWare's Mark Murphy recounts leaving Wear OS for an open-source Pebble Time 2 after growing frustrated with Google's wearable stack, and plans to start writing Pebble apps alongside his Kotlin Multiplatform work.
Argues the classic 16ms Android frame budget only holds at 60Hz; walks through per-frame budget as 1000/refreshRate, Choreographer's skippedFrames math and its 30-frame warning threshold, and how variable refresh rate (ARR) plus Surface.setFrameRate shift the real budget at runtime.
Ten prioritized fixes for Android video rebuffering in 2026: tuning Media3's LoadControl per network class, shipping AV1+HEVC while dropping VP9 (software VP9 thermal-throttles budget chips), enabling native CMCD telemetry, and reserving low-latency HLS/DASH for genuinely latency-sensitive streams, with dev-day cost estimates per fix.
Describes how a Flutter timer app added a native Kotlin foreground service to keep countdown state accurate while the Flutter engine is paused. Uses SystemClock.elapsedRealtime() for monotonic timing, a MethodChannel bridge, and state snapshots restored on resume.
Part four of an on-device AI series covering LiteRT (formerly TensorFlow Lite), Google's edge runtime for classical ML and quantized generative models like Gemma and Llama on Android. Walks through the CompiledModel API's tensor-buffer lifecycle for image classification and BERT text classification with manual int8 quantization handling.
Explains what the Android Keystore actually guarantees — hardware-backed key material via TEE or StrongBox versus software fallback — and gives a working pattern for generating an AES-256 GCM key with KeyGenParameterSpec, plus pitfalls like ECB mode or reused key aliases.
Explains Google's Android Skills system, launched in April: modular SKILL.md instructions that auto-trigger for confirmed AI failure modes such as Navigation 2.8+ type-safe routing, AGP 9 migrations, and R8 analysis. Warns against installing too many skills due to token cost, and includes a sample AGENTS.md template.
JetBrains Academy's July roundup, flagged as covering Kotlin's 15th anniversary and the IntelliJ IDEA Conf lineup announcement. The article body was blocked by a bot-check page at fetch time, so only the headline topics from the excerpt are available.
Android Developer Relations explains why official Android Skills for AI coding agents stay narrow: they're only built for verifiable knowledge gaps in current models, such as AGP 9, Navigation 3, Camera APIs, and Perfetto SQL, since every installed skill adds token overhead. Details the eval framework used to validate each skill before release and when smaller/cheaper models still benefit from basic skills.
Recap of Kotlin Kenya & Android254 meetup #38, hosted by Terra Softworks, covering a talk on building a BLE-based smartwatch companion app (Chronos), a panel on building products users love, and a plug for DroidCon x FlutterCon Kenya 2026 tickets.
Ktor 3.5.2 release notes: RateLimit can scope limits by authentication result, ApplicationCall.isStaticContent is fixed inside plugin interceptors, ContentNegotiation handles content-type suffixes, SwaggerUI adds oauth2-redirect.html support, and kotlinx-io bumps to 0.9.1.
Argues obfuscation can't secure Android apps since APKs are always readable, and proposes a two-layer 'Reduce & Detect' model: proxy API keys server-side, require auth, minimize returned data, and enable R8 so a cracked APK yields nothing; then add RASP (Play Integrity, root/tamper detection) to raise attacker cost.
No articles match your current filters.
Try broadening your selection or reset all filters.