你说：

在一个TypeScript编写的project中，“map”文件的用途是什么？

ChatGPT 说：

在一个用 TypeScript 编写的项目中，.map 文件通常指的是 source map（源码映射文件），它的作用可以一句话概括：把编译后的 JavaScript 映射回原始的 TypeScript 代码。
下面把它讲清楚一点——不绕弯：

一、为什么会有 .map 文件？

TypeScript 代码最终会被编译成 JavaScript，比如：
TypeScript
// 原始 TS
let x: number = 10;
编译后：
JavaScript
var x = 10;
问题来了：
👉 浏览器、Node.js 实际运行的是 JS，不是 TS
👉 报错、调试、堆栈信息也都是 JS 行号
这时候就会很难定位问题。

二、.map 文件在干嘛？

.map 文件记录了一种“对照关系”：
👉 JS 的第几行，对应 TS 的第几行
简单理解就是一个“翻译字典”：
app.js  第10行  →  app.ts 第3行

三、实际效果（很关键）

1️⃣ 调试体验

在浏览器 DevTools 或 VS Code 里：

• 你看到的是 .ts 文件（不是 .js）
• 可以直接在 TS 里打断点
• 报错会指向 TS 行号
  否则你只能面对编译后的 JS（尤其压缩后更难看）

2️⃣ 错误堆栈更可读

没有 map：
Error at app.js:482
有 map：
Error at app.ts:23
👉 这差别基本就是“能不能定位问题”的差别

四、.map 文件长什么样？

它本质是一个 JSON，例如：
JSON
{
“version”: 3,
“file”: “app.js”,
“sources”: [“app.ts”],
“mappings”: “AAAA…”
}
你不用读懂 mappings，那是压缩编码的映射规则。

五、怎么生成？

在 tsconfig.json 里开启：
JSON
{
“compilerOptions”: {
“sourceMap”: true
}
}
编译后会得到：
app.ts
app.js
app.js.map

六、要不要在生产环境保留？

这是个很现实的问题：

✅ 保留的好处

• 方便线上错误定位（比如配合日志系统）

❌ 风险

• 暴露源码（别人可以反推你的 TS 代码）
  👉 常见做法：
• 内部系统：保留 ✔
• 公网项目：通常不公开 .map ❌（但可私有上传到监控工具）

七、一句话总结

.map 文件就是：

让“运行时代码（JS）”和“开发时代码（TS）”之间建立映射，从而实现可读调试和准确报错定位。

如果你愿意，我可以帮你看一个真实 .map 文件是怎么对应代码的，或者讲讲它和 Webpack / Vite 里的 devtool 有什么关系。

你说：

“.map”文件中是否会保留ts源代码的原始变量名，函数名等信息？

ChatGPT 说：

短答案：通常会保留，而且往往是“完整保留”——但取决于配置和构建方式。

一、默认情况下（TypeScript 编译）

当你在 tsconfig.json 里开启：
JSON
{
“compilerOptions”: {
“sourceMap”: true
}
}
生成的 .map 文件里：

✅ 会包含的信息

• 原始 .ts 文件路径
• 行号、列号映射
• 变量名、函数名（基本都会保留）
  👉 因为 TypeScript 编译本身不会混淆（minify）代码
  举个简单例子：
  TypeScript
  function calculateTotal(price: number) {
  return price * 1.2;
  }
  编译后 JS 可能还是：
  JavaScript
  function calculateTotal(price) {
  return price * 1.2;
  }
  .map 里自然也会记录 calculateTotal 和 price

二、关键点：.map 能不能“反推出源码”？

这取决于一个非常重要的字段：

🔑 sourcesContent

.map 文件可能长这样：
JSON
{
“sources”: [“app.ts”],
“sourcesContent”: [
“function calculateTotal(price: number) { … }”
]
}

两种情况：

✅ 有 sourcesContent

👉 直接包含完整 TS 源码

• 可以几乎完整还原你的代码
• 连注释都可能在

❌ 没有 sourcesContent

👉 只有路径 + 映射关系

• 需要你本地有 .ts 文件才能还原
• 外部人较难直接看到源码

三、如果用了打包工具（Webpack / Vite / esbuild）

事情就没那么“单纯”了：

1️⃣ 如果没有压缩（development）

• 变量名 ✔ 保留
• 函数名 ✔ 保留
• 调试体验很好

2️⃣ 如果开启压缩（production）

比如用了：

• Terser
• esbuild minify
  代码可能变成：
  JavaScript
  function a(b){return b*1.2}
  这时候：
  项目
  是否保留
  JS 中变量名
  ❌ 被压缩
  .map 映射回 TS 名
  ✅ 仍然可以
  源码恢复能力
  ⚠️ 取决于 sourcesContent
  👉 重点来了：

  即使 JS 被压缩，.map 仍然可以映射回原始变量名

四、实际风险（你真正想问的点）

你其实是在问：

.map 会不会泄露源码细节？
答案是：有可能，而且很常见。

风险等级：

情况
风险
有 sourcesContent
🔥🔥🔥 完整源码泄露
无 sourcesContent
⚠️ 可读性较高（仍能推断逻辑）
+ 未混淆代码
🔥🔥🔥 非常容易还原
+ 已混淆
⚠️ 但仍可调试

五、行业常见做法

🟢 开发环境

• 开启 source map ✔
• 保留所有信息 ✔

🟡 生产环境（推荐）

• 生成 .map ✔
• 不对外公开 ❗
• 上传到错误监控系统（如 Sentry）

🔴 高安全项目

• 关闭 source map ❌
• 或去掉 sourcesContent

六、一句话总结

.map 文件不仅会保留变量名和函数名，在某些配置下甚至包含完整 TypeScript 源码；是否“泄露”，完全取决于你怎么生成和发布它。

如果你愿意，我可以帮你分析你项目的构建配置（比如 Vite / Webpack），看看现在到底有没有“无意中在公网裸奔源码”。

你说：

也就是说：使用TypeScript编程，如果要保证调试的方便性，“.map”文件是必须的，对吗？

ChatGPT 说：

可以这么说，但我帮你把话说得更“工程化一点”：

.map 文件不是“必须”，但几乎是“不可替代”的调试工具。

一、从结果看：没有 .map 会怎样？

如果你不用 source map：

• 浏览器里看到的是编译后的 JS
• 报错定位在 .js 文件
• 行号、变量名可能已经变化
• 打断点基本只能打在 JS 上
  👉 现实体验就是：
  能调，但很痛苦，尤其是项目一大就会崩溃

二、有 .map 时的变化（质变）

有了 .map：

• DevTools / VS Code 直接显示 .ts
• 断点打在 TS 上 ✔
• 报错指向 TS 行号 ✔
• 可以逐行调试 TS ✔
  👉 本质上就是：

  你“假装”在直接运行 TypeScript

三、所以它是不是“必须”？分情况说

🟢 开发环境（Dev）

👉 可以很明确地说：

基本等于必须
否则调试效率会明显下降，不是“慢一点”，而是“难很多”。

🟡 生产环境（Prod）

👉 就完全不同了：

• 不是为了调试（用户不会帮你 debug）
• 主要用于错误追踪（比如 Sentry）
  所以：

  可以有，但通常不对外暴露

四、一个更准确的结论

你这句话可以稍微修正为：

在 TypeScript 项目中，为了获得良好的调试体验，source map 几乎是必不可少的；但它并不是运行代码所必需的。

五、顺带给你一个实用建议

很多人踩的坑是：
JSON
{
“sourceMap”: true
}
但：
👉 忘了在打包工具里开启（比如 Vite / Webpack）
结果就是：

• TS 编译有 map ✔
• 打包后 map 丢了 ❌

六、总结一句人话版

不开 .map 也能跑，但你会调试到怀疑人生；开了 .map，世界恢复正常。

如果你想更深入一点，我可以帮你拆一下：

• Chrome DevTools 是怎么“用” .map 的
• 或者 Vite / Webpack 里不同 source map 模式的区别（这个在性能和安全上差别挺大）

你说：

所以即使在生产环境中，为了使得出现错误后便于定位问题，依然需要保留”.map”文件，对吗？

ChatGPT 说：

可以这么理解，但需要加一个关键前提，否则就容易踩坑：

生产环境“需要生成 .map 文件”，但通常“不应该对外公开”。

一、为什么生产环境仍然需要 .map？

因为线上错误不可避免，而你需要还原真实源码位置。
例如用户环境报错：
Error at app.min.js:1:84231
👉 这基本等于没信息（压缩后的一行代码）
但如果你有 .map：
Error at src/services/userService.ts:57
👉 立刻能定位问题

二、关键区别：生成 vs 暴露

这是很多人容易混淆的点：

✅ 应该做的

• 构建时生成 .map
• 上传到错误监控平台（如 Sentry）
• 内部保存

❌ 不建议做的

• 把 .map 文件部署到公网服务器
• 让用户可以直接访问 app.js.map

三、为什么不能随便公开 .map？

因为它可能包含：

• 原始 TypeScript 代码（sourcesContent）
• 真实变量名 / 业务逻辑
• 注释（甚至敏感信息）
  👉 本质上等于：

  把源码附赠给所有用户

四、行业标准做法（很重要）

典型流程：

1️⃣ 构建：

• 生成 .js
• 生成 .js.map
  2️⃣ 发布：
• 只上传 .js
• 不上传 .map
  3️⃣ 错误监控：
• 把 .map 上传到监控系统
• 用来解析堆栈

五、不同工具的常见配置思路

比如 Vite

TypeScript
build: {
sourcemap: true
}
👉 但部署时不带 .map

比如 Webpack

JavaScript
devtool: ‘source-map’
👉 配合隐藏 map：
JavaScript
devtool: ‘hidden-source-map’
（生成但不暴露）

六、一句话结论

生产环境中，.map 文件是“排查问题的利器”，但前提是“只给自己用，不给别人看”。

七、给你一个实用判断标准

你可以用这个简单原则：

• ❓ 你需要排查线上错误吗？
  → ✔ 保留 .map
• ❓ 你希望用户看到你的源码吗？
  → ❌ 不要公开 .map

如果你愿意，我可以帮你检查你当前项目（比如 Vite / Webpack）的配置，看看现在是“安全状态”还是已经在无意中把源码暴露出去了。

你说：

这个问题是TypeScript语言独有的吗？Javascript有类似的问题吗？

ChatGPT 说：

不是 TypeScript 独有的问题，JavaScript 同样有这个问题，而且在很多场景下更“明显”。

一、先说结论

Source Map 是“编译/构建体系”的机制，不是 TypeScript 独有的语言特性。
只要你的代码经过“转换、压缩、打包”，就会涉及同样的问题。

二、JavaScript 什么时候也需要 .map？

在现代前端开发中，JS 早就不是“原生直接运行”的那种简单形态了：

1️⃣ 代码压缩（Minify）

例如：
JavaScript
function calculateTotal(price) {
return price * 1.2;
}
压缩后：
JavaScript
function a(b){return b*1.2}
👉 这时候没有 source map，你基本无法调试

2️⃣ 代码转译（Transpile）

例如：

• ES6 → ES5（Babel）
• JSX → JS（React）
• Vue 模板 → JS
  👉 转译前后代码已经不一样了

3️⃣ 打包工具（Webpack / Vite / Rollup）

最终上线的 JS：

• 可能是多个文件合并
• 变量名可能被重命名
• 代码结构已经改变

三、JS 和 TS 在 .map 上的区别

TypeScript

• 必然涉及编译（TS → JS）
• .map 几乎是“标配”

JavaScript

• 原生 JS：不需要 .map
• 但一旦经过工具链（Babel / Webpack 等）：
  👉 同样需要 .map

四、一个更本质的理解

你可以这样理解：

.map 不是给 TypeScript 用的，而是给“被改变过的代码”用的。
只要发生了这些事情：

• 压缩（minify）
• 转译（transpile）
• 打包（bundle）
  👉 就可能需要 source map

五、一个现实对比

场景
TS
JS
直接写原生代码
❌（不能运行）
✔
需要编译
✔ 必须
❌（可选）
需要 .map
✔ 强烈建议
✔（现代项目几乎都会用）

六、什么时候 JS 不需要 .map？

只有一种情况：

你写的是“未经过任何处理的原生 JavaScript”，并且直接运行
例如：
HTML

  console.log(“hello”);

👉 这种情况下：

• 没有编译
• 没有压缩
• 没有打包
  → .map 没意义

七、一句话总结

Source Map 的本质是：帮助你在“被改造过的代码”和“原始代码”之间建立映射，而 TypeScript 只是最常见的使用场景之一。

如果你愿意，我可以帮你画一张“从 TS/JS → 打包 → .map → 调试”的完整链路图，这个对理解整个前端构建体系会很有帮助。

你说：

在你提供的如下例子中，保留”原始信息 -> 编译后信息”的具体数据结构和文件是什么样的，也是和TypeScript同样的”.map”文件吗？ ES6 → ES5（Babel） JSX → JS（React） Vue 模板 → JS
2/2

ChatGPT 说：

可以直说：是的，本质上就是同一类东西——Source Map（.map 文件）。
不管是 TypeScript 还是 Babel / React / Vue，它们用的都是同一种标准机制来做“原始代码 ↔ 编译后代码”的映射。

一、统一结论

你提到的这些转换：

• ES6 → ES5（Babel）
• JSX → JS（React）
• Vue 模板 → JS
  👉 都会（或可以）生成 标准的 Source Map 文件：

  .js.map（或 .map）文件
  而这个文件的结构是统一规范的（不是各家自定义的）。

二、这个“映射文件”长什么样？

所有工具（Babel、TypeScript、Vue 编译器）最终都遵循同一个规范，大致结构如下：
JSON
{
“version”: 3,
“file”: “app.js”,
“sources”: [“app.jsx”],
“names”: [“calculateTotal”],
“mappings”: “AAAA,SAASA…”
}
如果更完整一点，还可能有：
JSON
{
“version”: 3,
“file”: “bundle.js”,
“sources”: [“src/App.jsx”, “src/utils.js”],
“sourcesContent”: [“原始 JSX 代码…”],
“names”: [“Component”, “render”],
“mappings”: “…”
}

三、不同工具的“区别”在哪？

虽然最终产物都是 .map 文件，但来源不同：

1️⃣ TypeScript

• 由 TypeScript 编译器生成
• 映射 TS → JS

2️⃣ Babel（ES6 → ES5 / JSX → JS）

• Babel 也支持生成 source map
  配置示例：
  JavaScript
  {
  “presets”: [“@babel/preset-env”, “@babel/preset-react”],
  “sourceMaps”: true
  }
  👉 输出：
• ES5 JS
• .js.map

3️⃣ Vue（模板 → JS）

Vue 编译器（如 vue-loader）：

• 会把 .vue 模板编译成 render 函数
• 同样生成 source map

四、关键点：不是“谁的专属格式”

👉 很重要的一点：

Source Map 是一个标准规范（不是 TypeScript 专属，也不是 Babel 专属）
只要工具支持，就会生成同一种格式。

五、Source Map 内部是怎么工作的（核心理解）

.map 里有一个关键字段：

mappings

它是一个压缩编码字符串，描述：
压缩后的 JS位置  →  原始源码位置
例如：
AAAA,SAASA
👉 实际含义是：
bundle.js:10:5  →  src/App.jsx:3:1

六、再强调一个你容易忽略的点

不同工具可以决定要不要生成 sourceContent：

有些 .map：

JSON
“sourcesContent”: [“完整源码”]
👉 可直接还原源码（敏感）

有些 .map：

JSON
“sources”: [“src/App.jsx”]
👉 只提供路径，不含源码

七、总结（帮你收敛认知）

你可以这样记：

TypeScript、Babel、Vue 这些工具只是“生产 JS”，而 .map 是它们共同遵守的一种“调试用说明书”。

• 数据结构：✅ 统一（Source Map 规范）
• 文件形式：✅ .map
• 来源：❗ 各工具生成
• 目的：👉 把“编译后代码”还原回“原始代码”

如果你想更深入一点，我可以帮你拆一层更底层的东西：
👉 mappings 字符串到底是怎么编码行列信息的（VLQ 编码），这是很多人第一次看到会直接“看不懂但很神奇”的部分。

你说：

你所说的Source Map标准规范是谁制定的，何时制定的，当时制定的初衷是什么？

ChatGPT 说：

Source Map 不是某个“语言组织”制定的，而是由浏览器厂商和前端工具链共同推动形成的一个标准，核心来自 Google，后来被纳入社区标准并广泛实现。

一、是谁制定的？

最初的推动者是：

• Google
  由 Google 的开发者（主要是为 Chrome DevTools 设计）提出并实现
  随后：
• ECMAScript 社区（TC39）
• 各大浏览器厂商（Chrome、Firefox 等）
• 工具链（Babel、TypeScript、Webpack 等）
  共同逐步形成“事实标准”
  👉 可以理解为：Google 起头 + 社区共识 + 工具生态跟进

二、什么时候制定的？

Source Map 的出现时间大约在：

2010 年左右
当时正值：

• 前端开始复杂化（模块化、框架化）
• 代码开始被压缩、合并
• 开发与生产代码出现严重“脱节”

三、为什么要制定它？（核心初衷）

一句话总结：

让“开发时的代码”和“运行时的代码”重新建立可追踪关系。
在 Source Map 出现之前，前端调试面临几个痛点：

1️⃣ 压缩代码不可读

JavaScript
function a(b){return b*1.2}
👉 调试基本等于“猜谜”

2️⃣ 堆栈信息不可用

报错只会告诉你：
app.min.js:1:84321
👉 对开发者几乎没用

3️⃣ 转译代码断层

随着这些技术出现：

• TypeScript
• CoffeeScript（历史）
• JSX
• 代码压缩工具
  👉 代码经历了“多次变形”
  结果是：

  你写的代码 ≠ 浏览器执行的代码

四、Source Map 解决了什么问题？

它本质上做了一件事：

记录“每一段编译后代码，来自原始代码的哪里”
从而实现：

• 调试直接看到 TS / JSX / 原始 JS
• 错误定位到源码行号
• 断点调试“还原”源码

五、一个很关键的设计目标

Source Map 的设计目标非常克制：

只解决“映射问题”，不改变运行逻辑
它不会：

• 修改代码执行方式
• 影响性能（除了加载 map 文件）
• 改变语言本身
  👉 它只是一个“辅助信息文件”

六、为什么能成为“事实标准”？

因为它解决的是全行业共性问题，而不是某个框架的问题：

• 所有前端构建工具都需要它
• 所有浏览器调试器都支持它
• 所有语言编译到 JS 的工具都能接入它

七、一句话总结

Source Map 是由 Google 在约 2010 年提出的，用于解决“压缩/编译后代码难以调试”的问题，随后被浏览器和前端工具链共同采纳，逐步成为事实上的行业标准。

如果你感兴趣，我可以再往下讲一层更“底层”的内容：
👉 为什么 Source Map 要用 VLQ 编码（以及它是怎么做到高效压缩映射数据的）——这个是很多工程师第一次接触时最“反直觉”的地方。

你说：

如果原始的代码经过了多次转化，比如第一次转换是”TypeScript-> Javascript”，第二次转换是”Javascript -> 混淆后的Javascript”，这两次转换会生成不同的source map吗？

ChatGPT 说：

是的——通常会生成两份不同的 Source Map，而且这在实际工程里是标准做法。

一、你的这个链路可以这样理解

你描述的是两步转换：
1️⃣ TypeScript → JavaScript
2️⃣ JavaScript → 混淆 / 压缩后的 JavaScript
👉 每一步“变形”，理论上都可以有一份对应的 source map。

二、为什么需要两份 map？

因为每一层都在做不同的事情：
阶段
输入
输出
Source Map
第一步
TS
JS
TS → JS 的 map
第二步
JS
压缩 JS
JS → 压缩 JS 的 map
👉 每个 map 只负责自己这一步的映射

三、但实际调试是怎么“串起来”的？

关键点来了：Source Map 可以“叠加”使用（source map chaining）

情况一：只有第二步 map（理想但不完整）

压缩 JS → JS（未压缩）
👉 你只能看到“未压缩 JS”，但看不到 TS

情况二：有完整链路（推荐）

现代工具会把两个 map 串起来：
压缩 JS
↓（map2）
原始 JS
↓（map1）
TS
👉 最终效果：

你可以直接在浏览器看到 TS 代码调试

四、关键机制：Source Map 的“嵌套引用”

第二个 map（压缩后）通常会这样写：
JavaScript
//# sourceMappingURL=app.min.js.map
而这个 map 里面的 sources 可能指向：
JSON
“sources”: [“app.js”]
👉 而 app.js 本身可能也有自己的 .map

五、那工具是怎么处理“多层 map”的？

现代构建工具（Webpack、Vite、Rollup）会：
👉 自动“合并/消费” source map
也就是：

• 不需要你手动处理多层 map
• 工具会帮你把 TS → JS → minified JS 串起来

六、一个更现实的情况（很重要）

在实际项目中，你通常只看到一个 .map 文件
👉 因为：

🔥 构建工具会“消费上一层 map，再生成新的 map”

例如：
1️⃣ TypeScript 输出：
app.js + app.js.map（TS → JS）
2️⃣ Webpack 再处理：
bundle.js + bundle.js.map（直接从 TS 映射）
👉 结果：

你最终只需要一个“最终 map”

七、关键总结

✔ 理论上：

每一次代码转换都可以生成自己的 source map

✔ 实际上：

多个 source map 会被链式组合（chained），最终表现为“从最终代码直接映射回原始代码”

✔ 工程实践：

你通常只需要关心“最终产物的 source map”，工具会自动处理中间层

八、一句话总结

多次代码转换确实会产生多个 source map，但现代构建工具会把它们自动串联起来，让你在调试时可以“一步到位”看到最原始的源码。

如果你愿意，我可以帮你画一张“多层 source map 链路图”（从 TS → JS → minified JS → 浏览器调试）的结构图，这个对理解构建工具的工作原理会非常直观。

你说：

这种source map是Javascript语言生态所独有的吗？其他语言生态，如Java/Python是否存在类似的概念？

ChatGPT 说：

不是 JavaScript 生态独有的，但Source Map 这一“具体标准格式”基本是前端世界的产物。
在其他语言里，确实有类似“映射原始源码”的概念，但实现方式、形式都不一样。
我们可以这样理解：

理念是通用的，但实现和标准不通用。

一、JavaScript 生态：Source Map（统一标准）

在 JS/TS 世界中：

• Source Map 是一个统一规范
• 被浏览器（Chrome、Firefox）和工具链（Babel、TS、Webpack）共同支持
  👉 特点：
• 文件形式：.map
• 标准统一
• 浏览器原生支持

二、Java / JVM 生态：调试信息 + 符号表

在 Java 里，没有 Source Map 这种统一 .map 文件，但有类似机制：

1️⃣ 调试信息（Debug Symbols）

Java 编译后：

• .class 文件里可以包含调试信息
• 包括：
• 原始文件名
• 行号
• 变量名
  👉 作用类似 source map：

  把字节码映射回 .java

2️⃣ JVM 的设计优势

JVM 本身就支持：

• 保留方法名
• 保留类名
• 保留行号映射
  所以：
  👉 Java 调试体验“天生就很好”，不像 JS 那样依赖额外文件

3️⃣ 反编译（另一种“映射”）

工具如：

• JD-GUI
  可以：

  从 .class 反推出 Java 代码（接近原始）
  但这不是官方标准机制，而是“逆向工程”。

三、Python：更接近“原生可见源码”

Python 的情况更特殊：

1️⃣ 直接运行源码

Python 是解释型语言：
Python
运行
print(“hello”)
👉 没有强制编译过程
👉 源码本身就是运行代码

2️⃣ .pyc（字节码）

Python 会生成：

• .pyc（字节码）
  但：
• .pyc 仍然保留很多结构信息
• 可以反编译（如工具 uncompyle6）
  👉 但：

  没有一个像 Source Map 那样的“官方映射文件”

四、其他语言也有类似思想

1️⃣ C / C++：调试符号（DWARF）

• 使用 DWARF 调试信息
• 存在于 .debug 区段或 .pdb 文件（Windows）
  👉 用于：
• 行号映射
• 变量名
• 调试器（GDB / LLDB）

2️⃣ .NET / C#

• 使用 PDB（Program Database）文件
  👉 作用类似：
• 源码 ↔ IL 代码映射

3️⃣ Go

• 内置调试信息
• 支持直接映射源码（但不是独立 .map 文件）

五、对比总结（很关键）

生态
是否有 Source Map
实现方式
JavaScript
✅ 有（标准 .map）
Source Map
Java
❌ 没有统一 .map
JVM 调试信息
Python
❌ 没有统一 .map
字节码 + 可反编译
C/C++
❌
DWARF / debug symbols
.NET
❌
PDB

六、核心本质（真正重要的理解）

你可以这样抽象：

所有语言都需要解决：运行代码 ≠ 原始代码的问题
只是：

• JS → 用 .map
• Java → 用 JVM 调试信息
• Python → 几乎不用（或靠反编译）
• C/C++ → 用 DWARF

七、一句话总结

Source Map 不是唯一的解决方案，也不是 JS 独有的需求；它只是 JavaScript 生态中最标准、最显式的一种“源码映射实现”，而其他语言用的是各自体系内的调试/符号机制来解决同样的问题。

如果你愿意，我可以帮你深入对比一件更有意思的事：
👉 为什么 Java / Python 很少需要像 Source Map 这样的“额外文件”，而 JS 却强依赖它——这里面其实是语言设计哲学的差异。

你说：

请讲

ChatGPT 说：

这个问题的核心，其实不在“有没有 Source Map”，而在于：语言本身的执行模型和运行环境设计不同。
我直接把关键差异讲透，不绕弯。

一、JavaScript：被“编译之后才运行”的语言

现代前端里的 JavaScript（尤其是配合 TS、Babel、打包工具）：
👉 实际流程是：
源码（TS / JSX / ES6）
↓（多次转换）
编译后的 JS
↓（压缩/混淆）
最终 JS
↓
浏览器执行
关键点：

浏览器运行的代码 ≠ 你写的代码
所以必须有：
👉 一个“翻译说明书”来把运行时代码映射回源码
→ 这就是 Source Map

二、Java / Python：设计上“更接近源码运行”

1️⃣ Java：JVM 统一执行模型

Java 的结构是：
.java → .class → JVM执行
但重点是：
👉 JVM 设计之初就考虑了调试需求：

• 行号信息 ✔
• 方法名 ✔
• 类结构 ✔
  这些信息直接内建在字节码里
  👉 所以：

  JVM 本身就自带“源码映射能力”，不需要额外的 Source Map 文件

2️⃣ Python：几乎是“源码直跑”

Python：
.py → 解释执行 / .pyc
特点：

• 不需要强制编译步骤
• 代码结构非常接近执行模型
  👉 也就是说：

  源码本身就是“第一等公民”
  所以：

• 不需要一个独立的映射系统
• 调试时直接就是源码级别

三、关键差异：是否“隐藏源码”

这是本质区别👇

JavaScript（前端）

浏览器只看到“编译后的 JS”
所以：

• 你的源码是“被隐藏的”
• 调试时需要“反向映射”
  👉 Source Map 是“还原工具”

Java / Python

运行环境本身就“理解源码结构”

• Java：通过 JVM 记录调试信息
• Python：几乎直接运行源码
  👉 不需要额外“还原”

四、为什么 JS 生态必须有 Source Map？

这是前端特有的现实问题：

1️⃣ 浏览器是“黑盒执行环境”

• 你不能修改浏览器执行模型
• 浏览器只认 JS

2️⃣ 前端必须经过构建流程

现代前端几乎一定会：

• TS 编译
• JSX 转换
• 模块打包
• 代码压缩
  👉 每一步都“破坏了源码结构”

3️⃣ 代码压缩是默认行为

生产环境：
JavaScript
function a(b){return b*1.2}
👉 没 Source Map：

• 调试 ≈ 猜谜游戏

五、本质差异总结（重点）

可以这样理解：

JavaScript：

源码 → 多次变形 → 才能运行
所以必须：
👉 用 Source Map 把“变形路径”记录下来

Java / Python：

源码 → 运行环境直接理解
所以：
👉 不需要一个独立的“映射文件”

六、一个更底层的哲学差异

JS（前端）

运行环境不可控（浏览器）
👉 所以要靠工具链补救
👉 Source Map 是“补丁”

Java / Python

运行环境可控（JVM / 解释器）
👉 从设计上就支持调试
👉 映射能力“内建”

七、打个直观比喻

• JavaScript：
  👉 你写的是中文
  👉 机器只能看英文
  👉 Source Map = 翻译词典

• Java / Python：
  👉 机器本身就会中文
  👉 不需要翻译

八、一句话收尾

Source Map 的存在，本质上是因为 JavaScript 在运行时“失去了原始代码语义”，而 Java 和 Python 通过运行时设计保留了这些语义，所以不依赖独立的映射文件。

如果你愿意，我可以再帮你讲一个更“硬核”的问题：
👉 为什么 JS 不像 Java 一样把调试信息直接塞进运行代码里，而是选择用外部 .map 文件？这背后其实是“性能 + 安全 + 架构”的权衡。

你说：

请讲

ChatGPT 说：

这个问题已经触及到前端架构设计的“取舍本质”了。直接讲结论：

JavaScript 选择把 Source Map 放在“外部文件”，而不是像 Java 一样内嵌调试信息，是在性能、体积、安全、以及运行环境限制之间做的权衡。
我们分几层拆开讲清楚。

一、先对比两种设计

Java（JVM 体系）

• 调试信息可以直接嵌在 .class 里
• JVM 运行时可以读取这些信息
• 调试能力是“运行时自带”的
  👉 特点：内建 + 紧耦合

JavaScript（浏览器生态）

• Source Map 是独立文件
• 通过：
  JavaScript
  //# sourceMappingURL=app.js.map
  被“引用”
  👉 特点：外部 + 松耦合

二、为什么 JS 不直接内嵌？

1️⃣ 文件体积 & 性能问题（最现实）

如果把 Source Map 信息直接塞进 JS：

• JS 文件会变得非常大
• 每次加载都会多传一堆调试数据
  👉 但生产环境：

  用户根本不需要调试信息
  所以：
  ✔ 把它拆出去 = 按需使用
  ✔ 不影响线上加载性能

三、2️⃣ 浏览器执行模型限制

浏览器（Chrome、Safari 等）：

• 只执行 JS
• 并不会主动“理解 Source Map”
  👉 Source Map 是给：
• DevTools
• 调试器
  而不是给 JS 引擎本身
  所以：

  调试信息和执行逻辑必须解耦
  否则浏览器需要：

• 解析额外格式
• 增加复杂度
  👉 这对性能和实现都不友好

四、3️⃣ 安全 & 信息暴露问题（非常关键）

如果 Source Map 内嵌在 JS 里：
👉 所有人都能看到：

• 原始代码
• 变量名
• 业务逻辑
  而 JS 是：

  直接发到用户浏览器的
  所以：
  👉 你没法控制“谁能看到调试信息”

现在的方案（更安全）

你可以：

• 本地 / 内部系统：允许访问 .map
• 公网环境：禁止访问 .map
  👉 这就实现了：

  调试能力 ≠ 对所有用户开放

五、4️⃣ 按需加载（非常重要的设计）

Source Map 是：

• DevTools 用的时候才加载
• 不用的时候完全不加载
  👉 优势：
• 不影响页面加载速度
• 不影响用户体验
  如果内嵌：

  所有用户都会被迫加载调试信息

六、5️⃣ 构建工具链的复杂性

现代前端：

• TS → Babel → Webpack → 压缩
  👉 每一步都可能生成 source map
  如果强制内嵌：
• 工具之间必须深度耦合
• 每一步都要“理解上一层的调试信息”
  👉 这会让工具链非常复杂

七、6️⃣ 浏览器 DevTools 的设计选择

浏览器 DevTools 采用的是：

“按需解析外部 Source Map”
而不是：
“强制内嵌调试数据”
原因：

• 更灵活
• 不影响主线程执行
• 可以懒加载

八、一个非常关键的设计哲学

你可以把两种模式理解为：

Java：

“调试能力是运行时的一部分”

JavaScript：

“调试能力是开发工具的一部分”

九、一句话总结

Java 把调试信息“内建在运行环境里”，而 JavaScript 把调试信息“放在外部工具体系中”，这是为了在浏览器这个不可控、对性能敏感、且面向终端用户的环境中实现更灵活、更安全、更高效的调试方案。

Add Credit

Go to “here“, type the ammount such as “10” and tap “充值汇款”, then you can scan the displayed barcode and use “Alipay/Wechatpay” to recharge.

Model List

Go to “home -> 火山方舟 -> 开通管理“, you can see all the models you can use.

Response API example

Go to “home -> 火山方舟 -> 开通管理“, select a model in the list, such as “Doubao-Seed-1.8“, tap “API 接入”，it will tell you have to use this model with an API call, such as:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

curl https://ark.cn-beijing.volces.com/api/v3/responses \
-H "Authorization: Bearer $ARK_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "model": "doubao-seed-1-8-251228",
    "input": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": "https://oss.mxiqi.com/V1/AUC/20260301/IMG/2c24eefd37661"
                },
                {
                    "type": "input_image",
                    "image_url": "https://oss.mxiqi.com/V1/AUC/20260301/IMG/37591a998ae9c"
                },                {
                    "type": "input_text",
                    "text": "这是什么？目前的价格大概是多少？"
                }
            ]
        }
    ]

You need to replace the “$ARK_API_KEY” part with your API key before running.

On that day, the item wasn’t shipped, and she didn’t send me any messages. On the morning of March 3rd, I messaged her asking why she hadn’t shipped it yet, and she said, “I couldn’t find the item, I’ll look for it when I get home tonight.” I was completely speechless. What could I even say at that point? From March 3rd to the morning of March 4th, I still received no updates. By 2 p.m. on March 4th, I messaged her again, asking, “Did you find it?” but still no reply. At that point, I immediately applied for a refund.

Around 4 p.m., her message finally came: “Sorry, I didn’t see your message because I’ve been busy working.” This “sorry” was really hard to come by. If we break it down, she probably should have apologized to me several times by now. I even wonder if I hadn’t applied for a refund, she might never have bothered to say “sorry.” She then mentioned that she still hadn’t found the item, but at this point, it didn’t matter anymore. I asked her to approve the refund immediately because I didn’t want to waste any more seconds on someone like this.

So, what did I learn from this shopping experience?

1. Before making a purchase, don’t assume the seller is a reasonable person(sadly). Ask as many questions as possible, like when the item will be shipped, to avoid potential pitfalls.

2. The “seller reputation” numbers on Xianyu is just for reference (this seller had a 97% positive rating with zero disputes). A low rating is obviously a red flag, while a high rating doesn’t guarantee anything either.

3. In a society where overall social standards may still be lacking, no matter how much you try to prevent issues, there’s a high chance you’ll encounter people with poor manners. It’s necessary to be vigilant, but it’s also important to relax yourself to accept this fact. After all, what else can you do?

1. Use the online version of “Mathcha“.

2. Use the “GeoGebra“ application which is available on “macOS/iOS”.

Mathematics Equation(Markdown + LateX)

Plan A: write LaTeX in markdown content directly

1. Install MacTeX

   MacTeX is required by the “pandoc” command below. So please install it from this, or install the basic version(which is smaller and I installed this version) from this.

2. Use the following command to convert “markdown + Latex” into HTML file(from this):

   1 2 3 4 5 6 7 8 9 10 11

   # Export to HTML. pandoc --standalone --mathjax -f markdown -t html sample.md -o sample.html # Export to PDF(it seems the full version of "MacTeX" is required by this, # otherwise the Chinese characters cannot be displayed properly). # You may be prompted "weasyprint not found. Please select a different # --pdf-engine or install weasyprint", if so, install it first with # "brew install weasyprint". pandoc sample.md --pdf-engine=xelatex -V CJKmainfont="PingFang SC" \ --from=markdown+raw_html --resource-path=.:svg \ -V geometry:margin=1.5cm -o sample.pdf

3. Use the online tool “latex2image-web“ to convert a given LaTeX expression to local image(SVG/PNG) file.

Plan B: use online “markdown+LaTeX” editor

Use the online editor “upmath“ to write the markdown, and render the generated HTML content into PDF with the printing feature provided by browser like Chrome.

Content of “sample.md”

Here is the file content used in the commands above. The “./svg/equation.svg” file is an equation image made with “latex2image-web“.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# Abstract

From [there](https://goessner.github.io/mdmath/publication.html).

Euler's identity makes a valid formula out of five mathematical constants.

## 1. Introduction

Euler's identity is often cited as an example of deep mathematical beauty.
Three basic arithmetic operations occur exactly once and combine five fundamental mathematical constants [[1](#1)].

## 2. The Identity

这是一句中文，用于测试中文环境下使用Latex表达式是否正常，比如: $\Delta = b^2 - 4ac$

这是第二句中文，用于测试中文环境下使用Latex表达式是否正常，比如: ![](./svg/equation.svg)

Starting from Euler's formula $$e^{ix}=\cos x + i\sin x$$ for any real number $x$, we get to Euler's identity with the special case of $x = \pi$

$$e^{i\pi}+1=0\,.$$ (1)

The arithmetic operations *addition*, *multiplication* and *exponentiation* combine the fundamental constants

* the additive identity $0$.
* the multiplicative identity $1$.
* the circle constant $\pi$.
* Euler's number $e$.
* the imaginary constant $i$.

Add 2 more equations.

$$S = \pi r^2$$

$$e^{i\pi} + 1 = \lim_{n \to \infty}\frac{1}{n}$$

## 3. Conclusion

It has been shown, how Euler's identity makes a valid formula from five mathematical constants.

### References

1. [Euler's identity](https://en.wikipedia.org/wiki/Euler%27s_identity)

从字面意思看，“constitutional monarchy”的直译是“宪法的君主制/宪政式君主制”或简称“宪法君主制/宪政君主制”。在一百多年前，如果“宪法/宪政”这样的词语还没有诞生或者流传不广(虽然我觉得不太可能)，那也可以翻译成“立宪君主制”。而“君主立宪制”这个翻译看着就很怪，因为它既不符合直觉也不符合逻辑：直白翻译成“立宪君主制”不好吗？如果不好，它是哪里比不上“君主立宪制”这个翻译呢？

从含义的角度来看就更奇怪了：“君主立宪”是一个主谓结构，强调的是“立宪”这个动作；而“立宪君主”是一个偏正结构，强调的是处于“宪政”的一种状态。这两者有非常重要的差别，完全不是一个意思。

想象一下，作为一个不懂英语的中国人，当看到“君主立宪制”这个词时，你的第一反应是不是认为它的核心是“立宪”这个动作？换句话说，作为“君主”，做到了“立宪”这个动作，这个制度也就建立起来了，对吗？

而“constitutional monarchy”(“宪政式君主制”)说的是，有宪法仅仅是第一步，更重要的是：“要以遵循宪法的方式进行君主统治”。这不是一个“有了宪法就成功”的动作，而是需要统治者一直保持一种“君主遵循宪法统治”的状态。也就是说：即便有了宪法，如果君主没有遵循宪法进行统治，那它依然不能被称为“constitutional monarchy”。

你看出这两者之间的区别了吗？

回想戊戌变法“百日维新”期间，那些变法者急吼吼地“立法”，仿佛有了这些条文，“constitutional monarchy”就建立起来了。这让我不禁怀疑，当年那些人是不是被“君主立宪制”这个中文翻译误导了？

我又猜测，“君主立宪制”这个词是否来自日语对“constitutional monarchy”的翻译，进而误导了我们的先辈们。我向“豆包”提出这个问题，豆包给出的答案是：“constitutional monarchy”在日语中通常被翻译为“立憲君主制（りっけんきんしゅせい）”。呃……看来这个锅还真没法甩到日本人头上，日本人的翻译没有犯这个错误。

到了这一步我很想知道，当年是什么人给出了如此歧义的翻译？我又问了“豆包”，它给出的答案是：“一般认为梁启超是将‘constitutional monarchy’翻译为‘君主立宪制’的关键人物”。

如果这是真的，我忍不住从阴谋论的角度想：梁任公当年这么翻译，是不是在给当时的君主和国人降低难度？让大家误以为：这个事情就是把规矩立起来就好、而不是把权力装进笼子里这么难？是不是生怕知道了真相的人们会直接撂挑子不干了？10分难度的事情咱们现在做不到，那就先把难度降低到3分，然后告诉大家：你们看，这件事情吧，其实好像也没有那么难，你们尽管去试。岂知大家真的试了一下，发现根本不是那么回事儿，于是失去了耐心，直接掀了桌子。

至此，大家明白学外语的重要性了吧？

美国的所谓“言论自由”是代表什么言论都可以自由发表吗？如果不是，哪些言论是不能自由发表的？如果存在这样的言论，该如何理解受到限制的所谓的“自由”？

Answer from “ChatGPT“

好问题 👍。美国的“言论自由”确实是个容易被误解的概念。

在美国宪法第一修正案里，言论自由主要是指：政府不能随意限制或惩罚公民的表达（无论是文字、口头还是象征性的行为，比如焚烧国旗）。换句话说，它主要保护你免受政府的压制。

但这并不意味着什么话都可以随便说，它并不是“绝对自由”。美国最高法院已经明确划定了一些不受第一修正案保护的言论类别，包括：

1. 直接煽动即将发生的违法行为（incitement 比如在暴乱中喊“冲进去砸店！现在！”——这是违法的。

2. 真实威胁（true threats） 明确的、可信的暴力威胁（如“我明天要杀了你”）。

3. 诽谤、诬蔑（defamation） 散布虚假事实、恶意中伤他人名誉会被起诉。

4. 淫秽言论（obscenity） 这是个很窄的定义，不是单纯的色情，而是缺乏艺术、政治或社会价值、并且过度露骨的内容。

5. 欺诈与虚假商业广告 比如虚假宣传、诈骗广告。

6. 部分敏感场景下的言论 在学校：学生的言论可以在一定范围内被限制。在军队、监狱：言论自由受到更严格约束。

那么，“受限的自由”该怎么理解？

关键在于：

**核心价值言论（political speech）**几乎总是受到最强保护的，即便它很极端、很不受欢迎。

限制主要是针对会直接造成具体、立即、严重危害的言论，而不是因为“冒犯了谁”就被禁止。

所以，美国的“言论自由”更像是：

👉 只要不直接威胁公共安全、他人权利或触发法律明确禁止的类别，你就有权利说。

👉 但这不等于你说了就没人会反驳、没人会封号、没人会抵制。社会和私人平台（比如推特、脸书）可以对你进行限制，这不算政府侵犯你的言论自由。

要打个比方：

在美国，政府不能因为你喊“我讨厌总统”就抓你。

但如果你喊“我要明天去白宫炸掉总统办公室”，那就完了。

而如果你在推特上骂总统，推特觉得你违反平台规则，把你号封了——那是推特的“自由”，不是政府的行为。

Answer from “Grok“

美国的言论自由主要受宪法第一修正案保护，该修正案规定国会不得制定法律剥夺言论自由、出版自由等权利。这项权利旨在保护个人表达观点、批评政府和参与公共辩论的能力，但它并非绝对的、无条件的“任何言论都可以自由发表”。下面我将逐一回答你的问题，并基于可靠来源提供解释。

言论自由是否代表任何言论都可以自由发表？

不是。美国最高法院多次裁定，言论自由有界限。它保护大多数表达形式，包括政治言论、艺术、宗教观点和商业广告，但某些言论被视为有害或超出保护范围，会受到法律限制。这些限制是为了平衡个人权利与公共安全、社会秩序或其他宪法权利（如隐私权、平等权）。例如，政府不能基于内容审查大多数言论，但可以对某些类别施加合理限制。

哪些言论是不能自由发表的？

以下是美国法律中常见的言论自由例外。这些例外基于历史判例和联邦/州法律，通常由法院判定是否适用。注意，这些不是 exhaustive 列表，且具体情况需视上下文而定（如在线言论可能涉及额外平台政策）。我将它们分类列出，并简要说明理由：

• 煽动违法行为（Incitement）：如果言论旨在煽动或导致立即的违法行为，且很可能发生（如呼吁暴力起义），则不受保护。经典判例：Brandenburg v. Ohio (1969)，要求言论必须“直接煽动”且“迫在眉睫”。

• 真威胁（True Threats）：对他人发出真实的伤害威胁，不受保护。例如，威胁杀害某人或炸弹威胁。判例：Virginia v. Black (2003)，强调意图和上下文。

• 淫秽材料（Obscenity）：严重色情且无艺术/科学价值的材料不受保护。标准来自Miller v. California (1973)：必须诉诸淫秽兴趣、描绘性行为且整体缺乏严肃价值。但成人色情（如色情小说）通常受保护，除非涉及儿童。

• 儿童色情（Child Pornography）：任何描绘未成年人的性行为材料均非法，不受第一修正案保护。判例：New York v. Ferber (1982)。这包括虚拟或AI生成的图像。

• 诽谤和中伤（Defamation）：虚假陈述损害他人名誉，可被起诉（民事而非刑事）。公职人员需证明“实际恶意”（New York Times v. Sullivan, 1964）。这不禁止意见表达，但禁止故意散布谎言。

• 战斗性言语（Fighting Words）：直接面对面侮辱可能引发暴力反应的言语不受保护。判例：Chaplinsky v. New Hampshire (1942)，但现代法院很少适用此例外。

• 商业言论限制：虚假或误导性广告可被規制（如FDA对药品广告的管制），但纯商业言论受部分保护。

• 时间、地点和方式限制（Time, Place, and Manner Restrictions）：政府可对言论施加中性限制，如禁止在学校大声喧哗或限制游行路线，但不能基于内容歧视。

此外，在特定环境中（如学校、监狱、工作场所）言论自由更受限。例如，学生言论可被学校限制如果干扰教育（Tinker v. Des Moines, 1969）。仇恨言论通常受保护，除非落入上述类别。

这些限制主要通过刑事起诉、民事诉讼或内容移除（如社交媒体平台自愿执行）来实施。私营公司（如Twitter或Facebook）不受第一修正案约束，可自行设定规则。

如何理解受到限制的所谓的“自由”？

美国的言论自由被视为“有限制的自由”（qualified freedom），而非绝对的。这反映了宪法设计：第一修正案保护言论以促进民主、真理发现和个人自治，但必须与其他价值（如公共安全、平等和秩序）平衡。最高法院常引用“在拥挤的剧院里喊‘火’”（falsely shouting fire in a crowded theater）作为比喻（源自Schenck v. United States, 1919），说明自由有界限以防止伤害。

理解方式：

• 实用主义视角：自由不是无政府状态，而是通过司法审查（如严格审查标准）确保限制是最小必要的。只有当言论造成清晰且现实的危害时，才可限制。这比许多国家（如中国或俄罗斯）的言论管制更宽松，美国的体系允许更多争议性表达（如政治异见或讽刺）。

• 历史与演变：早期判例更宽松（如1919年允许限制反战言论），但20世纪中叶后趋向保护（如1960年代民权运动）。到2025年，随着数字时代，法院继续处理新挑战，如在线仇恨言论或AI生成内容，但核心原则未变。

• 批评与辩论：一些人认为这些限制太松（如允许仇恨言论），另一些认为太严（如对校园言论的管制）。这体现了“自由”的动态性：它通过法院、社会规范和立法不断调整。

Images to PDF

First method, you can use the command line tool “ImageMagick“.

1
2
3
4
5

# Before running, make sure you image files are named in order,
# such as "001.jpg", "002.jpg", "003.jpg" and so on.
magick *.jpg comic.pdf
# OR:
magick *.png comic.pdf

The second method, you can use Python script with the “Pillow“ library support.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from PIL import Image
import os
import sys


def convert(image_folder: str, target_pdf: str) -> None:
    # Get list of image files.
    image_files = sorted(
        [f for f in os.listdir(image_folder) if f.lower().endswith(('.jpg', '.png'))]
    )
    images = []
    for file in image_files:
        img_path = os.path.join(image_folder, file)
        img = Image.open(img_path).convert('RGB')
        images.append(img)
    # Save all images to a single PDF.
    if images:
        images[0].save(target_pdf, save_all=True, append_images=images[1:])


if __name__ == '__main__':
    if len(sys.argv) < 3:
        print('Usage: python comic.py <image_folder> <target_pdf>')
        exit(0)
    convert(sys.argv[1], sys.argv[2])
    print('Done.')

PDF to Images

The easiest way seems to use the command line tool “pdfimages” provided by “poppler“.

1
2
3
4
5
6
7
8
9
10
11
12
13

# Install "poppler" on macOS:
brew install poppler
# Or on Debian/Ubuntu:
sudo apt install poppler-utils
# Run the following commands to extract images from PDF file.
# The "prefix" value below will be used to name the extracted
# image file. With the command above, you will get image files
# with name like:
#   prefix-000.jpg
#   prefix-001.jpg
#   prefix-002.jpg
#   ...
pdfimages -all comic.pdf prefix

The questions I sent to ChatGPT were:

1. How to convert a batch of comic image files in “jpg/png” formats into a single PDF file?

2. Is there a way to extract images from a PDF file?

1
2

> ./single-file-aarch64-apple-darwin --browser-cookies-file="./cookies.json" https://... target.html
Invalid parameters when calling Network.setCookies({"cookies":[{ ... }]})

The cookie JSON file was exported by a chrome extension which contained the following content:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[
    {
        "domain": ".xyz.com",
        "expirationDate": 1756787525.533015,
        "hostOnly": false,
        "httpOnly": true,
        "name": "_esc_h38",
        "path": "/",
        "sameSite": null
        "secure": true,
        "session": false,
        "storeId": null,
        "value": "5nNCJOP4Ss"
    },
    ...
]

ChatGPT said only the “name/value/domain/path” fields were required which seemed correct. The “sameSite/storeId” fields seemed suspect because of the “null” value. I removed these two fields and tried. The error didn’t show anymore. Not sure why the “Cookie-Editor” extension exports invalid field values but good to know the solution with the help from ChatGPT.

回到问题的本质，ownership到底是什么意思？

如果去问ChatGPT，它会给出如下的答案：

“Ownership” generally means having legal or rightful control over something — whether it’s a physical object, idea, responsibility, or even a situation.

这个回答和我想的差不多。我的理解是：ownership本质上是一种权利，即对某事物的支配和做决定的权利。明白了这一点就可以知道，那些强调“员工应该具有ownership”的企业所说的“ownership”根本不是这个意思，因为他们说这句话的时候显然并不是要让员工支配资源和做决定。他们想让员工做的是更多的工作，尤其是超出了日常要求的工作。这件事如果一定要用一个单词来表达的话，那responsibility其实更好(虽然也不完全合适)。然而有意思的是，企业更喜欢使用“ownership”这个词不达意的字眼来表达，其中的心思呼之欲出，这就是毫无争议的PUA。

我向ChatGPT说出了以上想法，它表示同意，并给出了以下判断“ture ownership”和”false ownership”的简单方法：

1. 问自己：“我是否真的可以决定工作中的关键事情？”
2. 问自己：“我是否得到足够资源和支持去完成这些责任？”
3. 问自己：“我的付出是否被认可和合理回报？”
4. 问自己：“我是否可以拒绝不合理的额外要求而不会被责备？”

如果答案大多是否定的，那很可能你面对的是“false ownership”，甚至是职场PUA。

我觉得ChatGPT给出的这个判断方法不错，打工人可以按照这个方法自行判断。

我想了一下，这件事之所以让我印象深刻，大部分原因要归结于这个领导是一个对待下属很真诚很负责的好领导。这句话从他口中说出，应该是在我潜意识里产生了一种奇异的反差感，因而印象深刻，即使当时的我并没有想清其中原因。我更愿意相信，那时的他说出这样的话，其实也是被其他人PUA而不自知。算起来，我和这位曾经的领导也已有十多年没见过面，不知他近况如何，希望他现在一切都好。

1

PyInstaller/loader/pyimod02_importers.py:450: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.

I googled this and got the solution here, which was to add the “–exclude-module pkg_resources” argument in the “pyinstaller” command to exclude the “pkg_resources” package from the build.

The solution below comes from “ChatGPT“.

1
2
3
4
5
6
7
8

# Edit the configuration file which controls the behavior of "passwd".
sudo vi /etc/pam.d/common-password

# Update the following line:
password requisite pam_pwquality.so retry=3

# to:
password requisite pam_pwquality.so retry=3 minlen=6 dictcheck=0

1. In a record type, the appropriate accessors, constructor, equals, hashCode, and toString methods are created automatically.

2. Record type is used for immutable data. It means all record fields in it are final, and they can only be set within a constructor, either a “cononical constructor”(set all fields explicitly) or an “overloaded constructor”(set all fields with given field value(s) and the default value(s)). No-argument constructor is not allowed since it doesn’t make sence for immutable data.

3. Compact Constructor can be used to perform extra validation, transformation, or initialization logic.

   1 2 3 4 5 6 7 8 9 10 11

   public record Person(String name, int age) { // Canonical constructor is automatically provided // Compact constructor (custom constructor) public Person { if (age < 0) { throw new IllegalArgumentException("Age cannot be negative"); } } }

4. Record type cannot extend from other class(including another record type) or be extended by other subclass(including another record type), while it can implement interface, and can be a filed of another record type. You can take it as a special “final” class.

5. You cannot declare instance variables (non-static fields) or instance initializers in a record class.

Another post is also a good one for Java local variable type inference.

1

File size = sampling rate(Hz) * bit depth(Byte) * 2(stereo track) * time(Second)

And the samples how to use it.

1
2
3
4
5
6
7
8

# A 1-minute stereo track at 44.1 kHz and 16-bit depth can easily be around 10 MB.
File size = 44100(sampling rate) * 2(bit depth) * 2(stereo track) * 60(time) = 10,584,000(bytes)

# A 76-minute stereo track at 44.1 kHz and 16-bit depth(Standard audio CD):
File size = 44100(sampling rate) * 2(bit depth) * 2(stereo track) * 60 * 76(time) = 804,384,000(bytes)

# A 5-minute stereo track at 196 kHz and 32-bit depth:
File size = 192000(sampling rate) * 4(bit depth) * 2(stereo track) * 300(time) = 460,800,000(bytes)

rstr

1
2
3

>>> import rstr
>>> [rstr.xeger(r'^[a-z0-9]{6,6}$') for i in range(5)]
['qazxpj', 'spt53j', 'rvfkmu', 'juwerj', 'erlrz7']

exrex

1
2
3

>>> import exrex
>>> [exrex.getone('[a-z0-9]{6,7}') for i in range(5)]
['ac02qf4', 'h7ik7xk', 'uk3hvd6', 'i6soqy', 'mtwslb']

faker

1
2
3
4
5
6

>>> from faker import Faker
>>> fake = Faker(locale=['zh_CN', 'jp_JP', 'en_NZ'])
>>> [fake.name() for i in range(7)]
['高橋 翔太', '叶欢', '鈴木 花子', '郑旭', 'Vicki Morton-Smith', 'Shane Phillips', '木村 和也']
>>> [fake.email() for i in range(7)]
['momoko27@example.com', 'gaoming@example.com', 'elin@example.com', 'hidekiaoki@example.com', 'james47@example.com', 'francissean@example.net', 'minoru11@example.com']

1
2
3
4
5
6
7

> java -jar revas-1.0.0-all.jar
date=2025-02-27T10:31:55,361,level=INFO,thread=main,logger=revas.starter.MainApp: Starting 'maps-china-request-validator' service...
date=2025-02-27T10:31:55,607,level=INFO,thread=main,logger=revas.starter.MainApp: options.getStores().size(): 0
Exception in thread "main" java.lang.IllegalArgumentException: unknown configuration store implementation: json (known implementations are: [vault])
    at io.vertx.config.impl.ConfigRetrieverImpl.<init>(ConfigRetrieverImpl.java:111)
    at io.vertx.config.ConfigRetriever.create(ConfigRetriever.java:53)
    at revas.starter.MainApp.main(MainApp.java:60)

I googled “unknown configuration store implementation: json (known implementations are: [vault]” and find the following posts:

1. Explanation

2. Solution

The root cause is that, when packaging a fat jar, by default it won’t merge the service files under the “META-INF/services/“ path in each jar file. So when there’re multiple jar files with such service files, some content is missing. To make the fat jar creation process do the merge, add the following content into the “build.gradle” file.

1
2
3

shadowJar{
    mergeServiceFiles()
}

After that, the created fat jar works fine.

To test a given proxy works or not, you can use the following command:

1
2
3
4
5
6
7

# Request the headers only. HTTP status code 200 should be returned.
curl -I www.bing.com
# Request the headers by using the given "proxy host/port".
# If the proxy works, HTTP status code 200 will be returned.
# Otherwise you should get an error such as below:
#   curl: (52) Empty reply from server
curl -x http://proxy.server.domain.name:8000 -I www.bing.com

Ollama

Go to “Ollama“ website to download the “ollama” application for your OS(Linux/macOS/Windows). Install it. Then you need to select a model to run with Ollama. Go to this page to select. For example, I select “deepseek-r1:32b” from here.

Run the following command to start.

1

ollama run deepseek-r1:32b

The first time you run a given model, it will be downloaded and then start.

After “ollama” is running locally, you can install the “Page Assist“ browser extension, to chat in browser instead of in terminal.

llamafile(standalone with given model file)

From here.

In this mode, you need to have the “llamafile” application and a model file.

1. Download “llamafile” from “here“, such as “llamafile-0.9.0”. Extract the zip file if required and “chmod +x” to make it executable.

2. Go to ModelScope and select a “GGUF” format module file, such as “Qwen2.5-Coder-7B-Instruct-GGUF“ and download.

Run.

1
2
3
4

# Before running, you can run "./llamafile-0.9.0 --help" to get the knowledge
# how to set the "-ngl" or "--gpu" arguments, to leverage the CPU/GPU resources
# of your computer better.
./llamafile-0.9.0 -m qwen2.5-coder-7b-instruct-q5_k_m.gguf -ngl 999 --log-disable

llamafile(all-in-one)

From here.

In this mode, all you need is to download one file such as “llava-v1.5-7b-q4.llamafile“, make it executable(“chmod +x”) and run:

1

./llava-v1.5-7b-q4.llamafile

After that your browser should be opened automatically and display a chat interface. You can adjust the settings and start chatting.

An interesting part you may not notice above is that, one “llamafile” binary file can be used in almost all known operating systems like “Linux”, “BSD”, “macOS” and “Windows”, which is accomplished by combining “llama.cpp“ and “Cosmopolitan Libc“.

koboldcpp

From here.

Go to “koboldcpp“ official website, download the binary file, such as “koboldcpp-mac-arm64” for macOS. Make it executable(“chmod +x”) and run:

1

./koboldcpp-mac-arm64

This command opens a window in which you need to set the “GGUF Text Model” field with a “gguf” file(model file). You can download such “gguf” files from websites like “modelscope“ or “huggingface“.

Note that, after you launch the model, you can either chat in the opened browser window, or use the APIs hosted at “http://localhost:5001/v1/“. More details about how to use the APIs can be found in the official document here. Here is a sample.

1
2
3

curl http://localhost:5001/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"How to install Rust on Ubuntu?"}]}'

It will take a while to get the response, just be patient.

Resources

1. Hugging Face: The platform where the machine learning community collaborates on models, datasets, and applications.

2. ModelScope: 共享/共创/共进，构建持续创新的 AI 开源生态。And the team ever create a Python library “modelscope“. The library seeks to bring together most advanced machine learning models from the AI community, and streamlines the process of leveraging AI models in real-world applications.

3. TrendShift: A dashboard shows the trending GitHub repositories and developers.

4. build-your-own-x: This Git repository is a compilation of well-written, step-by-step guides for re-creating our favorite technologies from scratch. For example, “Python: A BitTorrent client in Python 3.5“.

Use the following instructions to install “pipx”.

1
2
3
4
5
6
7

# On Mac:
brew install pipx
pipx ensurepath

# On Ubuntu:
sudo apt install pipx
pipx ensurepath

Use “pipx”.

1
2
3
4
5

# Install package.
pipx install poetry

# List installed packages.
pipx list

Today I realized that the JWT token is completely plain text which can be decoded very easily. You can use some online tools(such as this and this), or the following Python script.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from base64 import urlsafe_b64decode
import json
import sys

def decode_jwt(token: str) -> dict:
    chunks = token.split('.')
    header = str(urlsafe_b64decode(chunks[0] + '=='), encoding='utf-8')
    payload = str(urlsafe_b64decode(chunks[1] + '=='), encoding='utf-8')
    signature = chunks[2]
    result = {
        'header': json.loads(header),
        'payload': json.loads(payload),
        'signature': signature
    }
    return result

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print('Usage: python dejwt.py <jwt_token>')
        exit(0)
    print(json.dumps(decode_jwt(sys.argv[1]), indent=4))

And the running sample:

1
2
3
4
5
6
7
8
9
10
11
12
13

~> python dejwt.py 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
{
    "header": {
        "alg": "HS256",
        "typ": "JWT"
    },
    "payload": {
        "sub": "1234567890",
        "name": "John Doe",
        "iat": 1516239022
    },
    "signature": "SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
}

The structure of JWT token is well explained by the script above. More details can be found in the official document here and here.

If you want to get more details about this topic, the following ChatGPT session provides them.

1
2
3
4
5

# Add "local" config.
git config user.email "your_email@abc.example"

# Add "global" config.
git config --global user.email "your_email@abc.example"

What about removing a configuration item? A simple answer is using the following commands(from here):

1
2
3
4
5

# Update(include removing) "local" config.
git config --edit

# Update "global" config.
git config --global --edit

The two commands start an editor app(such as “vi” or “Sublime Text”, depends on your local setting) to open the configuration files:

1. Local: “.git/config”

2. Global: “~/.gitconfig”

In another word, you can edit the configuration files directly to “add/update/remove” the configuration items.

The answer below comes from the posts here and here.

1

java -Dlog4j2.configurationFile=file:/home/auser/code/sample-project/src/test/resources/log4j2-test.xml -jar sample-project-1.0.0-all.jar

WARNING: sun.reflect.Reflection.getCallerClass is not supported. This will impact performance

Googling it and this post gives the answer: it’s introduced by the “log4j2” dependency. The original issue can be found here. The fix is:

…, you may need to have Multi-Release set to true in the jar manifest.

So I need to know how to do such configuration in the “build.gradle” of the Java project which creates the jar file.

The final solution comes from this article “Multi-release JARs - Good or bad idea?“, by adding the following content in the “build.gradle” file:

1
2
3
4
5

jar {
  manifest.attributes(
     'Multi-Release': 'true'
  )
}

The “Multi-release JARs“ is a feature of JDK 9. The article “Multi-release JARs - Good or bad idea?“ not only gives the steps how to create such jar file in Gradle, but also describes why this feature is not a good idea from his perspective.

In GitHub(the remote side), go the “Settings” of the repository, set the “main” branch as “Default branch”. Then open “View all branches” page of the repo, remove the “master” branch.

In local side, you need to following the instructions below(from here), to avoid the “Your configuration specifies to merge with the from the remote, but no such ref was fetched” error when running “git pull”.

1
2
3

git checkout main
git branch --unset-upstream
git branch --set-upstream-to=origin/main

Now you can run “git pull” without issue.

Please read the following Java code, which can be compiled and executed without any issue(with JDK 7+).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import org.junit.jupiter.api.Test;

public class TypeParameterTest {
    public static <T, X> T read(X test) {
        return null;
    }

    @Test
    public void test() {
        String a = TypeParameterTest.read("");
        String b = TypeParameterTest.read(123);
        Integer c = TypeParameterTest.read("");
        Integer d = TypeParameterTest.read(123);
    }
}

Notes

1. The “read” method has 2 type parameters, one for argument and another for return value.

2. In the “test” method, 4 invocations of the “read” method have different argument types and return value types. The magic part is that, all of them can be compiled successfully. It means the “read” method can return different types in different circumstances, depending on where it’s invoked. This happens to the method argument as well.

3. The reason is that, the Java compiler has an ability called “type inference” which is used “to look at each method invocation and corresponding declaration to determine the type argument (or arguments) that make the invocation applicable. The inference algorithm determines the types of the arguments and, if available, the type that the result is being assigned, or returned. Finally, the inference algorithm tries to find the most specific type that works with all of the arguments“(from here).

I noticed this when I was reading how to use the “JsonPath“ library here, and was astonished when I found the “read” method could return different types in different situations.

The full “Generics“ tutorial is also worth reading.

1

some_string: "\350\277\231\346\230\257\344\270\200\344\270\252\346\265\213\350\257\225"

Here is how to make the content readable.

From here and here.

1
2
3
4
5
6

# Convert an "escaped octal value" string to a text string:
b'\345\255\246\346\240\241'.decode('utf-8')

# Reversely, here is how to convert a text string to an
# "escaped octal value" string:
''.join([ '\\' + oct(x)[2:] for x in '学校'.encode('utf-8')])

With “zipapp“, you can create a executable Python archive with all its dependencies.

Basic Usage

Here is an example. Use the following Python file as the target script.

1
2
3
4
5
6
7
8
9
10

from termcolor import cprint

def hello_inside():
    cprint('Hello from zipapp inside...', 'red')

def main():
    hello_inside()

if __name__ == '__main__':
    main()

Run the following commands to create the “pyz” package file with “inside.py”.

1
2
3
4
5

mkdir build
mkdir dist
cp inside.py build/
pip install termcolor --target build
python -m zipapp build --main inside:main --output dist/test.pyz

After the “test.pyz” file is generated, you can run “python dist/test.pyz” to execute the Python package.

Advanced Usage

In some case, your code inside a “pyz” file needs to call external Python code out of the “pyz” file. Here is an example.

1
2
3
4
5
6
7
8
9
10
11
12

from termcolor import cprint
from outside import hello_outside

def hello_inside():
    cprint('Hello from zipapp inside...', 'red')

def main():
    hello_inside()
    hello_outside()

if __name__ == '__main__':
    main()

1
2
3
4

from termcolor import cprint

def hello_outside():
    cprint('Hello from outside...', 'blue')

Run the following commands to create the “pyz” package file with “inside.py” only.

1
2
3
4
5

mkdir build
mkdir dist
cp inside.py build/
pip install termcolor --target build
python -m zipapp build --main inside:main --output dist/test.pyz

Run the following command to execute the “test.pyz” file.

1
2
3
4

# "/Users/auser/test/dist" is where the "outside.py" resides.
# The "PYTHONPATH" environment variable sets the system path
# where Python looks for dependencies not in the "pyz" file.
PYTHONPATH=/Users/auser/test/dist python dist/test.pyz

1. First download the image file of Ubuntu Server for ARM from here.

2. Following the instructions to create a VM instance in UTM and install Ubuntu Server on it with the image file downloaded in the first step.

3. By default, Ubuntu Server only has CLI. Install GUI with the following commands:

1
2
3

sudo apt update
sudo apt install ubuntu-desktop
sudo reboot

4. Following the instructions here to enable clipboard and directory sharing. For example, install the following packages in the Ubuntu VM.

1

sudo apt install spice-vdagent qemu-guest-agent spice-webdavd

Then you need to set UTM to enable the “clipboard/directory” sharing. Go to “UTM -> select the target UTM -> Edit Selected VM -> Sharing”, check the “Enable Clipboard Sharing” checkbox, and select the “SPICE WebDAV” item for the “Directory Share Mode” option.

Basic Usage

First, you should download the execution file from here. Be sure to select the correct one for your “OS/Arch”. For example, if you’re using Mac with silicon chip(ARM arch), you should select “single-file-aarch64-apple-darwin”. In this post I will use “Linux/x86/_64” in the command samples.

Before running, make sure Chrome or a Chromium-based browser is installed and can be found in default “PATH”. Otherwise you may need to set the “–browser-executable-path” option in the command line when executing “single-file”.

After you add the execution permission to the downloaded file, you can try running it.

1
2
3

# Basic usage: single-file [url] [output] <option*>
# Runing without any arguments/options will print all the available options.
./single-file-x86_64-linux https://imtx.me/ index.html

Advanced Usage

Sometimes the target web page needs login to view the content. In this case we need to save the “cookies” of the website from your browser, then use the “cookies” in the “single-file” running to make it work.

Save the cookies

You need to install some extension in your browser to save the target cookies. For example, in Chrome you can install the “Cookie-Editor“ extension.

Open the target web page(login if it’s required), then open the “Cookie-Editor” extension, select “Export -> JSON”, the cookies of this website for you will be saved into a local JSON file. Let’s say it’s “cookies.json”.

Run

Now you can download the target web page with the cookie file like below.

1
2

./single-file-x86_64-linux --browser-cookies-file='cookies.json' \
 https://articles.zsxq.com/id_9getlhtuixe5.html venezeula.html

Be careful with your cookie file especially not share it with anybody else, because that means anyone which has this cookie file can do all operations as you can do on the target website, just like he/she can login the website with your account.

原文链接：“委内瑞拉：诅咒这个国家的，并不是资源”

发表时间：2024年8月1日 23:43

一个本该富得流油的土豪国，是怎么穷成拉美垫底。

1

委内瑞拉乱了。

7月29日凌晨，委内瑞拉国家选举委员会宣布，现任总统马杜罗再次当选委内瑞拉总统。

选举结果出炉后，委内瑞拉多地发生了旨在抗议马杜罗选举舞弊的示威活动，并引发暴力冲突。

这次选举造成的影响可能会愈演愈烈，因为与上次马杜罗宣布胜选连任时的较小规模骚乱不同，此次委内瑞拉骚乱不仅蔓延境内各州，而且包括阿根廷、智利、哥斯达黎加、秘鲁、巴拿马、多米尼加和乌拉圭等拉美诸多“邻居”都宣布不承认马杜罗的胜选，马杜罗政权目前正处于空前的内外交困中。当然，马杜罗的选择是一条路走到黑，对内严厉镇压反对派，对外则宣布与几乎所有不承认此次大选结果的邻居们断交。

到当地时间31日，委内瑞拉总检长表示，已逮捕1062名参与暴力事件的人员，并且逮捕名单还在急速扩大当中。另有消息称一些地方的军警因为不愿意向抗议民众开枪，已经发生倒戈。委内瑞拉的政局，正处于关键时刻。

但实际上，无论能否成功“摆平”其境内的民众，度过此次危机，马杜罗政权的未来都不甚美妙。由于长期的经济崩溃弄得民怨沸腾，如果在此次选举中下台，其下场当然十分不妙。但即便能够再次弹压反对派，未来六年的执政期内，马杜罗依然将面临的是越发严重的经济崩溃态势。在其接棒查韦斯领导委内瑞拉的过去十年中，委内瑞拉经历了西半球国家中最严重的经济崩溃事件：石油收入暴跌93%，GDP缩水达到80%。尽管后疫情时代委内瑞拉经济有所恢复，但高达85%的年货币通胀率和逼近六成的极端贫困率依然困扰着这个国家。

截至2017年，委内瑞拉的官方货币玻利瓦尔兑美元汇率自2000年以来已贬值92%。随着恶性通货膨胀的肆虐，马杜罗让货币进一步贬值95%，并在两年内将玻利瓦尔货币贬值11个零。

为了“解决”经济危机，2017年以后，委政府干脆宣布拒绝公布了所有经济数据，所以该国目前到底经济破产到了什么地步，其实只能靠猜。

2021年，根据国际权威机构的评估，委内瑞拉的人均实际收入已经低于海地，成为整个拉美最贫穷的国家，截至当时，有96%的委内瑞拉人生活在贫困中，79%的人生活在联合国所定义的极端贫困当中。

委内瑞拉老百姓，现在真的穷得只剩下形同废纸的钱了。

国家破产到这个样子，大量还走的动态的人其实已经开始选择“用脚投票”，截至2023年，委内瑞拉流亡海外的难民人口达到了创纪录的770万人，而该国目前的人口总数据估计也就只有2890万人左右，也就是说，在过去的几年中，有超过四分之一的委内瑞拉人已经“用脚投票”离开了自己的祖国，创造了人类历史上非战争状态下的难民奇迹，且这些难民大部分都是年轻跑得动或有一定资产走得了的高价值人口。

可以想见，如果马杜罗成功弹压了此次骚乱，看不到希望的委内瑞拉年轻人和仅存的技术人才恐怕会掀起又一轮“逃难潮”，等六年后再次大选时，该国还能剩下多少干的劳动的年轻人口都是个大问题。所以真的如其反对派领袖马查多所言，此次大选是“拯救祖国的最后机会”了。

此情此景，真的让人无法想象，如今沦为拉美最穷国的委内瑞拉，想当初曾经是拉美人均GDP最高的国度，那么这个本该土豪的国家是怎么混到今天这一步的呢？

2

如果问世界第一石油土豪国是谁？很多人的第一反应会是沙特。但实际上，根据2022年的最新数据，在已探明石油储量中，沙特占全球总量17.2%，仅仅排在全球第二，排名第一的就是委内瑞拉，已探明石油储量占全球的17.8%，加上委内瑞拉人口少于沙特。如果按照“把石油卖了发给全国老百姓躺着挣钱”的简单逻辑，世界上第一石油土豪国，不应该是沙特，而是委内瑞拉才对。

可是这个世界的经济运行，并不是按照上述简单逻辑来的，这个世界上有一种奇怪的说法，叫做“资源的诅咒”，说得不那么玄乎，就是像石油这种大家都想要的资源，即便你国家地下有，它也是不可能自己流出来，自动换成美金，然后公平地分配给所有国民的。怎样组织开采挖掘，怎样在国际市场上换成钱，最终怎样公平地分配给罪有应得的人——更关键的是，你怎么定义这个钱谁该拿谁不该拿。这都相当考验人类的政治组织架构是否现代而合理，中间稍微有一点点差池，很可能就会让这个国家承受不住这份“颇天富贵”，而陷入万劫不复的深渊。这就是“资源的诅咒”的成因。

而在这方面的，中东石油富国由于其宗教所提供的超稳定结构和普惠教众的理念，在维持其君主制的同时，还可以至少暂时维系摊子不散。而欧洲的一些富产资源的小国，比如卢森堡、挪威等，则因为在开发资源前已经建立了完善的现代国家制度，能够保证资源的有序开采和普惠民众。

除了这两种模式之外，“资源的诅咒”在全世界其他地方确实屡次应验。因为开采并出售资源这件事本身，会极大地扩张资源拥有者的力量，这使得资源拥有者可以不顾多数人的意愿，绕开现代国家“纳税人的普遍同意”的构建原则，去建构一个威权体系。如果这个资源的拥有者首先是跨国公司，而后通过收买和支持当地军政府成为其打手买办，弹压民众，那就会演化为拉美的很多“香蕉共和国”。而如果这个资源的拥有者就是政府本身，则很可能演化成我们今天看到的委内瑞拉这副模样。

其实委内瑞拉这个国家很不幸，上述两种情况，它都经历过。委内瑞拉的石油发现非常之早，早在1936年，美国的壳牌石油公司就在该国发现了大量石油，并随机建立了石油开采体系。但当时的委内瑞拉正处于军政府的独裁统治之下，本来该国民主革命正风起云涌，推翻军政府在望，壳牌公司一发现石油，硬生生强行给军政府续了一口命——资本是逐利的，为了保证开采环境的稳定，壳牌公司开始资助委国军政府强行弹压民众，以方便石油的开采。于是委内瑞拉的第一民主化浪潮就这么硬生生被摁下去了。

但壳牌毕竟是美国的公司，它这样为了开采石油强行资助军政府，在美国国内也是承压严重的。尤其是二战以后，由于美苏争霸中意识形态的需求，委内瑞拉军政府能得到的支持进一步减少。终于在1958年，在民众的抗议中，军政府被迫放弃权力，委内瑞拉于同年举行了第一次全国普选。

一切至此为止看起来都非常美好，二十世纪六十年代，一度也成了委内瑞拉经济发展的黄金期，委内瑞拉人均GDP雄霸拉美的经济奇迹，也是在那一段时间发生的。

但委内瑞拉的不幸在于，有两种因素，如胎毒一般，在其走向民主的最初就被种下了。

首先，由于壳牌公司等美国能源企业在委内瑞拉民主化进程中支持军政府的不光彩角色，委内瑞拉的民意尤其是知识界民意从一开始就带有非常强烈的反美色彩。民主运动成功后，要求政府彻底驱逐美帝国主义资本、没收壳牌等公司在委内瑞拉石油企业中的股份的呼声一直不绝于耳。

其次，委内瑞拉的历届政府，确实也存在着一种非常强烈的没收外国资本，以充实国库的冲动。因为委内瑞拉1958年革命成功之后，曾经在民主革命道路上志同道合的各党，为了在大选中争取民意，都争相许诺自己在上台后会多发福利、多建医保，甚至国家拨款提高大学中的知识分子待遇。

可是如此众多的许诺都是花钱的，钱总需要有一个来源，于是左翼的政党就开始主张应当彻底没收“帝国主义资本”，用这种打土豪分田地的方式给本国民众发福利。

至此，驱除外国资本和福利主义这两种左翼主张在委内瑞拉完成了合流，这种看似非常合理的主张深得民心，让主张尊重私有产权的委国的右翼保守政党被骂为“卖国贼”而无从立足。

1969年的大选中，在经济建设上颇有建树的民主行动党遭遇了惨败，委内瑞拉的十年黄金发展期结束。

新上任基督教社会党总书记R·卡尔德拉·罗德里格斯刚刚就任总统，就采取了激进的左翼政策，对外废除美委贸易互惠条约、低价强行赎买外国公司在委内瑞拉的石油产业，并且将所有石油产业收归国有等做法。

对内，罗德里格斯则极力推行福利主义政策，包括推行公费医疗、提高国民养老保障、免费教育、落实八小时工作制、提高工人最低工资……凡此种种，所有你能想到的福利主义政策，基督教社会党在上世纪70年代都在委内瑞拉搞过一遍。

**需要指出的是，基社党当时在委内瑞拉的这些举措，虽然今天看来非常像胡搞，可是在上世纪下半叶的拉美其实非常常见。**拉美流行的天主教思想本来就有非常浓厚的救济穷人的情怀，20世纪下半叶又与当时普遍流行的社会主义思潮相结合，在当时风靡一时。我曾经讲过阿根廷的故事，对比阿根廷贝隆夫妇执政时代所推行的社会改革运动，你会发现委内瑞拉基社党搞的这一套跟贝隆夫妇其实是如出一辙的。

但阿根廷不幸中的幸运在于，它没有石油这么强力的国际硬通货为政府的大型国有化和财政冒进背书，贝隆主义那一套搞上个几年，政府财政就面临破产，国内则民生凋敝，然后就会发生政权轮替。左右翼轮流上台让阿根廷左两年、右三年，虽然日子过得很苦，但好歹不会跌进最彻底的深渊。

但委内瑞拉就不同了，它幸运中的不幸就是，石油这玩意儿实在是太好卖了。70年代政府收归国有之后，委内瑞拉的石油开采技术和效率虽然已经逐渐开始与国际水平出现脱钩，但基社党政府幸运地赶上了（更确切地说，是参与制造了）70年代的石油危机，国际原油价格的高企让委内瑞拉赚了个盆满钵满。委内瑞拉老百姓得到了一个错误的经验，觉得罗德里格斯的这套主张不仅走得通，而且还挺好。

从此福利主义就成了委内瑞拉各党在竞选中都必须遵守的一条死线，因为民众的胃口已经被那次偶然“养刁了”。

可是在貌似的人间天堂背后，日后促成委内瑞拉崩解的绝症开始滋生。

首当其冲的就是官员腐败的问题，石油产业收归国有，和大量资金投入福利政策，让委内瑞拉政府获得了空前的财权，这对于一个还不成熟的现代政府来说本来就非常容易滋生腐败。更致命的是，70年代的委内瑞拉还丧失了抵抗腐败的最好保鲜剂——舆论的监督。

由于基社党政府同期执行的石油产业国有化、高福利政策受到了反对党的批评，政府得以借助民族主义情绪关停了那些批判最为猛烈的媒体，失去舆论监督的政府于是在石油高收入、高福利的滋养下变得越发腐败。

而在有钱就主要搞腐败、其次发福利的狂欢中，委内瑞拉也没有利用实有收入建立国家主权基金这样长远的投资行为。财政一直处于紧平衡的状态下。

在70年代，委内瑞拉受惠于国际的高油价，这一切问题还并不显现。

可是到了80年代以后，随着油价的下跌，委内瑞拉的政府收入急速减少，但福利和腐败的刚需却依然存在，危机一下子就凸显了。

当民众感受到自己的日子过得愈发艰难，又不愿意承认这是自己当初选择赶走外国资本、敦促政府搞高福利政策的错误造成的恶果时，一种莫名的焦躁情绪就在委内瑞拉国内蔓延。而基社党那种普通的左翼主张此时已经不能满足国民的需求了，另一种更为激进的主张取而代之，粉墨登场。这就是所谓的“查韦斯主义”。

3

1997年，查韦斯创建了“第五共和国运动”，1998年正式宣布参选总统，誓言消除国内两大政党（基督教社会党和民主行动党）的政治腐败，扬言打击“掠夺人民的寡头政治家”，深受贫穷老百姓的认同与支持。同年12月，查韦斯获得逾半数选票，成为委内瑞拉史上最年轻的总统，查韦斯时代开始了。

查韦斯在在野时代就猛烈地抨击基督教社会党的改革——但他的批评不是说基社党搞得太激进了，而是不够彻底。查韦斯认为基社党执政时期的政府腐败和国家财政困难、经济凋敝，都是来源于其改革的不彻底性——基社党虽然清除了美国的资本，但委内瑞拉在文化、政治制度上依然有很多美国式的元素，想要脱困，就必须清除这些“余毒”，走他提出的那条新路。

那么这条路究竟是怎样的呢？贯穿查韦斯执政纲领中，有个非常至关重要的单词，名叫“使命”。查韦斯将自己的整个计划称为“玻利瓦尔使命”，而在这个总体“使命”之下，又分为30多个分支使命，而且多数都以拉美革命先贤命名，有着异常复杂的名字，这些使命统领指挥社会的方方面面，每一个使命都有非常具体的分支目标，其中某些使命给老百姓许诺也非常美好。比如反腐败的使命许诺彻底清除百姓痛恨贪官，“一个不留”；有关石油经济的“使命”则旨在掌握“完全石油主权”，把基社党留下的那一丁点民间和外资参股的空间也清除掉了；医疗方面的使命许诺老百姓免费看得起病；住房方面的使命许诺年轻人都住得起房——一切看上去都是基社党当年许诺的翻倍，如此的美好，一下子就把老百姓忽悠住了。

而在现实逻辑层面，查韦斯所提出的“玻利瓦尔使命”最重要的突破，是它让行政权可以借此突破法律乃至宪法的制约。

原本基社党搞的那些革新虽然也十分激进，但受制于委内瑞拉的国家体系，是需要一步步通过修改法律、释放行政政策来的。可是查韦斯用“使命”成功突破了这种束缚。很多时候，虽然法条是这样写的，但查总统一拍脑门，说我提个什么什么使命，一下子就把这个法条绕开了。总之就是使命先行，法律靠边站。

这样一搞，就让原本还能在委内瑞拉勉强经营的内外资本变得惶惶不可终日，因为资本的长期投资是稳定性的，如果政府明天就可以通过某个“使命”绕开法律，把你这摊子生意以委内瑞拉人民的名义连锅端走。那甭说石油，小买卖也没法在这种环境下生存。

于是查韦斯时代首先发生的就是资本的成批出逃。委内瑞拉财政收入的单一性开始加剧，石油收入从1998年的70%一路飙涨到马杜罗时代的98%，而1999年委内瑞拉有49万个私人公司，到2018年，只剩了28万个。

简而言之，就是除了国家“掌握完全主权”的石油产业，委内瑞拉已经没有什么能赚钱的营生了。

此外，也许是因为在外资的奶牛已经被榨干之后，只能通过侵害中产的利益才能够填饱底层的碌碌饥肠，或者超前认识到了这群有知识的人最可能成为自己的反对者。查韦斯的使命计划还打击委内瑞拉几乎所有行业中的中产。比如石油行业的相关“使命”降低了石油工程师的工资，医疗行业的“使命”则发布了对医生的限薪令，文化产业的“使命”缄口了一切对其狂想冷嘲热讽的作家和记者……

所有这些行业的中层精英在被限制收入和发声后，不约而同地选择了一条路，那就是离开。所以在21世纪的头十年，委内瑞拉首先发生的，就是社会精英阶层的大量“蒸发”。

而对于最喜欢福利政策的底层百姓，查韦斯则创新性地提出了“弗洛伦蒂诺使命”，这个使命特别值得拿来一说的原因，是因为它给委内瑞拉的每个社区都派驻了“指导员”，名义上是指导这些社区的民众免受“资本家的蛊惑和侵蚀”，而事实上，这些人的主要任务是旨在记录并上报那些反对查韦斯政策、并公开表示下次不投票给他的老百姓，一旦你在这个名单上“榜上有名”。查韦斯政府一般也不会怎样暴力镇压你，只不过查韦斯政府许诺给老百姓的一切福利，你就都别想了。

查韦斯这样搞的理由冠冕堂皇：福利是发放给委内瑞拉人民的，你反对我，就不属于委内瑞拉人民，不属于人民你还领个屁的福利？

想享受医保吗？想领福利补贴么？想领就必须支持查韦斯、马杜罗。

从这个角度看，我其实咬不准马杜罗这次选举到底得了多少真实选票，因为在年轻人批量逃离之后，委内瑞拉想靠着政府救济凑合吧这辈子过完的老年人，确实占了相当比例。

资本和中产外逃，底层民众受到政府福利的绑架，按理说查韦斯的这套改革政策给委内瑞拉的负面效果应该是立竿见影的。

可是，关键时刻，石油给予委内瑞拉的“镇痛作用”再次呈现了。

查韦斯的运气是真的好，他执政的十几年刚好赶上了国际油价再次一飞冲天的时期。这就导致了委内瑞拉的经济非但没有在这期间崩溃，反而维持着增长。

但这段时期之内，不认同查韦斯政策理念的委内瑞拉精英阶层纷纷出走，而将经济增长错误地归功于查韦斯新政并感恩戴德的那批人则留了下来。二十世纪七十年代的那一幕，在委内瑞拉再度上演了。

但委内瑞拉此时的问题，其实更严重了。查韦斯的新政，让政府的财权变得更加扩张、腐败问题则在财政扩张的激励下实际上变得更加严重，资本和中产的出逃也让委内瑞拉失去了发展石油以外的产业的机会，国有化和技术能力的停滞则进一步制约了石油产业的开采效率……

所有这些，导致委内瑞拉想要维持稳定，对原油价格维持在高位的要求变得更加苛刻而脆弱。委内瑞拉经不起半点石油价格的下跌，因为一旦油价下跌发声，这个体系顷刻间就会崩溃。

而这种早晚会发生的“倒霉事”，最终就发生在了查韦斯去世，马杜罗接任的时代。

4

实话实说，马杜罗此人的运气真的是不好，他刚刚接任的2014年，国际原油价格就从一百美金一桶的高位腰斩到了44美金。查韦斯时代所积累的所有隐患，在这一刻被集中引爆，当年委内瑞拉就因为外汇收支的不平衡发生了严重的粮食短缺，平均每个国民减重8.7公斤。但马杜罗作为查韦斯的接班人，他的一切执政合法性来自对查韦斯的继承，面对这种困局，其所选择的只能是硬着头皮，将福利主义进行到底，不顾政府收支的不平衡，加大开支给民众发放粮食补贴，以维持稳定的局面。

可是这种寅吃卯粮本来就难以长时间维系，加之查韦斯时代留下的另一个恶果在此时也发作了——

由于常年执行反精英主义政策，再加上选举生态的不健康，委内瑞拉的专业精英们不是选择了移民，就是被排除在决策体系之外。马杜罗时代作出的诸多决策总是呈现出一种高度的不专业性。

**而查韦斯的“使命”体系又恰恰是极度依赖政府的能动施为的。**这就导致了马杜罗政府为了解决危机总是最终采取那些火上浇油的盲动和乱动，每每“好心办坏事”，总是进一步加剧了危机。

比如2017年灾难性的币制改革，几乎让官方货币玻利瓦尔成为废纸，民间本币交易体系已经完全崩溃了，老百姓只能用黑市上换得的美元进行交易，而委内瑞拉政府此时又更灾难性地加强了货币管制，让经济危机更加雪上加霜。

于是原本查韦斯时代，从委内瑞拉出逃的主力还只是内外资本和工程师、医生、高级知识分子等中产上层，但到了马杜罗时代，中产下层乃至但凡不愿意接受这套“福利体系”绑架的委内瑞拉年轻人也纷纷出走，由此才创造了前文提到的，一个国家在和平时代对外输出772万难民，四分之一多的国民流亡海外的奇景。

说来真的很讽刺，委内瑞拉，这个国家没有战争，有的只有被称为“21世纪黄金”的石油。然而这份上天的馈赠，让委内瑞拉人一再选择看上去很美的激进左翼福利政策，并且为了与这套政策相配套，支持了一个更比一个激进的威权政府，希望像查韦斯一样的强人、伟人，来公平地帮他们分配能从这份礼物中获得的利益。

然而，迎接委内瑞拉人的，是一次更比一次惨痛的困局。

如今委内瑞拉又出现了动乱，这个国家能走出这种死循环吗？我并不看好。因为在上述的长期折腾当中，能够给这个国家带来真正活力和附加值的中上层精英已经被蒸发掉了。还留在委内瑞拉国内的，大都是一些实在走不了，或者依然迷信福利政策的人——虽然马杜罗政府能给这批人的福利，也已经只够糊口而已了。而马杜罗政府为了解释其经济上的失败，近年来正在加剧仇外尤其是仇美教育。更将一切反对者指责为与西方相勾结。

而由于海量的石油储备，以及求得国际外援的可能性，马杜罗的日子虽然已经较为难过，却未必一定是过不下去的。摆平这次骚乱的可能性依然存在。而骚乱过后，随着又一批失望的人离开，委内瑞拉会剩下一批更加被福利所绑架，并且认同或者被迫认同马杜罗政府理念的民众。社会整体民意有可能进一步左转、并趋向于民粹化。

所以简而言之，资源的诅咒，如果这种东西真的存在的话，它依然可能在委内瑞拉的上空飘荡很久，但当我讲完这个故事之后，你回首再看，你能说，诅咒那个国家的，真的是资源么？

不是的，是人们被那黑金所激起的，对乌托邦过于天真而急切的向往，和随之而来的野心、偏激和妄念。

委内瑞拉，诅咒这个国度的，根本不是资源。

(全文完)

This post records the steps that in “utm“ how to make a Linux guest running on a Mac host be able to access the shared directory.

Host setup

First we need to enable the shared directory feature on host. Open the “utm” app, select the target guest VM and open the “Edit selected VM” dialog(the “upper-right” button). In the “Sharing” section, select the “SPICE WebDAV” item in the “Directory Share Mode” field, and the shared directory in the “Path” field, then “Save”.

Guest setup

From here, here and here.

1. Install the required packages first

1
2
3

# When installing "davfs2", it asked whether you want to mount by non-root user,
# I selected yes.
sudo apt install spice-webdavd qemu-guest-agent davfs2

2. Create the target directory

1

mkdir /home/auser/exchange

Update the “/etc/fstab” file by adding the following content.

1

http://127.0.0.1:9843       /home/auser/exchange         davfs           rw,user,uid=auser,noauto 0 0

3. Mount

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Restart service to reload "/etc/fstab".
systemctl daemon-reload

# Add the current user to the "davfs2" group.
sudo usermod -a -G davfs2 auser

# Mount.
# I had to restart the guest OS to run this command since it reported
# "auser must be in group davfs2" although it's already added. Restarting
# will make it take effect I think?
mount /home/auser/exchange
# It asks for the "username/password" to mount, since need account is needed
# in this case, just enter to go next. If everything works, you should be able
# to see the the content mounted(shared) directory and you can also write files
# in it.

After that, everytime the system is started, you can run “mount /home/auser/exchange” to mount the shared directory.

1
2
3
4
5
6
7
8
9
10
11

# The issue happens when a file is too big to save into git repo.
git push origin main
Enumerating objects: 7, done.
Counting objects: 100% (7/7), done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 653.14 KiB | 358.00 KiB/s, done.
Total 4 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
remote: warning: See https://gh.io/lfs for more information.
remote: warning: File cache.db is 69.36 MB; this is larger than GitHub's recommended maximum file size of 50.00 MB
remote: warning: GH001: Large files detected. You may want to try Git Large File Storage - https://git-lfs.github.com.

1
2
3
4
5
6
7
8
9
10

# 1. Install "git-lfs".
sudo apt-get install git-lfs
# 2. Setup "git-lfs".
git lfs install
git lfs track "cache.db"
git add .gitattributes
# 3. Do git operations as usual.
git add .
git commit -m 'Add the latest content.'
git push origin main

The core Git LFS idea is that instead of writing large blobs to a Git repository, only a pointer file is written. More details can be found in the offline document.

Added on 2024-06-05.

1
2
3
4
5
6
7
8

# Retrieve original files after a git clone with git lfs. From:
# https://stackoverflow.com/a/72830455/3115617

# Fetch all the LFS files from the remote.
git lfs fetch

# Replace the pointer files to the actual files.
git lfs checkout

1
2

pip install --upgrade pip --index-url https://mirrors.sustech.edu.cn/pypi/web/simple
pip config set global.index-url https://mirrors.sustech.edu.cn/pypi/web/simple

The second command creates a “~/.config/pip/pip.conf” file with the following content, which will be read by pip when running.

1
2

[global]
index-url = https://mirrors.sustech.edu.cn/pypi/web/simple

How to include Python files loaded dynamically?

From here and here.

In my code I use “importlib.import_module(…)” to load module dynamically. After packaged with “pyinstaller”. Running the program gets error that the target module cannot be found. The reason is, “pyinstaller” will parse the Python code and only include the modules explicitly imported.

To fix the issue, I can either:

1. Add explicit “import” statement in Python code(it’s OK not to use the explicitly imported module since the dynamically importing will work anyway);

2. Add the “–hidden-import” argument(s) when executing “pyinstaller”, such as:

1

pyinstaller --hidden-import 'tap.commands' --hidden-import 'tap.commands.id' tap.py

I choose option 1 since adding the explicit “import” statements is much clearer than updating the “pyinstaller” command.

How to package data(resource) files?

From here and here.

In my code, some data files locates at a project package which are loaded on runtime. The code works file until it’s running within the executable file compiled by “pyinstaller”. The reason is that such data files are not included when “pyinstaller” does the packaging. To fix this issue, 2 steps are required:

1. Add the “–add-data” argument when executing “pyinstaller”, such as:

1

pyinstaller --add-data "tap/commands/*.template:tap/commands" tap.py

2. Update project code by using “pkgutil” to read the data file instead of reading the target file directly:

1
2
3

import pkgutil
template_bin = pkgutil.get_data('tap', 'commands/id.template')
template = template_bin.decode('UTF-8', 'ignore')

Summary

Packaging everything into one executable file makes running a Python program much easier, but it breaks some fundamental assumptions how a Python program runs, which brings some extra cost to make it work.

The backup files are named with date like “backup-2024-03-26.tar.gz”. Then the problem becomes: how to select the files whose name matche the outdated pattern? The answer comes from the “date” command.

Let’s say the clean-up command runs in every 15th day of a month, and it removes the backup files created in the last month, which keeps the ones created in the current month. We just need to use the following “rm” command:

1

rm backup-$(date --date='1 month ago' +'%Y-%m')*.tar.gz

Note that the “date –date=’1 month ago’ +’%Y-%m’” part returns “2024-02” when the current date is “2024-03-xx”. So this command will just work as expected. More details about how to use the “date” command can be found here.

To make this command run every 15th day of a month, add the command line below after running “cronjob -e”:

1
2
3

# The cron schedule expresion below means "At 09:30 on day-of-month 15".
# From: https://crontab.guru/
30 9 15 * * rm /home/user/backups/backup-$(date --date='1 month ago' +'%Y-%m')*.tar.gz

Clean old version IntelliJ cache files

I find “IntelliJ IDEA” has a lot of old version cache files in the “~/Library/ApplicationSupport/JetBrains” directory. And there’s a safe way to clear them(from here).

Open “IntelliJ IDEA”, go to “Help -> Delete Leftover IDE Directories”, you can do the clearance safely.

Clean up “Homebrew” cache files

From here

1

trash $(brew --cache)

Note that “trash“ is a Homebrew formulae and CLI tool that moves files or folder to the trash.

SingleFile is software to save a complete web page into a single HTML file(via browser extension and a CLI tool). The CLI version “single-file-cil“ can be used as below.

Note that the instructions below show how to install and use this CLI tool with Docker which is the simplest way, however it requires you have Docker installed. You can also run from code without Docker, but it requires more work to do, such as installing the dependencies manually.

1
2
3
4
5
6

# Pull the Docker image of "single-file-cil".
docker pull capsulecode/singlefile
# Create a tag for the Docker image.
docker tag capsulecode/singlefile singlefile
# Run the tool by given the web page URL and save it to a file.
docker run singlefile "https://mp.weixin.qq.com/s/_MQmML08NWAtbhf8uxvZUg" > wechat.html

To better understand how the Docker image works, you can read the “Dockerfile” here.

1. Go to “Settings” to enable the “Background App Refreshing” for this app.

2. Open the app, check the photos which are NOT be uploaded, open some of them can tap upload manually.

3. Check the videos which are not uploaded and do the same thing as step 2.

After that the app started the upload process. Some other tricks such as “enable cellular backup” mentioned here may also work.

In Xcode, when you press “Shift + Command + O” to use the “Open Quickly” feature to open a file, by default the file will be opened in the existing tab instead of a new tab. However I want to change this behavior to open the file in a new tab. This can be done by the following configuration:

1. Press “Command + ,” to open “Settings”. Go to the “Navigation” tab.

2. Update the “Optional Navigation” by setting its value as “Uses Tab”.

3. Done.

Now when you press “Shift + Command + O” to use the “Open Quickly” feature to open a file, after searching and selecting the file, press “Option + Enter” to open it. Now the file will be opened in a new tab.

Please following the following file content to set multiple index URLs in “~/.pip/pip.conf”.

1
2
3
4
5
6

[list]
format=columns
[global]
index-url = https://pypi.testsite.com/simple
extra-index-url= https://pypi.org/simple
                 https://artifacts.testsite.com/artifactory/api/pypi/pypi-repos/simple

1
2
3
4
5
6
7
8

# Download the target Youbube video.
./yt-dlp_linux 'https://www.youtube.com/watch?v=oRxgYC5zrV4'

# Check the video info.
ffprobe 'Full Super Mario World 2： Yoshi'\''s Island OST [oRxgYC5zrV4].mp4'

# Extract the audio stream from the video to "mp3" file.
ffmpeg -i 'Full Super Mario World 2： Yoshi'\''s Island OST [oRxgYC5zrV4].mp4' -vn -ac 2 'Full Super Mario World 2： Yoshi'\''s Island OST [oRxgYC5zrV4].mp3'

The “mp4 -> mp3” converting tip comes from here.

The Youtube video in the command is “Super Mario World 2: Yoshi’s Island OST”.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

Super Mario World 2: Yoshi's Island (1995) was developed and published by Nintendo.

The soundtrack was composed by Koji Kondo(近藤浩治).

Tracklist:

1.  Nintendo Logo (0:00)
2.  Story Organ (0:04)
3.  Yoshi's Island (2:47)
4.  Yoshi's Start Demo (4:59)
5.  Practice Course (6:01)
6.  Game Start (6:44)
7.  The Flower Garden (6:49)
8.  Goal & Score (9:42)
9.  Underground (10:32)
10.  Castle & Fortress (12:19)
11.  Kamek's Theme (14:27)
12.  Mid-Boss (14:59)
13.  Athletic (16:13)
14.  Above Ground (18:24)
15.  Player Down (19:55)
16.  Game Over (20:01)
17.  In Front of the Boss' Room (20:11)
18.  Big Boss (21:10)
19.  Big Boss Clear (23:11)
20.  Map (23:20)
21.  Bonus Game (25:35)
22.  Powerful Baby (27:00)
23.  Koopa (28:00)
24.  Koopa Clear (30:45)
25.  Luigi's Rescue (30:56)
26.  Ending (32:28)

To make Hexo be able to render the math formula written in TeX/LaTeX notation, we need to add the “hexo-filter-mathjax” plugin.

First, update the “pacakge.json” file by adding the following line in the “dependencies” section:

1

"hexo-filter-mathjax": "^0.9.0",

Then run “npm install” to install it.

Second, update the “_config.yaml” file to add the corresponding configuration:

1
2
3
4
5
6
7
8
9

mathjax:
  tags: none # or 'ams' or 'all'
  single_dollars: true # enable single dollar signs as in-line math delimiters
  cjk_width: 0.9 # relative CJK char width
  normal_width: 0.6 # relative normal (monospace) width
  append_css: true # add CSS to pages rendered by MathJax
  every_page: false # if true, every page will be rendered by MathJax regardless the `mathjax` setting in Front-matter
  packages: # extra packages to load
  extension_options: {}

The last step is to add the following “front-matter” line into the post which contains the math formula written in TeX/LaTeX notation:

1

mathjax: true

After that in the post you can write the formula like below:

1
2

# https://en.wikibooks.org/wiki/LaTeX/Mathematics
$x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}$

The rendered result looks like:

Done.

• DOF = depth of field

• u = distance to subject

• N = f-Number

• c = circle of confusion

• f = focal length

The formula comes from Google result.

The method how to write mathematical expressions in markdown format(GitHub style) comes from here.

The “c” values of different camera can be found from the web page here which provides an online DoF calculator implementation. Here are some examples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<option value="0.005">Nikon Coolpix S8000</option>
<option value="0.005">Nikon Coolpix S8200</option>
<option value="0.005">Nikon Coolpix S8100</option>
<option value="0.005">Nikon Coolpix S9100</option>
<option value="0.005">Nikon Coolpix S9300</option>
<option value="0.011">Nikon 1 J1</option>
<option value="0.011">Nikon 1 V1</option>
<option value="0.020">Nikon D1H</option>
<option value="0.020">Nikon D1X</option>
<option value="0.020">Nikon D2H</option>
<option value="0.020">Nikon D2Hs</option>
<option value="0.020">Nikon D2X</option>
<option value="0.020">Nikon D2Xs</option>
<option value="0.030">Nikon D3</option>
<option value="0.030">Nikon D3x</option>
<option value="0.030">Nikon D3s</option>
<option value="0.030">Nikon D4</option>
<option value="0.020">Nikon D40</option>
<option value="0.020">Nikon D40x</option>
<option value="0.020">Nikon D50</option>
<option value="0.020">Nikon D60</option>
<option value="0.020">Nikon D70</option>
<option value="0.020">Nikon D70s</option>
<option value="0.020">Nikon D80</option>
<option value="0.020">Nikon D90</option>
<option value="0.020">Nikon D100</option>
<option value="0.020">Nikon D200</option>
<option value="0.020">Nikon D300</option>
<option value="0.020">Nikon D300S</option>
<option value="0.030">Nikon D700</option>
<option value="0.030">Nikon D800</option>
<option value="0.030">Nikon D800E</option>
<option value="0.020">Nikon D3000</option>
<option value="0.020">Nikon D3100</option>
<option value="0.020">Nikon D3200</option>
<option value="0.020">Nikon D5000</option>
<option value="0.020">Nikon D5100</option>
<option value="0.020">Nikon D7000</option>

From the list you can see that, for a “full frame(35mm)” cemara the “c” value is “0.030” while for a “APS-C frame” camera the “c” value is “0.020”. These two values cover most of the user scenarios.

What is TTF?

TTF is the short form for TrueType font. This is a product of coordinated efforts between Apple and Microsoft in the 1980s. TTF font was created because both Apple and Microsoft had a common goal: create a font that was capable of working across Windows and Mac and could be deciphered by most printers by default.

TTF puts both screen and printer font data in the same file. This makeup simplified the installation of new fonts and acted as an early hybrid platform font format that was compatible with most users’ devices.

What is OTF?

OpenType font, abbreviated OTF was also a product of collaboration between Adobe and Microsoft. OTF was also a hybrid creation with display font and printer font data packaged in a single platform.

OTF was designed to enable more functions than TTF. An example being that the former has a format capable of storing as much as 65,000 characters. The ability to keep extra characters besides the usual ones (A-Z, 0-9, punctuations, and symbols) gave designers a platform to add more character to OTF, such as:

1. Ligatures
2. Glyphs
3. Small caps
4. Alternate characters
5. Old-style figure

When using TTF, these had to be added as extra fonts but using OTF, they are all kept in a single file as the default typeface and can be accessed easily to consumers. Using OTF is a better option when it comes to designing, and it is, therefore, the preferred font by professional designers and hobbyists.

The difference between OTF and TTF

The most significant difference between OTF and TTF for both rookie and professional designers lies in the advanced typesetting programs. Another big difference is that OTF has provisions like glyphs and ligatures that present a designer with multiple options to use.

Which font is better for your needs?

These extra options are usually not used by non-designers. In simpler terms, OTF is the better of the two where designers are concerned due to the additional features. However, for regular daily computer use, the difference between OTF and TTF is not consequential.

When comparing OTF and TTF, the more robust of the two is the former due to its additional features. OTF is designed with more features to help designers and typesetters have the flexibility they need to make adjustments to a piece and make it look better. For non-designers who use computers for typical day-to-day tasks, the many features added to OTF don’t make a difference since they have no use.

If you have to choose between the two, OTF is the choice to make, but if you cannot access OTF, there is no harm in using TTF.

1
2
3
4
5
6
7
8
9

~/Library/Fonts> ls -la
...
-rw-r--r--@   1 maxhuang  staff    317628 Jan 17  2020 Hack-Bold.ttf
-rw-r--r--@   1 maxhuang  staff    322288 Jan 17  2020 Hack-BoldItalic.ttf
-rw-r--r--@   1 maxhuang  staff    316156 Jan 17  2020 Hack-Italic.ttf
-rw-r--r--@   1 maxhuang  staff    309408 Jan 17  2020 Hack-Regular.ttf
-rw-r--r--    1 maxhuang  staff  32683280 Nov 10  2021 SourceHanSans-VF.otf.ttc
-rw-r--r--    1 maxhuang  staff  56785868 Nov 10  2021 SourceHanSerif-VF.otf.ttc
...

What does the “@” sign here mean? The following answer comes from the post here.

That means the file has Extended file attributes. What is Extended Attribute?

1. Standard Attributes. For example, creation date, modification date, permission.

2. Extended Attributes. Stores extra, customizable, small info. For example, author name, file character encoding, short comments, security status.

3. Resource Fork. Widely used before Mac OS X , can be considered as a more elaborate extended attribute system, and may also hold main data of the file. (See: Mac OS X Resource Fork Tips)

Some related commands are listed below:

1
2
3
4
5
6
7
8

# View Extended Attribute with ls.
ls -l -@ <filename>

# Show Attribute with xattr.
xattr <filename>

# Delete All Extended Attribute.
xattr -c <filename>

What to Put in Extended Attribute? Extended Attributes are name/value pairs. The names are Unicode characters of less than 128 bytes. (they are probably encoded in utf-8 or utf-16) The values can be text or binary, recommended to be less than 4 kibibit.

There’s no standardize structure for names. Anyone can add a attribute named for example “xyz” to a particular file. Apple recommends the use of reverse DNS naming scheme to prevent name clash. This is the same scheme adopted by Java. Example:

1

com.apple.FinderInfo

If you have a domain name, such as “example.com” then your attribute name for file of author can be “com.example.author”. If you don’t have a domain name, just make sure the name is not likely used by others.

In some case, if we want to remove all the extended attributes, such as removing the warnings that “the app is not from verified developer”, we can run the following command(from here):

1

xattr -cr <file_or_dir>