Folay's Blog

LLMs Can't Count — Engineering Practices for Output Length Control

Thu, 28 May 2026 00:00:00 GMT

36 controlled experiments reveal: counting metric mismatch, reasoning token squeeze, and small-sample hallucination — three pitfalls stacked together cause 93% of outputs to exceed limits.

You tell an LLM to “write 2,500 words.” It can’t count.

It’s not a prompt issue. It’s not a parameter tuning issue. The autoregressive architecture predicts only the next token at each step — there’s no internal counter. The model’s “perception” of length comes from distribution patterns in training data, not precise calculation.

It took me two weeks and 36 controlled API calls to truly accept this.

I. 93% Over-Limit

In a Chinese long-text batch generation pipeline, each call requested approximately 2,500 Chinese characters (with structured outlines and contextual transitions). After running for a while, I audited 1,200+ outputs:

Target	Samples	Over-limit Rate	Avg Overshoot
2500	331	93%	+1,685 chars
2900	526	31%	+420 chars
3000	356	61%	+690 chars

The distribution is heavily right-skewed — almost always too long, rarely too short. This isn’t random error; it’s systematic bias.

II. You and the Model Are Counting Different “Characters”

The system counted characters using len(re.sub(r'\s', '', text)) — all characters after removing whitespace. The prompt said “write 2,500 characters (字).”

The model interprets “字” as Chinese characters. The system counts all characters including punctuation, digits, and letters.

Sampling 90 outputs:

Character Type	Percentage
CJK Characters	84.5%
Punctuation	12.1%
Digits + Letters + Others	3.4%

The model writes 2,500 Chinese characters, the system counts 2,950. The model writes 2,600 Chinese characters, the system counts 3,068 and flags it as over-limit. An 18% systematic bias — the model didn’t write too much; the measurement was wrong.

After switching to counting only CJK Unified Ideographs, the over-limit rate for target=2900 dropped from 31% to zero.

def count_cjk_chars(text):
    return sum(1 for c in text
               if '\u4e00' <= c <= '\u9fff'
               or '\u3400' <= c <= '\u4dbf'
               or '\U00020000' <= c <= '\U0002a6df')

One function change was more effective than all the prompt engineering that followed combined.

This type of bug is insidious because both sides “look correct.” The prompt says “characters,” the developer thinks “characters are characters” — each is reasonable, but combined they produce an 18% phantom bias. In multi-module systems, subtle drift in definitions of the same concept across components is a classic integration bug.

III. Cutting Token Budget Makes Output Longer

The model supports thinking mode, with max_completion_tokens initially set to 10,000. Intuitively, cutting to 5,000 should shorten output.

The result was the exact opposite:

max_tokens	thinking	Reasoning Tokens	Output Tokens	Actual CJK Chars
10000	on	1204	2077	3041
6000	on	689	2678	3840
5000	on	502	2568	3765
10000	off	0	2988	4313
5000	off	0	2032	3005

Cutting max_tokens from 10,000 to 5,000 with thinking on, the character count increased from 3,041 to 3,765.

The reason: reasoning tokens and output tokens share the same budget pool. Under budget pressure, the model cuts reasoning first (1204→502), but reasoning is precisely the capability that lets the model plan overall structure and sense “when to wrap up.” With reasoning compressed, the model doesn’t get the chance to think “time to stop” and just keeps writing.

max_tokens:       10000  →  6000  →  5000
Reasoning tokens:  1204  →   689  →   502  (↓)
Output tokens:     2077  →  2678  →  2568  (↑)
Actual CJK chars:  3041  →  3840  →  3765  (↑)

The thinking=off group showed that cutting max_tokens was indeed effective (4313→3005) because there’s no reasoning overhead — the physical cap takes direct effect.

Conclusion: On models with reasoning capability, token budget is a non-monotonic control variable. There exists a “reasoning sufficiency” threshold below which the constraint actually weakens.

IV. The Hallucination of Two Samples

After fixing the counting metric, I tried three prompt variants:

baseline: “Target 2500, range 2000–3000”
strict: Added “exceeding will trigger a discard and rewrite, seriously wasting compute”
countdown: Split 2500 into four section budgets, each with a specified character count

First ran two samples — all three variants showed 100% compliance. Almost committed right away.

Ran two more samples:

Config	Round 1 (n=2)	Round 2 (n=4)
strict + 10k	100%	25%
countdown + 10k	100%	25%
baseline + 10k	100%	0%

Summary of 36 calls (CJK output distribution at target=2500):

Min: 1671    Max: 4247
Mean: 3087   Std Dev: 520
Compliance (≤3000): 33%

With a standard deviation of 520, the “100%” from 2 samples is pure statistical noise.

There’s an even more hidden trap: the model silently ignores the temperature parameter in thinking mode, forcing 1.0. The API doesn’t error or warn. I thought I was testing differences between temp=0.6 and temp=0.8, but both groups ran at 1.0 — all “conclusions” about temperature were void.

Iron rule of LLM experiments: verify that the parameter you changed actually took effect. An API’s silent failure is more dangerous than an explicit error.

V. 0% Success Rate for “LLM Compression”

The system had another “safety net”: when over-limit, call the LLM to “compress to under 3,000 characters.”

Compression attempts: 174
Successes: 0
Success rate: 0%

A model that can’t count precisely — asking it to “trim to a precise word count” can never converge.

VI. Root Cause Ranking

Root Cause	Contribution
Counting metric mismatch (all chars vs CJK)	~18%
Model’s inherent uncontrollable output rhythm	~60%
LLM compression pipeline failure	~20%
Post-processing escape paths (polish/review rewrites without re-validation)	~2%

VII. Production Solutions

1. Align Counting Metrics

Whatever the code counts, the prompt should state explicitly. If counting CJK characters, write “number of Chinese characters,” not “word count.” This step has the highest ROI.

2. Set Target in the Model’s Comfort Zone

The model naturally produces 3,000–3,500 CJK characters. Setting target at 2,500 is asking it to brake at 70% of its natural output — it can’t do it. Setting 2,900, the compliance range covers the natural interval, achieving ~95% compliance.

Target	Natural Output	Compliance Range	Expected Rate
2500	3000-3700	2000-3000	~25%
2900	3000-3500	2400-3400	~95%
3000	3000-3500	2500-3500	~85%

3. Add Convergence Anchors to Prompts

“Reach the climax at 50%, begin wrapping up at 65%.” Not guaranteed to work perfectly, but reduces extreme deviations.

4. Over-Limit Retry with Feedback, Not Truncation

Truncation cuts logic at an arbitrary point — unacceptable quality loss. Retry with specific numbers fed back to the model — “Last attempt was 3,500, limit is 3,000, please write shorter.” More effective than blind retries.

5. Log Token Details

Reasoning tokens, output tokens, finish_reason, CJK character count. Provides a baseline for regression testing after model upgrades.

VIII. Looking Back

The essence of this problem is using a probabilistic system to enforce deterministic constraints.

LLM applications carry a common implicit assumption — “the model can follow instructions precisely.” This largely holds for classification and extraction tasks where the output space is small. But in long-text generation, the output space is exponential; requiring precise length control is like drawing a narrow band in high-dimensional space — the generation process has no such constraint mechanism.

From a control theory perspective, most LLM pipelines are open-loop systems — generate once and done. Adding retry + feedback converts open-loop to closed-loop: generate → count → evaluate → feedback → regenerate. When precision isn’t enough, iterate to compensate.

On experimental methodology: LLM output standard deviation far exceeds traditional software. For distributions with std dev 500+, you need dozens of samples to distinguish 10%-level differences. Most people run two or three cases and draw conclusions — not because they don’t understand statistics, but because API calls are expensive. But the money saved on API calls comes back doubled as production bugs.

All data above is based on mimo-v2.5-pro. Specific numbers (over-limit rates, reasoning token allocation, natural output ranges, etc.) do not apply to other models. Core conclusions — counting metric alignment, non-monotonic reasoning budgets, iterative convergence over truncation — are methodologically universal, but thresholds need to be re-measured on target models.

From PRD to MR: AI Coding Workflow Design for Enterprise Android Projects

Sun, 24 May 2026 00:00:00 GMT

Introduction

This article introduces a workflow I built in Cursor: starting from PRD and design mockup inputs, through technical design generation, structured task breakdown, task-by-task coding, real-device verification, and finally automated MR submission. The entire pipeline is split into 7 stages, each with gating and human confirmation points. Through layered loading, on-demand Skill injection, and cross-session knowledge persistence, it addresses two core pain points of AI in long-chain decision-making: quality degradation over steps and “starting from scratch” with every requirement.

Note: The content is tailored to a specific enterprise Android project (MVP architecture, RxJava conventions, proprietary UI component library), but the underlying design philosophy — staged gating + knowledge persistence + token layering + on-demand loading — is generalizable to any tech stack.

Architecture Overview

The diagram below shows the complete information flow from input to delivery:

flowchart LR PRD["PRD + API Docs + Figma"] --> S0 subgraph S0 ["Stage 0: Code Sync"] Git["git fetch + checkout
submodule update"] end S0 --> S1 subgraph S1 ["Stage 1: Requirements Analysis"] A1["Load cross-req knowledge"] --> A2["Fetch PRD/API docs
(DingTalk MCP)"] A2 --> A3["Extract features & list unknowns"] A3 --> A4["Output analysis.md"] end S1 -->|Human confirm| S2 subgraph S2 ["Stage 2: Design Analysis"] B1["Read Figma / screenshots"] --> B2["px→dp/sp conversion
layout structure inference"] B2 --> B3["Append to analysis doc"] end S2 -->|Human confirm| S3 subgraph S3 ["Stage 3: Technical Design"] C1["Generate tech-design.md/.html"] --> C2["Structured task table"] C2 --> C3["Server integration.md"] end S3 -->|Design confirmed| S4 subgraph S4 ["Stage 4: Task-by-Task Coding"] direction LR D1["Read learning notes"] --> D2["Search similar implementations"] D2 --> D3["Load corresponding Skill"] D3 --> D4["Code + module compile"] D4 -->|Human confirm| D5["Update task table"] D5 -->|Loop| D1 end S4 -->|All done + self-review| S5 subgraph S5 ["Stage 5: Full-Build Verification"] E1["Compile & install"] --> E2["Launch App"] E2 --> E3["Android MCP real-device verification"] E3 --> E4["Output verification-report.html"] end S5 -->|Verification passed| S6 subgraph S6 ["Stage 6: Submit MR"] F1["Create branch"] --> F2["Commit code & submodules"] F2 --> F3["Create MR"] F3 --> F4["Persist project learnings"] end S6 --> MR["MR Link + Verification Report"]

The entire process is driven by a Cursor Agent, relying on these underlying mechanisms:

Layer	Mechanism	Purpose
Rules	`.cursor/rules/*.mdc`	Coding constraints, auto-injected by context
Skills	`.cursor/skills/*/SKILL.md`	Specialized capabilities (API, DB, UI generation, etc.), loaded on demand
Commands	`.cursor/commands/*.md`	User-triggered shortcut tasks
MCP Servers	`.cursor/mcp.json`	External tool bridges (docs, designs, real devices, Git platforms)

Core Design Principles

1. Gating Mechanism: Preventing Decision Quality Degradation

AI decision quality in long chains degrades exponentially with the number of steps. Letting AI go straight from PRD to MR without intermediate calibration will inevitably result in severely degraded output quality. This parallels human development — coding without clarifying requirements guarantees rework.

Therefore, we enforce gating at the end of each stage: AI must wait for human confirmation via Ask Question before proceeding. Key gating points include:

Stage 3 → 4: Technical design must be confirmed. If the design deviates from requirements, all subsequent coding is wasted.
Stage 4 → 5: All tasks complete + final compilation passes + coding standards self-review passes.
Stage 5 → 6: Real-device verification complete, all PRD feature points checked off.

Stage 4 has even finer granularity: confirmation after each task. The earlier implementation deviations are caught, the lower the fix cost.

2. Token Layer Control: Reducing Context Overhead

Cursor injects alwaysApply: true Rules with every conversation turn. The more content injected, the smaller the available context window, and the less room for code analysis. We split constraints into three layers:

Layer	Trigger	Content Examples	Token Order
L0 Core	Every turn	16 prohibitions + 11 requirements	~500
L1 Coding	Editing `.java/.kt/.xml`	Lifecycle, UI component specs, common errors	~800
L2 Domain	Editing API/DB files	Condensed core constraints + pointer to corresponding Skill	~200 each

The core layer is small (~40 lines) and nearly immutable, making it very friendly to Anthropic’s prompt caching — the more stable the prefix, the higher the cache hit rate and the lower the API cost. During non-coding stages (git operations, PRD analysis), only L0 is loaded, keeping token consumption under 500.

3. On-Demand Skill Loading: Avoiding Full Knowledge Injection

Cursor Skills use the description in YAML frontmatter to let AI decide whether to load the full content. At the start of each conversation turn, AI reads only the descriptions of all Skills (~50 tokens each), loading the full body only when matching the current task.

We defined 19 specialized Skills covering these capability domains:

Core Development: API networking, database operations, data models, analytics
UI-Related: Layout XML generation, design-to-layout conversion (with Figma smart learning), MVP page generation
Quality Assurance: Module compilation verification, coding standards self-review, scripted code review
Utilities: Android SO/AAR dependency analysis, A/B experiment decommissioning, Wiki generation/conversion/sync checks
Process Control: Full requirements development flow (Stage 0→6)

All Skill descriptions total ~1,000 tokens; full content exceeds 25,000 tokens — on-demand loading saves over 95% of irrelevant context.

For example, the “API Networking Development” Skill’s description is “API networking development specification.” When AI needs to write network requests in Stage 4, it automatically matches and loads the Skill’s complete templates (API class selection guide, request templates, URL construction patterns, error handling). If the task is unrelated to APIs, this knowledge never enters the context.

4. Structured Task Table: Breaking Context Length Limits

Cursor sessions have context length limits. If a requirement includes 10+ coding tasks, by the 7th or 8th, AI may have forgotten which tasks were already completed. Relying solely on context memory is unreliable.

We embed a structured task table (Markdown table) in the Stage 3 technical design:

#	Task Name	Type	Skill	Files Involved	Status
1	Add xxx field	Data	data-model	parsers.xml	⬜ Pending
2	Add xxx API	Logic	api-development	CoreXxx.java	⬜ Pending

Status enum: ⬜ Pending → 🔄 In Progress → ✅ Complete → ⏭️ Skipped.

The table is written to a file on disk; AI can re-read the latest status at any time without depending on the context window’s “memory.” I evaluated JSON-based tracking but chose MD tables — humans can directly read and write them, AI parses MD tables effortlessly, and maintaining a separate JSON file only adds synchronization burden.

5. Self-Learning Loop: Cross-Requirement Knowledge Accumulation

During each requirement’s development, AI needs to search for similar implementations in the project to understand coding conventions. The first time a requirement type is encountered, 3-5 files need searching; if the same search is repeated for the second similar requirement, that’s efficiency loss.

The solution is maintaining a supplementary learning notes file convention-learnings.md. Before coding in Stage 4, AI reads this file and skips already-recorded patterns; during post-coding self-review, newly discovered patterns are appended. The next requirement’s Stage 4 directly reads the notes, skipping redundant searches.

flowchart LR Start["Before coding"] --> Read["Read convention-learnings.md"] Read --> Skip["Skip recorded patterns"] Skip --> Code["Code"] Code --> SelfReview["Self-review"] SelfReview --> Append["Append new findings"] Append --> Next["Next req reads notes"]

Key constraint: AI never modifies Skill files themselves, only maintains supplementary notes. The reasoning: if AI writes incorrect patterns into a Skill (core instruction), all subsequent requirements are contaminated; if the notes file has errors, deletion suffices — controllable impact. This design borrows from the Hermes Agent’s Closed Learning Loop, with added safety boundaries.

6. Cross-Requirement Knowledge Persistence

Another persistent file, project-memory.md, addresses cross-requirement “background knowledge” transfer: current database version, which APIs are deprecated, special technical decisions, lessons learned. After requirement A completes (Stage 6), AI appends this information; when requirement B starts (Stage 1), it’s auto-loaded — no need to grep or review commit history.

A deprecation mechanism is in place: when the file exceeds 80 lines, outdated entries are cleaned to prevent unlimited growth and loading overhead.

Stage Details

Stage 0: Code Sync

Terminal window

git fetch origin && git checkout origin/main && \
git submodule foreach 'git fetch origin && git checkout origin/master'

Ensures starting from the latest code baseline. Proceeds directly to Stage 1 without human confirmation.

Stage 1: Requirements Analysis

Load project-memory.md for cross-requirement context.
Read PRD + API docs. Three input modes supported: DingTalk document links (fetched as Markdown via DingTalk MCP), local files, or user-pasted text.
Extract client-side features, list unknowns and edge case gaps; cross-check API docs against PRD for contradictions.
Output docs/[requirement-name]/analysis.md and request confirmation.

Stage 2: Design Analysis

When a Figma link is available, Framelink MCP reads layers/styles/layouts; otherwise, PRD screenshots are used. The design conversion Skill is invoked for px→dp/sp conversion, color format mapping, and layout structure inference. Output is appended to the analysis document.

Stage 3: Technical Design

Three files are produced:

tech-design.md (with task table) and its .html visual version
server-integration.md

The task table in the technical design is the sole basis for subsequent coding. Each task is annotated with type (data/logic/UI), the Skill to invoke, and the list of files involved. The table also serves as a progress tracking board.

Stage 4: Task-by-Task Coding

Each task follows a fixed pipeline:

flowchart LR A["Read convention-learnings.md"] --> B["Search similar implementations
(new scenarios only)"] B --> C["Load corresponding Skill"] C --> D["Code"] D --> E["Module compile"] E --> F{"Ask Question confirm"} F -->|Pass| G["Update task table status"] F -->|Reject| D G --> H["Next task"]

After all tasks are complete, a coding standards self-review (5-item checklist) is executed:

Prohibited patterns check (e.g., context.getColor(), direct SharedPreferences calls)
Constant consistency
Repository-specific constraints
Import completeness (no fully-qualified class names in code body)
Android security self-review (android:exported declarations, hardcoded tokens, new permissions, debug code isolation)

After self-review passes, newly discovered coding patterns are appended to convention-learnings.md.

Stage 5: Full-Build Verification

This stage performs real-device UI verification, not unit testing. The flow:

flowchart LR A["PRD feature checklist"] --> B["Compile & install"] B --> C["Launch App"] C --> D{"Android MCP
screen-by-screen verification"} D --> E["All features checked?"] E -->|No| F["Locate issue"] F --> C E -->|Yes| G["Output verification-report.html"]

Android MCP can execute dump_ui_hierarchy, tap operations, and screenshots. AI obtains the UI tree and checks each feature against the PRD. The verification report is a single-file HTML (inline styles, not committed to git) containing feature cards, status filtering, and environment info.

Stage 6: Submit MR

Confirm change scope (main project + Git submodules).
Create branch, update .gitmodules.
Commit and push.
Create submodule MR → main project MR.
Persist project learnings: Append this requirement’s API changes, database version changes, lessons learned, etc., to project-memory.md.

MCP Integration & Toolchain

MCP Server	Function	Applied Stage
DingTalk Docs MCP	Read online DingTalk documents (PRD/API docs), return Markdown	Stage 1
Framelink MCP for Figma	Read Figma design layers/styles/layouts	Stages 2, 5
Android MCP	Real-device UI dump, tap, screenshot	Stage 5
Code Review MCP	Remote MR diff reading + comment submission	Optional (Stage 5.5)
Context7	Query third-party library docs (Fresco, RxJava, etc.)	On demand
Sequential Thinking	Step-by-step reasoning for complex problems	On demand

Design Reflections

1. Why Not Parallel Agents?

Requirements development is inherently serial: technical design determines coding direction, coding determines verification content, verification determines MR scope. Parallel agents have no independent work units to allocate in this scenario and would instead cause code conflicts and context fragmentation. Cursor’s /multitask is suited for truly independent parallel tasks (like running lint and tests simultaneously), not for pipelines with dependencies.

2. Why Gate Every Stage?

Two reasons: first, quality calibration — AI decision quality in long chains degrades with step count, and each confirmation is a “realignment”; second, responsibility boundaries — after user confirmation, if issues arise, the problematic stage’s decision can be precisely located.

3. Why Do Skills Only Write to Supplementary Files?

Letting AI directly modify Skill files carries two risks: first, prompt injection — if AI writes incorrect patterns into a Skill, all subsequent requirements are affected; second, knowledge degradation — accumulated “learnings” may overwrite carefully human-crafted specifications. The supplementary file convention-learnings.md allows humans to review and delete incorrect entries at any time, and clearing it “resets learning” — far lower risk than modifying Skills themselves.

4. Design Constraints from Token Economics

Empirical data from the Claude Code community shows: reducing alwaysApply content from 800 tokens to 500 tokens can jump prompt cache hit rate from 12% to 61%. This is because Anthropic’s prompt caching is sensitive to prefix matching — the more stable the system prompt, the higher the cache hit rate and lower the cost. This explains our decision to keep the core constraint layer extremely thin and stable.

5. Ultimate Reflection: Process Automation vs. General Intelligence

The current workflow isn’t “AI replacing humans” but a hybrid model where humans define processes and AI executes tasks. Gating decisions are human-made; AI handles repetitive, rule-clear execution tasks (reading docs, writing code, running verification). This division of labor is the most pragmatic for now — AI’s generation and reasoning capabilities still have boundaries, but process-oriented orchestration can maximize its deterministic benefits.

If your team is also experimenting with AI-assisted development, I suggest starting from the weakest link: make AI stop and wait for your confirmation at key decision points, rather than letting it run to completion. This single change often delivers the most direct quality improvement. From there, gradually introduce knowledge persistence, layered loading, and other mechanisms to build a full-process automation system suited to your project.

dead-code-pruner: Automated Dead Code Cleanup After Boolean Constant Folding

Tue, 19 May 2026 00:00:00 GMT

Large projects inevitably accumulate boolean flags that are “always true” or “always false” — BuildConfig.IS_PRODUCTION, FeatureFlags.isLegacyMode(), various runtime switches. Once a flag’s value is fixed, the code it guards becomes dead code.

A few if(false) blocks don’t affect compilation, but hundreds scattered across dozens of modules are a different story: IDE indexing slows down, code search becomes noisy, newcomers are misled by defunct logic, and APK size bloats unnecessarily.

Manually fixing hundreds of occurrences isn’t practical, and IDE Inspections only handle the simplest if(true) cases. I built a Python tool for this — dead-code-pruner.

What It Does

Give it a config file specifying which expressions are always true or false:

replacements:
  - pattern: "BuildConfig.IS_PRODUCTION"
    value: true
  - pattern: "FeatureFlags.isLegacyMode"
    value: false

The tool runs a 6-step pipeline. Each step’s output may create new simplification opportunities for the next, so the entire pipeline loops until convergence — stopping when a round produces no file changes.

flowchart TB subgraph Phase1 ["Phase 1: Constant Folding + Boolean Simplification"] S1[step1 Constant Substitution] --> S2[step2 Simple Boolean] S2 --> S3[step3 Compound Boolean] S3 --> S4[step4 If-Block Elimination] S4 -- changes found --> S1 end subgraph Phase2 ["Phase 2: Method Inlining + Cascade Simplification"] T1[step5 Constant-Return Inlining] --> T2[step2 Simple Boolean] T2 --> T3[step3 Compound Boolean] T3 --> T4[step4 If-Block Elimination] T4 -- changes found --> T1 end subgraph Phase3 ["Phase 3: Dead Method Cleanup + Cascade Simplification"] U1[step6 Dead Method Cleanup] --> U2[step2 Simple Boolean] U2 --> U3[step3 Compound Boolean] U3 --> U4[step4 If-Block Elimination] U4 -- changes found --> U1 end Phase1 -- converged --> Phase2 Phase2 -- converged --> Phase3 Phase3 -- converged --> E((Done))

Why Iterative Convergence Is Needed

Consider this code:

if (BuildConfig.IS_PRODUCTION) {
    showProduction();
} else {
    if (isLegacy()) {
        handleLegacy();
    }
}

Phase 1’s step1 replaces BuildConfig.IS_PRODUCTION with true, and step4 expands the if(true) block and removes the else block. Round complete.

But after handleLegacy() is removed, the isLegacy() method may become caller-free. Phase 3’s step6 scans and finds it’s a dead method, removing its definition. And isLegacy() might internally call other methods… cascading effects.

Running the pipeline only once would miss these cascade-generated dead code paths.

The 6 Steps Explained

step1: Constant Substitution

Reads the config file and replaces matching expressions with boolean literals. All substitution operations share a tokenizer that splits source code into “code segments” and “non-code segments” (comments, string literals), only modifying code segments. Without this protection, comments like // BuildConfig.IS_PRODUCTION would also be modified.

step2: Simple Boolean Simplification

Handles unary and binary boolean operations. The tool registers a complete pattern table internally:

Pattern	Result
`!true`	`false`
`!false`	`true`
`true == true`	`true`
`false == false`	`true`
`true == false`	`false`
`false == true`	`false`
`true != false`	`true`
`false != true`	`true`
`true != true`	`false`
`false != false`	`false`

It also handles redundant parentheses: (true) → true, (false) → false, but only in safe contexts — it won’t strip the parentheses in if(true) (syntax requirement) or in function calls like foo(true). The tool checks the token preceding the parenthesis: if/while/for → don’t strip; return/throw/operator/line start → safe to strip.

step3: Compound Boolean Simplification

Handles short-circuit operations and ternary expressions with correct operator precedence. Covered patterns:

Pattern	Result	Notes
`false && EXPR`	`false`	Short-circuit, EXPR entirely removed
`EXPR && false`	`false`	Reverse short-circuit
`true && EXPR`	`EXPR`	Identity elimination
`EXPR && true`	`EXPR`	Same, including preceding comment lines
`true \|\| EXPR`	`true`	Short-circuit
`EXPR \|\| true`	`true`	Reverse short-circuit
`false \|\| EXPR`	`EXPR`	Identity elimination
`EXPR \|\| false`	`EXPR`	Same
`true ? X : Y`	`X`	Ternary elimination
`false ? X : Y`	`Y`	Ternary elimination
`false + ""`	`"false"`	String concatenation folding
`true + ""`	`"true"`	Same

There’s an easy-to-miss precedence issue: true || A && B should simplify to true, not true || A leaving B behind. Because && has higher precedence than ||, A && B is a single operand of || and should be eliminated entirely. The tool treats && expressions as atomic units when processing ||.

Nested ternary expressions like condition ? (innerCond ? A : B) : C require tracking parenthesis depth and ternary nesting depth to find the correct : position — you can’t simply find the first colon.

Each pattern match also avoids ==/!= contexts — the true in x == true is a comparison operand, not a short-circuit left-hand side.

step4: If-Block Elimination

Covered scenarios:

Input	Output
`if (true) { A }`	`A` (block contents expanded)
`if (true) { A } else { B }`	`A`
`if (true) { A } else if (X) { B } else { C }`	`A` (entire else-if chain removed)
`if (false) { A }`	Removed
`if (false) { A } else { B }`	`B`
`if (false) { A } else if (X) { B } else { C }`	`if (X) { B } else { C }`
`if (false) return X;`	Removed (single-line, no braces)

Dead code deletion must not cross switch/case labels. Java’s cases lack explicit closing, and deleting too much would swallow adjacent case code.

step5: Constant-Return Method Inlining

Scans all method definitions for methods that only contain return true; or return false;, replacing call sites with the constant value:

// Before inlining
private boolean isLocal() { return false; }
if (isLocal()) { ... }

// After inlining
if (false) { ... }  // Cleaned up by step4 in the next round

There’s a subtle bug: when shouldBlock(); is a standalone statement, inlining turns it into false; — not a valid Java statement. The solution is to scan the file after inlining and remove all standalone true;/false; lines.

step6: Dead Method Cleanup

Finds empty void methods and constant-return boolean methods, removing both definitions and call sites.

This step requires building an in-memory reference index. A project might have tens of thousands of source files; running a global grep for each method’s references would take prohibitively long. The approach is to traverse all files once to build a method name → reference location inverted index, with subsequent lookups in memory. Complexity drops from O(N×M) to O(N+M). In practice, this turned “can’t finish” into 40-second completion.

Safety boundaries:

Exact parameter count matching — render() and render(dialog) are different methods
Non-private methods: inline calls only, don’t delete definitions — protected/package-private methods may be @Overriden by subclasses; static analysis can’t determine safety
Skip interface methods, abstract methods, @Override methods — builds class hierarchy to exclude framework-constrained methods
Chained call protection — method().subscribe() chains won’t break from removing void calls

Usage

Terminal window

git clone https://github.com/OldJii/dead-code-pruner.git

# Place a config in the project root
cp dead-code-pruner/pruner.example.yaml pruner.yaml
# Edit pruner.yaml

# Preview
python3 dead-code-pruner/prune.py . --dry-run

# Execute
python3 dead-code-pruner/prune.py .

# Verify compilation
./gradlew compileDebugJavaWithJavac

You can run a single phase (--phase 1/2/3) or execute individual steps (python3 step3_compound_boolean.py .). Zero external dependencies, Python 3.8+. YAML config requires PyYAML; use JSON format if you don’t want to install it.

In Practice

I used this tool for a complete cleanup on a medium-to-large Android project with hundreds of runtime boolean checks. The config file needed just one line: pattern: "BuildConfig.IS_PRODUCTION", value: true. After running the three-phase pipeline — boolean simplification → method inlining → dead method cleanup — everything was handled automatically.

Afterward, resource cleanup was done with Android’s shrinkResources and Android Studio’s Remove Unused Resources. Watch out for getIdentifier() dynamic resource references — shrinkResources can’t detect these reference relationships, so matching patterns need to be added to keep.xml as a whitelist.

The final APK went from 125 MB to 113 MB — roughly 12 MB reduction (nearly 10%). DEX shrank by 6 MB (source-level cleanup + R8 optimization positive feedback loop), resources by 5 MB.

Ongoing Maintenance

Cleanup isn’t a one-time event. Every main branch merge can introduce new conditional code. The tool is designed for repeated execution — run python3 prune.py . after merges to automatically clean incremental changes, no business logic understanding needed.

Limitations

Targets Java/Kotlin source files, based on pattern matching rather than semantic analysis
Cannot handle intermediate variable assignments (boolean x = BuildConfig.FOO; if (x) ...)
step6 dead method detection is deliberately conservative: only removes truly empty-body or single-constant-return methods

Conservative is intentional — leaving empty shell methods causes no bugs; deleting the wrong ones will.

Design Choices

Why not use AI / IDE? I evaluated both Cursor file-by-file editing and AS Inspections. AI’s context window can’t cover the complete reference chain of tens of thousands of files, and results vary each time. IDE only handles the simplest if(true) — nested ternaries, short-circuit operations, and cascading dead code are all ignored. Script behavior is deterministic — same input, same output; fix the script if it’s wrong and re-run.

Why 6 separate files? Each step can be run and debugged independently. When troubleshooting, you can run just step3 to see compound boolean simplification results without running the full pipeline.

Why subprocess instead of import? Isolation. Each step has its own file scanning logic and state; process isolation prevents shared-state bugs. The full pipeline runs in ~40 seconds, making process startup overhead negligible.

MCP Dock: Unified Config Management for 14 AI Clients

Mon, 18 May 2026 00:00:00 GMT

I’ve previously written two MCP-related posts — using Cursor for Code Review and a Cursor × Figma technical investigation. The biggest takeaway wasn’t how powerful MCP is, but how tedious the configuration is.

Every time you add an MCP Server, you have to manually edit claude_desktop_config.json, .cursor/mcp.json, .vscode/mcp.json… and the formats aren’t even the same. As my collection of AI tools keeps growing and each addition means editing multiple files, I got fed up.

So I built MCP Dock — a desktop app that unifies configuration management.

Project: OldJii/mcp-dock

Demo

Features

Store: Aggregates 9,200+ MCP Servers — browsable, searchable, sortable by Stars. Plus 3,100+ AI Skills.

One-Click Install: Pick a Server, select which clients to install it on, fill in the parameters, click install. The configuration is automatically written to each client’s config file. Currently supports Cursor, VS Code, Claude Code, Gemini CLI, Codex CLI, Windsurf, Zed, TRAE, TRAE CN, Kiro, Opencode, JetBrains, Antigravity, and OpenClaw — 14 clients in total.

Inspector: No need to spin up an IDE just to test a Server. The built-in Inspector lets you connect to a Server and inspect its Tools and Resources responses.

History: Every config change is automatically backed up. If something breaks, view the diff and roll back with one click.

Configuration Differences

Only after building this did I realize how varied the config formats are across clients — despite everyone supporting MCP:

Client	Format	Config Path	Server Field
Cursor	JSON	`~/.cursor/mcp.json`	`mcpServers`
VS Code	JSONC	`~/.vscode/mcp.json`	`servers`
Claude Code	JSON	`~/.claude.json`	`mcpServers`
OpenClaw	JSON5	`~/.openclaw/openclaw.json`	`mcp.servers`
Windsurf	JSON	`~/.codeium/windsurf/mcp_config.json`	`mcpServers`
JetBrains	JSON	Per-IDE config directories	`mcpServers`

JSON, JSON5, JSONC — three formats mixed together, with inconsistent field paths. An abstraction layer handles this internally.

JetBrains is even trickier — it’s not one tool but a family of IDEs (IntelliJ IDEA, WebStorm, PyCharm, GoLand…), each with different config directories, and both CE and Ultimate editions. MCP Dock scans for all JetBrains instances on the system and manages them uniformly.

Local-First

Config files, API keys, and history all stay local — nothing goes to the cloud. MCP configs frequently contain API keys and tokens; these should never leave the user’s machine.

Store data is served via CDN for fast loading globally. No account system, no login required.

Installation

Terminal window

# macOS
brew install --cask OldJii/tap/mcp-dock

# Or download manually
# https://github.com/OldJii/mcp-dock/releases

Supports macOS (Intel / Apple Silicon), Windows, and Linux (AppImage / deb).

Android 16KB Page Size Adaptation

Wed, 18 Mar 2026 00:00:00 GMT

Starting November 1, 2025, Google Play requires all new apps and updates to support 16KB page size devices. This post documents the pitfalls and lessons learned during this adaptation.

Background

Android 15 introduced the 16KB page size mode. Traditional Linux and Android use 4KB pages, while ARM architecture natively supports 4KB / 16KB / 64KB page sizes. Google’s core motivation for pushing 16KB is larger TLB coverage and fewer page table levels, which significantly reduces TLB misses in memory-intensive scenarios and improves overall performance. Devices like Pixel 8/8a have already enabled 16KB mode by default on Android 16.

On the surface, adaptation is just adding a -Wl,-z,max-page-size=16384 linker flag to SOs, but in practice it’s far from that simple. Our project APK contained 133 arm64 SOs from extremely diverse sources, ultimately involving coordinated changes across 9 base library repositories and 6 business submodules.

SO Source Analysis

An SO’s origin in a medium-to-large app typically falls into these categories: self-built NDK compilation output, third-party SDK AAR bundles, transitive dependencies (you might not even know they exist), and remote dynamic delivery (not in the APK but loaded at runtime).

The first step is building a complete inventory, grouping all SOs in the APK by dependency and tracing each to specific Maven coordinates and version numbers. This is the foundation for all subsequent work. We used Gradle’s dependency tree combined with unzip -l on the APK to compile the full list, mapping each SO to its specific dependency chain — this inventory proved invaluable for later troubleshooting.

p_align Declarations Are Unreliable

Android 16’s linker64 uses FixMinAlignFor16KiB() to calculate the real compatible page size from LOAD segment actual file offsets, not relying on the p_align declared in ELF headers.

During adaptation, we found some SDKs only declared p_align = 0x4000 in the ELF header while LOAD segment file offsets remained 4KB-aligned — this causes direct loading failure on linker64. When communicating with SDK vendors, explicitly state: changing p_align alone is insufficient; recompilation and relinking is required.

The only reliable verification is real-device loading:

Terminal window

adb push libxxx.so /data/local/tmp/
adb shell /system/bin/linker64 /data/local/tmp/libxxx.so

Success outputs load_bias=0x...; failure reports alignment (4096) is not a multiple of the page size (16384). readelf -l can assist verification, but linker64 real-device results are authoritative.

Categorized Handling

Incompatible SOs don’t have a one-size-fits-all fix; they need categorized handling.

Self-Built SOs with Source Code

The simplest case — add the linker flag during NDK compilation:

Android.mk

LOCAL_LDFLAGS += -Wl,-z,max-page-size=16384

# CMakeLists.txt
target_link_options(your_lib PRIVATE -Wl,-z,max-page-size=16384)

Note: if the SO statically links third-party libraries (like OpenSSL), all linked libraries must also be compiled with 16KB alignment. Missing any single static library makes the final SO incompatible. We hit this exact pitfall — when recompiling FFmpeg, we missed the OpenSSL build script, causing HTTPS video playback to fail. It took quite a while to trace it back to OpenSSL’s SO not being recompiled.

Another subtle issue is FFmpeg legacy version assembly compatibility. FFmpeg 3.4’s aarch64 NEON assembly (fft_neon.S, h264idct_neon.S, sbrdsp_neon.S, etc.) has PIC relocation incompatibilities that cause compilation failure in 16KB alignment mode. The short-term fix is --disable-asm to disable assembly optimization (hardware decoding is unaffected); long-term requires upgrading to FFmpeg 4.x+ to restore assembly acceleration.

Third-Party SDKs

Contact SDK vendors for 16KB-compatible versions. Most major SDKs had already released or were releasing compatible versions by 2025.

Remotely Delivered SOs

If an SO isn’t packaged in the APK but loaded at runtime through a remote delivery mechanism, exclude it in build.gradle:

android {
    packagingOptions {
        jniLibs {
            excludes += ['**/libxxx.so']
        }
    }
}

These SOs rely on the remote delivery mechanism for version compatibility and aren’t constrained by APK packaging. But watch for consistency between excludes configuration and the remote delivery manifest — we discovered a case where an SO was excluded in excludes but the remote delivery config marked it for local loading, causing a runtime not-found error.

Deprecated SOs

The best fix is removal. During adaptation, we found multiple SOs with no code references or deprecated functionality. Deleting them directly solved the 16KB issue while reducing package size. For example, our project had several early security hardening components; after the server team confirmed the related feature fields were deprecated, we cleaned up the SOs along with their ProGuard rules and initialization code.

SDKs Without Near-Term Compatible Versions

The trickiest situation. If an SDK vendor can’t provide a 16KB version promptly, assess the impact scope of SO loading failure on the app, and add fallback logic where necessary. For instance, we implemented a degradation for video thumbnail extraction — when the native library fails to load, it falls back to MediaMetadataRetriever’s pure Java implementation, preventing the entire feature from becoming unavailable.

Removing SoLoader

Many projects using Facebook open-source libraries (Fresco, Litho, etc.) load SOs via SoLoader. SoLoader has compatibility issues under 16KB mode — when decompressing SOs to the app’s private directory, alignment requirements may not be met.

Our approach was to completely remove SoLoader: upgrade Fresco to 3.x (no longer requires SoLoader), replace all SoLoader.loadLibrary() with System.loadLibrary(), and remove SoLoader.init() initialization calls.

Watch for side effects after removal: if you previously relied on SoLoader’s automatic dependency resolution to load libc++_shared.so, ensure this SO is correctly packaged in the APK after removal. One of our project’s flavors crashed during debug builds for this reason — the STL shared runtime library wasn’t correctly packaged.

Fresco 1.x → 3.x

The Fresco major version upgrade was one of the highest-effort parts of this adaptation:

AnimationListener interface signature change: callback parameter changed from AnimatedDrawable2 to Drawable
ImagePipeline.getMainFileCache() removed; disk cache lookup now uses getDiskCachesStoreSupplier()
ImagePipelineNativeLoader.load() no longer needs manual invocation
CircleProgressBarDrawable and other custom Drawables conflict with built-in versions; custom implementations must be removed
DefaultLifecycleObserver shim class must be removed in favor of the built-in AndroidX version

Recommended: global search for keywords like AnimatedDrawable2, getMainFileCache, SoLoader, ImagePipelineNativeLoader and fix each occurrence.

Reflection Restrictions

Android 16 tightens reflective access to system properties. If code or SDKs use SystemProperties.get("net.dns*") to retrieve DNS, it will fail on 16KB mode devices. Use public APIs instead:

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
Network network = cm.getActiveNetwork();
LinkProperties props = cm.getLinkProperties(network);
List<InetAddress> dnsServers = props.getDnsServers();

Verification

Post-adaptation verification has two parts.

SO Compatibility Verification: Use linker64 to load every arm64 SO in the APK one by one, establishing a compatibility baseline. After handling all incompatible SOs per the categorized strategies above, run full verification again.

Functional Regression: Dual-device regression on both 16KB devices (Pixel 8/8a, Android 16) and regular devices. Focus coverage on SO-heavy feature areas — video playback/recording, live streaming with co-hosting, voice message recording/playback, face authentication, image loading/caching, data persistence (database reads/writes), crash collection, and hot updates. These scenarios all have native libraries working behind the scenes and are the most likely failure points.

Additionally, integrating SO alignment checks into CI is recommended to prevent future iterations from introducing incompatible SOs.

Bonus Cleanup

The 16KB adaptation was a forced opportunity to touch the entire SO dependency graph, so we also performed some housekeeping: built a complete SO dependency inventory (source, version, Maven coordinates, and full transitive chains all recorded), removed multiple deprecated security components and SDKs, unified transitive dependency versions with resolutionStrategy.force, and audited remote delivery configs to ensure consistency with excludes.

Overall, 16KB adaptation isn’t just a compiler flag change — it’s a deep audit of an app’s entire native dependency landscape. The core challenges are scattered SO sources, verification requiring real devices, different SOs needing different handling strategies, and API changes from the Fresco major version upgrade. It involves coordinated changes across multiple base library repositories and business modules, and releases need to proceed in dependency order. Start early to leave buffer time for SDK vendor upgrades and internal testing.

Code Review with Cursor

Sun, 04 Jan 2026 00:00:00 GMT

Code Review is an integral part of the development workflow, but manual review has limited efficiency and easily misses issues. This article introduces a tool I built that lets Cursor directly read PRs/MRs, analyze code changes, generate review comments, and submit them to the corresponding platform.

Project: https://github.com/OldJii/code-review-mcp

Approach

Cursor itself doesn’t have the ability to access GitHub/GitLab APIs — it needs MCP (Model Context Protocol) for extension. MCP is a protocol by Anthropic that allows AI models to interact with external data sources and tools.

The overall approach:

Build an MCP Server wrapping GitHub/GitLab APIs
Configure this MCP Server in Cursor
Define review standards in mdc rule files to constrain AI’s review behavior
Chat in Cursor, having AI read PRs, analyze code, and submit comments

MCP Server

The MCP Server is implemented in Python, communicating with Cursor via stdio. The core is an abstract CodeReviewProvider base class, with GitHub and GitLab each implementing their specific logic.

class CodeReviewProvider(ABC):
    @abstractmethod
    def get_pr_info(self, repo: str, pr_id: int) -> Dict:
        pass

    @abstractmethod
    def get_pr_changes(self, repo: str, pr_id: int) -> Dict:
        pass

    @abstractmethod
    def add_inline_comment(self, repo: str, pr_id: int, file_path: str,
                          line: int, line_type: str, comment: str) -> Dict:
        pass

    @abstractmethod
    def add_pr_comment(self, repo: str, pr_id: int, comment: str) -> Dict:
        pass

The API differences between GitHub and GitLab are mainly in two areas:

Authentication: GitHub uses Bearer Token; GitLab uses PRIVATE-TOKEN Header
Inline comments: GitLab requires computing line_code; GitHub directly uses line numbers

Token Retrieval

To simplify configuration, rather than having users manually enter tokens, we reuse authentication from the gh and glab CLI tools.

GitHub directly calls gh auth token:

def _get_token(self) -> str:
    try:
        result = subprocess.run(
            ["gh", "auth", "token"],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            return result.stdout.strip()
    except FileNotFoundError:
        pass
    return ""

GitLab requires parsing from glab’s config file:

def _get_token(self) -> str:
    config_paths = [
        Path.home() / ".config" / "glab-cli" / "config.yml",
        Path.home() / "Library" / "Application Support" / "glab-cli" / "config.yml",
    ]

    for config_path in config_paths:
        if config_path.exists():
            with open(config_path, 'r') as f:
                content = f.read()
            pattern = rf'{re.escape(self.host)}:.*?token:\s*([^\s\n]+)'
            match = re.search(pattern, content, re.DOTALL)
            if match:
                return match.group(1).strip()
    return ""

This way, users only need to run gh auth login or glab auth login, and the MCP Server automatically picks up the token.

GitLab Inline Comments

GitLab’s inline comment API is more complex, requiring a line_code parameter. This parameter’s format is {head_sha}_{old_line}_{new_line}, which needs to be parsed from the diff.

def _find_line_code(self, diff: str, target_line: int, line_type: str, head_sha: str) -> str:
    lines = diff.split('\n')
    old_line = 0
    new_line = 0

    for line in lines:
        if line.startswith('@@'):
            match = re.match(r'@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@', line)
            if match:
                old_line = int(match.group(1)) - 1
                new_line = int(match.group(2)) - 1
        elif line.startswith('-'):
            old_line += 1
            if line_type == "old" and old_line == target_line:
                return f"{head_sha}_{old_line}_"
        elif line.startswith('+'):
            new_line += 1
            if line_type == "new" and new_line == target_line:
                return f"{head_sha}_{old_line}_{new_line}"
        else:
            old_line += 1
            new_line += 1

    return ""

The core logic traverses diff content, parses starting line numbers from @@ headers, then tracks old_line and new_line changes to find the line_code for the target line.

MCP Tools

Six tools are ultimately exposed to Cursor:

Tool	Description
`get_pr_info`	Get PR/MR title, description, branch info, etc.
`get_pr_changes`	Get code changes, supports file type filtering
`extract_related_prs`	Extract related PR links from descriptions
`add_inline_comment`	Add an inline comment
`add_pr_comment`	Add an overall comment
`batch_add_comments`	Batch add comments

batch_add_comments exists to reduce the number of user confirmations by submitting all comments at once.

Review Standards

MCP solves the “what can be done” question; “how to do it” is constrained through mdc rule files.

mdc is Cursor’s rule file format, definable in a project’s .cursor/rules/ directory. AI references these rules during conversations.

Core Principles

The review standard’s core is “understanding first”:

Understand the overall PR purpose before examining specific diffs
Deep analysis (architecture/logic/performance) takes priority over style checking
Only raise “confirmed issues,” not “possible issues”
Analyze with context, don’t judge in isolation

The last point is crucial. A common AI mistake is seeing a possibly-null variable and flagging NPE risk, when the caller has already validated it. The rules explicitly require AI to trace context to avoid false positives.

Review Flow

The rules define a complete review flow:

Get changes: Call get_pr_changes for all files’ complete diffs
Understand context: Grasp PR purpose from title, description, and change list
Deep analysis: Analyze architecture, logic, performance, and security per file
Deduplicate: Merge identical issues in the same file to avoid duplicate comments
Preview confirmation: Display all comments for user confirmation
Batch submit: Call batch_add_comments to submit all at once

Step 5 is key. AI-generated comments need human vetting to avoid submitting low-quality or incorrect feedback.

Priority Levels

Issues are categorized into three severity levels:

P0: Crashes, memory leaks, severe performance issues, security vulnerabilities
P1: Architecture issues, logic flaws, code quality
P2: Code reuse, naming improvements

P0 issues have no quantity limit; P1 and P2 dynamically adjust based on P0 count. If P0 exceeds 10, code quality is poor — reduce P1/P2 count to focus on critical issues.

Avoiding False Positives

The rules enumerate common false positive scenarios:

Type	False Positive Condition	Action
NPE	Caller already validates	Don’t flag
Out of bounds	Length checked upstream	Don’t flag
Performance	Data size ≤ 5	Don’t flag
Threading	Duration < 1ms	Don’t flag

These rules are distilled from real review experience. AI tends toward conservative judgments, easily flagging non-issues. These rules help AI more accurately identify genuine problems.

Usage

Configuration

MCP configuration is global — edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "code-review": {
      "command": "python3",
      "args": ["/path/to/cursor-ai-code-review/code_review_mcp.py"]
    }
  }
}

Review standards are project-level and need to be copied to each project’s .cursor/rules/ directory. This design accounts for different projects potentially having different review standards.

Reviewing

Once configured, simply type in Cursor:

Review https://github.com/owner/repo/pull/123

AI automatically calls MCP tools to fetch PR information and code changes, then reviews per the rules. After review, all comments are displayed for confirmation:

I deleted one line of import code from a Dart file in a Flutter project to demonstrate the tool’s workflow.

After confirmation, AI calls batch_add_comments to batch-submit comments to GitHub/GitLab.

Private GitLab

For self-hosted GitLab deployments, specify the address during authentication:

Terminal window

glab auth login --hostname gitlab.yourcompany.com

The MCP Server automatically reads the corresponding token from glab’s configuration.

Limitations

This tool currently has some limitations:

Limited context: AI can only see the diff, not the complete project code. Analysis ability is limited for issues involving multi-file interactions.
Rule dependency: Review quality largely depends on the completeness of mdc rules. Poorly written rules mean AI may miss issues or produce false positives.
Human confirmation required: Every comment submission requires human confirmation — cannot be fully automated. This is intentional to prevent AI from submitting low-quality comments.

Future improvements could include integrating more context, such as letting AI read related files and view commit history. Rules can also be continuously refined based on actual usage.

Summary

The core value of this tool is delegating the mechanical aspects of Code Review to AI, with humans only needing to confirm final results. In practice, AI’s detection rate for routine code issues (null pointers, resource leaks, performance hazards, etc.) is quite reasonable.

But AI cannot fully replace human review. Architecture design and business logic — issues requiring deep contextual understanding — still need human judgment. Using AI as an assistive tool that improves efficiency while maintaining human oversight is the most pragmatic approach today.

Cursor × Figma Technical Investigation

Thu, 11 Dec 2025 00:00:00 GMT

Exploring the feasibility of having AI directly read Figma designs and generate UI code.

Conclusion: Technically feasible, but fidelity is low in traditional XML projects. The investigation found that Jetpack Compose + Auto Layout is the ideal combination — production adoption requires both design and development teams to push for a tech stack upgrade together.

Figma MCP

MCP (Model Context Protocol) is a standard protocol enabling AI models to interact with external data sources and tools. cursor-talk-to-figma-mcp is built on MCP, establishing a bridge between Cursor and Figma that lets you directly:

Read complete Figma design information (layers, styles, layouts, components, etc.)
Edit Figma files (create shapes, modify properties, adjust layouts)
Generate code: produce corresponding UI code from designs

Setup

Step 1: Open Figma desktop, search for Cursor Talk To Figma MCP Plugin, and install it.

Step 2: The plugin and Cursor need a relay service to communicate. Open a terminal and run:

Terminal window

bunx cursor-talk-to-figma-socket

The service will listen on a local port once started. Keep the terminal window open.

If you don’t have bun installed, first run npm install -g bun.

Step 3: Open the plugin panel in any Figma file to see the Channel ID and MCP configuration info.

Step 4: Copy the configuration into Cursor’s mcp.json file.

Once configured, you can interact with Figma designs directly from Cursor’s Chat.

Permission Issues

Setup went smoothly, but usage hit a snag: enterprise accounts lack edit permissions.

Figma’s account system has two dimensions:

Dimension	Types
Account Type	Starter (free), Professional, Organization, Enterprise
Seat Type	Full Seat, Dev Seat, Collab Seat, View Seat

Our company uses an Enterprise account with developers assigned View Seats (read-only), meaning you can only view but not edit in the company Figma — and the Figma MCP plugin requires edit permissions to function.

Account	Seat	Can Use Plugin?
Company Enterprise	View Seat	No — no edit access in Drafts or Projects
Personal Starter (free)	Full Seat	Yes — full permissions in Drafts

Workaround: Copy the design to a personal account. Open the target design in the company Figma, select the needed Frame, Cmd + C to copy, switch to personal account, create a new file in Drafts, Cmd + V to paste.

Fidelity

After setup, I tried using Cursor to generate XML layout files from designs. The result was usable but with mediocre fidelity — generated code needed extensive adjustments.

Problem 1: Geometric Layouts Lack Semantics

Traditional Figma layouts are geometric — designers position elements using absolute coordinates:

Text A → (x: 20, y: 50)
Text B → (x: 20, y: 80)

AI receives this data and only knows two text boxes are 30px apart vertically, but can’t determine the designer’s intent:

Is this a vertical list with 30px fixed spacing?
Are these two independent elements that happen to be aligned?
Is this part of a list item that the designer manually duplicated?

AI can only guess using heuristics. Wrong guesses cause layout issues, and the guessing process itself consumes compute, affecting generation speed and accuracy.

Problem 2: XML Doesn’t Match Declarative Design

Even when designs use Figma’s Auto Layout (a declarative layout approach similar to frontend Flexbox), XML code generation results are suboptimal.

The root cause: Auto Layout is declarative, while XML layouts are imperative.

Auto Layout explicitly states “this is a vertical container with 30px spacing between children,” but converting to XML requires AI to translate these declarative rules into LinearLayout + layout_marginTop and other imperative attributes. This translation process loses significant information and is error-prone.

Investigation Conclusion

The investigation found that Jetpack Compose + Auto Layout is the ideal combination.

Compose is a declarative UI framework whose layout philosophy naturally aligns with Auto Layout. The mapping is:

Figma Auto Layout Property	Jetpack Compose Implementation
Horizontal	`Row { }`
Vertical	`Column { }`
No Auto Layout / Group	`Box { }`
Fill Container	`Modifier.fillMaxWidth()`
Hug Contents	`Modifier.wrapContentSize()`
Fixed Size	`Modifier.size(dp)`
Padding	`Modifier.padding()`
Space between items	`Arrangement.spacedBy()`
Alignment	`Arrangement.Center` / `Alignment.*`

Almost a one-to-one mapping. AI can directly map Auto Layout data to Compose code without guessing or conversion.

Current Value

Although it can’t perfectly reproduce UI in traditional XML projects, Figma MCP still offers value today:

Extract design parameters: Quickly get color values, font sizes, spacing, border radius, etc. without manual measurement
Understand page structure: Read layer hierarchy and naming to clarify component boundaries
Generate skeleton code: Produce rough layout frameworks for fine-tuning
Assist design reviews: Compare designs with implementations, quickly locate discrepancies

Treat it as an assistive tool, not a fully automated solution.

Upgrade Path

To truly leverage AI design-to-code capabilities, progress is needed from two directions:

Design Side

Adopt Auto Layout everywhere: Organize all components declaratively, not with absolute positioning
Establish a Design System: Unified design component library with standardized naming
Component-oriented thinking: Design at the same component granularity as development

Development Side

Migrate to Jetpack Compose: Declarative UI framework philosophically aligned with Auto Layout
Pair with KMP (Kotlin Multiplatform): One set of Compose UI code usable on both Android and iOS
Implement corresponding component library: One-to-one mapping between Figma components and code components

When both design and development adopt declarative paradigms and Figma components map to code components, AI only needs to “translate”:

Figma Auto Layout (declarative design)
    ↓ AI direct mapping
Jetpack Compose (declarative code)

At that point, a designer adjusting a button’s border radius and spacing in Figma, followed by a developer having AI sync the code in Cursor, takes just seconds — a dramatic efficiency improvement.

The ideal tech stack: Cursor + Figma MCP + Jetpack Compose + KMP + Auto Layout.

Guilin, Longsheng, and Yangshuo

Tue, 21 Oct 2025 00:00:00 GMT

I’ve always had a soft spot for landscapes. Growing up, I’d heard the saying “Guilin’s scenery is the finest under heaven,” and this time I finally made the trip during a holiday. This was my first solo trip — 7 days covering quite a few places. Before departing, I saw many posts on Xiaohongshu saying “you’ll want to leave Yangshuo after one day,” mostly complaining about tourist traps. But after experiencing it firsthand, the reality was quite different from what I’d read online.

For getting around: in Guilin city, I recommend a combination of shared e-bikes and ride-hailing. In Yangshuo, just rent an e-bike from your hotel — usually no deposit required (renting elsewhere requires one). Go for the bigger battery option; it’s slightly pricier but the extended range is worth it for visiting attractions.

If I were to subjectively tier the attractions I visited: Tier 1 would be the Li River three-star cruise, Yulong River bamboo rafting, the Thousand-Mile Landscape sunset viewpoint, and simply cruising around Yangshuo on an e-bike. Tier 2 would be Guihai Qinglan and Longji Rice Terraces. Places like Zhengyang Pedestrian Street, Elephant Trunk Hill, and Sun & Moon Twin Pagodas — I don’t think they’re worth a special trip. Not that they’re bad, but they’re too homogeneous; your hometown probably has something similar.

Guihai Qinglan

Guihai Qinglan is on the outskirts of Guilin proper, but the city is small and shared e-bikes are everywhere, so getting there isn’t a hassle. My hotel was near the Two Rivers and Four Lakes scenic area — about a 25-minute ride. Note that 1-2 km from the park, you’ll leave the e-bike service zone. Local aunties offer rides for 5 yuan to take you the rest of the way — very affordable.

The entire park feels like a scenic golf course — sprawling lawns, crystal-clear lakes, and rolling mountains in the distance. It’s like stepping into a fairytale. The park is huge, so take your time wandering. Find a nice spot, lie on the grass, and watch the sky meet the water — incredibly relaxing. The only downside is the heat; October in Guilin means intense sun on these open lawns until around 4 PM when it finally cools down. The park’s swans aren’t afraid of people at all, casually hanging around the lakeside.

Longji Rice Terraces

The Longji Rice Terraces are far from the city — I recommend booking a day tour with a round trip. When choosing a tour, skip any that include the Long Hair Village; it’s not worth it. I also wouldn’t recommend staying overnight on the mountain — the food options are limited, and there’s really only three things to do: enjoy the view, take portrait photos, and eat. I didn’t do a portrait session, and the food up there isn’t great. The bamboo rice that’s famous online tastes average — try it if your tour includes it for free, but don’t buy it. Better to eat back in Guilin proper.

The terraces themselves are genuinely beautiful, but there’s not much variety to see — a few glances and you’ve taken it all in, though you’d regret skipping it entirely. I recommend taking the cable car up and walking down. The descent has poor infrastructure — a long stretch shares the road with motor vehicles with no dedicated sidewalk, so be careful.

Li River

To get from Guilin to Yangshuo, I chose the Li River three-star cruise — this journey is not just transportation but a Tier 1 experience in my book. The route goes from Mopanshan Pier in Guilin to Longtoushan Pier in Yangshuo. Departures are at fixed times; the latest is 12:05. The scenic area offers a shuttle to the pier, but it won’t pick you up at your hotel — just a nearby meeting point — so I’d recommend taking a taxi yourself. I took the last noon departure, arriving 30 minutes early. The cruise takes about 4 hours, passing classic sights like Crown Cave, Yangdi, Nine Horses Mural Hill, and Yellow Cloth Reflection, with a guide narrating along the way. There’s food on board but it’s basic — better to eat after disembarking. At the pier exit, e-bike drivers offer rides; I suggest finding one to take you to your hotel since you’d have to walk quite far to hail a car.

Yulong River

You might wonder why I ranked “casually e-biking around Yangshuo” in Tier 1 — once you’re there, you’ll understand. Yangshuo’s beauty isn’t confined to any scenic area or specific location. Hop on an e-bike, ride along country roads, and you’ll find landscape-painting scenery everywhere. If the Li River is grandly magnificent, the Yulong River is elegantly refined — perfectly matching the traditional Chinese aesthetic of water in ink-wash paintings.

My top recommendation is the e-bike route along the Yulong River: Fuli Bridge → Yulong Bridge → Jiuxian Pier → Jima Pier → Shuiedi Pier. Park your e-bike at Shuiedi Pier and take the bamboo raft from there to the General Pier. After rafting, a shuttle takes you back to Shuiedi Pier, and you can continue riding to Zhudouzhai and Wanjing Pier. This route covers all the essential Yulong River scenery — an experience rivaling any 5A scenic area. Note: bamboo rafting costs 200 yuan per raft (seats two), so solo travelers should find a raft-mate in advance.

Sunset

Over 7 days I watched sunsets from many spots, but the most stunning was at the Thousand-Mile Landscape viewpoint. The setting sun bathes the rolling mountains in warm gold, clouds painted in tangerine-pink and deep purple. As the light sinks, mountain silhouettes shift from sharp to hazy — like a living ink-wash painting, serene yet magnificent.

A note on transportation: don’t ride an e-bike! It’s a 30km, 1-hour ride, the scenic area is on a mountain, the climb drains the battery, and mountaintop charging is slow due to low voltage. I nearly got stranded halfway. Plus, the return route on the national road has no streetlights in several sections — extremely unsafe after dark. Take a bus or taxi for peace of mind. Objectively, the variety here isn’t great and the scenery is somewhat one-dimensional — but this sunset alone is worth the dedicated trip. You’d genuinely regret missing it.

Unexpected Encounter

Compared to planned itineraries, unexpected encounters during travel are far more delightful. After posting about my trip on Xiaohongshu, a friend saw it and asked if I was heading to Guilin. Coincidentally, he had spontaneously planned a wild climbing trip to Yangshuo. We hit it off immediately — I adjusted my last two days’ itinerary, joined their climbing spot, and completed my first rock climbing session under my friend’s guidance.

A truly novel experience. Rock climbing demands total focus, letting you forget all your worries. No work performance pressure, no life’s distractions — just the rock wall before your eyes, the rough texture under your fingertips, and each carefully placed foothold. All that stress and anxiety seemed to be filtered away completely in that extreme concentration.

Rice Noodles

Finally, let’s talk about rice noodles. During my days in Guilin, I had at least one bowl every day. As a lifelong noodle enthusiast, I never got tired of them.

The rice noodle experience differs dramatically between Guilin city and Yangshuo. City noodles are delicious, cheap, and diverse; Yangshuo’s noodles offer no advantage in either price or taste. In the city, a medium serving of braised noodles is 6 yuan, a portion of crispy pork belly is 5 yuan — if prices are significantly higher, just try the next shop.

Guilin rice noodles arrive dry. I asked a local, and the proper way to eat them is to first toss them dry, then add broth when about a third remains, sipping soup while slurping noodles. Personally, I prefer adding broth right away — filling to about one-third of the noodle level — then adding an extra portion of crispy pork belly, extra pickled bamboo shoots, pickled radish, and roasted chili sauce, mixing everything thoroughly before digging in heartily.

One warning: go easy on the chili at first — start with a little, add more gradually. On my first night in Guilin, I misjudged the heat level and learned my lesson the hard way.

Multi-Image Layout Adaptation After Migrating to Slate

Sun, 13 Jul 2025 00:00:00 GMT

After migrating the blog from Hugo Even theme to the Astro-based Slate theme, the existing multi-image layout functionality needed re-adaptation due to the new theme’s different HTML structure.

In the Hugo Even theme, Markdown images are rendered as <a> tags wrapped in <p> tags, while the Slate theme uses <div class="rehype-figure-container"> wrapping <figure class="rehype-figure"> elements.

/* Two-image columns */
.rehype-figure-container:has(> .rehype-figure:nth-child(2)) {
  column-count: 2;
  column-gap: 8px;
  margin: 6px 0;
}

/* Three-image columns */
.rehype-figure-container:has(> .rehype-figure:nth-child(3)) {
  column-count: 3;
  column-gap: 8px;
  margin: 6px 0;
}

/* Four-image columns */
.rehype-figure-container:has(> .rehype-figure:nth-child(4)) {
  column-count: 4;
  column-gap: 8px;
  margin: 6px 0;
}

/* Five-image columns */
.rehype-figure-container:has(> .rehype-figure:nth-child(5)) {
  column-count: 5;
  column-gap: 8px;
  margin: 6px 0;
}

/* Six-image columns */
.rehype-figure-container:has(> .rehype-figure:nth-child(6)) {
  column-count: 4;
  column-gap: 8px;
  margin: 6px 0;
}

/* Image display handling */
.rehype-figure-container:has(> .rehype-figure:nth-child(2)) .rehype-figure,
.rehype-figure-container:has(> .rehype-figure:nth-child(3)) .rehype-figure,
.rehype-figure-container:has(> .rehype-figure:nth-child(4)) .rehype-figure,
.rehype-figure-container:has(> .rehype-figure:nth-child(5)) .rehype-figure,
.rehype-figure-container:has(> .rehype-figure:nth-child(6)) .rehype-figure {
  display: block;
  margin-bottom: 8px;
  break-inside: avoid;
}

.rehype-figure-container:has(> .rehype-figure:nth-child(2)) img,
.rehype-figure-container:has(> .rehype-figure:nth-child(3)) img,
.rehype-figure-container:has(> .rehype-figure:nth-child(4)) img,
.rehype-figure-container:has(> .rehype-figure:nth-child(5)) img,
.rehype-figure-container:has(> .rehype-figure:nth-child(6)) img {
  width: 100%;
  height: auto;
  display: block;
  margin: 0;
}

/* Responsive design */
@media (max-width: 768px) {
  .rehype-figure-container:has(> .rehype-figure:nth-child(2)),
  .rehype-figure-container:has(> .rehype-figure:nth-child(3)),
  .rehype-figure-container:has(> .rehype-figure:nth-child(4)),
  .rehype-figure-container:has(> .rehype-figure:nth-child(5)),
  .rehype-figure-container:has(> .rehype-figure:nth-child(6)) {
    column-count: 1;
    column-gap: 0;
  }
}

Usage rules remain the same as the Hugo Even theme. Images can have line breaks between them but not blank lines — CSS automatically adjusts column count based on the number of images in the container. Supports automatic 2-6 image columns.

Four-image demo:

For more image demos, see Hugo Multi-Image Layout for the Even Theme.

Add the CSS above to the Slate theme’s style file. The exact location may vary by theme configuration — typically src/assets/style/common.css, or create a new style file and import it in the theme config.

In-App Network Monitoring

Sat, 21 Jun 2025 00:00:00 GMT

App runtime environments are complex. A large proportion of user complaints center on “slow page loading,” “login failures,” and “unstable connections” — network-related issues that are often unreproducible in test environments. Traditional server-side monitoring or CDN logs cannot fully reconstruct the real network state on the client side.

The core objectives of this in-app network monitoring solution are:

Proactively sense the user’s actual current network conditions
Precisely identify the real root cause of network failures
Provide structured data support for diagnosing, fixing, and optimizing network issues

The implementation consists of two parts: application speed checks and DNS hijacking detection.

Application Speed Check

Principle

This module uses Android’s native TrafficStats API, measuring at the application UID granularity. Within a fixed short time window (5 seconds), it reads received traffic increments and calculates the client’s actual download speed by dividing increment bytes by time difference. This approach requires no extra permissions or network requests, runs lightweight, and reflects the user’s real network experience.

Check Triggers

App launch: Execute immediately on first launch
Network switch: e.g., switching from WiFi to cellular
App foreground resume: Avoid missing network state changes during background periods
Request failure: Assist in diagnosing network-layer causes
Every 20 seconds: Satisfy continuous sampling needs in long-session scenarios

Since detection inherently requires a 5-second sampling window, it naturally has built-in deduplication — no additional cooldown period needed. Additionally, to prevent concurrent multi-thread checks from causing statistical anomalies, an atomic variable marks the current check state, ensuring only one check runs at a time.

Data Reporting

Field	Example Value
Average download speed	`32.00 KB/s`
Current network type	`WIFI` / `4G` / `5G`
Carrier name	`China Unicom`
Cellular signal strength	`-88`
Roaming status	`false`
WiFi signal level	`3`

Note: Some fields require specific permissions (signal strength/WiFi level require ACCESS_FINE_LOCATION; roaming status requires READ_PHONE_STATE). The solution only checks for permissions without actively requesting them — if permissions are missing, corresponding fields aren’t reported. Speed values are automatically formatted as B/s, KB/s, or MB/s based on magnitude.

DNS Hijacking Detection

Principle

DNS hijacking is a common client-side network security issue, more likely to occur on public WiFi or with certain smaller carriers. We detect hijacking by comparing system DNS results against trusted DoH (DNS over HTTPS) service results.

System DNS: Results obtained via InetAddress.getAllByName()
DoH services: Authoritative results obtained through encrypted connections from Google DNS, AliDNS, and Tencent DNSPod

Google DNS: https://dns.google/resolve?name=%s&type=A
AliDNS: https://dns.alidns.com/resolve?name=%s&type=A
DNSPod: https://doh.pub/dns-query?name=%s&type=A

Trusted IP Pool and Caching

The trusted IP pool consists of two parts:

Current DoH results: IPs obtained from the three DoH services in this check
Historical DoH cache: Previously successfully resolved IPs via DoH, stored locally with a 90-day validity period

The cache uses a structured storage design with a core “domain-IP-timestamp” association: IPs are grouped by domain, each IP entry carries a last-updated timestamp for expiration checks. Core strategies:

Cache update: After each successful DoH resolution, valid IPs are added to the domain’s cache; existing IPs get their timestamps refreshed to maintain active IP validity
Expiration cleanup: Periodically filters out IP entries exceeding the 90-day validity period, preventing cache bloat on the device while ensuring timeliness

Before executing the judgment logic, a network connectivity check confirms the device is actually connected, avoiding misdiagnosis of no-network situations as DNS issues. The specific logic:

If all IPs returned by system DNS are in the trusted IP pool → resolution normal
If any system DNS IP is not in the trusted IP pool → suspected hijacking

This design accounts for CDN and load balancing scenarios where the same domain’s resolution results vary by time and region. Relying solely on real-time DoH comparison would easily misidentify normal IP rotation as hijacking. Maintaining historical DoH cache effectively mitigates this.

Check Triggers

To conserve device resources, DNS hijacking checks are triggered only when network requests fail AND match specific exception types, with a 5-second cooldown between checks. The cooldown’s core purpose is preventing a single network issue (like persistent connection failure) from repeatedly triggering detection: it reduces redundant DoH requests (saving user data) and avoids frequent thread utilization (improving app smoothness).

Compared to high-frequency triggers like launch or network switches, this on-demand trigger + precise exception matching strategy better fits real business scenarios while reducing unnecessary resource consumption.

Exception Type Set

The following network exceptions are highly correlated with DNS hijacking:

Exception Type	Cause Category	Description
`CertPathValidatorException`	Untrusted certificate	TLS certificate chain not trusted, common in MITM attacks
`SSLHandshakeException` / `SSLPeerUnverifiedException`	TLS handshake failure	Certificate chain anomaly or interrupted handshake, possibly hijacking-induced
`UnknownHostException`	DNS resolution failure	Cannot resolve domain to IP, commonly seen in DNS hijacking/poisoning
`ConnectException`	Connection refused	Network reachable but target port unresponsive, possibly a fake address post-hijack
`SocketTimeoutException`	TCP timeout	Network congestion or service unreachable, investigate alongside DNS results

Detection Result Categories

Based on system DNS and DoH resolution outcomes, results are classified as:

Result Status	Determination Condition	Description
Hijacked	Both system DNS and DoH succeed, but system IPs not in trusted pool	Suspected DNS hijacking
Network Issue	Network disconnection detected	Real network connectivity interruption
System DNS Failure	System DNS fails but DoH succeeds	Local DNS configuration issue
DoH Failure	System DNS succeeds but DoH fails	DoH service unavailable
Normal	All system DNS IPs in trusted pool	Resolution results consistent
Unknown	Network connected but all DNS services fail	DNS server issues or port blocking

This fine-grained classification helps quickly pinpoint root causes, avoiding the trap of attributing all anomalies to “hijacking.”

Data Reporting

Field	Example Value
Target domain	`api.example.com`
System DNS returned IPs	`[1.2.3.4, 5.6.7.8]`
DoH returned IPs summary	`GoogleDNS=[1.2.3.4]; AliDNS=[1.2.3.4, 9.9.9.9]`
Detection result status	`IS_HIJACKED` / `PASS` / `NETWORK_FAIL` etc.
Detailed reason	Contains anomalous IPs, trusted IP pool, etc.
Triggering exception type	`TLS_CERT_UNTRUSTED_SIGNATURE` / `DNS_RESOLUTION_FAILED` etc.

Note: To avoid noise in analysis, only hijacking-confirmed cases are reported.

Mobile App Authentication Pipeline Design

Wed, 16 Apr 2025 00:00:00 GMT

In mobile applications, user identity authentication is a critical module for ensuring account security and meeting compliance requirements. As business scenarios grow more complex (from simple avatar verification to real-name authentication, account recovery, etc.) and technical approaches evolve (from integrating a single SDK to dynamically dispatching multiple third-party services), building a highly cohesive, loosely coupled, and extensible authentication system becomes a real challenge.

High-Level Design

The authentication system design needs to be forward-looking to flexibly handle business changes and technology transitions. A layered, service-oriented architecture is recommended rather than coupling authentication logic directly into business code.

Business Application Layer: The origin point of authentication requests — scenarios like “Authentication Center” or “Account Appeal.” This layer only cares about when to initiate authentication and what results to receive, not how authentication is performed.
Authentication Service Layer: The core of the entire pipeline, providing a unified, stable interface to upper layers while shielding complex implementation details from lower layers. All authentication requests go through a unified authentication client.
SDK Abstraction Layer: Abstracts the capabilities of all third-party authentication SDKs, defining a unified authentication service interface covering atomic capabilities like “initialize” and “start authentication.” Whether it’s Provider A’s SDK or Provider B’s SDK, each implements this unified interface through an adapter.
Third-Party SDK Layer: The native SDKs provided by each service vendor.

Key Design Decisions

Cloud-Based Dynamic Allocation

Which third-party SDK to use is not hardcoded on the client — instead, the business server dynamically specifies it when issuing authentication credentials. This pattern greatly enhances business flexibility and system fault tolerance, while enabling the server to conduct A/B testing across different authentication providers on dimensions like success rate, latency, and cost, driving decisions with data.

Unified Multi-SDK Abstraction

The foundation of this design lies in unified multi-SDK encapsulation. By defining standardized service interfaces and unified data models, the differences between vendor SDKs are entirely confined within independent adapters. This fully decouples upper-layer business logic from specific SDK implementations, achieving plug-and-play authentication capabilities.

Dynamic Module Loading

Since authentication is not a high-frequency feature and its dependencies (especially native libraries) can be large, the entire authentication module is designed for dynamic loading. The client only loads it through a dynamic module loader when the user first triggers the authentication flow.

Authentication Flow

sequenceDiagram participant User participant Business Layer participant SDK Abstraction participant Auth Service participant Server User->>Business Layer: Trigger authentication Business Layer->>Business Layer: 1. Business auth scenario Business Layer->>Business Layer: 2. Build standardized params Business Layer->>SDK Abstraction: Request auth (with params) SDK Abstraction->>SDK Abstraction: 6. SDK initialization SDK Abstraction->>User: 7. Launch auth UI User->>Auth Service: 8. Perform action (e.g. input credentials) Auth Service->>Auth Service: 9. Local preprocessing Auth Service->>Server: Request/verify cloud credentials Server-->>Auth Service: Return credentials/verification result Auth Service->>Auth Service: 3. Obtain cloud credentials (done) Auth Service->>Auth Service: 4. Dynamic SO library loading Auth Service->>Auth Service: 5. Permission check Auth Service->>Server: 10. Report auth result Server-->>Auth Service: Confirm report Auth Service->>SDK Abstraction: Return auth result SDK Abstraction->>Business Layer: Return auth result Business Layer->>User: Display auth result

Hugo Multi-Image Layout for the Even Theme

Mon, 24 Mar 2025 00:00:00 GMT

When building a personal blog with Hugo, image layout issues are common — especially when mixing portrait and landscape images. Hugo’s default layout leaves large whitespace flanking portrait images, which looks unattractive. Additionally, Markdown doesn’t natively support side-by-side images (unless using inline HTML, which has too many issues; I tried and gave up).

I previously referenced a Hugo multi-image layout tutorial, but following it didn’t produce the expected results. Other users in the comments had similar issues, with no answer from the author.

image-20250325152613877

After investigation, I found the issue: the theme wraps Markdown images in <a> tags for click-to-preview functionality, which doesn’t match the original tutorial’s CSS selectors. Here’s the adapted solution.

/* Multi-image column styles */
.post-content p:has(> a:nth-child(2)) {
  column-count: 2;
  column-gap: 8px;
  margin: 6px 0;
}
.post-content p:has(> a:nth-child(3)) { column-count: 3; }
.post-content p:has(> a:nth-child(4)) { column-count: 4; }
.post-content p:has(> a:nth-child(5)) { column-count: 5; }
.post-content p:has(> a:nth-child(6)) { column-count: 4; }

/* Image display handling */
.post-content p:has(> a:nth-child(2)) a {
  display: block;
  margin-bottom: 8px;
  break-inside: avoid;
}

/* Spacing for 6-image mode */
.post-content p:has(> a:nth-child(6)) a {
  margin-bottom: 8px;
}

/* Ensure images fill container */
.post-content p a img {
  width: 100%;
  height: auto;
  display: block;
}

For the Even theme, append this code to Blog/themes/even/assets/sass/_partial/_post/_content.scss. Note that different Hugo themes may have different content file directories — adjust the path accordingly.

Usage Rules

Same as the original tutorial. Images can have line breaks between them but not blank lines — CSS automatically adjusts column count based on the number of <img> tags within a <p> element. For example:

#### More images, mixed orientations

![](https://cn.bing.com/th?id=OHR.Breckenridge_EN-US4460042968_768x1280.jpg)
![](https://cn.bing.com/th?id=OHR.BisonWindCave_EN-US4537340482_1280x768.jpg)
![](https://cn.bing.com/th?id=OHR.Umschreibung_EN-US4693850900_768x1280.jpg)
![](https://cn.bing.com/th?id=OHR.DonkeyFeast_EN-US1153850805_768x1280.jpg)
![](https://cn.bing.com/th?id=OHR.SessileOaks_EN-US1487454928_1280x768.jpg)
![](https://cn.bing.com/th?id=OHR.DonkeyFeast_EN-US1153850805_1280x768.jpg)
![](https://cn.bing.com/th?id=OHR.RumeliHisari_EN-US4800002879_1280x768.jpg)
![](https://cn.bing.com/th?id=OHR.InscriptionWall_EN-US1392173431_1280x768.jpg)
![](https://cn.bing.com/th?id=OHR.HummockIce_EN-US4606231645_768x1280.jpg)

Results

Two images

Three images

Four images

More images, mixed orientations

Column heights may vary, but this is acceptable.

Guizhou Landscapes

Fri, 20 Sep 2024 00:00:00 GMT

Day 1

Landed in Guiyang in the afternoon. Since I had to catch a high-speed train to Anshun that evening, I only planned one stop for the day — the Long March Culture Digital Art Museum (Red Ribbon). After exiting the metro, I realized it was still quite a distance away, though shared e-bikes were available at the entrance. This was my first real taste of Guizhou’s mountainous terrain — the metro station sits isolated on high ground with nothing but empty land for hundreds of meters around. Very Guizhou.

The museum’s highlight was an immersive film called Red Ribbon: Colorful Flight, using holographic projection and 3D Mapping to showcase Guizhou’s famous scenic spots (sidebar: Beijing Universal Studios’ Transformers ride uses similar tech). For dinner, I had Guizhou sour soup hot pot, which absolutely blew me away. After returning to Beijing, I deliberately sought out chain restaurants serving it, but unfortunately the Beijing locations don’t pre-make the dipping sauce — the taste just wasn’t the same.

Day 2

Spent the entire day at Huangguoshu Waterfall. As one of China’s most famous attractions, the reputation precedes it, but the actual experience was just okay. The waterfall itself is quite spectacular with heavy mist, but the signage is absurd — one sign said “viewpoint 20 meters ahead” but it took 200 meters to get there. The trail design is confusing and easy to get lost on, plus the sightseeing buses charge extra, which felt a bit greedy. Worth a first-time visit to check off the list, but keep expectations modest — a classic “well, I’m already here” attraction.

Day 3

If I had to rank this trip’s attractions, Libo’s Small Seven Holes would absolutely take the top spot. I booked a hotel right next to the scenic area, so time was plentiful. Started the morning with the beef noodles and shaved ice that were trending on Xiaohongshu — tasty, though the beef was a bit chewy and my jaw ached after eating too much.

Small Seven Holes requires quite a bit of walking, but the water is genuinely crystal clear — so green it looks filtered. The best part was the transparent kayak ride: in shallow sections you can see straight to the bottom. Paddle into the shade of the trees, lie back, listen to the flowing water, and zone out completely — I nearly fell asleep. Big Seven Holes is accessed by boat, with towering cliffs on both sides and perfectly still water — a completely different feel from the small version, almost reminiscent of Jiangnan water towns. Both are highly recommended!

Day 4

Guizhou has no shortage of ancient towns. Since the next day’s plan was rafting, I picked Zhenyuan Ancient Town as a convenient stopover. It still has quite a few locals living there, so commercialization isn’t too heavy — comfortable to walk around. The core area is small; stroll along the Wuyang River and you can cover it in two or three hours. The old buildings have character, but accommodation is average — don’t make it a destination trip, just a transit stop before rafting.

In the evening, I took a night cruise. Lights reflecting off the river and old buildings casting their reflections — beautiful. The summer night breeze was wonderfully pleasant. Dinner was at a decades-old red sour soup hot pot place with self-serve small plates — properly sour and spicy, more authentic than chain restaurants. Note: the default dipping sauce includes “zheergen” (houttuynia); mention upfront if you want it excluded. Overall, a place meant for leisurely wandering — no need to rush.

Day 5

Gaoguo River Rafting was this trip’s primary objective, and it did not disappoint. Being Mid-Autumn Festival, it was busier than usual, but the queues moved quickly. Two people per raft, and you can pair up on-site (solo-traveler friendly). The rapids were intense but that’s what makes it fun — several drops with big elevation changes, plunging completely into the water. Absolutely thrilling.

Water gun fights are a highlight too — vendors along the river sell water guns everywhere. I recommend the type with a hose attachment (no pumping needed, instant double firepower). Be careful though — capsizing happens almost daily, and it happened to us too. Lifeguards are stationed along the river, but in rapids they can’t safely enter the water — they wait until you drift to calmer sections. Overall: incredibly fun! Highly recommended!

Day 6

Since both flights were through Guiyang, I returned a day early to rest and visited Qingyun Market and Qianling Mountain Park. Qingyun Market is a renovated commercial street with mostly snacks and creative shops — similar to trendy pedestrian streets in other cities, nothing special. Qianling Mountain Park is a regular city park plus lots of monkeys — not as exciting as the internet hype suggests.

Thailand

Wed, 05 Jun 2024 00:00:00 GMT

My favorite: Muay Thai as the cover photo.

Preparation

No prep needed — just grab a SIM card beforehand, bring your passport, and go! Currency exchange: change at home for better rates, or at the airport for convenience. Everything else is optional — you don’t even need to pack much clothing. When in Rome, buy on arrival!

Metro is a bit convoluted — ride-hailing is more convenient. The main apps are Bolt and Grab. Bolt is cheaper and offers motorcycle rides (a bit sketchy but fast — the kind of fast that ignores traffic lights), cash-only. Grab drivers accept rides faster but cost more, and support Alipay.

Also, skip the airport pickup booking — just hail a ride right outside the airport.

Itinerary

Day 1

Pasted Graphic

First stop in Thailand was the Erawan Shrine (Four-Faced Buddha), which had been blowing up on Xiaohongshu with celebrities reportedly flocking to pray there. Reality was a bit underwhelming — it’s a small area right by a busy intersection with traffic rushing past. Like other religious sites, you can buy flowers and elephant figurines to offer to the shrine. Locals genuinely worshipping were plentiful, while tourists mostly just observed. Not really recommended.

img

Wat Pho, Grand Palace, and Wat Arun — these three temple complexes are similar in style. It’s a type of religious architecture you won’t find in China, so visiting one thoroughly is enough; hitting all three causes aesthetic fatigue. But Wat Arun at night is unmissable. Once darkness falls, the illuminated Wat Arun is arguably the most beautiful sight along the Chao Phraya River. View it from a river cruise or from a café across the river (I recommend Vivi The Coffee Place) — the golden temple standing solitary by the riverbank, casting shimmering golden reflections on the water. Breathtaking.

6A73D29A-C1BA-495C-B271-0533F6233EB1_1_105_c

4C6681D2-078A-48FA-9986-F5BB7AE3762B_1_105_c

The Siriraj Medical Museum (“Museum of Death”) was one of my favorite stops during the first few days. Operated by Siriraj Medical School, the overall mood after visiting is heavy — victims’ bodies from serial killers, cancer-ravaged organ specimens, cross-sections of terminal patients, deformed fetuses preserved in formaldehyde (you can clearly see the eyelashes on the infant in the jar). Walking out the museum doors, Bangkok’s 40°C air hits your face, and you feel grateful just to be breathing.

Khao San Road Night Market felt chaotic in one word. Every vendor seemed to be competing for the loudest speakers — music audible from blocks away, marijuana scent hanging in the air, secondhand smoke, mixed with cologne-and-sweat from Western tourists. You practically have to hold your breath to navigate the street. Even the chili oil on the food emanated a pungent sweat odor — unclear whether intentionally seasoned that way or simply absorbed from the air over time. Baffling.

Day 2

Pasted Graphic 1

The Bangkok Instagram Bridge has already gone viral on Chinese social media — one of Bangkok’s new landmarks. Plenty of Chinese tourists lining up for photos in orderly fashion. Posing for two minutes under nearly 40°C heat left everyone drenched in sweat. Below the bridge is the Bangkok Art and Culture Centre, the largest art exhibition space in Bangkok, though by Chinese standards it felt average. Worth a stop if you’re passing by, but not worth a dedicated trip.

6E65B424-751C-4C7B-AB56-CDEC3523C7FF_1_105_c

The Wat Paknam Big Buddha is also popular online, but expect disappointment if you go with high expectations. It’s just a large Buddha statue in the city. Online photos use ultra-telephoto lenses making it look massive — here’s my shot with a 105mm lens for reference. I recommend shooting from 796 Soi Thoet Thai 26 or 60 Phet Kasem 15 Alley. There’s a river nearby with boat tours, but given the water’s color and smell, I’d suggest skipping that.

1C24D257-1C43-4505-AA4F-3DA9F0E0DFD7_1_105_c

8D3D2528-EA43-477E-8C1E-C8D8FD3CE471_1_105_c

ICONSIAM sits right on the Chao Phraya riverbank, reachable by public ferry. It’s currently Bangkok’s newest shopping mall with impressive variety and foot traffic. The ground floor is an indoor market with clean versions of Bangkok’s street food — safe to eat freely. Upper floors have multiple Michelin-starred restaurants, though unfortunately no standout noodle shops.

48C2B81E-3DC5-43D3-B464-9E16B32B500B_1_105_c

3001FD2D-6F22-455F-A536-8DE157A75F67_1_105_c

Day 3 & Day 4

image-20240812231017462

Tiffany’s Show is the most famous mainstream cabaret, but I wouldn’t recommend it. The show is like a variety performance — lip-synced music and dance numbers. Viewing experience is average. After the show there’s a photo session where you tip the performers for pictures — they’re all very friendly. Side note: I recommend Bing Shu’s video “The Mummy” which includes an interview with cabaret performers that helps you better understand the profession.

7D49D6C8-EDA9-4365-AC32-0014CD3C5052_1_105_c

3870acfe181e9a107c3318b54cd605d5

Rajadamnern Boxing Stadium — a testosterone-fueled Muay Thai match. Personally my favorite experience in Thailand. The live atmosphere was electric. Tickets range from 1,600 to 2,500 baht; I recommend first-class seats for the full experience.

2D9BB3ED-4084-4AB8-91E9-22ED67458E06_1_105_c

Moon Bar — big vibes on a small budget. A rooftop bar on the 59th floor of Bangkok’s Banyan Tree Hotel, serving drinks and food. Admission is deductible from your tab. Great for photos. A similar popular spot is Mahanakhon SkyWalk (Pixel Tower), but the queues there are brutal.

Day 5 & Day 6

image-20250315184233283

The Sanctuary of Truth — a perpetually unfinished wooden palace. Every structure inside is made of wood, constantly eroded by the seaside elements and therefore always under renovation. Still quite spectacular. Chinese-language tours are available explaining the meaning of each carved deity, though I’m personally not into that kind of thing.

8CA27EAF-0FD7-4D95-952C-B5A98640A845_1_102_a

Elephant Village — fun! Recommended! You can ride elephants on both water and land routes circling the park. The ticket includes a 30-min elephant ride + coconut + show. One of the few attractions I wholeheartedly recommend.

34983618-E950-4468-8BD3-D54C044947D5_1_105_c

7EAC5F4E-BCE5-4042-B826-ABB726F56946_1_105_c

79 SHOW can only be described as mind-blowing. Phones and cameras are collected at the entrance. The venue is dim with lights focused only on the stage. Seating is first-come-first-served; you can switch seats if someone leaves mid-show. The first three rows are the interactive zone — the interactions are wild. If you don’t want to participate, avoid the front rows. An absolute must-do in Pattaya.

Jomtien Beach Night Market sits just across the road from the beach. Opens at 5 PM — buy food, grab a beer, sit on the wooden benches by the road and watch the sunset, then stroll across to Jomtien Beach. Very chill.

Day 7

image-20250315184301457

Koh Larn has three popular spots online: Tawaen, Tien Beach, and Samae Beach. We went to Tawaen, which has the most activities. Parasailing, glass-bottom boat, jet ski, banana boat, and snorkeling came to roughly 1,500 baht total after bargaining — definitely negotiate, you’ll save a lot. You can rent tuk-tuks on the island to explore, but the mountain roads are rough, so stay safe.

25780240-A7F6-461D-9B60-D06ADB589BD2_1_105_c

On IDEA Plugin Development

Sat, 11 May 2024 00:00:00 GMT

Given that the team’s code formatting plugin was far too outdated, I undertook an upgrade and rewrite. The new implementation switched the core formatting library, added Kotlin language support, and introduced several static code inspection (Inspections) features. Here I document my understanding of IDEA Plugin development and my first experience with it.

Why IDEA Plugins?

Focusing on Android development, I see the necessity of IDEA Plugin development in two areas: standardization and developer efficiency.

As a local development tool, every team member can customize their IDE configuration. If different developers use different coding standards and conventions, code management chaos is inevitable. Nobody wants to pull the latest remote code and face a flood of conflicts due to inconsistent formatting.

Beyond formatting, development teams also have various standards around code security. For example, use of java.util.Random (pseudo-random) or Color.parseColor() potentially throwing IllegalArgumentException when parsing unknown content. If these issues aren’t caught during development, the workload piles up at Code Review — or worse, reaches production. The accumulation of such trivial issues creates hidden risks for code quality and security, impacting daily development efficiency.

All these problems can be solved through custom IDEA Plugins. In summary, IDEA Plugin development aims to meet a specific team’s specific pain points around coding standards, architectural constraints, and unique workflows, thereby improving engineering efficiency.

PSI

PSI (Program Structure Interface) is a core concept in the IntelliJ platform — an abstract representation of code. Think of it as analogous to Android’s View hierarchy. In Android, all UI elements are abstracted as View objects organized in a tree structure; you traverse the View tree to find, modify, or operate on UI elements. Similarly, PSI parses source code (Java, Kotlin files) into an abstract syntax tree (AST) where each node is a PsiElement representing a code structure — class, method, variable, expression, etc.

Specifically, PsiElement is the base class of the PSI hierarchy. For example:

PsiFile: Represents a source file — the PSI tree root
PsiClass: Represents a class or interface
PsiMethod: Represents a method
PsiExpression: Represents an expression, e.g., new Random() or Color.parseColor("#FFFFFF")
PsiReferenceExpression: Represents a reference expression, e.g., the method name in a method call
PsiNewExpression: Represents a new keyword object creation
PsiMethodCallExpression: Represents a method call expression

PSI allows structured access, analysis, and modification of code without directly manipulating text. It’s like using findViewById to find a Button and calling setText() instead of modifying XML strings directly.

In plugin development, PsiDocumentManager is commonly used to get the PsiFile for the current document. For example, PsiDocumentManager.getInstance(project).getPsiFile(document) retrieves the PsiFile associated with a Document. With the PsiFile, you can use PSI APIs to traverse and analyze code structure for inspections, refactoring, formatting, and more.

Format

Previously, the plugin maintained formatting rules internally. After the upgrade, I delegated concrete formatting rules to mature open-source libraries — google-java-format for Java, ktfmt for Kotlin — and rewrote the formatting logic to be as concise as possible for better maintainability. The flow has three phases: register, listen, format.

On startup, FormatInstaller registers a custom FormatCodeStyleManager as the project’s CodeStyleManager. It wraps IntelliJ IDEA’s native CodeStyleManager and decides whether to use custom formatting logic or delegate to the native manager based on file type.

By implementing DocumentManagerListener, the plugin listens for pre-save events. When a user saves a Java or Kotlin file, the beforeDocumentSaving callback triggers formatting.

public class DocumentManagerListener implements FileDocumentManagerListener {
    @Override
    public void beforeDocumentSaving(@NotNull Document document) {
        // ... get current Project and PsiFile
        if (psiFile != null && (psiFile.getName().endsWith(".java") || psiFile.getName().endsWith(".kt"))) {
            ApplicationManager.getApplication().invokeLater(() -> {
                new WriteCommandAction.Simple(project) {
                    @Override
                    protected void run() {
                        CodeStyleManagerDecorator.getInstance(project).reformatText(psiFile, Collections.singletonList(psiFile.getTextRange()));
                        ApplicationManager.getApplication().invokeLater(() -> FileDocumentManager.getInstance().saveDocument(document));
                    }
                }.execute();
            });
        }
    }
}

Upon receiving a format request, FormatCodeStyleManager calls the appropriate formatting tool based on file type (Java or Kotlin) and obtains the formatted result. All replacements execute within a WriteCommandAction for atomicity.

private void formatInternal(PsiFile file, Collection<? extends TextRange> ranges) {
    if (JavaFileType.INSTANCE.equals(file.getFileType())) {
        performReplacements(document, JavaFormatterUtil.getReplacements(new Formatter(), document.getText(), ranges));
    } else if (KotlinFileType.INSTANCE.getName().equals(file.getFileType().getName())) {
        performReplacements(document, KotlinFormatterUtil.getReplacements(KotlinUiFormatterStyle.GOOGLE, document.getText()));
    }
}

private void performReplacements(final Document document, final Map<TextRange, String> replacements) {
    if (replacements.isEmpty()) return;
    TreeMap<TextRange, String> sorted = new TreeMap<>(comparing(TextRange::getStartOffset));
    sorted.putAll(replacements);
    WriteCommandAction.runWriteCommandAction(getProject(), () -> {
        for (Entry<TextRange, String> entry : sorted.descendingMap().entrySet()) {
            document.replaceString(entry.getKey().getStartOffset(), entry.getKey().getEndOffset(), entry.getValue());
        }
        PsiDocumentManager.getInstance(getProject()).commitDocument(document);
    });
}

Inspection

The plugin also includes a series of static code inspections to help team members catch potential issues during development. This parallels Android Lint’s goal — providing feedback at compile or development time to prevent issues from reaching later stages.

An Inspection typically extends AbstractBaseJavaLocalInspectionTool and overrides buildVisitor to return a PsiElementVisitor. This Visitor traverses the PSI tree and executes check logic when visiting specific PsiElement types. When problems are found, ProblemsHolder.registerProblem registers a ProblemDescriptor, which highlights the issue in the IDE and can include a LocalQuickFix for auto-repair.

Since most Inspections are business-specific, I’ll highlight two purely technical checks.

Random Pseudo-Random Number

Purpose: Detect usage of java.util.Random. For security-sensitive scenarios, java.security.SecureRandom is recommended.

Implementation: Override JavaElementVisitor.visitNewExpression to check if the PsiNewExpression creates a java.util.Random instance.

Quick Fix (RandomQuickFix): Replaces new java.util.Random() with new java.security.SecureRandom() and auto-imports SecureRandom.

@Override
public void visitNewExpression(PsiNewExpression expression) {
  super.visitNewExpression(expression);
  String qualifiedName = null;
  PsiJavaCodeReferenceElement classReference = expression.getClassReference();
  if (classReference != null) {
    qualifiedName = classReference.getQualifiedName();
  }
  if ("java.util.Random".equals(qualifiedName)) {
    holder.registerProblem(
        expression, INSPECTION_DESCRIPTION, INSPECTION_TYPE, new RandomQuickFix());
  }
}

private static class RandomQuickFix implements LocalQuickFix {
  @Override
  public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
    PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
    PsiExpression newExpression =
        factory.createExpressionFromText("new java.security.SecureRandom()", descriptor.getPsiElement());
    PsiElement replacedElement = descriptor.getPsiElement().replace(newExpression);
    JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
    codeStyleManager.shortenClassReferences(replacedElement);
    codeStyleManager.optimizeImports(replacedElement.getContainingFile());
  }
}

Color.parseColor()

Purpose: When Color.parseColor() parses an unknown-content variable, recommend wrapping it in a try-catch for IllegalArgumentException to improve robustness.

Implementation: Override JavaElementVisitor.visitMethodCallExpression to check for Color.parseColor calls. If the argument isn’t a constant/literal and the call isn’t wrapped in try-catch, register the problem. isWrappedInTryCatch traverses up the PSI tree looking for PsiTryStatement.

Quick Fix (ColorParseFix): Wraps the Color.parseColor() call in a try-catch block.

@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
    super.visitMethodCallExpression(expression);
    // ... get methodExpression
    if ("Color.parseColor".equals(method)) {
        PsiExpression argument = argumentList.getExpressions()[0];
        if (!PsiUtil.isConstantExpression(argument)
                && !(argument instanceof PsiLiteralExpression)
                && !isWrappedInTryCatch(expression)) {
            holder.registerProblem(
                    expression, INSPECTION_DESCRIPTION, INSPECTION_TYPE, new ColorParseFix());
        }
    }
}

private boolean isWrappedInTryCatch(PsiElement element) {
    // ... traverse up PSI tree looking for PsiTryStatement
}

private static class ColorParseFix implements LocalQuickFix {
    @Override
    public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor problemDescriptor) {
        // ... create try-catch block and replace original statement
    }
}

Android Studio Adaptation

Android Studio is built on the IntelliJ IDEA platform. To allow plugin access to JDK internal APIs (which libraries like google-java-format may depend on), specific --add-opens and --add-exports options must be added to JVM startup parameters. Insufficient JVM options may cause InaccessibleObjectException errors, breaking formatting functionality. Different IDEA platform versions handle these JVM parameters differently.

For platform baseline version >= 213, directly call VMOptions.setOption() for the required --add-opens and --add-exports parameters.

For baseline versions < 213, manually modify the VM Options file — read its contents, append missing parameters, and ensure the file is writable.

if (version >= 213) {
    VMOptions.setOption("--add-opens=java.base/java.lang", "=ALL-UNNAMED");
    VMOptions.setOption("--add-opens=java.base/java.util", "=ALL-UNNAMED");
    // ...
} else {
    Path path = VMOptions.getWriteFile();
    if (path == null) {
        return;
    }
    File file = path.toFile();
    try {
        String content = FileUtil.loadFile(file);
        if (!content.contains("--add-opens=java.base/java.lang=ALL-UNNAMED")) {
            content = content + "\n" +
                    "--add-opens=java.base/java.lang=ALL-UNNAMED\n" +
                    "--add-opens=java.base/java.util=ALL-UNNAMED\n" +
                    // ...
            FileUtil.writeToFile(file, content);
        }
    } catch (IOException ignored) {
    }
}

The Steady Idealist

Sat, 03 Feb 2024 00:00:00 GMT

Here’s the story: over the past couple of years, I’ve taken the MBTI personality test 5 times, and every single result came back as “INFJ-A” — even through several iterations of the question bank. Getting such consistent results was quite surprising. To further verify MBTI’s accuracy in categorizing personality types, I decided to compare the online descriptions of INFJ personalities with my own self-observed reality.

All quoted content below comes from the 16personalities website's description of the INFJ personality type.

INFJs may be the rarest personality type, but they certainly make their mark on the world. They are idealistic and principled, not content to coast through life — they want to stand up and make a difference. For INFJs, success doesn’t come from money or status but from seeking fulfillment, helping others, and being a force for good in the world.

The rarest personality type? After some research, I found that most MBTI content on the Chinese internet is directly translated from Western sources, so the “rarest” modifier needs an “in America” qualifier. Among post-95 Chinese millennials shaped by unique domestic circumstances, INFJ is actually fairly common. The truly rarest type domestically is probably ENTJ, known as “The Commander.” But this isn’t really about personality demographics.

Back to the point — I happily accept labels like “idealistic” and “principled.” Finding deviations caused by human nature in the process of implementing theories in practice is one of my pleasures. But “not content with a peaceful life” doesn’t quite fit. Everything I’ve done in recent years and my near-term plans are all preparation for the “peaceful life” I envision. Although I do agonize over the topic of “life’s meaning,” this meaning doesn’t come from social status or material wealth, but from realizing my inner vision — or rather, manifesting the rules (principles) I hold and applying them to reality. So… well, it’s hard. Visions remain just visions.

INFJs tend to feel different from most people. Because of their rich inner life and deep, abiding desire to find their life purpose, they don’t always fit in with those around them. Fortunately, this feeling of being out of step doesn’t diminish INFJs’ commitment to making the world a better place.

INFJs are troubled by injustice, and they typically care more about altruism than personal gain. Many INFJs see helping others as their mission in life, always looking for ways to step in and speak up for what is right. People with this personality type also aspire to solve society’s deeper problems, hoping that unfairness and hardship can become things of the past.

Stop, it feels like being mocked. If I had grown up in a more tolerant, open environment that embraced diverse values, I might indeed still be advocating for things as described above. But the reality is I currently can’t think of anything I can do to “make the world a better place.” I can only take care of myself and the people I cherish. While seeing a “sophisticated egoist” still makes me queasy, I no longer have any desire to argue or think “they’re wrong and I’m right.” I’m not even sure they’re wrong — I just don’t like it.

INFJs may be introverted, but they value deep, authentic relationships with others. Few things bring these personality types as much joy as truly getting to know another person — and being known in return. INFJs enjoy meaningful conversation far more than small talk, and they tend to communicate in a way that is warm and sensitive. This emotional honesty and insight can make a deep impression on the people around them.

This is actually true. Although I’m a typical introvert, when it comes to meeting new friends — especially getting to know them deeply and having profound conversations — I’m completely generous. When unlocking someone’s life experiences, emotional history, and especially the process that shaped their worldview, the satisfaction and joy I feel internally is incredibly strong. (I’ve always been curious about how different upbringings influence an individual’s worldview.)

INFJs prefer to keep things neat and orderly at work, prefer a peaceful and quiet atmosphere, and want everyone’s contributions to be recognized, everyone to feel fulfilled, and all work to achieve harmonious, positive results.

This makes me want to share my workstation of two years. As I wrote on my About page, “order” has always been the keynote of my life.

Finally, when I was debating the accuracy of MBTI with a friend, we discussed the difference between MBTI and astrology. During the discussion, someone offered an analogy I found perfectly apt:

In an exam, you score 90 in physics and 60 in chemistry, showing you’re better at physics, so I label you as a “physics person.” That’s MBTI. The discrepancy between MBTI’s personality descriptions and your self-observed reality can be seen as “unstable factors like luck that affect exam results.” Astrology, on the other hand, is determining your physics and chemistry scores based solely on your birth date — no exam required.

That’s all. Happy Lunar New Year.

2023 National Day Road Trip Along the Sichuan-Tibet Highway

Thu, 19 Oct 2023 00:00:00 GMT

The naked-eye 3D billboard at Chengdu Taikoo Li — absolutely stunning.

8794695C-73F1-4B96-946A-58012A58A255_1_105_c

A quick snapshot looking back at the Ya’an road trip base camp — the starting point of the 318 journey.

7AE60657-9E28-48B3-BB36-C9384EA6D12D_1_105_c

Leaving the city behind, heading into the mountains. Altitude rising, clouds close enough to touch.

26229F08-9B05-4941-B9EA-8E48214717CD_1_105_c

Prayer flags and national flags everywhere along the road.

950CB7B5-5767-48E4-AA52-8261AAD0CFEE_1_105_c

Zheduo Pass shrouded in clouds and mist.

4C481D9B-53F4-4C37-B353-59F102DD31DE_1_105_c

The team’s first group photo. (I was behind the camera.)

E13F7074-A0E9-44F4-BB2B-3B1B5B09F681_1_105_c

Missing you at Zheduo Pass.

C25FA65B-80DC-44E2-B023-9810D0B4651F_1_105_c

Clouds formed by warm, moist Indian Ocean air blocked by the Himalayas.

EDA0719D-6580-402B-B137-FC3997CFADF8_1_105_c

Yak hot pot served by the Tibetan guesthouse owner in Xinduqiao — incredibly flavorful! (One teammate was resting due to altitude sickness and missed out.)

9135CBBB-66AF-4C95-8D59-9CD1C15F9829_1_105_c

The nameless stream outside the guesthouse.

DB42D55D-9CE2-44F4-9987-B41EAC729261_1_105_c

Onward, driving through the wilderness.

71FD1F73-CB3E-4D98-9D01-5171CDAEA7D0_1_105_c

Tibetan script on the mountainside across from the viewpoint. (My cousin who taught in Tibet said it means “Master Tsongkhapa.”)

F3993ECD-F730-48D0-9665-A7A579823BDE_1_105_c

Snow mountain viewpoints everywhere.

FEC58901-817F-4256-9DC5-09773F86832D_1_105_c

Cattle grazing.

78C610FD-D055-41FB-9E5B-6A210B5C998A_1_105_c

Mountains beneath your feet. Reach out and embrace the clouds.

18C51B3A-F06A-4AAF-AD14-A06A77441A30_1_105_c

A Windows 10 wallpaper in real life.

57F91480-5954-41E4-8523-CCA23C67E5D1_1_105_c

Harley on the grasslands.

26E1C82F-4DF2-422B-B4E7-88DBBFD9F8FC_1_105_c

“Mongolian yurts” in Ganzi.

4248D4E4-B38B-4010-BB5E-CE4E62D4E22E_1_105_c

Hooray!

Arriving at the world’s highest city — Litang! (Spotted a beautifully modified BMW 3 Series.)

0B277FD7-05DD-487B-808C-99E63C0B5C6C_1_105_c

First steps into Daocheng Yading. (The 1-hour bus ride was exhausting.)

CADD30F2-F68E-4594-B3B4-C26F7D4FC293_1_105_c

Hiking up Yangmaiyong Sacred Mountain with Chichi.

E04D2530-3C15-4F53-8B86-81DBE7BC34E2_1_105_c

Pearl Lake (called “Zhuoma Latsuo” in Tibetan — really just a slightly larger pond).

E0964912-B26C-4A6B-AD1F-660253AD207D_1_105_c

A snow mountain in Yading — forgot which one. (Camera died by this point, so fewer photos from here on.)

791C9072-9EF5-4B3D-A109-32392A4926DA_1_105_c

The mani stone pile Chichi and I built together.

4D284DDE-DEB7-4D14-9664-5F2A2E5BCA84_1_105_c

Sister Lakes at Haizishan!

314C1B67-C73C-4141-B288-AE8993236075_1_105_c

A mobile coffee shop near the viewpoint.

AAC4EC2C-D34A-40BB-9EBF-5CFAC9274DF9_1_105_c

A dog.

86205820-3A51-45D1-AE6C-C9E1EEFF7EA9_1_105_c

Entering Cuopu Valley. (You can tell Batang really wants to develop this scenic area — extremely friendly to outside visitors. Highly recommended!)

BDAF952D-EDEB-4934-9440-3E145563B0E2_1_105_c

Tiffany blue at the foot of Cuopu Valley’s sacred mountain.

E5494276-2342-4FC1-924D-31B256556191_1_105_c

The three amigos.

1591697707273_.pic_hd

Golden sunrise on Namcha Barwa Peak, shot from the Sera Mountain pass.

B40C550B-E1A1-4184-927A-9AF93E4F3518_1_105_c

Reading, Traveling, and Love

Sun, 30 Apr 2023 00:00:00 GMT

Modern life is constantly under bombardment. With the winds of history blowing from all directions, how does one walk their own path through the chaos? Here I record my reflections from reading Professor Liang Yongan’s Reading, Traveling, and Love.

About the self — it spans multiple dimensions. There is the authentic self, shaped by all your choices throughout life. There is the imagined self, distorted and refracted through self-consciousness, not the true self. And there is the ideal self — who you believe you should be.

The process of knowing yourself is the process of finding the authentic self. First, you must understand your position on the stage of society and history, rather than drifting as an aimless creature of nature. Many people today cannot see themselves clearly because they don’t know where they stand or what value they hold. Never lock yourself in before you’ve understood the world.

In this transformative era where coordinates are lost, how should young people position themselves? To know yourself, you cannot sit indoors gazing at the sky through a well. You often need to discover yourself through imperfect exploration — through pain and joy. In pain, you discover you’re alive; in joy, you discover you’re still ordinary. Through this process, you gradually learn what kind of life you love and what kind of world you want to connect with. This is what we call the passion of youth.

In this process, solitude is a crucial link. When young, we discard many precious things, only to realize later that what we once dismissed as worthless was the most valuable. We often mistake meaningless things for treasures. Only through solitude and personal choices can we experience what is truly real.

The authentic self is certainly imperfect, but it is uniquely one’s own. Only when faced with resistance can a person be moved to reflect on whether their life is genuine. Once a person is touched by this raw force, clarity floods the heart, bringing a powerful sense of value and happiness. Once you experience this feeling, you won’t want to let it go. This joy can only be found on the road of exploration — no bitter cold, no plum blossom fragrance.

I hope our new generation can live with continuity of life as human beings — living authentically through childhood, youth, middle age, and old age, as people who live from the inside out, rather than from the outside in, living in the gaze of others.

The book also contains Professor Liang’s thoughts on character and cultivation, though I don’t entirely agree with his definition of a “good person.” The quality of one’s character shouldn’t be tied to the clarity of one’s cognition or the realization of life’s value. A simple, unenlightened, unambitious person may have a personality that genuinely radiates goodwill. Fortunately, regarding the importance of morality in character, I align with Professor Liang. As Kant said, “Two things fill the mind with ever new and increasing admiration and reverence — the starry heavens above me and the moral law within me.”

We arrive in this world by chance — what are we living for? Many people live to acquire, but how much acquisition does one truly need? Many people don’t cherish themselves, placing themselves in vanity, competition, and other relative values, thinking this will earn admiration — but what value does it ultimately hold? We may be exerting force on a chain of evil, chasing empty fame and fleeting profit, using only those around us as reference — “I want to live better than them.” This is actually an enormous devaluation of one’s own worth.

What truly has value is seeking and cherishing the self, understanding freedom in this world, treasuring the freedom of individual life, attending to your own value and the value society needs, confirming what you can do, and ultimately doing something different from everyone else — adding some light to society rather than clinging to the monotonous. Only then will we have a completely new view of life.

Finally, I’d like to share a line I love, which also reflects my current attitude toward life: “To possess the ability to accept and allow everything to happen, to share and express from the self, but not to hold fixed expectations for feedback and response.”

Setting Up Stable Diffusion on Colab

Wed, 22 Feb 2023 00:00:00 GMT

From Weird Wonderful Ai Art

September 23, 2023 Update: Colab has officially banned Stable Diffusion WebUI and the disconnection issue cannot be resolved. This tutorial is now obsolete. See https://decrypt.co/197428/google-colab-stable-diffusion-web-ui-ban

AI Art

Stable Diffusion is a deep learning text-to-image model released by stability.ai in 2022, capable of running on most hardware with a modest GPU.

Colaboratory (Colab) is a hosted Jupyter notebook service by Google Research that provides free GPU/TPU compute resources.

This is a comprehensive guide for deploying Stable Diffusion on Colab. Follow the steps below to experience the magic of AI art.

Allocate Resources

Open the Stable_Diffusion_WebUi_Altryne Colab notebook.

Click Connect in the top-right corner to allocate cloud resources and connect to the runtime.

1-image-20230222142539642

Run the commands in cell 1.0 to view host information.

1-image-20230222142936172

You’ll usually get a Tesla T4; if you’re lucky enough to get a V100, that’s worth bragging about.

Configure the Model

First, register a Hugging Face account and generate a WRITE-type Access Token.

1-image-20230222144043327

Return to Colab, expand the 1.4 Connect to Google Drive cell, check download_if_missing, and enter your Hugging Face Access Token.

1-image-20230222144232989

Set Password

Configure a password in 2.1 Optional - Set webUI settings and configs before running.

1-image-20230222144551905

Run the Service

Collapse all cells and run them sequentially to deploy the service.

Runtime:

Setup stage: 5min
Run the Stable Diffusion webui: 1s
Launch WebUI for stable diffusion: 1min

1-image-20230222144857944

A popup will request Google Drive login during runtime — log in and authorize normally.

1-image-20230222145720360

Once complete, click the Public URL to enter the Stable Diffusion WebUI. Username is “wubei,” password is what you configured above.

1-image-20230222150541478

Now enjoy! Enter a prompt to generate corresponding images, e.g., “an astronaut in the water.”

1-image-20230222151132661

Of course, you can provide more detailed prompts for more specific and accurate images.

(((masterpiece))),((best quality)), flat chest,((loli)),((one girl)),very long light white hair, beautiful detailed red eyes,aqua eyes,white robe, cat ears,(flower hairpin),sunlight, light smile,blue necklace,see-through

1-image-20230222154010936

Multiple Git Accounts on Mac

Tue, 14 Feb 2023 00:00:00 GMT

Clear Existing Config

Check current Git configuration:

Terminal window

git config --list

Clear username and email:

Terminal window

git config --global --unset user.name
git config --global --unset user.email

Generate SSH Keys

Use ssh-keygen to generate SSH keys with manually specified IDs:

Terminal window

ssh-keygen -t rsa -f ~/.ssh/id_rsa_xx1@gmail.com -C "xx1@gmail.com"

Successful generation outputs:

Terminal window

Generating public/private rsa key pair.
Enter file in which to save the key (/Users/james/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/james/.ssh/id_rsa.
Your public key has been saved in /Users/james/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:rwtxjGTJPoV9Mg8lFSf8D4X6jFexWVXKOMRaVyo+RO8 xx1@gmail.com
The key's randomart image is:
+---[RSA 3072]----+
|        .o=o+. .*|
|     . + o.=+++o.|
|      * * .==o== |
|     + + *ooo++  |
|      = S .+o+E  |
|       + .. +..  |
|      .   ..     |
|       . .       |
|        o.       |
+----[SHA256]-----+

Continue generating SSH keys for your other Git accounts:

Terminal window

ssh-keygen -t rsa -f ~/.ssh/id_rsa_xx2@gmail.com -C "xx2@gmail.com"

Trust SSH Keys

Add generated SSH keys to the ssh-agent trust list using ssh-add:

Terminal window

ssh-add ~/.ssh/id_rsa_xx1@gmail.com
ssh-add ~/.ssh/id_rsa_xx2@gmail.com

If you encounter Could not open a connection to your authentication agent., run:

Terminal window

ssh-agent bash

Then re-execute the ssh-add commands.

Configure Public Keys

Copy the corresponding public keys and add them to the respective Git platform (GitHub / GitLab):

Terminal window

pbcopy < ~/.ssh/id_rsa_xx1@gmail.com.pub
pbcopy < ~/.ssh/id_rsa_xx2@gmail.com.pub

For detailed steps, refer to Adding a new SSH key to your GitHub account.

Configure SSH Config

Navigate to the SSH directory:

Terminal window

open ~/.ssh/

Edit the config file (create if it doesn’t exist) following these rules:

Key	Value	Description
Host	hostname	Custom name
Hostname	host address	Git public address, e.g., github.com / gitee.com
IdentityFile	identity file	RSA file path
User	user	Custom, typically your email

Example config:

Terminal window

Host github1.com
Hostname github.com
IdentityFile ~/.ssh/id_rsa_xx1@gmail.com
User xx1@gmail.com

Host github2.com
Hostname github.com
IdentityFile ~/.ssh/id_rsa_xx2@gmail.com
User xx2@gmail.com

Test Connection

Test whether Git accounts connect successfully. The part after git@ is the Host from your config file:

Terminal window

ssh -T git@github1.com
ssh -T git@github2.com

Successful connection outputs:

Terminal window

Hi xxx! You've successfully authenticated, but GitHub does not provide shell access.

Notes on In the Game

Mon, 02 Jan 2023 00:00:00 GMT

Micro Level

In China, the government doesn’t just influence how the “pie” is distributed — it participates in making it. So we can’t discuss economics apart from government.

Local Government Powers and Functions

To understand governance and operational models, we must first understand how power and resources are distributed within the government system. This distribution depends on two key institutional characteristics: central-local relations and vertical-horizontal segmentation. Central-local relations concern the overall balance of power between central and local governments; vertical-horizontal segmentation means local departments simultaneously answer to both their vertical superior departments and horizontal local governments, facing dual constraints.

Based on these two characteristics, local government power allocation can be examined from three perspectives: from the externality perspective, if public services only affect the locality, they can be handled locally; if externalities exist, higher-level coordination is needed. From the information perspective, the side with information advantages holds greater de facto authority, so superiors often invest heavily in gathering lower-level information. From the incentive compatibility perspective, matters unrelated or contrary to local development goals tend toward vertical leadership, while those aligned with local development tend to be delegated locally.

Under these principles, local governments enjoy extremely broad powers in attracting investment and developing the economy, allowing them to deeply participate in resource production and distribution.

Finance and Government Behavior

Economic development requires not just administrative authority but fiscal authority. From 1985–1993, fiscal contracting caused central revenue’s share to decline steadily, prompting the tax-sharing reform of 1994, which increased central revenue but drastically reduced local fiscal resources.

The reform didn’t change local governments’ economic development mandate but reduced their disposable fiscal sources. Locals had to find alternative funding — thus began the era of land finance. Simply put, land finance means local governments rely on land-use rights transfer revenue to sustain fiscal spending.

In 1998, two events transformed the real estate market: first, work-unit housing allocation ended, meaning people now had to buy their own homes — launching the real estate era. Second, the revised Land Administration Law took effect, giving local governments authority over land sales with revenues staying local. Local governments could restrict residential/commercial land supply and earn monopoly profits from ever-rising land prices.

Some regions implemented land finance — subsidizing industrial land for investment attraction while restricting residential land, letting housing prices drive land prices. Regions unable to rely on land finance faced fiscal difficulties and growing inter-regional inequality, requiring central transfer payments and continued fiscal reforms like rural tax reform and county-level fiscal management.

Government Investment, Financing, and Debt

Land’s true power lies not in land finance itself but in the bank credit and other capital leveraged through land as collateral. Land finance grafted onto capital markets with leverage becomes land financialization, snowballing to drive rapid economic expansion.

Governments establish local government financing vehicles (LGFVs, or “city investment companies”), using future land revenues as collateral to leverage massive bank loans for urbanization and industrialization investments. Government investment flows in two directions: infrastructure investment and industrial investment. Infrastructure investment involves LGFVs developing land then handing it to government for investment attraction, or enterprises handling everything from development to investment with government paying for use — the PPP (Public-Private Partnership) model.

However, the land financialization model poses problems. At the micro level, it increases local government debt risk. Beyond explicit on-balance-sheet liabilities, the greater concern is LGFV “implicit debt.” During economic booms, land appreciation covers repayment; during downturns with falling land prices, severe debt problems emerge.

Current reform measures include replacing LGFV debt with government bonds, converting LGFVs into ordinary state-owned enterprises, preventing further capital inflows, and constraining officials’ investment impulses. Fundamentally, under the current system, both local officials and ordinary government workers have very strong incentives to develop the economy, leading to both over-investment and systematic “official-business collusion” corruption. Therefore, deeper reform should streamline administration and shift from a production-investment government to a service-oriented government.

Government’s Role in Industrialization

China’s economic reform emerged from a planned economy where government controlled vast resources critical to industrial development — land, banks, universities, research institutions — inevitably leading to deep government participation in industrialization.

The second direction of government investment is industrial investment — supporting and subsidizing specific enterprises. Additionally, governments establish industrial guidance funds, creating investment companies or entrusting market-oriented fund managers as “funds of funds” that invest in other funds, which then invest in unlisted company equity, channeling social capital toward strategic emerging industries.

The book details specific examples of local government industrial investment through BOE and photovoltaic industry development, which I won’t elaborate here.

Macro Level

The above describes micro-level impacts of the land financialization model. Below are macro-level impacts.

Urbanization and Imbalance

First, urbanization’s emphasis on “land over people” drives up housing prices, increases household debt burden, and exacerbates income and wealth inequality.

Rising housing prices in the medium-to-long term result from strictly managed urban construction land quotas that can’t keep pace with population inflows, creating housing supply shortages. Higher prices mean heavier household debt.

Income inequality stems from insufficient urban public service provision preventing free labor mobility, making it difficult for low-skilled workers to establish themselves in cities. During rapid growth, low-income groups are less sensitive to wealth gaps, but once growth slows, social tolerance for inequality decreases.

Therefore, reform should shift focus from land to people — allowing construction land quotas to flow, breaking urban governments’ monopoly on residential land, reforming the household registration system, and increasing low-income groups’ mobility and options.

Debt and Risk

Second, investment attraction’s emphasis on “scale and expansion” increases corporate debt burden and overall economic debt and financial risk.

Debt causes trace to relaxed financial regulations after the financial crisis, with banks more willing to lend.

From the debtor (enterprise) perspective, LGFVs, state-owned enterprises, and real estate companies carry the heaviest debt. Their asset sell-offs to repay loans cause asset price declines, which increase bank non-performing loans, reduce lending willingness, break corporate funding chains, and trigger economic recession.

From the creditor (bank) perspective: first, large scale with high leverage; second, maturity mismatches between bank liabilities and assets create liquidity risk; third, most bank credit is collateralized by real estate or land, so during downturns banks become reluctant to lend, accelerating decline; fourth, bank risks transmit to other financial sectors, creating systemic risk. Banks establish shadow banking to evade regulation; once bubbles burst, the entire financial industry is affected.

Resolving debt has two parts: repaying existing debt and curbing new debt.

Repaying debt means either asset sales, spending cuts, or monetary expansion. The latter has three approaches: direct issuance, quantitative easing, and debt monetization.

Curbing new debt requires, beyond housing price controls and land finance restrictions, addressing the root cause: why do enterprises constantly borrow from banks? Following the principle “whoever makes investment decisions bears investment risk,” China’s investments are primarily government and SOE-led, so risks are also borne by government and its controlled financial institutions — banks. Because bank risk is ultimately government risk. Therefore, the fundamental measure is capital market reform — decentralizing power to markets, broadening direct financing channels, letting enterprises raise funds through equity and bonds.

Domestic and International Imbalance

Third, development strategy’s emphasis on “investment and production over consumption” creates structural economic imbalance.

Internally, the most prominent structural imbalance is insufficient consumption, partly due to excessive savings caused by family planning policies, insufficient social spending, and rising housing prices, and partly due to low household income share.

In early development stages, heavy capital investment effectively drives industrialization and growth. But at a certain point, this model causes overcapacity, debt risk (investment flowing into real estate, pushing up prices), excessive wealth gaps, and external imbalance (exports chronically exceeding imports).

However, US-China trade friction isn’t driven by Chinese exports’ impact on American employment, but by manufacturing’s rise threatening American technology dominance, combined with rising American political conservatism. This necessitates China building a dual circulation model centered on domestic circulation, strengthening the domestic market and achieving a virtuous cycle of “market → R&D → iteration → larger market.”

The key to this transformation is raising household income and consumption through three approaches: continuing urbanization to further develop the service sector; increasing social spending while reducing production-oriented spending; and developing direct financing channels to broaden household property income.

Government and Economic Development

The government’s past economic development core was introducing competition mechanisms — central coordination, local government competition. The evaluation standard was economic development performance.

This “political arena + market” system’s advantage is designing clear, effective promotion criteria that provide officials with extremely strong incentives to develop the economy. But it also produces local protectionism and corruption. Just as planned-economy-era government intervention characteristics carried into market reforms, this system leaves path dependency of prioritizing economy over social welfare.

When market mechanisms are still imperfect, government can supplement by mobilizing and allocating resources, buying time for market economy development. But as markets mature, government must timely adjust its role — reducing government investment spending, increasing social spending, and transitioning from a production-oriented to service-oriented government.

This transformation aligns with development economics’ general perspective: for developing countries, the key to productivity improvement is learning known technologies and management models. Once productivity reaches a certain level, the shift must go from organizational learning to exploration and innovation. Regardless of development model, different countries and regions will adapt based on their specific political and social realities.

Notes on Intimate Relationships

Sun, 16 Oct 2022 00:00:00 GMT

Preface

Notes from reading Roland Miller’s Intimate Relationships.

Human relationships are shaped by a wide range of influences — from prevailing cultural trends to fundamental attributes of the human species. Beyond these general factors, many individual-specific influences like personality and experience (some learned, some inherited) play a role. Ultimately, two people from the same planet but differing in many ways begin their interaction. The outcome may be frustrating or deeply satisfying.

Intimate Relationships

Human relationships come in many forms. We have parents above us and possibly children below, plus friends and lovers. This book focuses primarily on the latter two types of partnerships, specifically between adults.

Defining Intimate Relationships

Intimacy is a complex concept encompassing various components that resist easy definition. Fortunately, both researchers and laypeople agree that intimate relationships differ from casual acquaintances across six dimensions of degree:

Knowledge: broad and private understanding
Care: mutual caring
Interdependence: the frequency, intensity, diversity, and duration of mutual need and influence
Mutuality: the degree of overlap in self-acceptance of the other
Trust: believing the other will treat you well and with respect
Commitment: wanting the relationship to endure, investing time, effort, and resources

The Need to Belong

Why do people need intimate relationships?

The importance of intimate relationships primarily manifests as the need to belong — an evolutionary product that has become a universal human tendency, making us feel that normal social interaction with connected others is essential. It is a need for sustained affection and acceptance.

Cultural Influence

Cultural standards are the foundation upon which people build relationships, shaping expectations and defining “normal” relationship patterns.

Take the increasingly common phenomenon of cohabitation. Many high schoolers today consider premarital cohabitation a “good idea” because they can test whether they truly “get along” (Bachman et al., 2001). This attitude makes cohabitation seem quite reasonable.

However, without concrete marriage plans, cohabitation doesn’t guarantee subsequent marital happiness — in fact, it increases divorce risk. As the research above shows, over time, cohabiting couples’ likelihood of marriage gradually decreases while their breakup probability doesn’t decline.

In summary, casual cohabitation — originally intended to test whether partners can live together harmoniously — seems to undermine positive attitudes toward marriage and the commitment to sustain it, which are the pillars of a happy marriage (Rhoades et al., 2009).

The Influence of Personal Experience

Attachment types are not genetically determined but are shaped by the interplay of innate individual characteristics and quality of caregiving.

Secure: comfortable with intimacy and interdependence; optimistic, sociable
Preoccupied: anxious and vigilant about any threat to intimacy; jealous, possessive
Fearful: self-reliant, dismissive of intimacy; cold, independent
Dismissive: afraid of abandonment; distrustful, suspicious, shy

Our childhood beliefs about the value of interpersonal relationships and whether others can be trusted originate from our interactions with caregivers. Through luck good or bad, we set off down a path toward either trusting or fearful intimate relationships. This journey never ends — the obstacles or assistance provided by subsequent companions can change the direction and course of our intimate relationships. Depending on interpersonal experiences, learned attachment styles may change over time or remain permanently stable.

The Influence of Individual Differences

Gender Differences

Differences between gender groups do exist but fall far short of the differences between individuals within the same gender.

Within-gender behavioral and attitudinal variation is typically far greater than the average between-gender difference. Men are more accepting of casual, brief sexual relationships than women (Peterson & Hyde, 2010), but this doesn’t mean all men prefer casual sex.

Some men enjoy sex with strangers while others absolutely don’t — these two groups of men are far less similar in their sexual behavior than the male and female averages. In other words, despite gender differences in sexual permissiveness, a highly permissive man differs more from a sexually conservative man than he does from the female average.

The book includes an amusing joke about stereotypes:

How to attract a woman:

Compliment her, cuddle her, kiss her, caress her, love her, comfort her, protect her, hug her, spend a fortune to make her laugh, wine and dine her, listen to her complain when she’s upset, care for her when she’s slightly ill, always be with her, always agree with her, and follow her to the ends of the earth.

How to attract a man:

Show up naked. Bring beer.

In reality, gender differences in relationship expectations are minimal — men and women are fundamentally not “opposite” types of people (Hyde, 2007). Believing the genders are vastly different makes one less likely to work at repairing cross-gender intimate relationships when conflict arises (which is inevitable). Thinking the opposite sex comes from another planet isn’t just wrong — it’s harmful. It blocks understanding of a partner’s perspective and interferes with collaborative problem-solving.

Gender Identity Differences

Gender identity differences refer to social and psychological differences between the sexes caused by culture and education — also called social gender (Wood & Eagly, 2009).

The best example of gender identity is gender roles — the “normal” behavioral patterns that society expects of men and women. Below is a common gender role classification; society expects and encourages men to be instrumental and women to be expressive:

Instrumental: assertive, independent, ambitious, leadership-oriented, decisive — ~25%
Expressive: warm, gentle, compassionate, kind, sensitive — ~25%
Cross-typed: ~35%
Undifferentiated: ~15%

Personality

The Big Five personality traits effectively distinguish people across many dimensions including behavior, thought, and emotion (McCrae & Costa, 2010):

Openness: imaginative, unconventional, artistic — versus rigid, inflexible, dogmatic
Extraversion: cheerful, sociable, enthusiastic — versus cautious, reserved, shy
Conscientiousness: hardworking, reliable, orderly — versus unreliable, careless
Agreeableness: sympathetic, cooperative, trusting — versus irritable, temperamental, hostile
Neuroticism: the degree of moodiness, worry, anxiety, and anger

Listed from least to most important. The most significant of the Big Five is the one with negative effects: neuroticism (Malouff et al., 2010). Neurotic individuals are prone to anger and anxiety — tendencies that often cause interpersonal friction, pessimism, and arguments (Suls & Martin, 2005).

Self-Esteem

Self-esteem is essentially self-evaluation within interpersonal contexts — a kind of “social relationship barometer.” When others treat us positively and value their relationship with us, self-esteem is high; when we can’t attract others’ attention, it’s low.

We humans are highly social animals. If others don’t like us, liking ourselves becomes very difficult (indeed, it would be quite unrealistic). In most cases, people who chronically receive insufficient acceptance and appreciation develop negative self-evaluations through sustained low self-esteem.

Notably, regarding self-esteem’s impact on intimate relationships: low self-esteem individuals sometimes underestimate their partner’s love, thereby damaging the relationship (Murray et al., 2001).

We all need balance between connection with others and self-protection, but low self-esteem people consistently prioritize their fragile egos over intimate relationships. Their self-doubt and hypersensitivity manufacture mountains of problems from countless trivial matters. They mistakenly interpret the normal bumps of love as ominous signs of their partner’s rejection. Then they display off-putting, self-defeating hurt and anger, completely severing the very comfort from their partner that they crave. By contrast, those with high self-esteem don’t bat an eye at the same minor hiccups, confidently expecting their partner’s acceptance and positive regard.

The Influence of Human Nature

The environmental pressures humans faced for survival over thousands of years have left mental and emotional traces. Certain inherited emotional and behavioral responses originated from our distant ancestors and are no longer necessary in modern times, yet these survival vestiges are indelibly carved into our character, giving everyone certain predispositions.

Three assumptions of evolutionary psychology:

Sexual selection has made humans the species we are today.
The sexes differ only because, to some degree, they faced different reproductive challenges in the past (parental investment).
Culture determines whether evolved behavioral patterns remain adaptive, and culture changes far faster than evolution (paternity uncertainty).

The Influence of Interpersonal Interaction

Relationships are often greater than the sum of their parts — this is the effect of the final component of relationships: “interaction.”

Take trust in a romantic relationship as an example. Trust is a bidirectional process, simultaneously influenced by both your and your partner’s temperaments. It arises from the dynamic process of giving and receiving with your partner every day. In other words, trust is a flowing process rather than a static thing — it rises and falls across all your relationships.

The Dark Side of Relationships

We must acknowledge that relationships also carry potential costs — sometimes dealing with others brings misfortune and pain.

When people get close to others, they may fear their most cherished secrets being exposed or exploited. They may worry about the loss of autonomy and self-control that comes with interdependence (Baxter, 2004). They might fear being abandoned by those they depend on. They recognize that deception can exist in relationships, and people sometimes confuse sex with love (Firestone & Catlett, 1999). In fact, most people (56%) have experienced relationship difficulties in the past 5 years (Levitt et al., 1996).

So why take the risk? The book’s answer is quite romantic:

Because we are social animals. We need each other. Without intimate connections to others, we would wither and die.

ring_layout: Flutter Circular Layout Implementation

Sun, 24 Apr 2022 00:00:00 GMT

Definition of Circular Layout

Given a circle A and several circles a, where all circles a intersect with circle A, all centers of circles a lie on circle A, and the center-to-center distances between adjacent circles a are equal.

A circular layout must satisfy two properties:

The distance from each child widget’s center to the container’s center remains constant.
The spacing between adjacent child widget centers remains constant.

Based on these properties, we can calculate the position of circle a relative to circle A using mathematical formulas — this is the key information for implementing circular layout.

The definition above doesn’t mention the radius relationship of circles a. In practice, the radii of circles a can differ. Treating circle a as the circumscribed circle of a child element, in complex production environments, child elements’ circumscribed circle radii often vary. So we also need to determine the maximum radius of circle a.

Calculating Child Element Positions

Mathematical Derivation

To determine circle a’s position relative to circle A, we first need to calculate the offset of center a relative to center A.

Let center A have coordinates ( (x_0, y_0) ), radius ( r ), center a have coordinates ( (x_1, y_1) ), and the angle between the line connecting centers A and a and the horizontal axis be ( \theta ).

Center a’s coordinates ( (x_1, y_1) ) equal center A’s coordinates ( (x_0, y_0) ) plus the axis offsets.

x1=x0+r×cos(θ)x_1 = x_0 + r \times cos(\theta)x1=x0+r×cos(θ) y1=y0+r×sin(θ)y_1 = y_0 + r \times sin(\theta)y1=y0+r×sin(θ)

Code Implementation

/// Calculate offset of center a relative to center A
///
/// @param centerPoint Center A coordinates
/// @param radius Circle A radius
/// @param count Number of circles a
/// @param which Circle a index
/// @param initAngle Starting position
/// @param direction Arrangement direction
Offset _getChildCenterOffset({
  Offset circleCenter,
  double radius,
  int count,
  int which,
  double firstAngle,
  int direction,
}) {
  double radian = _radian(360 / count);
  double radianOffset = _radian(firstAngle * direction);
  double x = circleCenter.dx + radius * cos(radian * which + radianOffset);
  double y = circleCenter.dy + radius * sin(radian * which + radianOffset);
  return Offset(x, y);
}

Calculating Child Element Radius

Mathematical Derivation

To satisfy circular arrangement requirements, the maximum child element’s circumscribed circle must be bounded by the inscribed circle of a ( 90° ) sector, as shown below.

Let the sector radius be ( R ), the sector central angle be ( \alpha ), and the inscribed circle radius be ( r ).

The maximum child element radius derivation:

sin(α2)=rR−rsin(\frac{\alpha}{2}) = \frac{r}{R - r}sin(2α)=R−rr r=(R−r)×sin(α2)r = (R - r) \times sin(\frac{\alpha}{2})r=(R−r)×sin(2α) r=R×sin(α2)−r×sin(α2)r = R \times sin(\frac{\alpha}{2}) - r \times sin(\frac{\alpha}{2})r=R×sin(2α)−r×sin(2α) r+r×sin(α2)=R×sin(α2)r + r \times sin(\frac{\alpha}{2}) = R \times sin(\frac{\alpha}{2})r+r×sin(2α)=R×sin(2α) r=R×sin(α2)1+sin(α2)r = \frac{R \times sin(\frac{\alpha}{2})}{1 + sin(\frac{\alpha}{2})}r=1+sin(2α)R×sin(2α)

Code Implementation

/// Calculate circle a radius
///
/// @param radius Circle A radius
/// @param angle Sector angle
double _getChildRadius(double radius, double angle) {
  if (angle > 180) {
    return radius;
  }
  return radius * sin(_radian(angle / 2)) / (1 + sin(_radian(angle / 2)));
}

/// Calculate radians
///
/// @param angle Degrees
double _radian(double angle) {
  return pi / 180 * angle;
}

Implementation

We chose CustomMultiChildLayout for the circular layout. From the official documentation:

“CustomMultiChildLayout is appropriate when there are complex relationships between the size and positioning of multiple widgets.”

A perfect fit. Here’s the result:

The complete code is published on pub.dev. Below is a partial excerpt of RingLayout.

ring_layout: https://pub.dev/packages/ring_layout

class RingLayout extends StatelessWidget {
  final List<Widget> children;
  final double initAngle;
  final bool reverse;
  final double radiusRatio;

  const RingLayout({
    Key? key,
    required this.children,
    this.reverse = false,
    this.radiusRatio = 1.0,
    this.initAngle = 0,
  })  : assert(0.0 <= radiusRatio && radiusRatio <= 1.0),
        assert(0 <= initAngle && initAngle <= 360),
        super(key: key);

  @override
  Widget build(BuildContext context) {
    return CustomMultiChildLayout(
      delegate: _RingDelegate(
          count: children.length,
          initAngle: initAngle,
          reverse: reverse,
          radiusRatio: radiusRatio),
      children: [
        for (int i = 0; i < children.length; i++)
          LayoutId(id: i, child: children[i])
      ],
    );
  }
}

Notes on The Selfish Gene

Thu, 24 Mar 2022 00:00:00 GMT

I first heard about The Selfish Gene at the end of 2021. I had just left Xiaomi, and the start date at my new company was slightly delayed. I planned a spontaneous trip to clear my head, but the year-end pandemic outbreak disrupted everything.

Being confined at home felt endless. I watched episodes of Round Table every day to pass the time. The most memorable was Season 5, Episode 11, where the guest was Yin Ye, CEO of BGI Genomics. A scientist and three humanities scholars had a heated discussion around “genes” — from in vitro embryo technology to cellular renewal, from the Ship of Theseus to Dawkins’ selfish gene. Every topic sparked intellectual fireworks. At the end, Yin Ye recommended this book.

After reading it over several months, I gained a great deal. Here I briefly record the author’s main arguments and some of my own reflections.

“Throughout history, humanity’s self-image has been continually diminished.”

From Copernicus’s heliocentric model shattering the notion that Earth was the center of the universe, to Darwin’s theory of evolution making us realize we descended from primates, to Freud’s psychoanalysis revealing that our behavior is driven by primitive libido rather than self-control — and finally Dawkins taking it further in The Selfish Gene, arguing that humans are merely vehicles for genes, nothing more than tools for genes to replicate and propagate.

Dawkins argues that genes manipulate humans. Just as when a person drives a car — the car has no sense of direction; the person controls it. Humans drive cars to satisfy their need for rapid movement. For the car itself, existence is blind and meaningless. Similarly, individual human survival is blind and meaningless — we are merely tools for our internal genes to replicate and spread, existing only to help genes replicate faster, spread further, and live longer.

“Apparently altruistic behavior is actually selfishness in disguise.”

From an individual organism’s perspective, nurturing offspring is altruistic. But Dawkins argues this behavior is premised on genes achieving replication and propagation through such altruistic acts. All behavior that appears altruistic from the individual’s perspective is a product of gene selfishness.

For genes, the only meaningful thing is to continuously replicate and spread to gain more advantages in the “war” of biological evolution — to increase the chances of survival.

Reading this, one can’t help feeling somewhat disappointed — disappointed in humanity, disappointed in oneself. Human existence is accidental and absurd; the meaning of life seems insignificant. The noble acts of self-sacrifice and fearlessness in human history seem so unreasonable in the objective world of genes.

But as Dawkins writes, we cannot turn a blind eye to facts, nor should we despair because of them. The views and conclusions in the book are observations of biological nature — statements of scientific fact, not Dawkins’ personal moral philosophy.

On the contrary, he argues that if we want to build a society of generosity and selfless devotion, we cannot rely on our biological nature. We must try to instill generosity and altruism through education, because we are born selfish.

“We have the power to defy the selfish genes of our birth. We can even discuss ways of deliberately cultivating and nurturing pure, disinterested altruism — something that has no place in nature, something that has never existed before in the whole history of the world. We are built as gene machines, cultured as meme machines, but we have the power to turn against our creators. We, alone on earth, can rebel against the tyranny of the selfish replicators.”

As Yin Ye said at the end of the show: “If humanity is a set of code, then I believe love is written into that code.”

To you and me — may we encourage each other.

LaTeX Math Expressions in Hugo

Sat, 18 Dec 2021 00:00:00 GMT

Hugo doesn’t support LaTeX-style math expressions by default — Markdown math syntax isn’t recognized out of the box.

Integrating MathJax, a JavaScript math display engine for all browsers, solves this problem.

The integration is straightforward: add the following to your article template HTML.

<script type="text/javascript"
        async
        src="https://cdn.bootcss.com/mathjax/2.7.3/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
MathJax.Hub.Config({
  tex2jax: {
    inlineMath: [['$','$'], ['\\(','\\)']],
    displayMath: [['$$','$$'], ['\[\[','\]\]']],
    processEscapes: true,
    processEnvironments: true,
    skipTags: ['script', 'noscript', 'style', 'textarea', 'pre'],
    TeX: { equationNumbers: { autoNumber: "AMS" },
         extensions: ["AMSmath.js", "AMSsymbols.js"] }
  }
});

MathJax.Hub.Queue(function() {
    // Fix <code> tags after MathJax finishes running. This is a
    // hack to overcome a shortcoming of Markdown. Discussion at
    // https://github.com/mojombo/jekyll/issues/199
    var all = MathJax.Hub.getAllJax(), i;
    for(i = 0; i < all.length; i += 1) {
        all[i].SourceElement().parentNode.className += ' has-jax';
    }
});
</script>

<style>
code.has-jax {
    font: inherit;
    font-size: 100%;
    background: inherit;
    border: inherit;
    color: #515151;
}
</style>

Make sure this HTML is loaded by the Hugo framework on every page. I added it to layouts/partials/footer.html since that file is guaranteed to be included on every page.

The pure MathJax integration doesn’t actually require this much code — the extra parts resolve conflicts between Markdown and LaTeX’s different interpretations of the underscore _. For details, see this article.

D(x)={lim⁡x→0axb+c,x<3π,x=3∫a3bxij+e2dx,x>3D(x) = \begin{cases} \lim\limits_{x \to 0} \frac{a^x}{b+c}, & x<3 \\ \pi, & x=3 \\ \int_a^{3b}x_{ij}+e^2 \mathrm{d}x,& x>3 \\ \end{cases}D(x)=⎩⎨⎧x→0limb+cax,π,∫a3bxij+e2dx,x<3x=3x>3 lim⁡x→∞x222−∫15xdx+∑n=120n2=∏j=13yj+lim⁡x→−2x−2x\lim_{x \to \infty} x^2_{22} - \int_{1}^{5}x\mathrm{d}x + \sum_{n=1}^{20} n^{2} = \prod_{j=1}^{3} y_{j} + \lim_{x \to -2} \frac{x-2}{x}x→∞limx222−∫15xdx+n=1∑20n2=j=1∏3yj+x→−2limxx−2

Now enjoy LaTeX in Hugo!

HLS Streaming Protocol: m3u8

Sat, 25 Sep 2021 00:00:00 GMT

For easier understanding, this article covers topics in order: “Streaming Protocols” → “HLS” → “M3U8.”

Their relationship:

HLS is a streaming media transport protocol
M3U8 is a component within HLS transport content

Streaming Media Protocols

Common Streaming Protocols

Streaming media delivers audio and video content in real time as data streams. The key technology is stream transmission.

Streaming protocols define how stream transmission works, specifying how streaming servers and clients communicate.

Major streaming protocols:

RTMP (Real Time Messaging Protocol): TCP-based FLV chunked message protocol, designed for Flash clients.
HTTP-FLV: HTTP long-connection-based FLV chunked tag protocol, usable for both VOD and live streaming.
HLS (HTTP Live Streaming): HTTP-based MP4 segment protocol by Apple, supporting both VOD and live streaming; each segment download requires a separate HTTP request.

This article covers only HLS in detail, not RTMP or RTSP.

Streaming Encryption Principles

Most streaming protocols can be divided into two parts: segmentation and encryption.

Segmentation splits a complete video stream into consecutive video segments. Different protocols differ in segment size and video container format.

Encryption encrypts each video segment using symmetric encryption — encrypted server-side, decrypted client-side, with restricted access to decryption keys.

AES encryption is typically used.

Why Symmetric Encryption?

Symmetric encryption is relatively efficient; asymmetric encryption is slower but more secure. Streaming scenarios demand high real-time performance with large data volumes, so the more efficient symmetric encryption is preferred.

Similar patterns appear elsewhere — for example, in HTTPS: content transmission uses symmetric encryption (TLS) for efficiency, while certificate verification uses asymmetric encryption (SSL) for security.

HLS

HLS (HTTP Live Streaming) is an HTTP-based streaming protocol proposed by Apple for real-time audio/video transmission, now widely used in both VOD and live streaming.

Reference: HTTP Live Streaming Document

How It Works

The complete HLS architecture has three parts:

Server: Encodes and segments the video stream into consecutive MPEG-TS segments, providing corresponding M3U8 media playlist and index files.
CDN: Standard web servers that receive client requests and distribute resources.
Client: Downloads the m3u8 index file first, selects an appropriate m3u8 media playlist based on bandwidth, then sequentially downloads all TS segments.

The complete HLS process:

Six stages:

Capture media source
Media encoder encodes the source
Encoded content passes to the segmenter as MPEG-2 transport stream
Stream Segmenter splits media into multiple Media Segments, creating corresponding Media Playlist and Master Playlist files
Upload: Resources uploaded to HTTP server
Playback: Client requests playback

Structure

After step 4’s processing, the complete structure consists of Master Playlist, Media Playlist, and Media Segment:

The complete HLS structure has two parts:

m3u8 Master Playlist file: Contains links to multiple Media Playlists differentiated by bandwidth and other parameters.
m3u8 Media Playlist file: Contains basic video information and links to multiple Media Segments that compose the full video.

Media Segments are simply TS-format video files with no descriptive metadata, independently playable.

M3U8 is the Unicode version of M3U; the “8” denotes UTF-8 encoding. Both M3U and M3U8 are multimedia playlist file formats.

M3U8

M3U8 descriptor files consist of various descriptor fields. Below are explanations of key fields.

Here’s a random m3u8 video URL I found online: https://mgtv-com.jjyl12349.com/20210519/fXE0kuJ7/index.m3u8

Requesting this URL returns an m3u8 file — the Master Playlist.

Master Playlist

#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=150000,RESOLUTION=416x234
/20210519/fXE0kuJ7/150kb/hls/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=150000,RESOLUTION=416x234
/20210519/fXE0kuJ7/150kb/hls/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1000000,RESOLUTION=1280x720
/20210519/fXE0kuJ7/1000kb/hls/index.m3u8

Field explanations:

EXTM3U: Identifies the file as m3u8; every M3U file starts with this
EXT-X-STREAM-INF: Represents a variant stream with its metadata
- BANDWIDTH: Bits per second (bitrate)
- RESOLUTION: Optimal pixel resolution for this variant

Select an appropriate Media Playlist URL based on BANDWIDTH, RESOLUTION, etc., and combine with the video URL’s domain for the full link.

For example, the 1000kb bandwidth, 1280x720 resolution variant’s URL: https://mgtv-com.jjyl12349.com/20210519/fXE0kuJ7/1000kb/hls/index.m3u8

Requesting this also returns an m3u8 file — the Media Playlist.

Media Playlist

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:6
#EXT-X-PLAYLIST-TYPE:VOD
#EXT-X-MEDIA-SEQUENCE:0
#EXT-X-KEY:METHOD=AES-128,URI="https://mgtv-com.ycshengwang.com/20210519/fXE0kuJ7/1000kb/hls/key.key"
#EXTINF:3,
https://mgtv-com.ycshengwang.com/20210519/fXE0kuJ7/1000kb/hls/mDHy0Stk.ts
#EXTINF:3,
https://mgtv-com.ycshengwang.com/20210519/fXE0kuJ7/1000kb/hls/FWZjOCHy.ts
...
...
...
#EXT-X-ENDLIST

Field explanations:

EXT-X-VERSION: HLS protocol version
EXT-X-TARGETDURATION: Maximum allowed TS segment duration
EXT-X-PLAYLIST-TYPE: Streaming media type
EXT-X-MEDIA-SEQUENCE: Sequence number of the first TS segment
EXT-X-KEY: TS file encryption information
- METHOD: Encryption method — NONE, AES-128, or SAMPLE-AES
- URI: Key URL
EXTINF: Duration of the following TS segment URL