FuKun.Net –

域名折腾记录

Thu, 21 May 2026 15:00:00 +0800

把个人网站从 http://IP 变成一个正经的 https://域名，中间要走的路比想象中多。这篇文章记录我的实际操作过程，供有同样需求的朋友参考。

前提

服务器：腾讯云 Lighthouse，Ubuntu 24.04，4 核 4G
网站：Hugo 静态博客，Nginx 提供服务
域名注册商：腾讯云

一、域名申请

控制台路径：腾讯云控制台 → 产品 → 域名注册 → 域名注册

在腾讯云域名注册页面搜索想要的域名，.com 早就被抢光了，.net 还有一些。我选了 fukun.net，首年 90 元。

购买后进入 控制台 → 产品 → 域名注册 → 我的域名，找到刚买的域名，点击「实名认证」。上传身份证正反面，审核大约半小时到两小时。通过后域名状态变为「正常」。

回到我的域名页面，点击域名进入 域名管理 → DNS 解析 → 添加记录：

主机记录	记录类型	记录值
@	A	62.234.90.54
www	A	62.234.90.54

TTL 默认 600（即 10 分钟）即可。关于 TTL 的设置经验：

日常使用：600 足够。DNS 修改后最迟 10 分钟全球生效，实际通常更快。
迁移前夕：如果计划更换服务器 IP，提前 24 小时把 TTL 降到 60–120，这样迁移时 DNS 切换更快。
不要设太短：TTL 过短（如 10 秒）会增加 DNS 查询量，对个人站点没必要。
不要设太长：TTL 过长（如 86400）会导致修改后一天才能生效，出问题时无法快速切换。

生效很快，几分钟后 ping fukun.net 就能看到正确 IP。

二、工信部 ICP 备案

这是整个流程里最耗时的环节。根据《互联网信息服务管理办法》，中国大陆境内提供互联网信息服务的网站必须取得 ICP 备案号。

控制台路径：腾讯云控制台 → 产品 → 网站备案 → 开始备案

操作流程

进入备案系统，选择「首次备案」
填写主体信息（个人姓名、身份证号、详细通信地址）
填写网站信息：
- 网站名称：注意不能包含「中国」「中华」等字样，个人备案也不能用太过商业化的名称（我填了「FuKun 技术笔记」）
- 网站域名：fukun.net
- 网站简介：如实描述，不要写「论坛」「商城」等需要前置审批的内容
上传证件照片（身份证正反面、手持身份证照）
进行人脸识别验证（微信扫码完成）
提交初审

时间线

阶段	耗时	说明
腾讯云初审	1 个工作日	审核材料完整性，不合格会退回修改
提交管局	3 个工作日	初审通过后提交至通信管理局
工信部短信核验	即时	收到短信后 24 小时内点击链接确认
通信管理局审核	10–15 个工作日	各地管局速度不同，广东大约 12 天

我从提交到拿到备案号大约用了 12 个工作日。通过后会在 控制台 → 网站备案 → 我的备案 看到备案号和电子证书。

关键注意事项

备案期间网站必须关闭（Nginx 先别配域名，或者返回 403）
个人备案不得涉及企业、商品、新闻等内容
备案号需要在网站底部展示，链接到 beian.miit.gov.cn
备案通过后 30 天内需完成公安备案

三、SSL 证书申请

备案通过后域名可以解析了，此时网站还是 HTTP。下一步申请 SSL 证书开启 HTTPS。

控制台路径：腾讯云控制台 → 产品 → SSL 证书 → 我的证书 → 申请免费证书

我使用的是腾讯云「SSL 单域名证书（一年期）」，TrustAsia DV 品牌，RSA 2048 位加密，SHA256 签名算法。证书覆盖主域名 fukun.net 和 www.fukun.net。

证书链：fukun.net → TrustAsia DV TLS RSA CA 2025 → DigiCert Global Root G2。

操作步骤

在 SSL 证书控制台点击「申请免费证书」（或购买对应类型的证书，¥64.6/年）
填写申请信息：
- 证书绑定域名：fukun.net
- 选择「自动添加 DNS 验证记录」— 腾讯云会自动添加一条 TXT 记录
提交申请，等待验证通过（通常 1–5 分钟）
验证通过后状态变为「已签发」，点击「下载」
选择「Nginx」格式下载，得到一个 zip 包

解压后得到四个文件：

文件	用途
`fukun.net.csr`	证书请求文件，申请时自动生成，部署不需要
`fukun.net.key`	私钥，Nginx ssl_certificate_key 使用
`fukun.net_bundle.crt`	CRT 格式证书，含中间证书，Nginx 使用
`fukun.net_bundle.pem`	PEM 格式证书，与 CRT 同内容，备用

四、Nginx SSL 配置

上传证书到服务器

# 将证书文件传到服务器
scp fukun.net.key fukun.net_bundle.crt ubuntu@62.234.90.54:~/

# SSH 登录服务器
ssh ubuntu@62.234.90.54

# 移动到 Nginx SSL 目录并设置权限
sudo mv ~/fukun.net.key ~/fukun.net_bundle.crt /etc/nginx/ssl/
sudo chown root:root /etc/nginx/ssl/fukun.net*
sudo chmod 600 /etc/nginx/ssl/fukun.net.key

Nginx 站点配置

编辑 /etc/nginx/sites-available/hugo-blog：

# HTTP → HTTPS 重定向
server {
 listen 80;
 server_name fukun.net www.fukun.net;
 return 301 https://$host$request_uri;
}

# HTTPS 站点
server {
 listen 443 ssl http2;
 server_name fukun.net www.fukun.net;

 ssl_certificate /etc/nginx/ssl/fukun.net_bundle.crt;
 ssl_certificate_key /etc/nginx/ssl/fukun.net.key;

 ssl_protocols TLSv1.2 TLSv1.3;
 ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
 ssl_prefer_server_ciphers on;
 ssl_session_cache shared:SSL:10m;
 ssl_session_timeout 10m;

 root /home/hugo/hugo-blog/public;
 index index.html;

 location / {
 try_files $uri $uri/ =404;
 }

 # 静态资源缓存
 location ~* \.(css|js|jpg|jpeg|png|gif|ico|svg|webp)$ {
 expires 30d;
 add_header Cache-Control "public, immutable";
 }
}

# 启用站点
sudo ln -sf /etc/nginx/sites-available/hugo-blog /etc/nginx/sites-enabled/

# 测试配置
sudo nginx -t

# 重载 Nginx
sudo systemctl reload nginx

五、备案号悬挂

工信部要求备案号须挂在网站首页底部。在 Hugo 的 hugo.yaml 配置：

params:
 footer:
 icp: "粤ICP备2026061516号"

在布局文件 layouts/_partials/footer.html 中渲染：

{{- with .Site.Params.footer.icp }}
<div class="hx:mt-2 hx:text-xs">
 <a href="https://beian.miit.gov.cn/" target="_blank" rel="noopener noreferrer">
 {{ . }}
 </a>
</div>
{{- end }}

六、公安部网站备案

ICP 备案通过后 30 天内，还需进行公安机关互联网站备案。注意需要先完成主体备案，再完成网站备案，两步都要做。

网站：www.beian.gov.cn → 全国公安机关互联网站安全服务平台

第一步：主体备案

注册账号并登录
进入「办事大厅」→「开办主体管理」→「新增主体」
填写主体信息（个人姓名、身份证号、地址、联系方式等）
提交审核，通过后可进行网站备案

第二步：网站备案

进入「办事大厅」→「新办网站申请」
填写网站信息：网站名称、域名、IP 地址、服务器所在地
选择网络接入服务商：腾讯云
提交审核（约 7–10 个工作日）
审核通过后获取公安备案号，格式为「粤公网安备 XXXXXXX 号」

公安备案号也需要悬挂在网站上（通常放在 ICP 备案号旁边）。

七、新增二级域名

网站上线后如需新增二级域名（如 gallery.fukun.net），二级域名与主域名共用同一个 ICP 备案号，公安备案同理，不需要重复办理。只需要做好DNS解析、证书申请、Nginx配置。

DNS 解析：在域名管理 → DNS 解析中新增 A 记录，主机记录填 gallery，指向同一 IP。

SSL 证书：单域名证书覆盖不到新二级域名，需要为新二级域名单独申请一张（流程同第三章，约 5 分钟）。

Nginx 配置：新增站点文件 /etc/nginx/sites-available/gallery：

server {
 listen 443 ssl http2;
 server_name gallery.fukun.net;

 ssl_certificate /etc/nginx/ssl/gallery_bundle.crt;
 ssl_certificate_key /etc/nginx/ssl/gallery.key;

 ssl_protocols TLSv1.2 TLSv1.3;
 ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
 ssl_prefer_server_ciphers on;

 root /home/hugo/blog-site/public;
 index index.html;

 location / {
 try_files $uri $uri/ =404;
 }
}

# HTTP 跳转 HTTPS
server {
 listen 80;
 server_name gallery.fukun.net;
 return 301 https://$host$request_uri;
}

启用并重载：

sudo ln -sf /etc/nginx/sites-available/gallery /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

事项	耗时	费用	控制台路径
云服务器	1 天	¥99/月	控制台 → Lighthouse
域名注册	—	¥90/年	控制台 → 域名注册
实名认证	—	—	控制台 → 域名注册 → 我的域名
DNS 解析	—	—	域名管理 → DNS 解析
ICP 备案	10–15 工作日	—	控制台 → 网站备案
SSL 证书	—	¥64.6/年	控制台 → SSL 证书 → 我的证书
CDN 加速	—	¥14/年	控制台 → CDN
云硬盘扩容	—	¥70	控制台 → Lighthouse → 云硬盘
Nginx 配置	—	—	无
公安备案	7–10 工作日	—	beian.gov.cn
合计	约 25–33 天	¥337.6

Mermaid 图表语法示例

Tue, 19 May 2026 10:00:00 +0800

原文：Mermaid Examples

Examples

This page contains a collection of examples of diagrams and charts that can be created through mermaid and its myriad applications.

If you wish to learn how to support mermaid on your webpage, read the Beginner’s Guide.

If you wish to learn about mermaid’s syntax, Read the Diagram Syntax section.

Basic Pie Chart

pie title NETFLIX
"Time spent looking for movie" : 90
"Time spent watching it" : 10

pie title What Voldemort doesn't have?
"FRIENDS" : 2
"FAMILY" : 3
"NOSE" : 45

Basic sequence diagram

sequenceDiagram
Alice ->> Bob: Hello Bob, how are you?
Bob-->>John: How about you John?
Bob--x Alice: I am good thanks!
Bob-x John: I am good thanks!
Note right of John: Bob thinks a long<br/>long time, so long<br/>that the text does<br/>not fit on a row.
Bob-->Alice: Checking with John...
Alice->John: Yes... John, how are you?

Basic flowchart

graph LR
A[Square Rect] -- Link text --> B((Circle))
A --> C(Round Rect)
B --> D{Rhombus}
C --> D

SequenceDiagram: Loops, alt and opt

sequenceDiagram
loop Daily query
Alice->>Bob: Hello Bob, how are you?
alt is sick
Bob->>Alice: Not so good :(
else is well
Bob->>Alice: Feeling fresh like a daisy
end
opt Extra response
Bob->>Alice: Thanks for asking
end
end

SequenceDiagram: Message to self in loop

sequenceDiagram
participant Alice
participant Bob
Alice->>John: Hello John, how are you?
loop HealthCheck
John->>John: Fight against hypochondria
end
Note right of John: Rational thoughts<br/>prevail...
John-->>Alice: Great!
John->>Bob: How about you?
Bob-->>John: Jolly good!

Sequence Diagram: Blogging app service communication

sequenceDiagram
participant web as Web Browser
participant blog as Blog Service
participant account as Account Service
participant mail as Mail Service
participant db as Storage
Note over web,db: The user must be logged in to submit blog posts
web->>+account: Logs in using credentials
account->>db: Query stored accounts
db->>account: Respond with query result
alt Credentials not found
account->>web: Invalid credentials
else Credentials found
account->>-web: Successfully logged in
Note over web,db: When the user is authenticated, they can now submit new posts
web->>+blog: Submit new post
blog->>db: Store post data
par Notifications
blog--)mail: Send mail to blog subscribers
blog--)db: Store in-site notifications
and Response
blog-->>-web: Successfully posted
end
end

A commit flow diagram.

gitGraph:
commit "Ashish"
branch newbranch
checkout newbranch
commit id:"1111"
commit tag:"test"
checkout main
commit type: HIGHLIGHT
commit
merge newbranch
commit
branch b2
commit

用宝可梦解释 Prolog 基础

Mon, 18 May 2026 13:30:00 +0800

原文作者：Alexander Petros
原文链接：Prolog Basics Explained with Pokémon
本文已获授权翻译，有删节和注释。

启发这篇文章的项目有点傻——我要详细描述一个儿童电子游戏的机制——但正是这个特定问题最终让我真正理解了 Prolog。这是自从读了 Bruce Tate 的《七周七语言》以来一直在追寻的顿悟。

对于某些类型的关系，逻辑编程是我用过的最简洁、最具表现力的编程系统。要理解为什么，让我们来聊聊宝可梦。

宝可梦基础

宝可梦是一个电子游戏系列，设定在一个人类与各种色彩缤纷的动物角色共存的世界。“Pokémon” 既是系列名称，也是这些动物角色的统称，每个角色都有自己的物种名称。从妙蛙种子（#1）到桃歹郎（#1025），共有超过一千种不同的宝可梦物种。

受欢迎的宝可梦包括（从左到右）：皮卡丘（#25）、始祖大鸟（#567）和裹蜜虫（#1101）。

现在有各种各样的宝可梦游戏，但主系列始终围绕着捕捉和对战。在对战中，你的六只宝可梦队伍与另一支队伍交锋。每只宝可梦配备四个招式，通常用来对对手造成伤害。你需要将对方所有宝可梦的 HP 减到零，同时防止对方先对你做同样的事。

每只宝可梦都有独特的特性影响对战表现：基础能力值、可学的招式、特性和属性组合。这里的庞大组合数量正是试图用软件来追踪这些信息的动机。

巨钳螳螂是虫/钢属性，攻击力高但速度低（数据来自 Smogon）。

速度决定哪个招式先出手；攻击和特攻分别影响物理招式和特殊招式的伤害；防御和特防影响受到的伤害。

属性尤其重要。招式有属性（如火或岩石），宝可梦可以拥有最多两种属性。如果招式属性对对方宝可梦效果绝佳，造成双倍伤害；效果不佳则只造成一半伤害。

月石是岩石/超能力属性。岩石弱水，超能力对水中性，所以冲浪会造成 2 倍伤害。

举个直观的例子：火属性的喷射火焰对草属性宝可梦造成 2 倍伤害（草弱火），但水属性的冲浪只造成 ½ 伤害（草抗水）。

属性修正可以叠加。巨钳螳螂是虫/钢属性，虫和钢都弱火，所以火属性招式对它造成 4 倍伤害。电弱水，但地面免疫电——如果你对水/地面的巨沼怪使用电属性招式，伤害为零，因为 0×2 还是 0。

宝可梦属性相克表。

这些基本上就是我 8 岁时理解的宝可梦机制。点击招式造成伤害，尽量选择属性相克有利的招式。这些游戏是为儿童设计的，表面上看并不难。

Prolog 基础

在解释宝可梦机制底层有多复杂之前，先解释逻辑编程的工作原理。宝可梦非常适合逻辑编程，因为宝可梦对战本质上是一个极其精密的规则引擎。

首先创建一个包含事实的文件：

pokemon(bulbasaur).
pokemon(ivysaur).
pokemon(venusaur).
pokemon(charmander).
pokemon(charmeleon).
pokemon(charizard).
pokemon(squirtle).
pokemon(wartortle).
pokemon(blastoise).

在 Prolog 中，我们声明"谓词"（Predicate）。谓词定义关系：bulbasaur 是一个 pokemon，charmander 是一个 pokemon，以此类推。我们称这个谓词为 pokemon/1，因为它有一个参数。

这些事实被加载到一个交互式提示符——“顶层”（top-level）中。你输入一个语句到提示符，Prolog 试图找出所有使该语句为真的方式：

?- pokemon(squirtle).
true.

不是所有东西都是宝可梦。

?- pokemon(alex).
false.

接着添加宝可梦的属性，作为谓词 type/2：

type(bulbasaur, grass).
type(bulbasaur, poison).
type(ivysaur, grass).
type(ivysaur, poison).
type(charmander, fire).
type(squirtle, water).
type(blastoise, water).

有些宝可梦只有一种属性，有些有两种。后一种情况用两个 type 事实建模。妙蛙种子是草属性，也是毒属性——两者都为真。

交互式查询：

?- type(squirtle, water).
true.
?- type(squirtle, grass).
false.

Prolog 中首字母大写的名字是变量。Prolog 尝试将谓词与变量的所有可能匹配进行"合一"：

?- type(squirtle, Type).
Type = water.

对于有两种属性的宝可梦，谓词会合一两次：

?- type(venusaur, Type).
Type = grass
; Type = poison.

分号 ; 表示"或"。任何参数都可以是变量，这意味着我们可以从任意方向提问。所有草属性宝可梦有哪些？只需把第一个参数设为变量：

?- type(Pokemon, grass).
Pokemon = bulbasaur
; Pokemon = ivysaur
; Pokemon = venusaur
; ...

逗号用于列出多个谓词——Prolog 会合一变量使得所有谓词都为真。列出所有水/冰属性的宝可梦：

?- type(Pokemon, water), type(Pokemon, ice).
Pokemon = dewgong
; Pokemon = cloyster
; Pokemon = lapras
; Pokemon = ironbundle
; false.

Iron Bundle 是一只水/冰属性宝可梦，特攻很高。具体多高？

?- pokemon_spa(ironbundle, SpA).
SpA = 124.

特攻这么高，我们想利用强力的特殊招式。Iron Bundle 会哪些特殊招式？

?- learns(ironbundle, Move), move_category(Move, special).
Move = blizzard
; Move = freezedry
; Move = hydropump
; Move = icebeam
; Move = icywind
; ...

Freeze-Dry 是一个特别好的特殊招式。找出所有特攻大于 120、会 Freeze-Dry 的冰属性宝可梦：

?- pokemon_spa(Pokemon, SpA), SpA #> 120, learns(Pokemon, freezedry), type(Pokemon, ice).
Pokemon = glaceon, SpA = 130
; Pokemon = kyurem, SpA = 130
; Pokemon = kyuremwhite, SpA = 170
; Pokemon = ironbundle, SpA = 124.

最后一个概念：规则（Rules）。规则有头部和主体，如果主体为真，则规则合一：

damaging_move(Move) :-
 move_category(Move, physical)
; move_category(Move, special).

?- damaging_move(tackle).
true.
?- damaging_move(rest).
false.

SQL 对比

到目前为止展示的内容在逻辑上并不复杂——只是关于各种事实的"与"和"或"语句。不过请花一点时间体会一下，查询这个数据库比 SQL 舒服多少。

我会这样设置 SQL 表：

CREATE TABLE pokemon (pokemon_name TEXT, special_attack INTEGER);
CREATE TABLE pokemon_types(pokemon_name TEXT, type TEXT);
CREATE TABLE pokemon_moves(pokemon_name TEXT, move TEXT, category TEXT);

然后查询特攻 > 120、会 Freeze-Dry 的冰属性宝可梦：

SELECT DISTINCT pokemon, special_attack
FROM pokemon as p
WHERE p.special_attack > 120
 AND EXISTS (SELECT 1 FROM pokemon_moves as pm
 WHERE p.pokemon_name = pm.pokemon_name AND move = 'freezedry')
 AND EXISTS (SELECT 1 FROM pokemon_types as pt
 WHERE p.pokemon_name = pt.pokemon_name AND type = 'ice');

对比等效的 Prolog 查询：

?- pokemon_spa(Pokemon, SpA), SpA #> 120, learns(Pokemon, freezedry), type(Pokemon, ice).

我不是在贬低 SQL——我很喜欢 SQL——但 Prolog 版本简单和灵活得令人惊叹。如果我们继续添加更多条件，SQL 查询会变得难以管理，而 Prolog 查询仍然易于阅读和编辑。

升级

宝可梦对战拥有数量惊人的机制，以复杂且概率性的方式相互影响。我尚未提及的部分机制：

某些招式有一定概率落空
某些招式会提升或降低能力值
宝可梦可以携带具有各种效果的物品
伤害计算不是恒定的，而是呈正态分布
宝可梦可以被冰冻、灼伤、麻痹、中毒或陷入睡眠
各种场地效果（天气、戏法空间等）会改变招式伤害和出手顺序
每只宝可梦都有一个特性（如漂浮免疫地面招式、降雨改变天气、强行增伤 1.3 倍）
玩家分配努力值提升选定能力值

如果你想为这个游戏构建软件，挑战在于在所有复杂性的建模过程中不疯掉。Prolog 在这方面出奇地擅长，主要有两个原因：

查询模型擅长描述临时组合
数据模型非常适合以一致的方式分层叠加规则

为了说明这一点，以下是我为宝可梦选秀联赛实现优先度招式的过程。

宝可梦选秀大致就是字面意思。宝可梦根据实力被赋予分值，每个玩家获得一定分数，轮流选直到用完。你的队伍最终会有大约 8-11 只宝可梦，每周你和联赛中的另一个人正面交锋。

我定义的队伍：

alex(meowscarada).
alex(weezinggalar).
alex(swampertmega).
alex(latios).
alex(volcarona).
alex(tornadus).
alex(politoed).
alex(archaludon).
alex(beartic).
alex(dusclops).

我的宝可梦里有哪些会 Freeze-Dry？

?- alex(Pokemon), learns(Pokemon, freezedry).
false.

一个都没有。唉。

非常重要的一类招式为优先度招式。大多数招式的优先度为零：

?- move_priority(Move, P).
Move = absorb, P = 0
; Move = accelerock, P = 1
; Move = acid, P = 0
; ...

Accelerock 的优先度为 1。使用它的宝可梦会先于任何使用优先度 0 招式的宝可梦行动，即使后者速度更高。

我定义一个 learns_priority/3 谓词：

learns_priority(Pokemon, Move, P) :-
 learns(Pokemon, Move),
 move_priority(Move, P),
 P #> 0.

“我的队伍学会了哪些优先度招式”——返回了大量答案，但很多是双打专用招式。过滤掉双打招式和保护招式：

learns_priority(Mon, Move, Priority) :-
 learns(Mon, Move),
 \+ doubles_move(Move),
 \+ protection_move(Move),
 Move \= bide,
 move_priority(Move, Priority),
 Priority #> 0.

doubles_move(helpinghand).
doubles_move(allyswitch).
doubles_move(ragepowder).
protection_move(detect).
protection_move(protect).
protection_move(endure).
protection_move(magiccoat).

搞定！结果精简为真正有用的优先度招式：

?- alex(Pokemon), learns_priority(Pokemon, Move, Priority).
Pokemon = meowscarada, Move = quickattack, Priority = 1
; Pokemon = meowscarada, Move = suckerpunch, Priority = 1
; Pokemon = beartic, Move = aquajet, Priority = 1
; Pokemon = dusclops, Move = shadowsneak, Priority = 1
; Pokemon = dusclops, Move = suckerpunch, Priority = 1.

优先度招式的缺乏实际上是我的队伍的一大弱点。

同样地查询对手的优先度招式也非常有用：

?- morry(Pokemon), learns_priority(Pokemon, Move, Priority).
Pokemon = mawilemega, Move = suckerpunch, Priority = 1
; Pokemon = walkingwake, Move = aquajet, Priority = 1
; ...

此时，Morry 提了一个挑战：恶作剧之心特性的宝可梦，其变化招式额外获得 +1 优先度。能否在规则中体现？

我的队伍恰好有一只这样的宝可梦——Tornadus。使用 Prolog 的 if/then 结构 ->/2，三分钟搞定：

learns_priority(Mon, Move, Priority) :-
 learns(Mon, Move),
 \+ doubles_move(Move),
 \+ protection_move(Move),
 Move \= bide,
 move_priority(Move, BasePriority),
 (
 pokemon_ability(Mon, prankster), move_category(Move, status) ->
 Priority #= BasePriority + 1
 ; Priority #= BasePriority
 ),
 Priority #> 0.

现在查询会包含 Tornadus 所有变化招式的提升后优先度。

与电子表格的比较

宝可梦社区已经有类似的工具，构建在最优秀的编程界面上：朴素的电子表格。

Techno 的准备文档，一份功能强大的 Google Sheets。

我使用一份被称为"Techno’s Prep Doc"的 Google Sheets，输入队伍后自动生成海量对阵信息。

我好奇它的优先度招式查找公式是怎样的。

电子表格后端的硬编码招式列表。

结果是——相当复杂：

={IFERROR(ARRAYFORMULA(VLOOKUP(FILTER(INDIRECT(Matchup!$S$3&"!$AV$4:$AV"),
INDIRECT(Matchup!$S$3&"!$AT$4:$AT")="X"),
{Backend!$L$2:$L,Backend!$F$2:$F},2,FALSE))),
IFERROR(FILTER(INDIRECT(Matchup!$S$3&"!$AW$4:$AW"),
INDIRECT(Matchup!$S$3&"!$AT$4:$AT")="X"))}

Prolog 的范式显然更具可扩展性。电子表格后端是一个硬编码的显要招式列表，而我的数据库可以查找任何招式。这个查询——找出 Tornadus 学会的、对 Justin 队伍中任何成员效果绝佳的特殊招式——在现有工具中根本不存在。我只用了 30 秒就拼出来了：

?- justin(Target), learns(tornadus, Move),
super_effective_move(Move, Target), move_category(Move, special).
Target = charizardmegay, Move = chillingwater
; Target = scizor, Move = heatwave
; Target = scizor, Move = incinerate
; Target = screamtail, Move = sludgebomb
; ...

最后的思考

这个项目始于一个玩笑——“如果我拿 Prolog 来做宝可梦组队会怎样”——但它教给我的逻辑编程知识比任何教科书都多。

我最大的领悟是：Prolog 迫使你思考什么是真的，而不是做什么。 在命令式编程中，大部分精力花在控制流上。在 Prolog 中，你只需陈述什么是真的，让求解器处理剩下的事。

对于一个有着数千条互动规则的规则引擎（比如宝可梦对战），这简直是天启。与其写 if/else 链检查属性相克，不如声明属性表，让 Prolog 处理其余部分。

如果你感兴趣，推荐：

安装 SWI-Prolog 并玩玩 prologdex 数据集
阅读 Adventure in Prolog 教程
用 Prolog 对你熟悉的领域建模——它会彻底改变你对数据和关系的思考方式

祝编码愉快，愿你的属性相克永远是效果绝佳。

AI 生产力的唯一落点

Sun, 17 May 2026 18:10:00 +0800

晚上和炎明吃饭，聊到 AI 的实际应用。几杯酒下去，话题从宏大叙事落到日常体验。我俩有个共同感受：

AI 目前能有生产力的，只有 coding 这一项。

这是一个残酷但诚实的判断。

为什么只有 Coding

仔细想想，Coding 和其他场景有什么本质不同？

第一，输出可验证。 代码跑不跑得通，一运行就知道。结果客观、即时、无歧义。AI 写对了就是对了，错了就是错了，不存在"写得好不好"的主观拉扯。

第二，反馈闭环极短。 写一段代码 → 编译/运行 → 看到结果 → 修改，这个循环可以秒级完成。AI 和开发者之间形成了高频的"对话-验证-迭代"机制。

第三，错误可容忍。 代码写错了不会死人。你可以反复试错，直到跑通为止。这种低代价的试错环境，是 AI 学习和人类协作最舒服的区间。

第四，人类判断力最低介入。 代码的逻辑正确性由机器判定，不需要专家逐行审阅。非技术类任务（写文章、做设计、决策建议）都需要人的判断力做最终把关——这恰恰是最稀缺的。

其他场景为什么不行

写文章 → 需要人类判断风格、语气、事实准确度，改了半个小时不如自己写
数据分析 → AI 能跑数，但"问对问题"才是关键，而这个恰恰是 AI 做不到的
创意设计 → 生成一堆选项，人类从中选一个最不差的，本质是降本不是提效
聊天陪伴 → 有情绪价值，但没有产出，不算生产力

这些场景的共同问题：判断成本转移了，但没有消失。 写文章的时候，AI 帮你省了打字的力气，但审稿的时间一点没少。效率提升只是把体力活变成了脑力活。

Coding 也是例外，也是范式

但仔细想，未来真正有生产力的 AI 场景，都会呈现出某种"可验证性"——无论是否在写代码。

比如合同审查：如果有一套明确的合规规则，AI 可以逐条校验；比如医疗影像：如果有标注好的数据集，AI 可以辅助诊断。这些场景的共同特征都是：输出可以被客观判定对错。

而那些依赖人类主观判断的领域——策略、审美、人情世故——AI 很难产出真正的生产力。不是技术问题，是评价标准的问题。

写在最后

和炎明的一顿饭，让我更清楚了一件事：AI 不是万能工具，它是一把专门在"可验证"领域发力的扳手。

承认它的边界，比鼓吹它的全能，更有意义。

而当前这把扳手最趁手的活，就是 coding。这也是为什么从大厂到个人开发者，都在往这个方向猛押注——不是跟风，是因为这里真的能看到产出。

家庭网络与 NAS 搭建方案

Sun, 17 May 2026 15:00:00 +0800

折腾家庭网络的终点是克制。和 Linux 桌面美化一样，容易用力过猛。本文记录一套低成本但够用的家庭网络方案。

网络拓扑

光猫 → 软路由（OpenWrt）→ 交换机
├── Wi-Fi 6 AP ×2
├── NAS（TrueNAS）
└── 有线设备

软路由选 J4125 或 N100 这类低功耗 x86，刷 OpenWrt，负责拨号、DHCP、科学上网。AP 选 Wi-Fi 6 的，TP-Link XDR 系列性价比不错，刷 OpenWrt 或者用原厂固件都可以。

两个 AP 组 Mesh，不需要折腾 AC 控制器。家里 120 平米基本无死角覆盖。

NAS 硬件与系统

旧电脑加几块硬盘就是一台 NAS。电费要算：不要拿老 i7 加独显当 NAS，待机功耗四五十瓦，一个月电费够买半块硬盘。

推荐方案：J4125 或 N100 小板 + 8GB 内存 + 2~4 块 4TB 硬盘组 RAID-Z1。系统选 TrueNAS Scale，基于 Linux，容器和虚拟机支持比 Core 版更好。待机功耗 15W 左右，一年电费不到一百块。

软件方案

三个核心应用：

软件	用途	替代方案
Plex	媒体服务器，自动刮削海报和元数据	Jellyfin（开源免费）
Syncthing	文件同步，多设备自动备份照片和文档	Resilio Sync
Tailscale	虚拟局域网，外面也能访问家里的服务	ZeroTier、WireGuard 裸配

Plex 装在 TrueNAS 的 App 里，显卡直通给 Plex 做硬件转码——手机上用较低码率看片时自动转码，画质损失不大。Syncthing 每台设备装一个，照片目录设为"仅发送"，电脑上的文档文件夹设为"双向同步"。

Tailscale 是真正的体验质变。不需要公网 IP，不需要端口转发，不需要记 IP 地址。手机、笔记本、NAS 在同一个虚拟局域网里，出门在外访问 Plex 和 NAS 文件就像在家一样。免费版支持最多 100 台设备，个人用完全够。

总结

方案的核心思路：够用即可。不要想着一步到位，先从旧硬件开始跑起来，哪里不够补哪里。家庭网络的价值在于稳定无声地跑着，不是折腾本身。

Rust Error Handling: From unwrap to anyhow

Sat, 16 May 2026 13:00:00 +0800

Rust forces you to think about errors. Starting with unwrap() everywhere is fine for prototypes, but production code needs proper error types.

Stage 1: The Unwrap Phase

let config = read_config().unwrap();
let db = connect(&config).unwrap();
let result = query(&db).unwrap();

Every Rust beginner goes through this. It’s fine for scripts and prototypes — if something fails, the panic message with a line number is good enough. The problem starts when you need graceful error handling or meaningful error messages for users.

Stage 2: Box

The quick upgrade path:

fn do_thing() -> Result<(), Box<dyn std::error::Error>> {
 let config = read_config()?;
 let db = connect(&config)?;
 query(&db)?;
 Ok(())
}

The ? operator works with any error type that implements From<T>. Box<dyn Error> catches everything. But you lose type information — the caller can’t match on specific error variants.

Stage 3: Proper Error Types with thiserror

For libraries, define explicit error types:

use thiserror::Error;

#[derive(Error, Debug)]
pub enum AppError {
 #[error("configuration error: {0}")]
 Config(String),
 #[error("database error: {0}")]
 Database(#[from] sqlx::Error),
 #[error("not found: {0}")]
 NotFound(String),
}

The #[from] attribute auto-implements From<T>, so ? works seamlessly. Callers can match on variants:

match do_thing().await {
 Err(AppError::NotFound(id)) => { /* handle 404 */ }
 Err(e) => { /* log and return 500 */ }
 Ok(data) => { /* success */ }
}

Stage 4: Application Errors with anyhow

For binaries, anyhow provides flexible error handling without the ceremony:

use anyhow::{Context, Result};

fn main() -> Result<()> {
 let config = read_config()
 .with_context(|| "failed to read config file")?;
 let db = connect(&config)
 .context("database connection failed")?;
 Ok(())
}

context() and with_context() attach human-readable messages at each fallible step. The error output is a chain of contexts, making debugging straightforward.

The Ecosystem Split

Crate	Use Case	Key Feature
`thiserror`	Library crates	Derive macro, typed errors
`anyhow`	Application binaries	Context chains, easy `?`
`eyre`	Applications (alternative)	Colorful error reports, custom hooks

The ecosystem has settled on this pragmatic split: thiserror for libraries, anyhow for binaries. Libraries expose typed errors so callers can react programmatically; applications benefit from rich, human-readable error chains.

Remember: unwrap() and expect() still have their place — in tests, in examples, and when an invariant violation truly merits a panic. But for production code paths, make errors part of your type signature.

Hugo 站点中嵌入视频与图片的最佳实践

Sat, 16 May 2026 12:00:00 +0800

静态博客常被认为只能承载纯文本，但实际上 Hugo 对多媒体内容的支持相当完整。本文记录本站的视频嵌入和图片排版方案，供有类似需求的读者参考。

B 站视频嵌入

Hugo 的 unsafe: true 配置允许直接插入 <iframe>，这让嵌入第三方播放器变得简单。下面是本站文章中使用的 B 站视频嵌入代码：

几个关键参数：high_quality=1 默认启用高清画质，autoplay=0 禁用自动播放（避免对读者造成打扰）。外层容器的 padding-bottom: 75% 是 4:3 比例，如果视频是 16:9 改成 56.25% 即可。

图片排版实践

宽幅配图

对于需要烘托氛围的宽幅图片，直接使用 Markdown 默认语法即可，Hugo 会自动处理响应式缩放：

宽幅配图适合放在文章开头，作为视觉呼吸点。

这类图片适合放在文章开头或章节之间作为视觉呼吸点。

多图并列

需要对比展示时，可以将图片连续排列。配合 Hugo 的渲染引擎，相邻图片会自动获得合适的间距：

编程与思考。

配图居中

适量使用图片比堆砌更能提升阅读体验。一张位置恰当的配图可以给段落之间留出自然的停顿：

一张位置恰当的配图，给段落之间留出自然的停顿。

多媒体文件的组织

本站将所有图片和字体统一放入 static/ 目录，引用时使用绝对路径 /images/xxx.jpg。这样做的好处是路径清晰、不受页面层级影响，也方便后续迁移到 CDN。

如果你也在用 Hugo 搭建个人站点，多媒体内容的处理原则就一条：路径统一、格式克制、体积有数。祝搭建愉快。

善假说

Sat, 16 May 2026 01:30:00 +0800

杜堇《伏生授经图》，明，大都会艺术博物馆藏

荀子说，君子生非异也，善假于物也。我以前读完也就过了，没细想。

AI 这两年用得不少，ChatGPT、Claude、DeepSeek 都试过。问问题、写代码、润文字，确实方便。但模式始终是单向的——它等你问，你问它答，问完结束。

直到我用上一个能自己干活的智能体。它叫"爪子"，跑在腾讯云一台轻量服务器上，4 核 4G，配置不高。搭起来很简单：在服务器上装了一个叫 OpenClaw 的智能体框架，绑好微信，配上 Todoist 和 Git 的 API 密钥，就能远程使唤了。这东西驻扎在服务器上，能直接执行 Shell 命令、读写文件、操作 Git 仓库、浏览网页。从有想法到跑起来，花了半晚上。

役物和任人

同样是 AI，心态不同，用法天差地别。

役物——问一句答一句，答错了你纠，纠完再问。你是指挥，还得盯着每一步。

任人——说清楚方向，交给它去做。做完验收就行，中间过程不必过问。

前者把你绑在操作台前，后者让你从执行中抽身。区别不在技术，在心法。

三件事

试了五天，挑三件说说。

博客

午间忽想建站，交代了一句。它 SSH 上服务器就开始干活。

flowchart LR
A[我：建个博客] --> B[SSH 登录服务器]
B --> C[安装 Hugo + Nginx]
C --> D[配置 HTTPS]
D --> E{测试通过？}
E -->|否| F[自修权限问题]
F --> D
E -->|是| G[回复就绪]

装 Hugo、配 Nginx、设 HTTPS、修 404 错误，全是它自己弄的。后来主题换了三次——PaperMod、terminal、Hextra——都是半夜一句话的事。第二天醒来网站已经跑在新主题上了。

资讯推送

每天早上想看国际新闻、科技动态和通信消息。我让它写了个定时脚本，每天 8:30 推送微信。

flowchart LR
A[Cron 8:30] --> B[拉取待办 + 新闻]
B --> C[编译简报]
C --> D[推送微信]
D --> E{成功？}
E -->|失败| F[自查超时]
F --> G[延长时限重发]
G --> D
E -->|成功| H[记入日志]

第三天推送没来。没等我问，它已经查了日志，发现 DeepSeek API 响应变慢导致超时，自动调长时限重发了。

工单管理

工作对话截图丢过去，说一句"入待办"。

flowchart LR
A[我：发聊天截图] --> B[读取并提取信息]
B --> C[创建 Todoist 任务]
C --> D[标优先级 + 截止日]
D --> E[回复确认]

读图、识人、提取待办、写入 Todoist、标优先级、定截止期。原来要折腾一分钟的事，现在十秒。

信任是试出来的

一开始不放心，只让它看看日志、查查状态。后来发现出错能自愈、操作有日志可查、半夜发消息也能秒回——慢慢就放手了。

邮件过滤。 信任更进一步，我给了它 IMAP 权限，让它每天扫收件箱。

flowchart LR
A[每日扫描收件箱] --> B{发给我但<br>没给下属？}
B -->|是| C[建文件夹存档]
C --> D[附件存 / 正文转 md]
D --> E[撰写摘要]
E --> F[关联已有文件信息]
F --> G[入待办跟进]
B -->|否| H[跳过]

筛出发给我但没抄送下属的邮件，拆附件、正文转 markdown、写摘要、关联已有资料，分类归档到我本地工作目录的 inbox。第二天上班打开文件夹，摘要和附件已经摆好了。

写在最后

有人问：这和 ChatGPT 有什么区别？

我说：ChatGPT 是字典，这是秘书。 字典再全，不会替你写材料。秘书不一定比你懂行，但会替你跑腿。

需要什么投入？一台低配云服务器，一套 API 凭证，花半晚上搭环境。门槛不高。

回头看荀子那句话——“善假于物”。最好的工具不是功能最强的，而是能让你从琐事中脱身的。用到某个程度你会发现，真正费脑子的不是"怎么问 AI"，而是"什么可以交给 AI"。

这念头一转，效率的瓶颈就从工具变成了自己的想象力。

Go Concurrency Patterns in Practice

Fri, 15 May 2026 10:00:00 +0800

I’ve been writing Go for a few years now, and concurrency remains one of those topics where textbook knowledge doesn’t quite prepare you for production. Here are a few patterns I’ve found genuinely useful.

The Worker Pool

The classic. Useful when you need bounded parallelism:

func workerPool(jobs <-chan Job, results chan<- Result, count int) {
 var wg sync.WaitGroup
 for i := 0; i < count; i++ {
 wg.Add(1)
 go func() {
 defer wg.Done()
 for job := range jobs {
 results <- process(job)
 }
 }()
 }
 wg.Wait()
 close(results)
}

Context Propagation

Probably the single most important practice I’ve adopted: every long-running goroutine should accept a context. It makes cancellation and timeout handling explicit rather than an afterthought.

func fetchWithTimeout(ctx context.Context, url string) ([]byte, error) {
 ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
 defer cancel()

 req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 if err != nil {
 return nil, err
 }
 // ...
}

The Select Loop

When you need to coordinate multiple channels, select is your friend. A common pattern:

for {
 select {
 case msg := <-messages:
 handle(msg)
 case <-ctx.Done():
 return ctx.Err()
 case <-ticker.C:
 flush()
 }
}

Things I Wish I Knew Earlier

Channel ownership — the goroutine that writes should also close the channel
Buffered channels aren’t a fix for deadlocks — they just push the problem further out
sync.WaitGroup copies by value — pass it by pointer, always
The race detector is free — go test -race should be part of your CI

Concurrency in Go is easy to write but hard to get right. The compiler won’t save you from logical races. That’s on us.

CI/CD Patterns with GitHub Actions

Fri, 15 May 2026 09:00:00 +0800

GitHub Actions is now the default CI for most open-source projects. Build matrices save config lines, caching node_modules and Go modules saves minutes per run. Reusable workflows keep things DRY across repos.

Build Matrices

Don’t copy-paste job definitions for different Node versions or OS targets. Use a matrix:

jobs:
 test:
 strategy:
 matrix:
 node: [18, 20, 22]
 os: [ubuntu-latest, macos-latest]
 runs-on: ${{ matrix.os }}
 steps:
 - uses: actions/setup-node@v4
 with:
 node-version: ${{ matrix.node }}
 - run: npm test

This single definition expands to 6 parallel jobs. Add fail-fast: false if you want all runs to complete even when one fails — helpful for catching platform-specific bugs in one CI run.

Smart Caching

Caching is the easiest way to cut CI minutes:

- uses: actions/cache@v4
 with:
 path: ~/.npm
 key: npm-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
 restore-keys: npm-${{ runner.os }}-

The restore-keys fallback is important: even a partial cache hit saves time. For Go modules, cache ~/go/pkg/mod. For Docker builds, use BuildKit’s registry cache (--cache-from type=registry) for layer caching across CI runs.

Environment-Specific Deployments

Use environments to gate production deploys:

deploy-prod:
 needs: [test, build]
 environment: production
 steps:
 - run: ./deploy.sh production

The environment: production lets you set required reviewers, wait timers, and environment-specific secrets in the GitHub UI. No more accidentally deploying to prod from a feature branch.

Reusable Workflows

When you maintain multiple repos, reusable workflows prevent drift:

# .github/workflows/deploy.yml in a shared repo
on:
 workflow_call:
 inputs:
 environment:
 required: true
 type: string
 secrets:
 AWS_ROLE:
 required: true

Call it from any repo:

jobs:
 deploy:
 uses: org/shared-workflows/.github/workflows/deploy.yml@main
 with:
 environment: staging
 secrets:
 AWS_ROLE: ${{ secrets.AWS_ROLE }}

Update the shared workflow once, and every repo benefits. This pattern scales well for orgs with 10+ services.

Practical Tips

Set timeout-minutes on every job — the default is 360 minutes, and you don’t want a hung test burning your quota.
Use concurrency to cancel redundant runs when pushing to the same PR multiple times.
Pin action versions to SHA hashes for supply-chain security, not just tags.

Vim Motions That Actually Save Time

Thu, 14 May 2026 14:00:00 +0800

Everyone tells you to learn Vim, but nobody tells you which motions are worth the muscle memory investment. After three years of daily use, here’s my honest ranking.

Tier 1: Non-Negotiable

These pay for themselves within a week:

Motion	What it does	Why it matters
`ci"`	Change inside quotes	Editing strings, attributes
`ci(` / `ci{`	Change inside brackets	Refactoring arguments
`%`	Jump to matching bracket	Navigating code blocks
`*` / `#`	Search word under cursor	Quick variable tracing
`.`	Repeat last change	The single biggest time-saver

Tier 2: Worth Practicing

These take a few weeks to internalize but compound:

f{char} / F{char} — find character inline. Faster than h/l spam
t{char} / T{char} — find until character. Perfect for deleting until a comma
ctrl+d / ctrl+u — half-page scroll. Keeps your eyes on the same spot
zz — center current line. Eliminates mental reorientation

Tier 3: Nice to Have

Useful but not essential for daily work:

gt / gT — switch tabs
ctrl+o / ctrl+i — jump back/forward in the jumplist
Macros (q{register}) — only worth it for repetitive tasks of 10+ iterations

What I Don’t Use

Line numbers as targets (:42) — too slow mentally
Visual block mode — I use multi-cursor in VS Code instead
/ search with regex — I just use * and f 90% of the time

The real productivity gain isn’t in any single motion — it’s in not thinking about navigation. When your fingers just move the cursor without conscious effort, that’s when the payoff arrives.

Deploying to AWS ECS with Terraform

Thu, 14 May 2026 10:00:00 +0800

ECS with Fargate is the sweet spot between managing servers and going full serverless. Terraform makes it reproducible.

The Stack

Here’s what we need to provision:

Resource	Purpose
VPC	Isolated network
Public & private subnets	Multi-AZ placement
Security groups	Network access control
ECR repository	Container image storage
ECS cluster + service	Run containers
ALB + target group	Traffic distribution

Security Groups: Getting Them Right

The key is getting the security groups right — one misconfigured rule and your containers can’t talk to each other, or worse, your database is exposed to the internet.

resource "aws_security_group" "ecs_service" {
 name = "ecs-service-sg"
 vpc_id = aws_vpc.main.id

 ingress {
 from_port = 3000
 to_port = 3000
 protocol = "tcp"
 security_groups = [aws_security_group.alb.id]
 }

 egress {
 from_port = 0
 to_port = 0
 protocol = "-1"
 cidr_blocks = ["0.0.0.0/0"]
 }
}

The principle: allow the minimum. The ALB security group allows inbound from the internet on 80/443. The ECS security group only allows inbound from the ALB. The database security group only allows inbound from ECS.

Fargate Configuration

Fargate abstracts the EC2 instances. You specify CPU and memory, and AWS handles the rest. For most web services, 0.25 vCPU / 512 MB is a good starting point — scale up based on load testing, not guessing.

CI/CD Integration

After Terraform creates the infrastructure, your CI pipeline needs to:

Build and tag the Docker image
Push to ECR
Update the ECS service with the new task definition

Use a Terraform backend with state locking — S3 + DynamoDB is the standard approach. Without state locking, two people running terraform apply at the same time can corrupt your infrastructure state.

Cost Notes

Fargate is more expensive per vCPU-hour than raw EC2, but you save the operational cost of patching instances and managing capacity. For small-to-medium workloads, the difference is negligible compared to the engineering time saved.

REST API Design: Mistakes I've Made So You Don't Have To

Wed, 13 May 2026 09:00:00 +0800

I’ve designed, built, and maintained enough REST APIs to have made most of the classic mistakes. Here’s what I wish someone had told me upfront.

1. Versioning Early

Don’t wait until you need it. Version your API from day one, either in the URL (/v1/users) or via the Accept header. Retrofitting versioning onto an unversioned API is painful for everyone involved.

My preference: URL-based versioning. It’s visible, impossible to forget, and trivially cacheable.

2. Pagination by Default

Every list endpoint should be paginated. Every. Single. One.

{
 "data": [...],
 "pagination": {
 "cursor": "eyJpZCI6MTIzfQ==",
 "has_more": true,
 "total": 847
 }
}

I’ve moved from offset-based to cursor-based pagination almost everywhere. Cursors handle real-time data changes gracefully and perform better on large datasets.

3. Error Responses Should Be Consistent

A predictable error shape means less client-side code:

{
 "error": {
 "code": "INSUFFICIENT_BALANCE",
 "message": "Account balance too low for this transaction",
 "details": {
 "required": 29.99,
 "available": 12.50
 }
 }
}

Never expose stack traces in production. Never leak internal IDs without intent.

4. Idempotency Keys

For any mutating endpoint, support an Idempotency-Key header. Your payment team will thank you, and so will your users when a retry doesn’t double-charge them.

5. Think in Terms of Deprecation

Add a Deprecation and Sunset header to old endpoints:

Deprecation: true
Sunset: Sat, 01 Aug 2026 00:00:00 GMT

Give consumers time to migrate, then actually follow through on removal. Keeping deprecated endpoints around “just in case” is technical debt with interest.

Good API design is mostly about empathy for the consumer. Ask yourself: would you enjoy integrating with this?

Migrating to Tailwind CSS v4

Wed, 13 May 2026 08:00:00 +0800

Tailwind v4 drops the JavaScript config file in favor of CSS-based configuration. The migration is mostly mechanical but there are gotchas with the @apply directive and custom variants.

CSS-First Configuration

The biggest change: tailwind.config.js is replaced by CSS. Your design tokens live in the @theme directive:

@import "tailwindcss";

@theme {
 --color-primary: #2563eb;
 --color-primary-dark: #1d4ed8;
 --font-sans: "Inter", sans-serif;
 --spacing-container: 1280px;
}

VSCode IntelliSense still works — the Tailwind CSS extension reads theme values from your stylesheet.

The Migration Path

Install v4: npm install tailwindcss@next
Run the automatic migration tool: npx @tailwindcss/upgrade
Manually check @apply usages — the tool handles most cases, but deeply nested @apply with custom utilities sometimes breaks.
Replace theme.extend in your old config with @theme blocks in CSS.

New Features Worth Using

Container Queries

No more media queries for component-level responsiveness. Tailwind v4 ships container query utilities:

<div class="@container">
 <div class="grid @lg:grid-cols-2">...</div>
</div>

Dynamic Utility Values

Arbitrary values are simpler: w-(--sidebar-width) references a CSS custom property. No more bracket syntax for common cases.

Native Cascade Layers

Tailwind v4 uses @layer to control specificity. Base, components, and utilities are layered in the correct order — @apply in component layer no longer risks specificity wars.

Gotchas

Custom variants defined in old JS config need to be re-registered via @variant in CSS.
The important config option now needs an explicit CSS strategy.
Some plugins haven’t updated yet — check compatibility before migrating production projects.

Overall, the migration took about two hours for a mid-sized project. The CSS-first approach feels more natural, and the build is noticeably faster thanks to the new Oxide engine.

从 5G 到算力网络：通信行业的技术演进观察

Tue, 12 May 2026 23:00:00 +0800

入行通信这些年，看着技术代际更迭，有些感触想记下来。

5G 的这五年

5G 商用五年，回头看当初的 hype 和现实之间的差距很有意思：

超预期的部分：

网络能力和覆盖远超 4G
行业应用从概念走到落地
切片、边缘计算等特性开始产生价值

没达到预期的部分：

C 端杀手级应用迟迟未出现
资费下降快，增量不增收
数字化转型需求 vs 实际付费意愿之间的鸿沟

下一个五年：算力网络

行业现在提的更多的是「算力网络」—— 把通信网络和计算资源统一调度。

几个值得关注的方向：

云网融合 — 网络即服务，算力即服务
通感算一体化 — 通信、感知、计算在基站层面融合
AI 原生网络 — 用 AI 管网络，从辅助运维到自动运维
低空经济 — 无人机、飞行汽车对网络覆盖的新需求

运营商面临的挑战

传统语音+流量模式见顶
云业务面临互联网厂商竞争
组织流程迭代跟不上技术迭代速度
人才结构转型压力大

不过换个角度看，通信基础设施作为数字经济的「水电煤」，长期价值不会消失，只是价值形态在变。关键是找到自己在价值链中的新位置。

子弹日记三年记：极简记录的力量

Tue, 12 May 2026 22:00:00 +0800

用子弹日记（Bullet Journal）三年了，从最初的跟风尝试变成现在离不开的习惯。

为什么用纸笔

在数字化时代选择纸笔看起来有点反潮流，但正是它的「笨」反而成了最大的优点：

没有通知 — 不会突然弹出消息
没有多巴胺陷阱 — 不会刷着刷着就跑偏了
慢即是快 — 手写迫使你思考，而不是机械记录
零成本启动 — 一本本子 + 一支笔足矣

我的极简体系

不搞复杂的 collections，不画花哨的装饰，保持 Ryder Carroll 原教旨风格：

月度记录（Monthly Log）

左侧：当月日历，标记关键日期和截止
右侧：当月任务清单

每日记录（Daily Log）

按天记录任务和笔记
符号系统：
- · 任务
- × 已完成
- > 迁移
- < 计划中
- — 笔记
- ○ 事件

月度迁移（Monthly Migration）

每个月底花 15 分钟回顾：

未完成的任务：迁移或删除
当月的经验教训
下个月的重点

跟数字工具结合

纸笔做规划，数字化工具做执行和归档：

Todoist 管理需要提醒的短期任务
子弹日记 做周度和月度规划
互不干扰，各司其职

三年下来最大感受：工具不重要，重要的是坚持记录和定期回顾。

2026 年 AI 工具链实用观察

Tue, 12 May 2026 21:00:00 +0800

2026 年的 AI 工具生态可以用一个词形容——务实。经过前两年的概念爆发，现在已经进入落地阶段。

DeepSeek 实测

最近深度体验了 DeepSeek V4 系列模型，几点感受：

V4-Flash

日常使用首选。响应快、性价比高，适合：

代码辅助和 debug
文档撰写和润色
信息检索和整理
日常问答

V4-Pro

复杂场景下表现出色，适合：

长文分析和总结
多步推理任务
代码架构设计
领域专业知识问答

账户余额 ¥74.31，按目前用量够跑一阵子。

智能体（Agent）趋势

今年 Agent 是主题词。从单纯对话到能独立执行任务的智能体，有几个方向值得关注：

编码 Agent — 从写代码到提 PR，全流程自动化
文档 Agent — 自动生成周报、会议纪要、汇报材料
运维 Agent — 日志分析、异常告警、故障排查
个人助理 Agent — 日程管理、信息聚合、任务委派

怎么用更划算

大部分日常任务用 Flash 就行
复杂任务才上 Pro，避免资源浪费
善用上下文缓存，减少重复 token 消耗
配合工具链（MCP、Function Calling）发挥更大价值

AI 工具的价值不在于它能做什么，而在于你用它做了什么。

从零搭建个人博客：Hugo + PaperMod 实践记录

Tue, 12 May 2026 20:00:00 +0800

为什么选 Hugo

静态博客框架不少，选 Hugo 主要看中三点：

快 — 编译以毫秒计，生成纯静态文件，部署无压力
简单 — 一个二进制文件，无需 Node.js、PHP 等运行时依赖
主题丰富 — PaperMod 主题简洁优雅，阅读体验好

环境

服务器: 腾讯云 Lighthouse，北京地域
系统: Ubuntu 24.04 LTS
域名: 备案审核中
Hugo: v0.161.1 (extended)
主题: PaperMod v8

踩坑记录

GitHub 下载慢

国内 VPS 下载 GitHub 上的文件速度感人，最终通过 GitHub API 的 /zipball/master 接口才成功拉下 PaperMod 主题：

curl -L -H "Accept: application/vnd.github.v3+json" \
 "https://api.github.com/repos/adityatelange/hugo-PaperMod/zipball/master" \
 -o papermod.zip

Snap 里的 Hugo

系统里 apt 源的 Hugo 版本较旧（v0.123.7），snap 里有最新的 v0.161.1 但 snap 在 LXC 容器里有 cgroup 问题。解决方式是直接从 snap 挂载目录拷贝二进制：

cp /snap/hugo/current/bin/hugo /usr/local/bin/

最终效果

现在博客跑着 PaperMod 主题，支持：

明暗主题自动切换
RSS 订阅
标签分类
代码高亮与复制
响应式布局

后续等备案通过后绑定域名，配上 HTTPS 正式证书就齐活了。

VPS 新手入门：从购买到上线一个网站

Tue, 12 May 2026 19:00:00 +0800

买了一台云服务器之后，怎么让它真正跑起来？这篇文章记录基本的 VPS 初始化和安全配置流程。

购买后的第一件事

拿到服务器 IP 和 root 密码后：

1. SSH 登录

ssh root@你的服务器IP

第一次登录会提示确认主机指纹，输入 yes 即可。

2. 创建普通用户

root 权限太大，日常操作应该用普通用户：

adduser 用户名
usermod -aG sudo 用户名

3. 配置 SSH 密钥登录

# 在本地机器上生成密钥
ssh-keygen -t ed25519

# 把公钥传到服务器
ssh-copy-id 用户名@服务器IP

然后编辑 /etc/ssh/sshd_config，关闭密码登录：

PasswordAuthentication no

4. 防火墙配置

用 ufw 简单配置：

ufw allow OpenSSH
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable

5. 安装必要的软件

apt update && apt upgrade -y
apt install -y nginx curl wget git

部署静态网站

最简单的方式是用 Nginx：

把构建好的静态文件放到 /var/www/html 或自定义目录
配置 Nginx 站点文件指向该目录
运行 nginx -t && systemctl reload nginx

安全底线

不要用 root 直接操作日常任务
关闭 SSH 密码登录
定期更新系统包
非必要不开放额外端口

服务器就像一间屋子，基础装修做好才能住得安心。

我的效率工具链 2026

Tue, 12 May 2026 18:00:00 +0800

持续折腾工具多年，今年终于稳定下来。记录一下目前的工具链，给想优化工作流的朋友参考。

笔记与知识管理

子弹日记（纸笔） — 每日规划和自我对话的核心载体。具体用法之前写过，不再重复。

Hugo + Hextra — 个人博客，用于对外输出。纯静态，零维护成本。

GitHub — 技术笔记和代码片段的存档。Markdown 文件 + 搜索，比任何笔记软件都好用。

任务管理

Todoist — 短期任务和提醒工具。优点是快速、跨平台、自然语言识别能力强。「今天要做的事」用它就够了。

AI 工具

DeepSeek V4 — 主力 AI 助手。Flash 模型日常用，Pro 模型处理复杂任务。API 接入各种场景。

开发相关

VS Code — 主力编辑器
Hugo — 静态博客生成器
Nginx — Web 服务器
Git — 版本控制

选工具的原则

够用就好 — 不追求功能最全，追求用得顺手
数据可控 — 优先选能导出、能自托管的方案
学习成本低 — 花在学工具上的时间要能赚回来
跨平台 — 手机和电脑都能用

好工具的标准不是功能多，而是让你忘记工具的存在，专注于事情本身。

极简主义的实用指南：少即是多

Tue, 12 May 2026 17:00:00 +0800

极简主义不是家徒四壁，而是去掉多余的，留下重要的。

数字极简

信息过载是这个时代的通病。几个容易上手的做法：

清理通知

手机里 90% 的推送都不需要即时响应。关掉非必要通知，只保留电话、短信和真正重要的一两个 App。

统一信息入口

每天固定时间看消息，而不是随时被消息打断。可以设成上午、下午各一次。

减少「收藏即学到」

收藏夹里存了几百篇「以后再看」的文章，真正回看的不到 5%。不如看到就处理：要么现在读，要么归档待读，要么直接删。

物品极简

一个简单的判断标准：这件东西在过去一年里用过吗？

用过 → 保留
没用到但将来可能用 → 先收起来，再给一年期限
没用到将来也不会用 → 送人或扔掉

精神极简

比物品和信息更重要的，是减少内心的负担：

少承诺 — 不会做的事不要答应，做不了的事及时说
少比较 — 别人的进度和你的关系不大
少内耗 — 纠结 5 分钟还没决定的事，说明选哪个都行

2026 上半年阅读清单与推荐

Tue, 12 May 2026 16:00:00 +0800

上半年读了十几本书，挑几本值得推荐的记一下。

技术类

《软件设计的哲学》

不是讲设计模式的，而是讲复杂度管理。核心观点：软件设计的本质是降低复杂度。写得深入浅出，适合有几年经验想突破瓶颈的开发者。

《凤凰项目》

用小说的形式讲 DevOps 转型。IT 运维的日常在书里无比真实，读起来很有代入感。

效率类

《深度工作》

Cal Newport 的代表作。核心论点：在这个随时被打断的时代，深度专注的能力越来越稀缺，也越来越有价值。

书里给了一些具体的训练方法，比如：

安排固定的深度工作时间段
社交媒体断舍离
用仪式感帮助进入状态

人文类

《你以为你以为的就是你以为的吗？》

一本有意思的思维训练书，帮助识别日常思考中的逻辑漏洞。适合碎片时间翻几页。

阅读习惯

今年调整了阅读方式：

早上的时间给深度阅读 — 30 分钟，不碰手机
通勤时间给信息类阅读 — RSS、Newsletter、技术文章
周末下午给整本书 — 泡杯茶，一次读一两章

读书不求多，读完、消化、能用上，一本顶十本。

Python Async: Beyond the Basics

Tue, 12 May 2026 11:00:00 +0800

Async Python is no longer optional if you’re doing any kind of I/O-bound work. Beyond the basics of async/await, understanding the event loop helps debug elusive issues.

The Event Loop in Practice

The event loop runs one coroutine at a time, switching at await points. This is cooperative multitasking — a coroutine that never awaits blocks everything else. If you have CPU-bound work inside an async function, offload it to a thread pool with asyncio.to_thread().

import asyncio

# Bad: blocks the event loop
async def bad():
 result = heavy_computation() # CPU-bound, no await
 return result

# Good: offloads to a thread
async def good():
 result = await asyncio.to_thread(heavy_computation)
 return result

Async Context Managers

Writing proper async context managers is essential for managing connections and locks:

class AsyncConnection:
 async def __aenter__(self):
 self.conn = await create_connection()
 return self.conn

 async def __aexit__(self, *args):
 await self.conn.close()

The contextlib.asynccontextmanager decorator makes this even cleaner for simple cases.

Common Pitfalls with `asyncio.gather`

gather runs tasks concurrently, but one failing task doesn’t cancel the others by default. If you need all-or-nothing semantics, use asyncio.TaskGroup (Python 3.11+):

async with asyncio.TaskGroup() as tg:
 t1 = tg.create_task(fetch(url1))
 t2 = tg.create_task(fetch(url2))
# Both succeeded, or both were cancelled

Cancel Scopes

Cancellation in asyncio is cooperative: asyncio.CancelledError is raised at the next await. If your coroutine catches and suppresses it, the task becomes uncancellable — usually a bug. Use asyncio.shield() sparingly to protect critical cleanup code.

Structured Concurrency

The trend across languages (Trio in Python, Kotlin coroutines, Swift concurrency) is toward structured concurrency: every task has a clear parent scope that determines its lifetime. TaskGroup is Python’s step in this direction. Embrace it over bare create_task() calls.

Async Python has matured significantly. Most of the old footguns have been addressed, but the fundamentals — understand the event loop, respect cancellation, and structure your concurrency — remain essential.

Linux 桌面美化指北

Mon, 11 May 2026 10:00:00 +0800

Linux 桌面环境的选择很多，但真正好用的配置往往很简单。本文记录从 Ubuntu 默认桌面开始，逐步调整到一套耐看、高效的配置。

主题选择

白天用亮色主题降低反光，晚上切暗色保护眼睛。推荐 Nord 和 Catppuccin 两套配色——前者冷峻克制，后者柔和温暖，每天盯着看八小时不累。

GTK 主题建议选择维护活跃的项目，避免 Gnome 大版本升级后样式错乱。Qt 应用在 Gnome 下可以用 qt5ct 统一风格。

字体配置

终端字体一定要等宽且清晰。推荐 Fira Code 做编程字体，连字（ligatures）让 =>、!=、>= 这类符号组合更易读。中文字体用 Noto Sans CJK，和西文搭配自然。

终端与 Shell

终端模拟器推荐 Alacritty——GPU 加速，配置文件清晰。配合 zsh + starship 提示符，日常使用效率提升不少。Starship 的优势在于跨 shell 兼容，换到 fish 或 nu 不用重新配置。

窗口管理

Gnome 默认的三指滑动切换工作区已经很好用。如果追求更极致的键盘操作，可以试试 Pop Shell 平铺扩展，或者直接上 i3/sway。但对大多数人来说，Gnome 的默认交互已经够用。

关键原则：不追求花哨，追求每天盯着看不累。

数据库索引优化实战

Sun, 10 May 2026 16:00:00 +0800

EXPLAIN 是 DBA 的眼睛。看 type 字段从 ALL 变成 ref 是最有成就感的事。

从慢查询开始

一切优化从定位问题开始。打开 MySQL 的慢查询日志（slow_query_log），设置 long_query_time = 0.1，跑一段时间后分析。PostgreSQL 用 pg_stat_statements 扩展，同样有效。

拿到慢查询，先 EXPLAIN 看执行计划。关注几个关键字段：

字段	含义	目标
type	访问类型	至少到 range，最好到 ref/const
key	使用的索引	不为 NULL
rows	扫描行数	越小越好
Extra	额外信息	避免 Using filesort / Using temporary

最左前缀原则

联合索引是最容易出错的地方。假设索引是 (a, b, c)：

WHERE a = 1 ✅ 用到索引
WHERE a = 1 AND b = 2 ✅ 用到索引
WHERE b = 2 ❌ 用不到
WHERE a = 1 AND c = 3 ⚠️ 只用到了 a 列

排序也受这个规则约束。ORDER BY a, b 没问题，ORDER BY b, c 就需要额外排序。

覆盖索引

如果查询需要的所有列都在索引里，就不需要回表取数据。Extra 列显示 Using index 就是覆盖索引。对一个高频查询，覆盖索引能减少大量随机 I/O。

代价是索引变大了。不要为了覆盖索引把所有列都塞进索引——算一笔写入性能和存储空间的账。

真实案例

某个订单列表查询，原始 SQL 跑了 8 秒。EXPLAIN 一看，type: ALL，全表扫描 200 万行。加了 (user_id, created_at) 联合索引后，type: ref，扫描 20 行，耗时 12ms。

索引不是越多越好——每个索引都会拖慢写入速度并占用磁盘空间。建索引前问自己：这个查询的执行频率值得一个索引吗？

Svelte 初体验：不一样的思路

Sun, 10 May 2026 09:30:00 +0800

用惯了 React 和 Vue，第一次接触 Svelte 的时候确实有种新鲜感。最直观的感受：代码量少了很多。

Runes 语法

Svelte 5 引入了 runes 语法，让响应式声明更显式：

$state — 声明响应式变量，替代了之前靠赋值触发响应式的隐式规则。
$derived — 衍生值，类似 Vue 的 computed。
$effect — 副作用，自动追踪依赖并在变化时执行。

<script>
 let count = $state(0);
 let doubled = $derived(count * 2);

 $effect(() => {
 console.log(`count is now ${count}`);
 });
</script>

逻辑清晰，没有 useEffect 的依赖数组心智负担。

编译时魔法

Svelte 的核心理念：没有虚拟 DOM，编译器在构建时直接把组件转成高效的 DOM 操作代码。打包体积小得惊人，一个简单的组件可能只有几百字节。对移动端场景尤其友好。

SvelteKit

SvelteKit 是 Svelte 的全栈框架，文件路由设计简洁。约定优于配置——新建一个 src/routes/about/+page.svelte，就自动有了 /about 路由。内置 SSR、SSG、CSR 多种渲染模式，服务器端数据加载用 load 函数，类型安全做得不错。

总结

Svelte 适合想要减少样板代码、追求小打包体积的项目。React 和 Vue 的生态更成熟，但 Svelte 的思路值得关注。下一步打算用 SvelteKit 重写个人博客试试看。

SSH 隧道实用指南

Sat, 09 May 2026 14:00:00 +0800

SSH 隧道是开发者的必备技能，但很多人只用过最基本的 ssh user@host。三种端口转发模式记清楚了，日常开发基本够用。

本地端口转发（-L）

把远程内网的服务映射到本机。

ssh -L 3306:db.internal:3306 jump-host

这条命令让本地的 localhost:3306 流量通过跳板机转发到内网的数据库服务器。典型场景：你在家开发，公司的数据库只在内网可访问。连上跳板机后，mysql -h 127.0.0.1 -P 3306 就能直接操作数据库。

远程端口转发（-R）

反过来，把本地端口暴露给远程服务器。

ssh -R 8080:localhost:3000 public-server

这个场景适合调试 webhook：你在本地起了服务，第三方服务需要回调你的端点。把本地的 3000 端口映射到公网服务器的 8080，webhook URL 填 http://public-server:8080 就能收到回调。

记得在 remote 服务器上设置 GatewayPorts yes 才能让外部访问。

动态端口转发（-D）

临时搭建 SOCKS 代理。

ssh -D 1080 jump-host

然后浏览器或系统代理设置为 socks5://localhost:1080，流量就全走跳板机出去了。配合 SwitchyOmega 这类浏览器扩展，按域名自动切换代理规则，体验更好。

实用技巧

加 -N 不执行远程命令，纯隧道。
加 -f 后台运行。
加 -C 压缩传输，慢网络下有用。
用 ~/.ssh/config 给常用隧道起别名，避免每次敲长命令。

三种模式记清楚，SSH 隧道基本够用。