Daily Digest

每日新聞摘要

2026年04月11日

今日總結

內容會跟隨語言切換。

📝 今日焦點：示範 Kotlin 入門程式（fun main、print/println 與註解）並指出以位元組碼（Graphite）可取得更完整的呼叫與常數解析。 🔧 效能最佳化：提出線性時間 O(n) 的高速高斯模糊實作與多次 box blur 近似，適用高解析或即時影像處理以降低運算成本。 🏗 架構設計：建議以 Clean Architecture、MVVM、Room 與 Jetpack Compose 組成可測試且可維護的 Android 分層專案，同時審慎評估協程與並發模式取捨以避免隱蔽錯誤與資源競爭。 ✅ 測試與品質：強調將 JUnit 單元測試納入開發流程以捕捉回歸並保障重構安全，並示範將大型模型（如 Gemma 4:E2B）本地化時的儲存與記憶體權衡。

📝 Today’s focus: A Kotlin primer covers fun main, println vs print, in-source comments for learning, and recommends bytecode analysis (Graphite) for complete call and constant resolution. 🔧 Performance: A linear O(n) Gaussian blur using separable passes and repeated box blurs achieves near-identical results with much lower cost, suiting high‑resolution and real‑time pipelines. 🏗 Architecture: Use Clean Architecture, MVVM, Room, and Jetpack Compose for maintainable, testable Android apps, and weigh coroutine use and threading vs multiprocessing to avoid hidden bugs and contention. ✅ Testing & quality: Adopt JUnit unit tests as a developer safety net to catch regressions and enable safe refactors, and plan storage/memory tradeoffs when embedding large on‑device models like Gemma 4:E2B.

From Theory to Code: My Kotlin Journey. Part 1

Dev.to Kotlin 作者：ojubizimnitsuj 發布：04-11 10:34

From Theory to Code: My Kotlin Journey — Part 1

Following the official Kotlin guide, I wrote my first Kotlin lines and explored fun main(), println() vs print(), and how to use comments to document code.

重點摘要

fun main() is the mandatory entry point for Kotlin programs.

println() prints text and moves to a new line; print() keeps the cursor on the same line.

Use // for single-line and /* ... */ for multi-line comments to document code.

Following the official Kotlin documentation, the author writes their first Kotlin code and steps through basic elements of the language. They demonstrate that fun main() is the required entry point, and experimentally compare the two output functions: println(), which prints text and then advances to a new line, and print(), which prints text without moving to a new line. A practical tip emphasizes recording notes directly inside source files rather than on paper: the Kotlin SDK and the online playground ignore comments, so using // for single-line and /* ... */ for multi-line comments turns code into a self-documenting learning record. The short post includes simple examples and invites readers to try similar snippets and share their results.

从理论到代码：我的 Kotlin 旅程（第一部分）

按照官方 Kotlin 指南写下第一段代码，实践 fun main()、println() 与 print() 的用法，并演示如何在代码中添加注释记录学习过程。

重點摘要

fun main() 是 Kotlin 程序的必需入口点。

println() 会打印并换行；print() 打印但不换行。

使用 // 单行或 /*...*/ 多行注释，使代码自我说明并记录学习。

作者依照官方 Kotlin 教程撰写了第一段 Kotlin 程序，說明 fun main() 為程式必備的進入點，並實作比較 println()（印出後換行）與 print()（印出但不換行）兩者差異。文中強調一個快速小技巧：不必拿紙筆記錄，直接在程式碼內加入註解（// 單行、/*...*/ 多行）即可，Kotlin SDK 與線上 playground 會忽略註解，使程式既能正確執行又能自我說明，方便做為學習進度的紀錄。文章附上簡單範例，並邀請讀者嘗試並分享成果。

從理論到程式：我的 Kotlin 旅程（第一部）

依照官方 Kotlin 指南撰寫第一段程式，探索 fun main()、println() 與 print() 的差異，並示範在程式碼中加入註解作為學習紀錄。

重點摘要

fun main() 是 Kotlin 程式的必備進入點。

println() 印出後換行；print() 印出但不換行。

用 // 單行或 /*...*/ 多行註解，讓程式自我說明並記錄學習。

作者依照官方 Kotlin 指南寫下第一段程式碼，說明程式的進入點 fun main() 為必備啟動函式；透過實驗比較 println()（印出後換行）與 print()（印出但不換行）的差異；並提供快速提示：無需紙筆，可直接在程式碼中加入註解（// 單行、/*...*/ 多行），Kotlin SDK 與 playground 會忽略註解，讓程式既能執行又能自我說明，成為學習進度的紀錄。文章附上簡單範例並鼓勵讀者動手練習與分享成果。

Why AI Agents Get JVM Codebases Wrong — and How Bytecode Changes That

Dev.to Kotlin 作者：Johnson 發布：04-11 11:48

Why AI Agents Get JVM Codebases Wrong — and How Bytecode Changes That

Agents that read source code miss compiler-driven changes and cross-file resolution, producing incorrect call graphs; bytecode reveals the actual execution structure.

重點摘要

Source-level parsers (e.g., Tree-sitter) lack cross-file type resolution and miss compiler transformations.

Bytecode contains resolved types, inlined functions, synthetic methods, annotations, and constant values.

Graphite builds a program graph from bytecode and answers structural queries quickly and accurately.

Source-based analysis often misleads AI agents because parsers like Tree-sitter operate at the syntax layer and lack type resolution, cross-file dataflow, and compiler-expanded constructs. In real JVM projects this causes missed call sites (e.g., Kotlin inline functions erased at compile time, synthetic bridge methods, inherited Spring annotations, and constants defined in other modules). Bytecode, by contrast, is what the JVM actually executes: types are resolved, inline bodies are expanded, synthetic methods and constant pool values are present, and annotations can be traversed across hierarchies. Graphite leverages compiled bytecode to construct a program graph (methods, fields, constants, call sites, and relations) and exposes it via Cypher queries. The result is far more accurate call graphs (19 actual AB test constants vs. 6 seen in source) and huge token/efficiency savings for LLM agents querying structure instead of re-reading millions of source tokens.

为什么 AI 代理在 JVM 代码库上出错——以及字节码如何改变这一切

直接读取源代码会漏掉编译器展开和跨文件解析，从而产生错误的调用图；字节码能揭示实际的执行路径。

重點摘要

语法层工具（如 Tree-sitter）无法做跨文件类型解析与数据流追踪。

字节码含已解析的类型、内联展开、合成方法、注解与常量值。

Graphite 从字节码构建程序图并通过 Cypher 查询，快速且高准确度。

基于源代码的代码智能容易出错，因为像 Tree-sitter 这样的解析器只处理语法，无法解析跨文件的类型或数据流，也看不到编译器生成或消除的结构（如 Kotlin 的 inline 展开、为 lambda/私有字段生成的 synthetic 方法、抽象控制器继承的注解，以及在不同模块定义的常量）。字节码是编译器的最终产物：类型被解析、内联函数被展开、合成方法和常量存在于常量池中，注解可通过类层次遍历查询。Graphite 利用字节码构建程序图（方法、字段、常量、调用点与关系），并用 Cypher 提供结构化查询，因此能准确找出真实的调用位点（例如返回 19 个 AB 常数而不是源代码能见的 6 個），并大幅降低 LLM 需要处理的 token 数量。

為何 AI 代理在 JVM 原始碼上出錯 — 以及位元組碼如何改變這一點

直接讀源碼會遺漏編譯器展開與跨檔案解析，導致錯誤的呼叫圖；位元組碼揭示實際的執行結構。

重點摘要

語法解析器（如 Tree-sitter）只看語法，缺乏型別解析與跨檔案資料流。

位元組碼包含已解析的型別、內聯展開、合成方法、註解與常數值。

Graphite 從位元組碼建構程式圖並用 Cypher 查詢，快速且更精確。

以原始碼為基礎的程式分析對 AI 代理常常會產生誤導：Tree-sitter 等工具只解析語法樹，無法進行跨檔案型別解析或看到編譯器所做的變換，例如 Kotlin 的 inline 展開、為 lambda 或私有欄位產生的 synthetic 方法、抽象控制器上繼承的註解，以及定義在不同模組的常數。位元組碼則反映編譯後的真實執行：型別被解析、內聯已展開、合成方法可見、常數在常數池中可查。Graphite 以 JAR/WAR 等位元組碼建構節點與關係的程式圖，並透過結構化查詢回應問題，提供更完整的呼叫位點、端點映射與類別階層解析，且顯著減少 LLM 需掃描的原始碼量。

How I Built a Production-Ready Android App Using Clean Architecture, MVVM, Room & Jetpack Compose

Medium Kotlin 作者：arun singh 發布：04-11 09:46

How I Built a Production-Ready Android App Using Clean Architecture, MVVM, Room & Jetpack Compose

The author shares how he built a production-ready Android application using modern Android practices like Clean Architecture, MVVM, Room, and Jetpack Compose.

重點摘要

Built a production-ready Android app using Clean Architecture, MVVM, Room, and Jetpack Compose

Explains architecture choices and layered project structure

Offers practical tips, common pitfalls, and lessons for production apps

Arun Singh outlines his approach to building a production-ready Android application using modern Android practices: Clean Architecture, MVVM, Room, and Jetpack Compose. The article focuses on why these patterns and tools were chosen and how they work together to create a layered, maintainable codebase that supports testability and declarative UI development. It highlights the role of Room for local data persistence, MVVM for separating UI and business logic, Clean Architecture for clear boundaries between layers, and Jetpack Compose for modern UI implementation. The piece also shares practical lessons learned, common pitfalls to avoid, and pragmatic tips for moving an app from prototype to production, aimed at Android developers seeking a maintainable, modern foundation for robust apps.

我如何使用 Clean Architecture、MVVM、Room 与 Jetpack Compose 构建可投入生产的 Android 应用

作者分享他如何利用现代 Android 开发实践（包括 Clean Architecture、MVVM、Room 与 Jetpack Compose）构建可投入生产的应用。

重點摘要

以 Clean Architecture、MVVM、Room 与 Jetpack Compose 构建可投入生产的 Android 应用

说明架构选择与分层项目结构的互相作用与优势

提供实现要点、常见陷阱与投入生产的实务建议

本文作者 Arun Singh 分享他如何以现代 Android 开发实践建立可投入生产的应用，采用 Clean Architecture、MVVM、Room 与 Jetpack Compose。文章说明选择这些架构与工具的理由、在分层项目中的交互、数据持久化与声明式 UI 的实现要点，以及对可维护性和可测试性的帮助。作者还分享实作重点、常见陷阱与实务建议，适合寻求构建稳健、可扩展 Android 应用的开发者参考。

我如何使用 Clean Architecture、MVVM、Room 與 Jetpack Compose 建置可投入生產的 Android 應用

作者分享他如何利用現代 Android 開發實務（包括 Clean Architecture、MVVM、Room 與 Jetpack Compose）建構可投入生產的應用。

重點摘要

以 Clean Architecture、MVVM、Room 與 Jetpack Compose 建置可投入生產的 Android 應用

說明架構選擇與分層專案結構的互動與好處

提供實作重點、常見陷阱與投入生產的實務建議

本文作者 Arun Singh 分享他如何以現代 Android 開發實務建立可投入生產的應用，採用 Clean Architecture、MVVM、Room 與 Jetpack Compose。文章說明選用這些架構與工具的理由、在分層專案中的互動、資料持久化與宣告式 UI 的實作要點，以及對可維護性與可測試性的助益。作者並提供實作重點、常見陷阱與實務建議，適合尋求建構穩健、可延展 Android 應用的開發者閱讀。

When NOT to Use Coroutines (Yes, Really)

Medium Kotlin 作者：Oliver Bozhinovski 發布：04-11 13:01

When NOT to Use Coroutines (Yes, Really)

Most coroutine bugs don't come from complex logic.

重點摘要

Most coroutine bugs don't come from complex logic.

The author urges caution when choosing to use coroutines.

Read the full article on Medium for the complete argument.

The piece titled "When NOT to Use Coroutines (Yes, Really)" asserts that most coroutine bugs don't arise from complicated algorithmic logic. Instead, it serves as a caution: coroutines are not a one-size-fits-all solution and their use should be considered deliberately rather than assumed. The author challenges the notion that adopting coroutines automatically simplifies asynchronous code and encourages readers to evaluate trade-offs and context before applying them. The short excerpt emphasizes rethinking default choices and points readers to the full Medium article for the extended discussion and examples supporting this recommendation.

何时不该使用协程（真的）

大多数协程错误并非源自复杂的逻辑。

重點摘要

大多数协程错误并非来自复杂逻辑。

选择使用协程时应保持谨慎。

完整论述请前往 Medium 阅读原文。

文章《何时不该使用协程（真的）》指出，多数与协程相关的错误并不是由于复杂的算法或逻辑引起，而是提醒读者不要把协程当作放之四海而皆准的解决方案。作者建议在决定使用协程前应审慎评估具体情境与权衡利弊，避免盲目采用带来隐藏性错误或维护难题。文中简短片段强调重新审视默认选择，并引导读者至 Medium 查看完整论述与示例。

何時不該使用協程（真的）

大多數協程相關的錯誤並非來自複雜的邏輯。

重點摘要

大多數協程錯誤並非源自複雜邏輯。

應謹慎評估是否使用協程。

欲了解完整論述請閱讀 Medium 原文。

文章《何時不該使用協程（真的）》指出，多數協程問題並非源於複雜的演算法或邏輯，而是提醒讀者不要把協程視為萬用解方。作者主張在決定採用協程前要審慎評估情境與權衡，避免盲目使用造成隱蔽錯誤或維護困難。原文片段強調應重新思考預設選擇，並引導讀者至 Medium 查看完整說明與範例。

Fast Gaussian Blur Implementation in Java

Baeldung 作者：Nikhil Bhargav 發布：04-11 05:45

Fast Gaussian Blur Implementation in Java

Using separable 1D box-blur passes with a sliding-window moving average yields a near-Gaussian blur in linear time independent of radius.

重點摘要

Decompose 2D Gaussian into separable 1D horizontal and vertical passes

Approximate Gaussian by repeating equal-weight box blurs (Central Limit Theorem)

Use sliding-window (moving average) to achieve O(n) complexity independent of radius

This article presents a faster, computationally efficient Gaussian blur implementation in Java. It replaces costly 2D convolution with two optimizations: using separable filters (applying 1D horizontal then vertical blurs) and approximating Gaussian kernels by repeating equal-weight box blurs, leveraging the Central Limit Theorem. By implementing box blurs with a sliding-window (moving-average) update and clamping edges, each pass runs in linear time O(n) independent of blur radius. The reference implementation performs multiple passes (configurable, commonly three to five), ping-pongs pixel arrays between temporary buffers, and applies horizontalBoxBlur and verticalBoxBlur for rows and columns. Tests include an impulse image to verify edge handling and diffusion, and real-image support by splitting ARGB channels, blurring RGB independently, and recombining. The result is a visually near-identical Gaussian blur with substantially lower computational overhead, suitable for higher-resolution or real-time processing.

Java 中的快速高斯模糊实现

通过可分离的一维方框模糊加滑动窗口移动平均，可在与半径无关的线性时间内近似高斯模糊。

重點摘要

将 2D 高斯核分解为水平和垂直两次一维模糊

重复等权重方框模糊，借助中心极限定理逼近高斯分布

采用滑动窗口技术使复杂度降为 O(n)，与模糊半径无关

本文介绍一种在 Java 中更高效的高斯模糊实现：通过将二维高斯核分解为可分离的一维水平与垂直滤波，并用多次等权重的方框模糊(box blur)逼近高斯（依赖中心极限定理），结合滑动窗口的移动平均更新与边界重复（clamping），将时间复杂度降为 O(n)，与模糊半径无关。实现中通过 horizontalBoxBlur 与 verticalBoxBlur 分别按行按列处理像素，使用临时数组在多次通道之间交替(ping-pong)以避免覆盖；测试包含脉冲图验证边界处理与能量扩散，真实图像则拆解 ARGB 通道分别模糊再合成。该方法在高分辨率或实时场景中能显著减少计算开销。

Java 中的快速高斯模糊實作

以可分離的一維方框模糊搭配滑動視窗移動平均，可在與半徑無關的線性時間內近似出高斯模糊。

重點摘要

將 2D 高斯捲積分解為水平與垂直的一維通道

重複等權重方框模糊，利用中心極限定理近似高斯分布

以滑動視窗更新窗口和，時間複雜度降為 O(n)，與半徑無關

本文介紹一種在 Java 中更快速的高斯模糊實作：透過將 2D 高斯核分解為可分離的一維水平與垂直濾波，並以多次等權重的方框模糊(box blur)近似高斯分布（利用中心極限定理），配合滑動視窗的移動平均更新與邊界重複(clamping)，將時間複雜度降為 O(n)，與模糊半徑無關。實作以水平與垂直的 horizontalBoxBlur/verticalBoxBlur 函式逐行與逐列處理，使用暫存陣列在多次通過間 ping-pong 資料以避免被覆寫；測試包含衝激圖以驗證邊界與擴散效果，真實影像則拆分 ARGB 通道分別模糊後再合成。該方法在高解析度或即時處理場景能顯著降低運算成本。

How to do Unit Testing in Android (Kotlin) using JUnit

Medium Kotlin 作者：Megha kumari 發布：04-11 02:52

How to do Unit Testing in Android (Kotlin) using JUnit

Gone are the days when 'it works on my machine' was enough — modern development requires developers to be their own first line of defense.

重點摘要

Argues that 'it works on my machine' is no longer acceptable.

Focuses on unit testing Android apps written in Kotlin.

Introduces JUnit as the tool for writing and running unit tests.

This article stresses that the old excuse 'it works on my machine' is insufficient and that modern developers must take responsibility for ensuring code quality. It presents unit testing for Android applications written in Kotlin, framing tests as a developer-first safety net. The piece highlights JUnit as the primary framework for creating and executing unit tests and discusses why incorporating tests improves reliability and maintainability. Rather than being an optional extra, unit testing is portrayed as an essential part of the development workflow that helps catch regressions early and supports safer refactoring. The article aims to guide Kotlin Android developers toward adopting JUnit-based unit tests to produce more robust, predictable applications.

在 Android (Kotlin) 中使用 JUnit 进行单元测试

“只要在我的机器上能运行就行”的时代已过，现代开发要求我们成为自己的第一道防线。

重點摘要

指出“在我的机器上能运行”已不足以交付功能。

聚焦于 Kotlin 编写的 Android 应用的单元测试。

以 JUnit 作为编写与执行单元测试的主要工具。

本文强调仅凭“在我的机器上能运行”已不足以应对现代开发要求，开发者需主动承担保证代码质量的责任。文章以 Android + Kotlin 为背景，倡导将单元测试纳入日常开发流程，并推荐使用 JUnit 作为测试框架。通过单元测试，可以更早发现回归问题、提升代码可维护性，并在重构时提供安全保障；作者将单元测试视为开发者的第一道防线，而非可选项，旨在引導 Kotlin Android 开发者采用 JUnit 来构建更可靠的应用。

在 Android (Kotlin) 中使用 JUnit 進行單元測試

「只要在我的機器上能運行就行」的時代已過，現代開發要求我們成為自己的第一道防線。

重點摘要

指出「在我的機器上能運行」已不足以交付功能。

聚焦於用 Kotlin 編寫的 Android 專案的單元測試。

以 JUnit 作為撰寫與執行單元測試的主要工具。

本文強調僅憑「在我的機器上可運行」已無法滿足現代開發需求，開發者需主動為程式品質把關。文章以 Android + Kotlin 的情境為主，說明應將單元測試納入開發流程，並以 JUnit 作為撰寫與執行測試的框架。作者指出，透過單元測試可以及早捕捉回歸問題、提升程式可維護性並在重構時提供安全保障，將測試視為開發者的第一道防線，而非可有可無的附加工作。

Android Concurrency Deep Dive: Multithreading vs Multiprocessing

Medium Kotlin 作者：Parita Dey 發布：04-11 05:26

Android Concurrency Deep Dive: Multithreading vs Multiprocessing

When an app freezes, crashes under load, or struggles to scale, the root cause often comes down to how developers handle concurrency.

重點摘要

App freezes and crashes under load often stem from concurrency handling.

The article contrasts multithreading and multiprocessing on Android.

It aims to guide developers in choosing and implementing concurrency strategies.

This article is a deep dive into Android concurrency, contrasting multithreading and multiprocessing and examining how developers' concurrency decisions affect app stability and scalability. It highlights that app freezes, crashes under load, and scaling problems frequently trace back to how concurrency is handled. The author compares the two approaches, discusses trade-offs in complexity and resource usage, and outlines practical implications for performance and reliability on Android. Readers can expect a technical overview to help determine when to prefer threads versus separate processes, common pitfalls that lead to contention or failure, and guidance on diagnosing concurrency-related issues. The goal is to provide engineers with a clearer framework for choosing and implementing concurrency strategies that reduce crashes, improve responsiveness, and support scaling under load.

Android 并发深度解析：多线程 vs 多进程

当应用冻结、在负载下崩溃或难以扩展时，根本原因往往与开发者如何处理并发有关。

重點摘要

应用在负载下冻结或崩溃常源于并发处理不当。

文章比较 Android 上的多线程与多进程模式。

旨在帮助开发者选择并实施合适的并发策略。

本文对 Android 并发做深入解析，对比多线程（multithreading）与多进程（multiprocessing），并审视开发者在并发设计上的选择如何影响应用的稳定性与可扩展性。文章指出，当应用在负载下冻结、崩溃或难以扩展时，往往可以追溯到并发处理方式的问题，并就两种方案在复杂度、资源使用和实务影响上进行讨论。读者可获得技术性概览，以判断何时应优先使用线程或独立进程、识别常见陷阱并掌握诊断并发相关故障的方向，从而降低崩溃风险、提升响应性与扩展能力。

Android 並發深度解析：多執行緒 vs 多程序

當應用程式當機、在負載下崩潰或難以擴展時，根本原因往往與開發者如何處理並發有關。

重點摘要

應用在負載下當機或凍結常源於並發處理不當。

文章比較 Android 上的多執行緒與多程序模式。

目的是協助開發者選擇並落實合適的並發策略。

本文對 Android 並發進行深度解析，對比多執行緒（multithreading）與多程序（multiprocessing），並檢視開發者在並發設計上的抉擇如何影響應用穩定性與可擴展性。文中指出，當應用程式在負載下凍結、崩潰或無法順利擴展時，往往可追溯到並發處理方式的不當，並就兩種模式的取捨、複雜度與資源使用面提出討論。讀者可從中獲得技術性概覽，協助判斷何時採用執行緒或分離程序、了解常見陷阱並掌握診斷方向，進而降低崩潰風險並提升回應性與擴展性。

Running Gemma 4:E2B on Android: A Minimal Kotlin App

Medium Kotlin 作者：Gabriel Preda 發布：04-11 06:39

Running Gemma 4:E2B on Android: A Minimal Kotlin App

No backend, no API — just a 2.5GB model running locally (and what it took to make it work)

重點摘要

Runs Gemma 4:E2B locally on Android (2.5GB)

Minimal Kotlin app without backend or API

Explains the engineering effort and challenges to make it work

Gabriel Preda’s article describes running the Gemma 4:E2B language model directly on Android by building a minimal Kotlin app. Instead of relying on a backend or remote API, the approach loads a roughly 2.5GB model locally on the device. The post outlines the motivation for on-device inference, the practical steps and trade-offs involved in packaging and launching a large model inside an Android app, and the engineering effort required to make it work. It touches on considerations such as storage and memory constraints, app architecture for model loading and inference, and debugging and deployment hurdles encountered during development. Presented as a hands-on case study, the write-up gives developers a concrete example of integrating a substantial offline model into a mobile app and highlights the benefits and limitations of a local-first approach.

在 Android 上运行 Gemma 4:E2B：一个极简 Kotlin 应用

无后端、无 API — 只有一个约 2.5GB 的模型在本地运行（以及让它能工作的过程）

重點摘要

在 Android 本地运行 Gemma 4:E2B（2.5GB）

极简 Kotlin 应用，无需后端或 API

讨论封装、内存与部署等工程挑战

Gabriel Preda 的文章示范如何在 Android 上以一个极简 Kotlin 应用直接运行 Gemma 4:E2B，无需后端或 API，模型大小约 2.5GB 并本地加载。文章说明采用本地推理的动机、将大型模型打包进 Android 应用的实务步骤与取舍，以及为让模型运行所面临的工程挑战与解决经验。内容涉及存储与内存限制、应用架构与加载/推理流程、调试与部署上的实践心得，作为开发者整合离线大型模型到移动设备的参考案例。

在 Android 上執行 Gemma 4:E2B：一個極簡的 Kotlin 應用

無後端、無 API — 只有一個約 2.5GB 的模型在本地執行（以及讓它能運作所需的努力）

重點摘要

在 Android 本地執行 Gemma 4:E2B（2.5GB）

極簡 Kotlin 應用，無需後端或 API

討論封裝、記憶體與部署等工程挑戰

Gabriel Preda 的文章示範如何在 Android 上以一個極簡 Kotlin 應用直接執行 Gemma 4:E2B，無需後端或 API，模型大小約 2.5GB 並本地載入。文章說明採用本地推論的動機、將大型模型打包進 Android 應用的實務步驟與取捨，以及為了讓模型運作所面臨的工程挑戰與解決經驗。內容涵蓋儲存與記憶體限制、應用架構與載入／推論流程、除錯與部署上的實作心得，作為開發者整合離線大型模型到行動裝置的範例與參考。