每日新聞摘要

Kotlin Weekly #489 (14 December 2025) summarizes recent developments in the Kotlin ecosystem. JetBrains released IntelliJ IDEA 2025.3 that unifies Community and Ultimate into a single IDE, preserving core Java and Kotlin features as free while offering advanced tools via an optional Ultimate subscription. The issue highlights Kotlin notebooks for interactive analysis and visualization of kotlinx-benchmark results, and a post by certified trainer José Luis González covering backend anti-patterns, coroutine testing practices, and a checklist for diagnosing memory issues. Compose 1.10 adds a feature to include user code in stack traces. Featured articles include deploying Kotlin Spring Boot apps to Kubernetes and a one-command IDE Provisioner for standardized setups. The newsletter also covers Docker build-cache optimization, Android 16 edge-to-edge migration guidance, new KMP libraries, tutorial videos, and an upcoming Advanced Compose cohort course.

第489期 Kotlin Weekly（2025-12-14）汇总近期 Kotlin 生态要闻：IntelliJ IDEA 2025.3 将 Community 与 Ultimate 合并为单一 IDE，保留核心 Java 与 Kotlin 功能免费，进阶功能改为可选 Ultimate 订阅；介绍用 Kotlin notebooks 以 DataFrames 与图表互动分析 kotlinx-benchmark 结果；认证讲师 José Luis González 分享后端反模式、协程测试最佳实践与内存诊断清单；Compose 1.10 提升堆栈追踪以包含用户代码。还涵盖了将 Kotlin Spring Boot 部署到 Kubernetes 的指南、单命令 IDE Provisioner、Docker 构建缓存优化、Android 16 边缘体验迁移、多款 KMP 库、教学视频以及高级 Compose 课程资讯。

This article discusses using Kotlin Multiplatform's expect/actual mechanism to provide native, platform-specific implementations while maintaining a shared codebase. In KMP, common modules declare expected APIs or types that describe behavior needed by shared code; each target (JVM, JS, native, or mobile platforms) then supplies actual implementations that satisfy those expectations. This separation enables reuse of business logic and portability of most code, while permitting access to platform-specific capabilities, native libraries, or performance-sensitive code where required. The expect/actual approach helps organize platform differences cleanly, keep the common API surface stable, and encapsulate native details in their respective platform modules, simplifying development and maintenance across multiple targets.

本文讲解如何在 Kotlin Multiplatform 中利用 expect/actual 机制提供平台特定的原生实现，同时保留共享代码。做法是在通用模块中声明预期的 API 或类型（expect），各目标平台（如 JVM、JS、Native 或移动平台）在各自模块中提供实际实现（actual）。这种方式将可移植的业务逻辑集中到共用模块，而在需要时在平台端接入原生 API 或进行性能相关的实现，从而把平台差异封装到相应模块，简化多平台开发与维护。

This article exposes a hard lesson for Android developers: the system will sometimes kill app processes, and that behavior has real consequences for state, user experience, and app reliability. It explains that Android reclaims memory and enforces background limits, how process-level termination differs from ordinary activity destruction, and why in-memory assumptions break under memory pressure. The piece stresses designing defensively—persisting essential state, restoring UI and background work on restart, adopting resilient architecture patterns, and testing for cold starts and background eviction. By understanding platform behavior and using persistence and scheduling APIs appropriately, developers can reduce user-facing surprises and make apps behave correctly even when Android reclaims resources.

本文揭示了在资源紧张时 Android 会终止应用进程的事实，这是每个 Android 开发者迟早会学到的一课。文章说明系统为何回收内存与限制后台进程、这种进程级别的终止如何影响应用状态与生命周期，以及它与普通 Activity 销毁的不同之处。作者强调要有防御性设计：持久化必要状态、在重启时恢复界面与后台任务、采用稳健架构并测试冷启动与被回收场景。理解平台行为并合理使用存储与调度等机制，可以让应用在被系统回收时仍维持可靠的用户体验。

The provided content includes the article title, author (Erlan Kanybekov), and a short notice indicating an introduction with a prompt to "Continue reading on Medium." Based on the title, the article intends to compare Kandy and Matplotlib as data-visualization tools, positioning them in a direct showdown. However, the supplied text contains only the introductory fragment and no substantive comparisons, examples, benchmarks, or conclusions. Because the full article body is not included here, specific strengths, weaknesses, or usage guidance for either library cannot be extracted. To read the complete analysis, comparisons, and any code or visual examples the author provided, follow the linked Medium post.

当前提供的内容仅包含标题、作者（Erlan Kanybekov）和一句“继续在 Medium 阅读”的导言提示。根据标题可判断作者打算对 Kandy 与 Matplotlib 两个数据可视化工具进行比较，但所给文本没有包含任何实质性的对比内容、示例或结论。因此无法从该片段中提取两者的优缺点或使用建议。若需阅读全文以获取完整分析、示例代码或评测结果，请访问文中所指的 Medium 链接。

This article clarifies the fundamental difference between Kotlin's val and var, aimed particularly at developers coming from Java. It explains that val creates a read-only reference that cannot be reassigned after initialization, while var declares a mutable variable that can be reassigned. The piece notes that immutability applies to the reference, not necessarily to the object's internal state, and emphasizes why choosing val where possible leads to clearer, safer code and reduces accidental mutations. It also touches on practical considerations like initialization and type inference, and the mindset shift for Java developers learning Kotlin's concise syntax and emphasis on immutability as a best practice.

本文解释了 Kotlin 中 val 与 var 的基本区别，面向尤其来自 Java 的读者。文中指出 val 用于声明不可重新赋值的只读引用，而 var 则用于声明可重新赋值的可变变量；需注意不变性是针对引用本身，引用的对象内部状态可能仍为可变。作者强调在可行情况下优先使用 val，可以减少意外修改、提升代码可预测性和可维护性，同时涉及初始化、类型推断等实用注意事项，帮助开发者从 Java 思维过渡到 Kotlin 更强调不变性的编程风格。

This article introduces Kotlin's null safety feature and explains the difference between nullable and non‑nullable types. It emphasizes that null safety was designed to eliminate one of the most common causes of app crashes — null reference errors — by making nullability an explicit part of the type system. The piece outlines how Kotlin distinguishes values that can hold null from those that cannot, and how this distinction shifts many potential runtime failures into compile‑time checks, helping developers catch issues earlier. Although concise, the article frames null safety as a core language tool that reduces crashes and clarifies developer intent when declaring variables and functions, and it underscores that understanding nullable versus non‑nullable types is central to writing safer Kotlin code.

本文介绍 Kotlin 的 null safety 概念，说明可为 null（nullable）与不可为 null（non‑nullable）类型的差异，并指出其设计目的是消除导致应用程序崩溃的常见原因之一──空引用错误。文章解释 Kotlin 如何将 nullability 明确纳入类型系统，使许多潜在的运行时错误在编译期被检测，帮助开发者尽早发现问题。虽然内容简洁，但强调 null safety 是减少崩溃与表达变量意图的重要工具，并提醒读者掌握 nullable 与 non‑nullable 的概念对编写更安全的 Kotlin 代码至关重要。

This article presents five advanced approaches for combining Kotlin extension functions and operator functions to produce cleaner, more expressive code. It explains how these features can be used together to design fluent, DSL-like APIs, reduce repetitive boilerplate, and make intent clearer for readers and maintainers. The piece also warns about subtle pitfalls—most notably the well-known String.get gotcha—and provides a fix to avoid unexpected behavior. Rather than introducing entirely new language features, the article focuses on practical patterns and careful design choices that leverage existing Kotlin capabilities to unlock expressive "superpowers" while maintaining safety and readability. The guidance is aimed at Kotlin developers who want to compose language features thoughtfully to achieve concise, maintainable code.

本文介绍了通过五种高级方式，将 Kotlin 的扩展函数与运算符函数组合使用，以实现更简洁、更具表现力的代码。文章说明这些特性如何协同构建类似 DSL 的流畅接口、减少重复样板并让意图更清晰，同时提示开发者注意潜在陷阱，尤其是广为人知的 String.get 问题，并给出相应的修复办法。作者侧重于实用模式与设计考量，示范如何在不引入新语言特性的前提下，充分利用 Kotlin 现有能力提高代码的安全性、可维护性与可读性，适合希望精进 Kotlin 表达力的开发者阅读。

This article examines a disciplined approach to error handling in Android that goes beyond merely catching exceptions. It argues for combining Kotlin's runCatching, the MVI (Model-View-Intent) pattern, and Flow to keep ViewModels running, ensure UI predictability, and protect business logic from being disrupted by failures. Rather than letting exceptions crash components or scatter error-handling code, the piece advocates encapsulating outcomes, modeling error states within the UI state, and using reactive streams to deliver results and failures in a controlled way. The result is more robust apps where errors are surfaced, handled, and rendered consistently, enabling safer retries, clearer user feedback, and cleaner separation of concerns between presentation and domain layers.

本文探讨在 Android 中更稳健的错误处理思路，主张结合 Kotlin 的 runCatching、MVI 架构与 Flow，既不只是捕获异常，也要维持 ViewModel 的生命周期、让 UI 表现一致并保护业务逻辑。通过封装返回值与异常、在状态中显式建模错误，并以 Flow 作为结果与错误的传输通道，可以使错误被可控地呈现与处理，从而实现更清晰的一致性、便于重试与更好的用户反馈，同时保持表示层与领域层的职责分离。

This article introduces Netflix Hollow, a low-latency library for distributing frequent, structured data from a producer to multiple consumers while avoiding JVM heap issues by persisting large snapshots to external storage (file systems, object stores, or networked storage). Hollow follows a producer-consumer pattern: producers use publishers and announcers to write snapshots and announce versions, driven by a state engine; consumers use announcement watchers and blob retrievers to fetch and deserialize the correct snapshot versions. The tutorial demonstrates a MonitoringEvent entity, a producer that polls an external monitoring service and writes snapshots, and a consumer that loads generated APIs (via HollowAPIGenerator) to read events. It also shows the Maven dependency, notes generator plugin limitations, and explains deployment options (same or separate JVMs). The library abstracts snapshot management and versioning so developers can focus on entity models and processing logic.

本文介绍了 Netflix Hollow 的架构与示例实现。Hollow 适用于频繁且低到中等量的结构化输入数据，核心思路是通过将大型数据快照持久化到文件系统或对象存储等外部介质，减少 Java 应用的堆内存压力。系统以 producer-consumer 模式运作：producer 使用文件系统 publisher 和 announcer 写入并宣布快照版本，state engine 负责写入与版本管理；consumer 通过 announcement watcher 和 blob retriever 获取并反序列化正确的快照版本。文中示例包括 MonitoringEvent 实体、轮询并写快照的 producer，以及通过 HollowAPIGenerator 生成并在独立 consumer 应用中使用的 API。文章还提到 Maven 依赖与插件支持情况，以及将生成的 API 纳入构建流程的实践。

This article explains recommended Android architecture patterns using Kotlin and Jetpack Compose, emphasizing reactive, unidirectional data flow. It defines key roles: Compose UI as state-only @Composable functions, ViewModel as the presentation-state holder exposing StateFlow/LiveData, a Domain layer for business rules and use cases, and a Data layer for repositories, APIs and databases. It reviews three main patterns: MVVM (the most recommended for Compose with a simple unidirectional flow), MVI (suitable for large or complex UIs with immutable state and reducers but more boilerplate), and Clean Architecture (layered separation for scalability and testability). Google’s guidance favors MVVM + unidirectional flow + StateFlow, keeping events separate from state. The article concludes that a state-centered, unidirectional approach reduces bugs and improves maintainability across project sizes.

本文介绍了在 Kotlin 与 Jetpack Compose 环境下常见的 Android 架构实践，强调反应式与单向数据流的重要性。文中划分关键角色：Compose 负责渲染状态，ViewModel 管理并公开 StateFlow/LiveData 表示的 UI 状态，Domain 层处理业务规则与 UseCases，Data 层负责仓库、API 与数据库。比较了三种主要模式：MVVM（适用于多数场景且与 Compose 配合良好）、MVI（适合大型或复杂 UI，使用不可变状态与 reducer，但代码量较多）、以及 Clean Architecture（层次分离，利于扩展与测试）。Google 建议以 MVVM + 单向数据流为基线，ViewModel 为单一状态来源，借助状态驱动的单向流程降低 bug 并提升可维护性，按项目规模选用或组合相应模式。

This short excerpt from Marlon López introduces an article titled "Kotlin + Compose: The Formula for Elegant and Efficient Android Architecture Patterns." The visible line asks, "What Do We Call Android Architecture Patterns?" and the post points readers to Medium to continue reading. From the title and excerpt alone, the piece frames Kotlin (the programming language) together with Compose (the modern Android UI toolkit) as a combined influence on how Android architecture patterns can be designed to be elegant and efficient. The snippet does not provide detailed arguments or concrete patterns in full; instead, it signals the author’s intent to explore naming, principles, or approaches around Android architecture and invites readers to view the full article on Medium for the complete discussion.

這則由 Marlon López 发布的短摘，标题为「Kotlin + Compose：打造优雅且高效的 Android 架构模式公式」，并以一句「我们应如何称呼 Android 的架构模式？」提出问题。从可见内容来看，文章将 Kotlin（编程语言）与 Compose（现代 Android UI 工具）并列为影响架构设计的要素，暗示讨论它们如何共同促成更优雅与高效的架构方式。摘录并未给出详细论证或具体模式，仅表明作者将围绕命名、原则或实践方向展开讨论，并邀请读者在 Medium 阅读完整内容。

This article is a comprehensive guide to Kotlin's context receivers, framed for modern Android development. It explains what context receivers are, why they matter, and how they can be used alongside common Android libraries and paradigms such as Coroutines, Flow, Retrofit, and Jetpack Compose. The guide discusses practical integration strategies and development patterns so developers can apply context receivers in asynchronous code, reactive streams, networking, and UI composition. Emphasis is placed on real-world applicability for contemporary Android projects and on helping readers understand where context receivers simplify APIs, reduce boilerplate, and improve modularity. The piece serves as a focused resource for developers looking to adopt context receivers while maintaining compatibility with typical Android toolchains and libraries.

本文是一篇面向现代 Android 开发者的完整指南，介绍 Kotlin 中的 Context Receivers，阐述其概念、适用场景与设计考量。文章讨论了 Context Receivers 如何与常用技术栈配合使用，包括协程（Coroutines）、数据流（Flow）、网络库（Retrofit）以及 Jetpack Compose，并说明在异步处理、流式数据、网络请求和界面组合等场景中的实用整合策略。目标是帮助开发者了解何时使用 Context Receivers 能够减少样板代码、增强模块化并简化 API，同时提供在真实工程中安全采用此特性的实践建议。

This brief Medium post by Triono Hidayat, titled "Compose State 101: remember and mutableStateOf for Beginners," greets Compose developers and serves as an introductory guide to state handling in Jetpack Compose. It focuses on the fundamental concepts of remember and mutableStateOf, targeting readers new to Compose who want to understand how basic state is stored and observed in composables. The article's intent is to clarify the roles of these primitives, outline typical beginner use cases, and point readers to further reading on Medium. It emphasizes practical, approachable explanations suitable for developers starting with Compose state management.

这篇由 Triono Hidayat 在 Medium 发布的短文《Compose State 101：remember 和 mutableStateOf 给初学者》，以问候 Compose 开发者开场，作为 Jetpack Compose 状态管理的入门指南。文章侧重介绍 remember 与 mutableStateOf 的基本概念与用途，帮助刚接触 Compose 的读者理解如何在 composable 中保存与观察状态，并引导读者继续查阅相关资源。

In this article, Bhanit Gaurav presents the Compose Stability Analyzer as an easy and practical way to understand stability in Jetpack Compose. The analyzer provides immediate feedback on which composables are stable or unstable, helping developers identify causes of unnecessary recompositions. By making stability visible, it reduces wasted recompositions and supports a clearer mental model of how state and recomposition interact. The piece frames the tool as a useful aid for diagnosing and optimizing UI behavior without extensive manual inspection, improving performance and developer understanding through real-time insights and actionable observations.

Bhanit Gaurav 介绍的 Compose Stability Analyzer 是一个用于理解 Jetpack Compose 稳定性的实用工具。它能实时指出哪些 composable 是稳定或不稳定，帮助开发者查明导致不必要重组的原因。通过将稳定性可视化，开发者可以减少浪费的重组、提升 UI 性能，并建立更清晰的状态与重组交互的心智模型。文章强调该分析器能够在日常开发中快速诊断与优化行为，无需大量手动检查即可获得有价值的反馈。