普通视图

发现新文章，点击刷新页面。

昨天以前Origin

Origin
在 Python 中复现 Race ConditionSingee
背景在学习 Race 或原子操作时，往往会有一个很经典的示例12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <pthread.h>static long long counter = 0;static long long loops = 0;static void *worker(void *arg) { (void)arg; for (long long i = 0; i < loops; i++) { counter += 1; // 故意不加锁：会丢更新 } return NULL;}static long long parse_ll(co
2026年1月24日 09:18

在 Python 中复现 Race Condition

Origin

作者 Singee

2026年1月24日 09:18

背景

在学习 Race 或原子操作时，往往会有一个很经典的示例

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>

static long long counter = 0;
static long long loops = 0;

static void *worker(void *arg) {
    (void)arg;
    for (long long i = 0; i < loops; i++) {
        counter += 1;  // 故意不加锁：会丢更新
    }
    return NULL;
}

static long long parse_ll(const char *s, const char *name) {
    errno = 0;
    char *end = NULL;
    long long v = strtoll(s, &end, 10);
    if (errno != 0 || end == s || *end != '\0' || v < 0) {
        fprintf(stderr, "invalid %s: %s\n", name, s);
        exit(1);
    }
    return v;
}

int main(int argc, char **argv) {
    if (argc != 3) {
        fprintf(stderr, "usage: %s <loops> <threads>\n", argv[0]);
        return 1;
    }

    loops = parse_ll(argv[1], "loops");
    long long num_threads_ll = parse_ll(argv[2], "threads");

    if (num_threads_ll <= 0 || num_threads_ll > 1000000) {
        fprintf(stderr, "threads out of range: %lld\n", num_threads_ll);
        return 1;
    }

    int num_threads = (int)num_threads_ll;

    pthread_t *threads = (pthread_t *)malloc(sizeof(pthread_t) * (size_t)num_threads);
    if (!threads) {
        perror("malloc");
        return 1;
    }

    printf("Initial value: %lld\n", counter);

    for (int i = 0; i < num_threads; i++) {
        int rc = pthread_create(&threads[i], NULL, worker, NULL);
        if (rc != 0) {
            fprintf(stderr, "pthread_create failed (rc=%d)\n", rc);
            free(threads);
            return 1;
        }
    }

    for (int i = 0; i < num_threads; i++) {
        pthread_join(threads[i], NULL);
    }

    long long expected = loops * num_threads_ll;
    printf("Expected: %lld\n", expected);
    printf("Final value: %lld\n", counter);
    printf("Lost updates: %lld\n", expected - counter);

    free(threads);
    return 0;
}

用 ./race 2000 5 来运行它，最终会创建 5 个线程并发对一个全局变量自增，因为这个「自增」操作不是原子的，所以最终的更新结果往往是一个小于 10000 的数字

但是，如果把这个代码翻译成 Python

import sys
import threading


counter = 0
loops = 0


def worker():
    global counter
    for _ in range(loops):
        counter += 1


def main():
    global loops

    if len(sys.argv) != 3:
        print("usage: python race.py <loops> <threads>", file=sys.stderr)
        sys.exit(1)

    loops = int(sys.argv[1])
    num_threads = int(sys.argv[2])

    threads = []

    print("Initial value:", counter)

    for _ in range(num_threads):
        t = threading.Thread(target=worker)
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print("Expected:", loops * num_threads)
    print("Final value:", counter)
    print("Lost updates:", loops * num_threads - counter)


if __name__ == "__main__":
    main()

你会发现无论执行 python race.py 2000 5 多少次，最终的结果永远是稳定的 10000 —— 竞争消失了

GIL

没错，稍有经验的人几乎可以一下子反应过来这是 GIL 的锅！

Python 3.10 起引入了一个优化，并不是所有操作都会去进行获取 + 释放 GIL 的操作。而我们想要产生竞态的核心逻辑 [LOAD_GLOBAL counter, LOAD_CONST 1, INPLACE_ADD, STORE_GLOBAL counter] 正好都不在这些 GIL 操作上，因此上述代码看似是两个线程并行，但实际上是分开执行的，所以并没有产生竞争、没有同时读写一个全局变量的情况出现，导致无法复现

解决办法

关闭 GIL

既然它是 GIL 导致的，那我们关了 GIL 不就好了🤔 Python 3.13 起开始有了一个 free-threaded 版本（常称为 python3.13t ），将 GIL 剔除了，所以我们如果直接用这种不含 GIL 的发行版去执行上面的程序，可以发现竞态成功复现了

引入 GIL 切换

既然问题出在我们的代码「过于简单」以至于不会给 GIL 释放锁的机会，那我们就手动给它引入释放的机会就好了，最简单方法就是利用「函数返回」—— 我们只需要将 += 1 替换成一个函数调用即可

import sys
import threading
import time


counter = 0
loops = 0

def one():
    return 1


def worker():
    global counter
    for _ in range(loops):
        counter += one()


def main():
    global loops

    if len(sys.argv) != 3:
        print("usage: python race.py <loops> <threads>", file=sys.stderr)
        sys.exit(1)

    loops = int(sys.argv[1])
    num_threads = int(sys.argv[2])

    threads = []

    print("Initial value:", counter)

    for _ in range(num_threads):
        t = threading.Thread(target=worker)
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print("Expected:", loops * num_threads)
    print("Final value:", counter)
    print("Lost updates:", loops * num_threads - counter)


if __name__ == "__main__":
    main()

counter += one() 的指令是 [LOAD_GLOBAL counter, CALL_FUNCTION x, INPLACE_ADD, STORE_GLOBAL counter] ，而其中的 CALL_FUNCTION 会触发 GIL 切换检查，即在读写的过程中给了 GIL 释放锁的机会、允许了竞争

不过注意一点，因为现在 GIL 是 time-based switching，默认要 5ms 才会触发一次线程切换，所以每轮多跑几次，例如用 python race.py 200000 5 - 少了的话在现代 CPU 上可能根本来不及满足切换的条件程序就运行完了

参考

https://www.reddit.com/r/learnprogramming/comments/16mlz4h/race_condition_doesnt_happen_from_python_310/

再看看 SQL 中的 null

Origin

作者 Singee

2025年10月16日 13:52

NULL 与任何值的运算结果都是 NULL

NULL 有一个很重要的特性：NULL 与任何值的运算结果都是 NULL

SELECT 1 = 1; -- true
SELECT 1 = NULL; -- null
SELECT NULL = NULL; -- null
SELECT 1 != NULL; -- null
SELECT NULL != NULL; -- null

这也就意味着，对于存在列 col BOOLEAN NULLABLE 的表，如果一行中 col 列的值为 NULL，则下面的四条查询都不会包含这行

-- 等于自不必说
SELECT * FROM "table" WHERE col = true;
SELECT * FROM "table" WHERE col = false;

-- 但不等于也不会包括值为 null 的行 
SELECT * FROM "table" WHERE col != true;
SELECT * FROM "table" WHERE col != false;

IS NULL

我们其实基本都知道这点，所以我们在进行不等运算时通常会用 IS NULL / IS NOT NULL 特殊处理 NULL 列

1 2	SELECT * FROM "table" WHERE col is null OR col != true; -- 筛选 col = null 或 false SELECT * FROM "table" WHERE col is null OR col != false; -- 筛选 col = null 或 true

IS TRUE / IS FALSE

但其实，除了 IS NULL， IS 操作符后面还可以跟随 BOOL 值，那么，用 IS NOT 其实是一个更加精准的不等于操作

1 2	SELECT * FROM "table" WHERE col IS NOT true; -- 筛选 col = null 或 false SELECT * FROM "table" WHERE col IS NOT false; -- 筛选 col = null 或 true

而对于不是 bool 类型的 nullable 列，我们则可以搭配使用 = != 与 IS

1
2
3

-- 筛选 col = null 或任何不为 1 的值
SELECT * FROM "table" WHERE col is null OR col != 1;
SELECT * FROM "table" WHERE col = 1 IS NOT TRUE;

concat

NULL 与任何值的运算结果都是 NULL，但在函数中则不一定（取决于具体实现）

以连接字符串为例，如果中间存在 NULL，用 || 连接属于运算符，中间任何一项为 NULL 则结果为 NULL，而用 concat 连接则是函数，中间出现的 NULL 会被忽略

1 2	SELECT 'hello-' \|\| NULL \|\| 'world'; -- null SELECT concat('hello-', NULL, 'world'); -- hello-world

布尔逻辑

NULL 与任何值的运算结果都是 NULL，但在布尔逻辑中则不一样…… 试试看能不能说出下面的返回值

select not NULL;
select null or null;
select null and null;

select null OR true;
select true OR null;
select null OR false;
select false OR null;

select null AND true;
select true AND null;
select null AND false;
select false AND null;

答案

select not NULL;          -- NULL
select null or null;      -- NULL
select null and null;     -- NULL

select null OR true;      -- TRUE
select true OR null;      -- TRUE
select null OR false;     -- NULL
select false OR null;     -- NULL

select null AND true;     -- NULL
select true AND null;     -- NULL
select null AND false;    -- FALSE
select false AND null;    -- FALSE

其实逻辑在于理解 NULL 代表着「未知」，与「真」「假」一起构成了一个三值集合

那么自运算，无论「未知的反面」还是「未知和未知」「未知或未知」都是未知，也因此都是 NULL

OR 的逻辑则是「有任何一个值为 TRUE 就是 TRUE」，因此，在 NULL 参与的运算中，存在 TRUE 则为 TRUE，不存在 TRUE 则为 NULL（继续未知）

AND 的逻辑则是「有任何一个值为 FALSE 就是 FALSE」，因此，在 NULL 参与的运算中，存在 FALSE 则为 FALSE，不存在 FALSE 则为 NULL（继续未知）

在聚合函数中

在聚合时，如果对 NULL 值进行聚合，它的数值是被完全忽略的 —— 一个例子是 avg，如果对 1, 2, 3, 4, NULL 做 avg，结果是 (1+2+3+4)/4

如果期望给 NULL 在聚合时一个默认值，可以用 coalesce 函数为它赋一个「默认值」

COALESCE

上面已经提过 coalesce 函数了，再说一句就是，coalesce 函数可以接受多个参数（而不只是两个），会返回第一个非 NULL 值

例如用 coalesce(first_name, nickname, email) 取用户「昵称」

NULLIF

pg 中还存在一个 nullif 函数，接收两个值，如果两个值相等则返回 NULL 否则返回第一个值，等价于 CASE WHEN a = b THEN NULL ELSE a END

这个函数主要用来「将零值转换为空值」；举个例子就是

SELECT 
  NULLIF(TRIM(name), '') AS name,
  NULLIF(status, 'N/A')  AS status
FROM t;

还有就是搭配 NULL 的「可转换为其他类型」的特性

SELECT
  -- 将 '' 直接转换成 date 是会报错的，但是先转换为 NULL 再转换为 date 就可以了
  NULLIF(col_date, '')::date AS date
FROM t;

NULL 值在 PostgresQL 协议中的表示

虽然大概率不会引起混淆，但还是说一下，虽然我们用 psql 规则看到 NULL 值就像是文本一样，但它的底层传输是二进制，PG 规定用 len = -1 代表 NULL 值，所以不存在它与空字符串、null 字符串等混淆的情况

另外，特殊的，在 COPY 中，如果用的 text format（PG 的消息协议中，对于一个值存在 text 和 binary 两种 format），那么会用 \N 代表 NULL 值

参考：https://www.postgresql.org/docs/current/protocol-message-formats.html 中的 Query, Parse, Bind, RowDescription, DataRow

NULL 值在文件系统中的存储

当行中有任一列值为 NULL 时，「行头」HeapTupleHeaderData 中的 t_infomask 字段内的 HEAP_HASNULL flag 会被标记为 1，此时在行头后面、其余数据前面会增加一个 null bitmap，用位图的形式存储所有列的 NULL 情况，且如果某一列的值为 null，后面的 data 中将不会出现这一列的信息

另外，null bitmap 除了用来处理 NULL 值，还会用来处理 drop column —— 当一列被删除时其实际上依然存在着，只是后面所有的行都会带有 null bitmap 将这一列标记为 NULL（更事实上，删除列是懒删除，行内的数据都还在，只有下次更新行时才会清理这些数据 —— 当然，清理的方式也是将它标记为 NULL）；

参考：https://www.postgresql.org/docs/current/storage-page-layout.html

再见 xlog

Origin

作者 Singee

2025年8月1日 08:21

2023 年 4 月我在 xlog 下写下了第一篇博客。xlog 真的是一个我很喜欢的博客平台，好看，对于 markdown 的第一方支持，不用考虑部署、图床等问题，自带 AI Summary、自带双语翻译，真的是一切只需要「写」即可，哦对，更重要的是，依赖于区块链技术，虽然你写的文章是在平台上的，但所有数据都依然属于你，且所有数据都是永久保存。

然而，两年过去了，xlog 这个平台虽然还在，但我认为它已经死了。GitHub 更新已基本停滞，没有人处理 issue、没有人审阅 pr，xlog 官网上充满了 spam，也没有人去管理社区。

其实这一切的原因都很好理解 —— xlog 的开发者 DIYGod 转去做 Folo 了。是啊，Folo 相比于 xlog 绝对是更有前景的项目，也更容易讲故事……

xlog 已被放弃，再加上 xlog 的母公司 RSS3 最近的动荡，我觉得是时候从 xlog 迁移走了。

我其实无比庆幸，两年前的时候我是打算把我所有博客迁移到 xlog 的。但是我的博客用的是 /yyyy/mm/dd/xxx 的 url 格式，而 xlog 并不支持这种格式，因而我一直是用 blog.singee.me 作为博客主域名 + articles.singee.me 作为 xlog 博客域名的，然后通过自动化将内容进行同步，且配置 xlog 博客的链接作为 Canonical URL。

这让我这次的迁移十分简单：将我原始博客的链接删掉、将 articles.singee.me 的原链接进行跳转即可！

嗯…… 唯一的副作用，通过 RSS 订阅我的博客的人应该会因为 id 变化了重新看一遍我的博客。其实这个是可以解决的，因为我之前 blog.singee.me 的 RSS 是通过 patch 了 hexo-generator-feed 实现的，完全可以特殊处理，但考虑到经历这个事件以后我应该不会再考虑这种「奇葩」的两处链接的形式了，所以我就把之前的 patch 回滚了，顺便增加一下我博客的曝光度 emm

anyway，博客又回来了，我又回到了原来的工作流：Notion 写作 + 同步到博客。已经这样写了两个博客了，一切都挺好，和两年前相比仿佛什么都没变 XD

2024Q3 订阅 Recap

Origin

作者 Singee

2024年10月17日 06:22

现存订阅

（按照实付月金额降序）

Proton

我是 Proton Visionary 用户，Proton Visionary 的价格 $479.76 / 2y，是我所有订阅服务中最贵的了。

我依然在持续订阅中，且目前对于 Proton 依然很满意

Visionary 套餐持续「加量不加价」
相比之前，近年明显增加了 Visionary 套餐的「新品尝鲜特权」，所有新产品/新功能都会优先给 Visionary 用户使用

在可以预见的未来我将继续长期订阅下去

AD：Proton Visionary 可以分享给他人加入，如果你想加入我的家庭组请发邮件给我 singee@proton.me，价格为 92 天 ¥109

Monica

订阅了 Monica Unlimited，年付 $199

Monica 是一个我认为最全的 AI 工具，可以说覆盖了几乎所有需要 AI 的平台，有网页版的 chat、浏览器插件扩展（Chrome + iOS Safari）、桌面端、手机端，几乎可以说只要订阅 Monica 即可满足所有对于 AI 的需求

AD：如果想购买 Monica，请使用我的邀请链接 https://monica.im/?ref=bryan

Zero to Mastery

订阅了 ZTM 年度订阅，价格 $195.3 / 年（使用了提供给中国用户的 30% PPP 折扣）

一个计算机相关知识的学习网站。我是从 Udemy 学习到的他的课程，质量很不错而且持续更新，并且有比较多我感兴趣的内容，所以就去网站订阅了。目前在这上主要用来学习算法、系统设计和设计。

如果你也对它感兴趣，单门课程可以看看 Udemy 搞促销的时候，大概七八十一节，如果想订阅的话记得取申请 PPP 折扣订阅

另外他家还有一点有意思的是，Lifetime 标价 $999，但只要你学习 30 个月（每个月学习至少一节课）就可以得到免费的 Lifetime Plan。这种不促销而是鼓励你持续学习的做法我很喜欢。

Duolingo

订阅了 Duolingo Family，价格 $195.3 / 年

和 GF 一起用，总觉得用多邻国学知识是次要的，玩玩才是主要的…… 我目前用它来学习日语和粤语，女票用来学习韩语

如果你也对多邻国感兴趣，去淘宝买 ¥40 / 年的家庭组拼车或许才是最划算的方案

GitHub Copilot

订阅了 Personal Plan，价格 $10 / 月

不知何故我三年的 Copilot 免费突然没了，或许和最近确实没怎么折腾开源有关吧。一直用 Copilot 已经形成惯性了，写代码时候没有 Copilot 提示（特别是一些错误信息什么的）总觉得麻烦好多，价格也不贵，就付费订阅了。

而且现在 Copilot 已经不只是代码补全了，一方面支持了 CLI，一方面支持了 Chat。特别是 Chat，之前只能在 IDE 和手机版用，现在不但可以在 GitHub 主站用了，还可以索引仓库来 Ask Repo，甚至还有独立的 Chat 页面。

Copilot 我唯一不满意的应该还是在 JetBrains 下生成 Commit Message 吧（而 JetBrains 自家的 JetBrains AI 就支持），我其实挺期待一个可以学习我历史 commit message 习惯来自动生成一个 commit message 然后我只需要简单更改就可以提交的功能的。

iCloud

订阅了 iCloud+ 2TB，价格 ¥68 / 月

emmm 这可能是唯一一个我一直想退订但是没退吧，还每次扣款前五天提醒我下让我头疼。因为和家人共用，存储照片 + 备份，所以虽然感觉这是个性价比极低还不好用的东西我也只能忍着用了

Dler Cloud

翻*服务，Pass Gold 套餐，享受了 8 折，折后 ¥800 / 年

实话说已经不是很满意了，两年前我对 Dler 的评价是「综合体验最好的翻*服务」，但是现在我已经要打个问号了。

近年来持续的涨价 + 服务劣化，可能和大环境有关，但是我也实在不想为它付这么高昂的费用了。（事实上，之前我的套餐是最高等级 ¥1688/年的 Diamond，现在也降级了）

山姆

卓越会员，¥680 / 年

有点乱入的感觉，毕竟山姆可能是这个列表里唯一不是数字产品的了

之前一直都是蹭别人的卡或者闲鱼，今年终于自己开了。在 ¥260 的普通卡和 ¥680 的卓越卡之间纠结来着，但是想了下差价每个月 ¥35，卓越+联名卡额外返利共 3%，平均每个月消费 1167 应该还是很容易的；而如果想完全赚回卡费，扣除掉送了 ¥50 开卡礼券、副卡 ¥100 闲鱼卖了，¥530 的价格在 4% 的返利下只需要每月消费 1104 就能回本相当于卡完全没付钱（这个金额我没算错哈，420/0.3 > 530/0.4），更何况还有副卡也会消费、加上卓越还有一些洗牙洗车券什么的，很容易回本，就开了。

Cloudflare Workers

Paid Plan，$5.2 / 月（因为我超用量了……）

我有数十个小服务跑在 Worker 上，大大提升了我的效率，可以说这个 5 刀是我付的最值的 5 刀了。

iximiuz

前期通过 Pateron 赞助获得的 Premium，$5 / 月

一个用来学习服务端技能的 learn-by-doing 平台，提供 tutorial 和对应的实验环境

Inoreader

RSS 服务商，活动时候开的 $89.99 / 18 月

Readwise

$4.5/月（中国用户 PPP 优惠 50%）

我在同时用着它的回顾卡和 Reader 服务。但事实上我对它并不是非常满意，更多的是一种「市面上没有替代品」心态在用着它；我也在筹备我自己的类似产品，或许 2025 能见面。

X Premium

HK$396 / 年（前几天活动 40% off 开的）

X Premium 可以说是一个我有时候需要有时候不需要的东西，大多数情况 Basic 够了，但我又很烦广告。之前一直都是一阵开一阵关的，这次想了下入了年付。

X Premium 有一个非常坑的地方！如果你点了升级按钮，那么不会有任何二次确认而是会给你直接升级+扣费；而如果你点了降级按钮，那么会立刻把你降级而且没有任何退款。

月付下损失可控，但是想像下年付的情况下，还剩下 11 个月的时候，想看看 Premium+，点了下，立刻升级成功了，反应过来不对，我只是想看看啊，于是又点了下降级，然后立刻降级成功了，紧接着发现哎竟然扣款了，那我降级会退款吗，等了几天发现没退，然后想那应该差额成为 credit 了吧，再次支付，嘿，又扣了一次钱。。然后联系客服，等待一周得到了一个「no refund」的回复……

GLaDOS

同样是翻 * 服务，¥398 / 400 天

我用来做 Dler 的 backup 的，另外如果坚持每日签到的话价格要低于标价，因为差不多每签到 20 天能得 10 天，算下来 ¥398 能用两年多

IPRoyal

固定美国家宽出口 IP，$4 / 月

懂得都懂，应付风控

WeRSS

微信公众号转 RSS 订阅，VIP3 ¥292.5/年

Setapp

家庭组拼车，¥18/月

单单其中的 Timing 这个订阅 App 就能回本了，我额外在用的 Spark、Bartender、iStat Menus 等都算是白送的

Dropbox

土耳其订阅 TRY 809.99/年

我认为体验最好的网盘，没有之一

Exercism

一个编程学习平台，在出 Insider 之前赞助了 $2 / 月现在获得了免费的 Insider【但其实所有功能都能免费使用】

主要可以用来学习多种编程语言，让自己刻意走出舒适区，而且有问题可以找 mentor 帮忙，完全免费

IFTTT

Pro+ Plan，很早期订阅的，$1.99 / 月

labuladong 算法笔记

算法学习网站，¥109 / 年

淘宝 88 VIP

¥88 / 年

各种域名

我名下目前有 13 个域名，差不多均价 $12 / 年，加起来约 $150

服务器

目前我的主要服务都跑在 fly.io 和 Digital Ocean 上，约 $100 / 月，但目前均在免费 credit 范围内

杂七杂八的国内会员

腾讯视频
爱奇艺
优酷
京东 plus
网易严选
京东 1 号店
QQ 绿钻
网易云
QQ 超级会员
QQ 阅读
知乎会员

各种联名卡活动开的，很难去算清楚具体花了多少钱，差不多每年 ¥400 吧

信用卡年费

建行大山白：¥1800/年，可用 40w 积分抵扣
中信
- 美国运通 Safari 白金卡：¥480/年，可用 6w 积分抵扣
- 银联 Plus 白金卡：¥480/年，可用 12w 积分抵扣
- 万豪精逸白金卡：¥980/年，刚性年费

相比于 2024Q2 的主要变化

取消了 Monica 的自动续费

之前订阅了 Monica 的年付（$199 / 年），本来是打算长久用下去的，但是这个季度我决定取消了它的自动续费，等到过期了再重新考虑是否续费，主要原因：

降价，Monica 的 Unlimited 在我订阅期间有一两个月的 $99 / 年的循环折扣，现在应该也只需要 $149 / 年；而我的订阅费用却只能是 $199 / 年，不能享受折扣
劣化：GPT-4 在很多情况下比 GPT-4o 要强，但是 Monica 在 4o 出了以后下掉了 GPT-4，且无法恢复（在智能体 - Models 中仍然可以选择 4，但是无法使用任何非文字的功能）
劣化 + 涨价：我初用的时候 Monica 可以在长上下文的情况下获得比较不错的响应，但是两个月前我开始发现在长上下文的情况下 Monica 会丢失一些信息，猜测做了截断/压缩；在 o1 出了以后直接更新摊牌，不限上下文的要按量付费

申请了 Memex 的退款

我曾经入了 Memex 的 lifetime plan，但是用了不到一周就发现完全不足以达到我的期望，就申请了退款。作者很快回复了，了解我不满意的点并承诺会在 6 个月内改善（也就是到现在这个月，2024.10）如果到时候仍然未能改善，继续给我退款，我同意了。

但自那以后，我所有的询问邮件、产品反馈邮件都石沉大海，再无人回复过。而现在 6 个月到了，我更是发现整个产品已经 3 个月没有更新了。

我以 Chargeback 作为威胁给作者再次发了最后一封邮件并表达了我的愤怒之情，这次作者倒是很快恢复了，说会 asap 启动退款流程，然而至此又消失了，没有退款、没有回复……

计划停用 inoreader

其实早在两年前我就已经计划停用 inoreader 了，一个原因就是日益渐长的年费，现在已经丧心病狂到了$7.5 / 月（对比 miniflux 官方实例只要 $15/年），另一个原因就是最近的新 UI 让我卡到完全无法正常使用（事实上，在我现在的数据规模下，旧的 UI 也在某些地方会很卡，但至少不至于卡到不能用）

替代方案现在主要打算自己开发了，想做一个完整的 RSS + Workflow 的形式，来替代我目前 inoreader + IFTTT 的形式

Python 的 pth 文件：在程序启动前自动执行命令

Origin

作者 Singee

2025年7月18日 05:36

Python 的 pth 文件提供了在任何 Python 解释器执行前执行命令的能力，可以方便的执行一些初始化脚本

pth 文件的能力

Python 解释器在启动时会自动 import site 模块（除非启动时指定 -S flag），而 site 模块有一个行为就是会寻找 site-packages 目录（最常用的场景就是我们安装包的目录）下的所有 .pth 文件并依次「执行」它。

需要注意的是， pth 实质上并不是脚本，它的定义是「path configuration file」，格式是每行一个「additional items (one per line) to be added to sys.path」，实际上，它每一行可以是下面的值之一：

空行、注释行（以 # 开头）：跳过
以 import 开头的字符串：会被 exec() 解释执行
其他字符串：会被追加进 sys.path 之中

因此，利用第二个能力，我们实质上可以任意执行我们需要的脚本！

🗒️ 注：如果脚本执行出现异常，只会打印出错误而不会阻止解释器的继续执行

可用性 & 执行时机

在 Python 3 的所有版本可用

相关 pth 文件会在 python 解释器启动时执行 —— 这包括执行脚本前、启动解释器前、执行任何用 python 写的程序前（如 pip）

当存在多个 pth 文件时，将采用字母序的方式依次执行 —— 一个值得强调的点是，python 的 virtualenv 就是通过 _virtualenv.pth 执行的 —— 这意味着，我们应当注意 pth 的命名以让其确保在 venv 之前或之后运行

浏览器从 A 到 Z

Origin

作者 Singee

2025年3月21日 07:57

将 A-Z 逐一输入到 Google Chrome 的地址栏里，我的 Google Chrome 都会自动补全出哪些域名呢？

本文灵感来源于 2024: 浏览器从 A 到 Z，首发于少数派

A - https://axiom.co

Axiom 是我最喜欢的网站日志收集分析工具，免费版拥有着高达 500GB / 月的免费额度，我的多款产品（包括我最新正在做的 1Space）都是使用的它作为日志收集。

如果你在找一款日志工具，强烈推荐它！

B - https://baidu.com

无可争议…… 虽然我现在确实不怎么用百度了，但是网络连不上的时候还是第一时间用百度做测试的😂

C - https://chatgpt.com

ChatGPT 作为 AI 时代的先驱，在目前似乎仍然保持着第一🤔

如果这篇文章是在 2024 年写的，那么我的 C 可能就不是它了；2024 年或许算是 ChatGPT 落后的一年，但是在 2025 年，O1-Pro 和 Deep Research 让它再次成为了模型领域的 No.1。我追随着最新的前沿技术，也订阅了高达 $200 / 月的 ChatGPT Pro，或许很贵，但我觉得它确确实实为我节省了很多的时间和精力。

D - https://discord.com

论「社区」，似乎已经有越来越多的服务选择在 Discord 这个平台上建立了。我在用的很多产品都用它作为产品发布和讨论的渠道。

E - edge://inspect

没想到竟然是个 Inspect 页面。这是 Chrome 自带的浏览器调试工具页面（不过因为我在用的是 Edge，所以不是 chrome://inspect 而是 edge://inspect）。我在做的 1Space，因为利用了 Shared Workers 作为多标签页的同步方案，因此我需要频繁访问它来查看同步日志。

F - https://fly.io

Fly IO 是我用了数年的容器服务平台，曾经驱动了我绝大多数的产品（其实现在也有不少，还剩下 40% 吧），体验很不错。

Fly IO 给我印象最深刻的其实是他们的招聘。他们的招聘与绝大多数的面试不同，采用的是「做 2-3 道实践题」+「与他们工作一天」的形式，只看能力，不看背景（甚至他们不要求简历），而且是全远程工作、薪资透明（仅与面试定级有关，与历史薪资、所在地域无关）。

G - https://gmail.com

Gmail —— 一个不存在的邮箱平台

H - http://localhost:3333

好好好，竟然是 localhost —— 3333 这个端口是我的 1Space 的本地开发服务器所使用的端口。

I - https://inoreader.com

虽然 RSS 越来越没落，虽然 RSS 平台越来越多（嗯？这俩之间的因果关系有点反直觉），但我还是觉得 RSS 是最适合我的信息收集渠道，inoreader 也是最好用的 RSS 客户端。

多说一句（广告时间到），inoreader 单纯做 RSS 已经到了几乎极致了，但是我们用 RSS 的目的或许不是为了收集信息，而是为了学习信息，而在整理回顾上，inoreader 就没那么强了，甚至我觉得其他能作为它下游知识管理的产品（例如我目前在用 readwise，或许下面 R 能看到它的身影）也不够优秀。因此我做的 1Space 目的就是打通知识「收集 - 管理 - 回顾」的全流程。

J - https://www.jetbrains.com

JetBrains 曾经是无可争议的 IDE 老大。

唉，曾经。JetBrains 的体验真的比 VS Code 好太多，哪怕在 VS Code 最擅长的前端领域，我也敢说 WebStorm 吊打它。奈何，现在是 AI 的时代，IDE 已经被 Cursor 为首的 AI IDE 重塑，而 JetBrains 真的在 AI 的潮流上落后了。打败你的，可能并不是你的竞争对手。

K - https://kb.singee.me

哦吼，我自己的 Knowledge Base！我的知识库一直是公开的，我的很多懒得不适合整理成博客的内容都写在了上面，主要记录我各种笔记、踩过的各种坑。

L - http://localhost:3333

嗯…… 和 H 一样，看出来我真的很努力去做 1Space 了。

M - https://monica.im

在我从浏览器中测试「M」之前，我就猜到了，我最常用的网站必有它。

Monica 可能宣传的不多，但是说它所属公司的另一个产品 Manus 估计大多数人都听过。如果说 Manus 是 AI Agent、完全替代人工方面的王炸，那么 Monica 就是你日常使用 AI 过程中的瑞士军刀 —— 你需要的 AI 能力，几乎总能在 Monica 中找到。

N - https://notion.so

竟然是 Notion。Notion 似乎我已经不用多余篇幅介绍了，估计能看到本文的受众都见过它。我曾经是 Notion 最早期的用户之一，但坦白说我已经挺长时间没怎么用过 Notion 了…… 其他 N 开头的产品还不够能打哇🤷

O - https://originui.com

又是一个程序员专属产品。这是一个 UI 组件库，算是 shadcn 的补充，同样以「复制-粘贴」的形式引入组件，需要的人值得一看！

P - https://www.paypal.com

竟然是 Paypal，类似国内的支付宝的产品？又是一个实际上我没怎么用的产品，看起来 P 开头的服务也不够能打😮‍💨

Q - 不便透露

emm 企业内部平台，略过

R - https://read.readwise.io

哦！Readwise Reader！一个稍后读的阅读器 + RSS！

真的挺好用的，而且对于我一个早期的 Readwise 用户而言直接是加量不加价。但我其实对它的很多细节还是不怎么满意的。我的 1Space 去年才开始正式做，但其实早在数年前就有计划了。但当时，刚刚打算做，就遇到了 Readwise Reader 宣布立项，我被他们开始宣传的「Reader for Power Reader」吸引了，决定等他们的产品，奈何，等了这么久，虽然已经比其他阅读器做的好很多了，还是不足以达到我想要的地步😮‍💨 最后还是没逃开自己做的命运。

S - 不便透露

我的某产品的内测页面🤔

T - temporal-web.temporal.svc.cluster.local:8080

Temporal 的管理面板。Temporal 是一个 Workflow 管理与调度的工具。写后端的人应该都知道，如果一个逻辑直接使用很普通的代码编写，在项目发展的过程中，很容易就会遇到复杂度指数级提升。如果并发、重试等基础操作在每个接口、每个 RPC 调用都自己写一遍，实在是没有意义，而且很容易漏了哪里导致上线 bomb。Workflow 就是对这种场景的一个解决方案，你的一切逻辑都定义成 Workflow，而重试、日志、并发等等都由调度器管理，项目初期看起来可能稍显繁琐，但是随着项目复杂度的提升、随着项目对并发的要求的提升，你会感谢当年选型选择了使用 Workflow 进行组织的你的。

哦对，Temporal 被设计为可以支撑超大型项目。如果你的项目是个中小型项目，也可以看看其他解决方案，例如 Trigger.dev、inngest、Restate。

U - https://ui.shadcn.com

要不是这篇文章严格按照字母序组织，它应该是和前面的 Origin UI 放在一起的。Shadcn/ui 简直就是没有设计能力的开发者的福音，如果你想做一个自己的产品，又苦于不知如何让页面变得好看，不如试试它。

另外，shadcn/ui 的开发者目前已经加入了 Vercel，因此 Vercel 的 v0 对 shadcn/ui 有很强的支持，如果你不但没有设计能力、甚至不是开发者，那么，利用 v0，只动动嘴皮子也可以得到利用 shadcn/ui 组织的很好看的界面。

V - https://v2ex.com

~~i2ex~~v2ex 论坛可以说是中国最大的~~同性交友社区~~程序员论坛了，嗯，就是这样。

W - 不便透露

我自用的某产品页面

X - https://x.com

全球最大的社交平台，实话说，对不追星的人来说，比微博好玩多了

Y - https://www.youdao.com

各种词典软件层出不穷，但我觉得依然还是有道最好用。带有韦氏、柯林斯、牛津的资源，各种原版例句，而且完全免费。

Z - https://zeabur.com

如果你是一个开发者，又不想浪费过多的精力在自动部署、运维上，就选 Zeabur 吧！推送代码秒部署，最重要的是，还有国内的服务器节点，真的很好用

[随笔] 一开始就公布定价

Origin

作者 Singee

2023年11月25日 17:13

看到了 FeedbackTrace 这个项目，看起来不错，但是我不会去使用，一个主要的原因就是它没有公布定价。

如果去选择一个一个直接面向 C 端的第三方产品，我一定会选择已经有了明确定价的 —— 否则我将承担巨大的未来的风险。如果未来定价不满足我的预期，我需要去考虑怎么迁移数据、怎么抹平用户体验差异等，一方面可能带来不确定的时间成本，另一方面可能产生糟糕的终端用户体验。

面对公测期间的价格和上线后不一致的做法，各个产品有各个产品不同的思路，最统一的就是降价后下一期账单自动降价、涨价保持原有价格不变或至少保持原有价格一定时间。特别的，Rewind 在 Early Access 期间的策略是调低定价后为历史订单全额退款、调高价格保持用户的原有价格不变，而 ChatGPT 的策略则是调低定价后给予用户差额价格退款并给予额外补偿。

多说一句，公测免费并不是不预先提供价格点的「借口」，完全可以预先告诉哪些是付费点但是公测期间可以免费使用（例如 Omnivore 明确在文档中说明了它的哪些功能未来可能是收费的）。

因此，我的产品，也一定在最初就给出一个收费点定价方案 —— 哪怕不够完美。大体来说，我会提前将价格和收费点列明，公测期间可以免费使用收费功能（或部分收费功能），而预先开始订阅收费版本的用户（即早期支持者）承诺未来如果存在价格调整他们一定可以「使用最低且不高于现有的价格得到最多的服务」。

[随笔] 避免完美主义导致的看似时间不够

Origin

作者 Singee

2023年5月23日 15:43

我经常会有想做一件事然后看了下时间可支配时间只有半小时了然后就会想「只有半小时了，等时间充裕的时候再做吧」然后一点点拖延下去

然而突然发现，以时间不够为为理由的拖延不但是完美主义的表现之一，更是一种可笑的借口

时间是最最宝贵的不可再生资源，一天可支配时间有 12 小时已经很了不起了，半小时已经是一天中的 1/24 了、半小时已经可以做很多事了。
而一周多来几次半小时的话，完成的事情可能已经抵得上正常半天甚至一天的任务量了。
更何况，借效率之名实拖延之事、让时间白白流逝，才是更可惜、又可笑的。

action >> thinking

[随笔] 背单词

Origin

作者 Singee

2023年4月26日 15:34

我一直在使用不同的单词学习应用程序，目前为止扇贝已经打卡了 2287 天、墨墨已经打卡了 1376 天。

我已经很久没有使用扇贝来背单词了。自从扇贝单词在之前的某个时间改版，单词书和生词要分开背（并且学习进度等是完全独立的），就再也没用它背过单词。

但最近，开始打算使用三个月来「严肃学英语」，于是就重新捡起了扇贝。不得不说，除了分离的割裂，扇贝做的是真的不错，特别是背几个单词就给你展示下之前的单词让你二次复习，非常有助于提高效率，另外还有自动根据最近学习的单词给你推荐短文的功能真的感觉是 killing feature（坦白说这东西是我三年前的点子，终于做出来了）。
目前扇贝感觉是国内英语学习最值得深入使用的软件了（综合上，单项其实都达不到最优，但是整合起来目前似乎没有可比的，扇贝单词+听力+阅读+口语，真的很全，要求不高的话一个就够了）。

目前在单词上，我是同步使用墨墨盒扇贝的，扇贝每天定量55复习+15新（+ 若干短文中的新词），墨墨则是每天累计 250 个单词（通常 50-100 新词），二者并行使用。
用墨墨的目的主要在于快速的把认知词汇提升上去，选用的是分频词书，而扇贝则是要深入学会一个单词，选用的是雅思写作词书。
二者共同使用是不冲突的，甚至我觉得比单一的一个软件选择背 300 多要强；一方面同时学了不同维度的单词，效率和扎实度同时并进，另一方面二者有一些相同的词汇，可以直接互补。

另外，墨墨的词汇量测试，建议所有人都去玩玩😂

[随笔] 走在计划前面

Origin

作者 Singee

2023年4月9日 15:29

感觉同样是要做一个事情一个小时

打算开始半小时，然后一不注意时间就超时多用了半小时是很正常并且很舒服的
但是如果一开始脑子想的就是「接下来要做一个小时」，那么可能就会想着拖延了

果然，要尽可能走在计划的前面

在 Shell 脚本中嵌入二进制文件

Origin

作者 Singee

2023年8月28日 04:03

前言

在构建 Linux/Unix 系安装包时，除了打包成标准的适用于各种发行版的软件包以外，我们更多的可能希望可以提供一个 shell 脚本进行程序的安装，将安装步骤简单收敛为两步：下载脚本 + 运行脚本。

通常，这种大多数的安装脚本都是再次从互联网上下载所需资源的，这样可以最小化脚本的体积并保证安装的始终是最新版本，但是这同样导致了下载到的「安装包」本质上是个「安装器」，无法离线安装。

本文将介绍一种已经在生产环境验证过的方案，来动态在安装包中嵌入网址。

受限于一些原因，本文更多的从原理层面进行讲解，暂无法提供完整的代码解决方案，敬请谅解
另外，以下代码均为根据原理为本文撰写，虽然原理已经经过生产验证但所使用的代码并未经过严格的生产验证，如有 bug 烦请告知

脚本构成

整个脚本由 head + embed-bin 两部份构成；embed-bin 是不加改动的将我们的程序进行嵌入的，而 head 是一个动态生成的脚本，用于从当前脚本中提取 embed-bin 并执行。

head 脚本随是动态生成，但为了维护的简单，这里采用模板的形式

#!/bin/sh
#
# NAME:     {{ .Name }}
# PLATFORM: { .Platform }}
# DIGEST:   {{ .MD5 }}, @LINES@

THIS_DIR=$(DIRNAME=$(dirname "$0"); cd "$DIRNAME"; pwd)
THIS_FILE=$(basename "$0")
THIS_PATH="$THIS_DIR/$THIS_FILE"
EXTRACT={{ if .AutoExtract }}1{{ else }}0{{ end }}
FORCE_EXTRACT=0
PREFIX={{ .DefaultPrefix }}
EXECUTE={{ if .AutoExecute }}1{{ else }}0{{ end }}
{{- end }}

USAGE="{{ .Opts.Usage }}"

while getopts ":h{{ .Opts.FlagNames }}" flag; do
 case "$flag" in
    h)
        printf "%s" "$USAGE"
        exit 2
        ;;
    {{- range .Opts.All }}
    {{ .Name }})
        {{ range .Action.DoIfSet }}{{ . }}
        {{ end }};;{{ end }}
    *)
        printf "ERROR: did not recognize option '%s', please try -h\\n" "$1"
        exit 1
        ;;
 esac
done

# Verify MD5
printf "%s\\n" "Verifying file..."
MD5=$(tail -n +@LINES@ "$THIS_PATH" | md5sum)
if ! echo "$MD5" | grep {{ .MD5 }} >/dev/null; then
    printf "ERROR: md5sum mismatch of tar archive\\n" >&2
    printf "expected: {{ .MD5 }}\\n" >&2
    printf "     got: %s\\n" "$MD5" >&2
    exit 3
fi

{{ if .Archive -}}
if [ -z "$PREFIX" ]; then
    PREFIX=$(mktemp -d -p $(pwd))
fi

if [ "$EXTRACT" = "1" ]; then
    if [ "$FORCE_EXTRACT" = "1" ] || [ ! -f "$PREFIX/.extract-done" ] || [ "$(cat "$PREFIX/.extract-done")" != "{{ .MD5}}" ]; then
        printf "Extracting archive to %s ...\\n" "$PREFIX"

        {
            dd if="$THIS_PATH" bs=1            skip=@ARCHIVE_FIRST_OFFSET@ count=@ARCHIVE_FIRST_BYTES@  2>/dev/null
            dd if="$THIS_PATH" bs=@BLOCK_SIZE@ skip=@ARCHIVE_BLOCK_OFFSET@ count=@ARCHIVE_BLOCKS_COUNT@ 2>/dev/null
            dd if="$THIS_PATH" bs=1            skip=@ARCHIVE_LAST_OFFSET@  count=@ARCHIVE_LAST_BYTES@   2>/dev/null
        } | tar zxf - -C "$PREFIX"

        echo -n {{ .MD5 }} > "$PREFIX/.extract-done"
    else
        printf "Archive has already been extracted to %s\\n" "$PREFIX"
    fi
fi

if [ "$EXECUTE" = "1" ]; then
    echo "Run Command:" {{ .Command }}
    cd "$PREFIX" && {{ .Command }}
fi
{{- end }}

exit 0
## --- DATA --- ##

这个脚本模板存在着两种类型的变量：{{ XX }} 与 %XX%，其中主要的区别在于整个模板渲染要分成两步：首先渲染所有的 {{ XX }} 变量，然后再渲染剩余的 %XX% 变量；渲染前者时无特殊要求，而渲染后者时需要保证变量的渲染前后文本的长度与行数不变。

这个脚本会将 embed-bin 作为压缩包进行解压，这主要是因为我们内部使用时相关数据可能很大（数百兆乃至上 GB），如果你只需要一个小的脚本可以移除压缩有关的代码。

另外，这个脚本会在执行前进行一次 MD5 校验，这主要是为了防止一些情况下脚本下载不完全导致的。但是因为本身 embed-bin 就是压缩包了，因此可以删除校验有关的代码来加快安装速度（我们内部保留的原因一方面是因为我们 embed 的内容不止压缩包甚至不止一个文件，另一方面就是为了给出更好的错误提示）。

这个脚本也提供了参数传递的能力和部分默认值的指定，这是因为在某些情况下相关步骤可能异常而全量执行所有步骤较为耗时，在实际使用中你可根据实际需要删改脚本参数。

脚本的参数由模板渲染引擎给出，这主要是为了可维护性，如果你更希望在脚本中撰写相关的内容则可以修改相关部分

渲染脚本

话不多说，直接上代码

//go:embed "header.sh.tmpl"
var headerTemplate string

type headerOptions struct {
Name string
MD5  string

Opts *Opts

*ArchiveOptions
}

type ArchiveOptions struct {
DefaultPrefix string
AutoExtract   bool
AutoExecute   bool
Command       string // 使用 $PREFIX 引用 prefix

Filename string // 供 builder 使用，不会打入最终文件
}

func (o *ArchiveOptions) QuotedCommand() string {
return shells.Quote(o.Command)
}

func renderHeaders(o *headerOptions) ([]byte, error) {
t := template.New("")

tt, err := t.Parse(headerTemplate)
if err != nil {
return nil, ee.Wrap(err, "invalid template")
}

b := bytes.Buffer{}

err = tt.Execute(&b, o)
if err != nil {
return nil, err
}

return b.Bytes(), nil
}

func getHeaders(o *headerOptions) ([]byte, error) {
tmpl, err := renderHeaders(o)
if err != nil {
return nil, err
}

lines := bytes.Count(tmpl, []byte("\n")) + 1

tmpl = bytes.ReplaceAll(tmpl, []byte("@LINES@"), []byte(strconv.Itoa(lines)))

replaceAndFillSpace(tmpl, "@BLOCK_SIZE@", blockSize)

return tmpl, nil
}

func replaceAndFillSpace(data []byte, old string, new int64) {
oldBytes := []byte(old)
newString := strconv.FormatInt(new, 10)

newWithExtraSpace := append([]byte(newString), bytes.Repeat([]byte{' '}, len(old)-len(newString))...)

// assert len(old) == len(newWithExtraSpace)

// Apply replacements to buffer.
start := 0
for {
i := bytes.Index(data[start:], oldBytes)
if i == -1 {
return // stop
}

start += i
start += copy(data[start:], newWithExtraSpace)
}
}

type Opts struct {
All []*Opt
}

func (opts *Opts) FlagNames() string {
b := strings.Builder{}
for _, opt := range opts.All {
b.WriteString(opt.Name)
if len(opt.Arg) != 0 {
b.WriteString(":")
}
}

return b.String()
}

func (opts *Opts) Usage() string {
b := strings.Builder{}

b.WriteString("Usage: $0 [options]\n\n")

all := make([][2]string, 0, 1+len(opts.All))

nameLen := 2

all = append(all, [2]string{"-h", "Print this help message and exit"})

for _, opt := range opts.All {
bb := strings.Builder{}
bb.WriteString("-")
bb.WriteString(opt.Name)

if opt.Arg != "" {
bb.WriteString(" [")
bb.WriteString(opt.Arg)
bb.WriteString("]")
}

name := bb.String()

if len(name) > nameLen {
nameLen = len(name)
}

all = append(all, [2]string{name, opt.Help})
}

for _, a := range all {
b.WriteString(a[0])
b.WriteString(strings.Repeat(" ", nameLen-len(a[0])))
b.WriteString("\t")
b.WriteString(a[1])
b.WriteString("\n")
}

return b.String()
}

type Opt struct {
Name   string
Arg    string
Help   string
Action OptAction
}

type OptAction interface {
DoIfSet() []string
}

type DoAndExitAction struct {
Do       []string
ExitCode int
}

func (a *DoAndExitAction) DoIfSet() []string {
r := append([]string{}, a.Do...)
r = append(r, "exit "+strconv.Itoa(a.ExitCode))
return r
}

type DoAndContinueAction struct {
Do []string
}

func (a *DoAndContinueAction) DoIfSet() []string {
return a.Do
}

func SimpleSetEnvAction(envName string, envValue interface{}) *DoAndContinueAction {
return &DoAndContinueAction{
Do: []string{fmt.Sprintf("%s=%v", envName, envValue)},
}
}

type Builder struct {
Name string

ArchiveOptions *ArchiveOptions
}

func openAndWrite(filename string, w io.Writer) (int64, error) {
f, err := os.Open(filename)
if err != nil {
return 0, err
}
defer f.Close()

return io.Copy(w, f)
}

func fillAndSetHeader(prefix, filename string, f io.Writer, headers []byte, offset int64) (int64, error) {

fileLength, err := openAndWrite(filename, f)
if err != nil {
return 0, ee.Wrap(err, "cannot append data for "+prefix)
}

firstOffset := offset
firstBytes := blockSize - (firstOffset % blockSize)
replaceAndFillSpace(headers, fmt.Sprintf("@%s_FIRST_OFFSET@", prefix), firstOffset)
replaceAndFillSpace(headers, fmt.Sprintf("@%s_FIRST_BYTES@", prefix), firstBytes)

copy2Start := firstOffset + firstBytes
copy2Skip := copy2Start / blockSize
copy2Blocks := (fileLength - copy2Start + firstOffset) / blockSize
replaceAndFillSpace(headers, fmt.Sprintf("@%s_BLOCK_OFFSET@", prefix), copy2Skip)
replaceAndFillSpace(headers, fmt.Sprintf("@%s_BLOCKS_COUNT@", prefix), copy2Blocks)

copy3Start := (copy2Skip + copy2Blocks) * blockSize
copy3Size := fileLength - firstBytes - (copy2Blocks * blockSize)
replaceAndFillSpace(headers, fmt.Sprintf("@%s_LAST_OFFSET@", prefix), copy3Start)
replaceAndFillSpace(headers, fmt.Sprintf("@%s_LAST_BYTES@", prefix), copy3Size)

return fileLength, nil
}

func (b *Builder) Build(saveTo string) error {
header := &headerOptions{
Name:           b.Name,
ArchiveOptions: b.ArchiveOptions,
Opts:           &Opts{},
}

fileMD5 := md5.New()

var dataSize int64

if header.ArchiveOptions != nil {
if header.ArchiveOptions.AutoExtract {
header.Opts.All = append(header.Opts.All, &Opt{
Name:   "E",
Help:   "Do not extract archive",
Action: SimpleSetEnvAction("EXTRACT", 0),
})
} else {
header.Opts.All = append(header.Opts.All, &Opt{
Name:   "e",
Help:   "Also extract archive",
Action: SimpleSetEnvAction("EXTRACT", 1),
})
}

header.Opts.All = append(header.Opts.All, &Opt{
Name:   "f",
Help:   "Force extract archive",
Action: SimpleSetEnvAction("FORCE_EXTRACT", 1),
})

prefixOpt := &Opt{
Name: "d",
Arg:  "DIR",
Help: "Extract to directory",
Action: &DoAndContinueAction{
Do: []string{`PREFIX="${OPTARG}"`},
},
}
if header.ArchiveOptions.DefaultPrefix != "" {
prefixOpt.Help += fmt.Sprintf(" (default: %s)", header.ArchiveOptions.DefaultPrefix)
}

header.Opts.All = append(header.Opts.All, prefixOpt)

if header.ArchiveOptions.Command != "" {
if header.ArchiveOptions.AutoExecute {
header.Opts.All = append(header.Opts.All, &Opt{
Name:   "X",
Help:   "Do not execute command",
Action: SimpleSetEnvAction("EXECUTE", 0),
})
} else {
header.Opts.All = append(header.Opts.All, &Opt{
Name:   "x",
Help:   "Also execute the command",
Action: SimpleSetEnvAction("EXECUTE", 1),
})
}
}

n, err := openAndWrite(header.ArchiveOptions.Filename, fileMD5)
if err != nil {
return ee.Wrap(err, "failed to read archive file to get md5")
}
dataSize += n
}

_ = dataSize

header.MD5 = hex.EncodeToString(fileMD5.Sum(nil))

headers, err := getHeaders(header)
if err != nil {
return ee.Wrap(err, "failed to get headers")
}

f, err := os.OpenFile(saveTo, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
if err != nil {
return ee.Wrap(err, "failed to write file")
}
defer f.Close()

// write header
headersLen, err := f.Write(headers)
if err != nil {
return ee.Wrap(err, "failed to write headers")
}

currentOffset := int64(headersLen)

//  embed archive
if header.ArchiveOptions != nil {
n, err := fillAndSetHeader("ARCHIVE", header.ArchiveOptions.Filename, f, headers, currentOffset)
if err != nil {
return ee.Wrap(err, "failed to embed installer")
}
currentOffset += n
}

_ = currentOffset

// rewrite headers
_, err = f.Seek(0, 0)
if err != nil {
return ee.Wrap(err, "failed to seek file")
}
newHeadersLen, err := f.Write(headers)
if err != nil {
return ee.Wrap(err, "failed to rewrite headers")
}
if headersLen != newHeadersLen {
return ee.New("headers unexpected change after rewrite")
}

return nil
}

使用则是

b := &Builder{
    Name: name,
    ArchiveOptions: &binbundler.ArchiveOptions{
        DefaultPrefix: "/path/to/extract",
        AutoExtract:   true,
        AutoExecute:   true,
        Command:       "bash $PREFIX/install.sh", # 安装命令，简单可直接执行，复杂可使用一个额外的脚本
        Filename:      "/path/to/embed",
    },
}
err = b.Build("/path/to/script-save-to.sh")

在整个脚本中，动态插入了相关模板变量，并计算了相关 offset

后记

本文更多的只是提供一种思路（利用 dd 来解压、动态生成 opt 来控制执行过程），相比于网上更多的利用 grep 等手段来定位二进制内容更加的高效、易维护。

在此基础上，其实还可以实现更多的事情（依赖验证、安装多个文件等），欢迎尝试

谈谈时区

Origin

作者 Singee

2023年8月20日 14:52

通常在本地化时往往会涉及到时区转换的问题，而通常在真正关注到时区之前我们所「默认」使用的时区为 UTC 或“本地”。

本文以 Go 为例，分析下 Go 中的时区使用。

读取时区

在 Go 中，读取时区使用的是 LoadLocation 函数。

// LoadLocation returns the Location with the given name.
//
// If the name is "" or "UTC", LoadLocation returns UTC.
// If the name is "Local", LoadLocation returns Local.
//
// Otherwise, the name is taken to be a location name corresponding to a file
// in the IANA Time Zone database, such as "America/New_York".
//
// LoadLocation looks for the IANA Time Zone database in the following
// locations in order:
//
// - the directory or uncompressed zip file named by the ZONEINFO environment variable
// - on a Unix system, the system standard installation location
// - $GOROOT/lib/time/zoneinfo.zip
// - the time/tzdata package, if it was imported
func LoadLocation(name string) (*Location, error)

阅读注释可知，如果 name 为空 / UTC 则使用 UTC、为 Local 则使用本地时区（在后面进行讲解），否则，从特定位置进行读取。

所谓读取，是读取的 tzfile 时区文件，可阅读该文档查阅更多信息。简单来说，时区文件是一个以 TZif 开头的二进制文件，其中包含了时区的偏移量、闰秒、夏令时等信息，Go 可以读取相关文件并解析。

如果存在 ZONEINFO 环境变量，利用该变量指向的目录/压缩文件进行读取
在 Unix 系统上，使用系统标准位置
（主要用于编译 Go 时）从 $GOROOT/lib/time/zoneinfo.zip 进行读取
（如果 import 了 time/tzdata ）从程序嵌入的数据读取

我们比较关注的是 2，即 Unix 的标准时区文件的存储位置。在 Unix 系系统中，时区文件通常存储在 /usr/share/zoneinfo/ 目录中（根据系统不同，还可能是 /usr/share/lib/zoneinfo/ 或 /usr/lib/locale/TZ/），例如，中国（Asia/Shanghai）的时区定义文件就是 /usr/share/zoneinfo/Asia/Shanghai。因此，通常程序可以直接从系统中获取到时区的信息。

注意，在 alpine 环境中，是没有时区定义文件的，因此我们需要特别关注进行处理

可以在程序中使用 import _ "time/tzdata" 在编译期将时区文件编入程序中，这样在无法找到系统中的时区定义时也可以查找到标准的 IANA 时区定义
如果我们不需要特别动态的时区，我们可以避免使用 LoadLocation 而是使用 FixedZone 由我们自己提供时区名称和偏移，例如对于中国 UTF+8 可以使用 time.FixedZone("Asia/Shanghai", 8*60*60)

本地时区

通常在我们真正考虑到时区问题之前我们所「默认」使用的时区均为所谓的「本地时区」。

以 time.Now 为例，

type Time struct {
wall uint64
ext  int64

loc *Location
}

// Now returns the current local time.
func Now() Time {
sec, nsec, mono := now()
mono -= startNano
sec += unixToInternal - minWall
if uint64(sec)>>33 != 0 {
// Seconds field overflowed the 33 bits available when
// storing a monotonic time. This will be true after
// March 16, 2157.
return Time{uint64(nsec), sec + minWall, Local}
}
return Time{hasMonotonic | uint64(sec)<<nsecShift | uint64(nsec), mono, Local}
}

可以看到，Time 结构体的最后一个字段 loc *Location 就是时区，而 time.Now 中使用的时区为 Local。

我们本文主要关注时区，如果你对这段代码中的其他因素感兴趣，欢迎阅读你真的了解 time.Now() 吗？。

这里的 Local 就是本地时区，即运行这个程序所在的机器的时区。

// Local represents the system's local time zone.
// On Unix systems, Local consults the TZ environment
// variable to find the time zone to use. No TZ means
// use the system default /etc/localtime.
// TZ="" means use UTC.
// TZ="foo" means use file foo in the system timezone directory.
var Local *Location = &localLoc

阅读 Go 中关于 Local 的说明可知，Go 会优先尊重 TZ 环境变量所指定的时区，如果没有特殊指定，则使用 /etc/localtime 文件读取当前时区。

那么，Local 又是怎么初始化的呢？

// localLoc is separate so that initLocal can initialize
// it even if a client has changed Local.
var localLoc Location
var localOnce sync.Once

func (l *Location) get() *Location {
if l == nil {
return &utcLoc
}
if l == &localLoc {
localOnce.Do(initLocal)
}
return l
}

从这段代码的逻辑中不难猜出，Local 并没有真的在程序启动时读取上述信息，而是在首次使用时才真正的通过执行 initLocal 函数来进行初始化。同时，这段代码也隐性的为使用 Location 提出了一个要求：必须调用 get 方法来获取「真正的 Location」。

initLocal 函数在 zoneinfo_*.go 中定义，在不同的机器上有着不同的实现，但本质上都是

如果 TZ 内容以 : 开头，则会忽略该冒号

如果没有指定 TZ 环境变量，阅读 /etc/localtime（通常就是指向了真正时区文件的软链接）
如果指定的 TZ 环境变量为绝对路径，阅读该文件
否则按照上文所分析的 LoadLocation 流程进行时区文件的读取

另外，上述 3 步骤如果失败，会 fallback 到使用 UTC 时间

加餐：tzdata

tzdata 详细定义了历史时区的变更情况，包括夏令时、闰秒等，因此 Asia/Shanghai 相比于简单的 GMT+8 更具有通用性、且可正确处理历史数据。

如果你感兴趣，可以利用 zdump Asia/Shanghai -i 查看上海的时区变化，并和使用夏令时的时间 zdump America/Chicago -i 进行对比。

部署 OpenCat Team Server 到 Fly.io

Origin

作者 Singee

2023年4月4日 13:55

准备工作

Fly.io 账号
预先安装好 flyctl（官方指引）
在 flyctl 中登录（flyctl auth login，官方指引）

创建项目

在本地新建一个空文件夹，使用命令行进入该文件夹，然后输入以下命令创建项目：

1	flyctl launch

运行过程中，你需要设置项目名称（或保留空白以自动生成名称）和选择地区（注意不要选择香港）。确认后，系统将生成 fly.toml 文件。

创建存储

为确保数据持久化，请创建一个新的 Volume 来存储相关数据。执行以下命令创建：

1	flyctl volumes create opencat_data --size 1

在执行过程中，选择与之前步骤相同的地区。该命令将创建一个名为 opencat_data、大小为 1GB 的存储桶，用于存储后续数据。

编辑 `fly.toml` 文件

在 [env] 段之前，插入以下内容：

[build]
  image = "bayedev/opencatd:latest"

[mounts]
  destination = "/opt/db"
  source = "opencat_data"

将 [[services]] 下的 internal_port 值修改为 80。

启动服务器

执行 flyctl deploy 启动服务器，并确保通过安全检查。

绑定自定义域名

如没有自定义域名，请跳过此步骤。

执行 flyctl certs add YOUR_DOMAIN 配置自定义域名（将 YOUR_DOMAIN 替换为你的域名），并按照要求配置相应的 CNAME 记录。

配置完成后，稍等片刻。访问 https://fly.io/apps/APPNAME/certificates （将 APPNAME 替换为你创建项目时指定的名称），确保所有检查项目都已成功。

激活

打开 OpenCat 的创建团队页面，将域名设置为 https://YOUR_DOMAIN （将 YOUR_DOMAIN 替换为你在上一步绑定的自定义域名；如果未绑定，请使用 https://APPNAME.fly.dev）。确认激活，即可正常使用。

解决 CentOS8 中 yum 源失效

Origin

作者 Singee

2023年6月7日 05:34

先吐槽下，为什么 CentOS 会 breaking 正常运行的系统啊

如果之前没有配置过其他镜像的话

1 2	sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-* sed -i 's\|#baseurl=http://mirror.centos.org\|baseurl=http://vault.centos.org\|g' /etc/yum.repos.d/CentOS-*

如果配置过的话，将 baseurl 中的域名改成 http://vault.centos.org 就好（注意只支持 HTTP）

这个原因是，因为 CentOS 8 Deprecated 了于是就在 Mirror 中把仓库删了🙃

epoll 中的边缘触发

Origin

作者 Singee

2021年7月4日 09:58

如果说 poll 是 select 的简单优化，那么 epoll 就是 poll 的下一代。

典型的同步非阻塞方案

epoll 作为「次时代」的同步非阻塞 IO 模型，其真正划时代的点在于终于实现了「边缘触发」。

思考如下情况

(epoll_add) 监听 socketA，socketA 此时无数据
socketA 被写入了 2Byte
select / poll / epoll_wait 监听 socketA 返回结果
从 socketA 读了 1Byte

如果这时，再对 socketA 执行 select 或 poll，那么它们会立刻返回，因为这时 socketA 依然「可读」。这就是水平触发（Level-Triggered），描述的是文件描述符的状态。

epoll

在 epoll 的世界中，默认和 select/poll 行为是一样的，但如果 socketA 被设定了边缘触发（在 epoll_ctl add/mod 时指定了 EPOLLET，即边缘触发的设定是被监听的文件描述符级别而不是 epoll 的文件描述符级别），那么这时 epoll_wait 不会返回，因为 socketA 在两次 wait 之间没有「变化」。这就是边缘触发（Edge-Triggered），描述的是文件描述符的变化状态。

在边缘触发的模型下写程序需要注意一点：所监听的文件描述符应当也是非阻塞的。以 read 为例，在调用 read 时需要传递一个固定大小的缓冲区，如果可读的大小大于缓冲区那么进行一次读是无法满足需求的，这就会造成除非向这个文件写了新的数据，否则之前没有读到的数据就永远无法读到了（在水平触发下则不会出现这个问题，因为该文件描述符仍然可读，因此下一次会立刻返回）。这个的解决方案就是一直读直到读完，但「读完」这一行为在网络中是受限的，如果相关文件描述符是阻塞的那么读取操作会一直阻塞直到来了新数据，因此正确的做法是将相关文件描述符设定为非阻塞而一直 read 直到出现 EAGAIN 才认为读完。

ONESHOT

但这样其实依然有改进空间，考虑如下情况

epoll_ctl ADD ET socketA，socketA 此时无数据
socketA 被写入了 10Byte
epoll_wait 返回 socketA
从 socketA 读了 8Byte，返回的非 EAGAIN，继续读
socketA 又被写入了 2Byte
从 socketA 再读 4Byte，返回 EAGIN，读完
epoll_wait 再次返回 socketA
读 socketA 直接返回 EAGAIN

在 7 中返回是因为两次 epoll_wait 间隔是 3-7，而这其中在 5 时 socketA 又出现了变化，因此 7 仍然会返回

虽然 7,8 步骤不会有副作用，但在高并发情况下会造成额外的资源浪费，因此为了解决这一问题 epoll 提供了 EPOLLONESHOT 功能，当在 add/mod 时指定了这一 flag 后，一旦 epoll_wait 返回这一文件描述符则相关的变更监听会被暂停，直到处理完后再调用 epoll_ctl 恢复这一文件描述符

多个 wait 只有一个会被唤醒

在 epoll 中，如果有多个进程/线程对同一个 epollfd 进行 epoll_wait，那么在相应被监听的文件描述符出现变化时只有一个会被唤醒处理，也因此在多进程/多线程使用 epoll 时往往都会指定 ONESHOT，否则可能出现处理已经文件描述符变动时其再次变化唤醒其他进程或线程处理而导致竞争

ELPass 加密分析

Origin

作者 Singee

2020年8月29日 18:02

文件结构

分解分析

Index

首先 Index 是利用了 MsgPack 压缩的，利用 Python 脚本解密

# pip install u-msgpack-python

with open('Index', 'rb') as f:
index = umsgpack.unpack(f)

masterPasswordSalt = index['s']
encryptedDescriptorData = index['d']
encryptedDescriptorDataNonce = index['dn']
version = index['v']

print(len(masterPasswordSalt), masterPasswordSalt.hex())
print(len(encryptedDescriptorData), encryptedDescriptorData.hex())
print(len(encryptedDescriptorDataNonce), encryptedDescriptorDataNonce.hex())
print(version)

拿到的 index 是一个有四个键的字典，这四个键含义分别为

s masterPasswordSalt 主密码的盐，固定为 16 Bytes
d encryptedDescriptorData
dn encryptedDescriptorDataNonce 加密 descriptorData 使用的随机数，固定为 24 Bytes
v version 当前数据库版本（目前固定为 1）

下一步就是根据用户的主密码 masterPassword 和盐 masterPasswordSalt 生成用于加密的 masterKey 了，这用到了 Argon2id 算法，利用 Python 实现代码

# 这里使用了与 ELPass 相同的 libsodium 库
# Mac 使用 brew install libsodium 即可安装
# 然后还需要安装 Python 的包装函数以简化使用
# pip install pysodium

from pysodium import crypto_pwhash
from pysodium import crypto_pwhash_OPSLIMIT_SENSITIVE, crypto_pwhash_MEMLIMIT_MODERATE, crypto_pwhash_ALG_DEFAULT

masterKey = crypto_pwhash(
                32, masterPassword, masterPasswordSalt,
                crypto_pwhash_OPSLIMIT_SENSITIVE, crypto_pwhash_MEMLIMIT_MODERATE, crypto_pwhash_ALG_DEFAULT
            )

print(len(masterKey), masterKey.hex())

生成 masterKey 后利用之前的 encryptedDescriptorData 校验 masterKey 是否正确

from pysodium import crypto_secretbox_open

descriptorData = crypto_secretbox_open(encryptedDescriptorData, encryptedDescriptorDataNonce, masterKey)
unzippedDescriptorData = umsgpack.loads(descriptorData)

realMasterKey = unzippedDescriptorData['masterKey']

参考信息

How Elpass Encrypt Your Data

surge-networks/Elpass-Core

jedisct1/swift-sodium

Password hashing

stef/pysodium