#post 想看中文mdBook不容易 (#rust by #wasm Example )
是啊🤭！我觉得这俩SDK搭配一起学很合适，尤其因为真正的C++程序员不多。而 Web APIs 的话，小白也有共同语言呢
https://wasm-bindgen.github.io/wasm-bindgen/

先说说availability吧
WASI，它之于std::*，就像linux基础框架之于libc。WA的线程ABI都还没确定(这也是涉及fs,shm,stdio咋缓冲,甚至需不需要进程和argv? 的容器化革新)。
即使过几年，有稳定的IoContext接口了，WA也只适合高频func和二进制读写。甚至，我不确定后者还能卡js的脖子几年。
算法和并行的话前有WebGL2 WebGPU，后有native numpy，高并发又不适合WASM，比较鸡肋。 Rust可以说是以后WA原生的主力了

—— #AI锐评 本段 https://x.com/i/grok/share/OZlvWyOJwE3RWlpngMKrYLmGe

但我对新资料喜欢的很。坏处是，目前这本书没有翻译(https://llever.com/rustwasm-book/ 不算)。
想让便宜AI(DS3.1,kimi-k2 什么的)帮我弄一下，结果找到的“小”工具，各种震惊我爷一整年的复杂度or莫名其妙的坑……

最后我还是使用 WebUI翻译器 + (pip install flat-tree, 这是grok的一个幻觉😒:可实现 a/b.md <=> a__b.md 互操作) 了……

UI: https://github.com/ruanyf/weekly/issues/7446 ，在这里只需要设定下 CustomLLM=https://openrouter.ai/api/v1/chat/completions ,token
model=moonshotai/kimi-k2-0905,UserPrompt=${content}, 然后关闭翻译缓存！ 即可
#SystemPrompt
你是一个顶级的翻译引擎和语言专家。你的任务是提供专业、精准、且忠于原文的翻译或内容改写。
请将用户提供的文本内容，根据指示翻译或改写成中文，需要严格保持原有技术内容的意义、语气和语境。
完全保留原始内容的格式，包括但不限于段落、链接文字、代码块、Markdown 标记等。

不过……这也有坑。 .md 翻译Agent我不相信没人做，可各种不兼容和为省钱出的bug…… 🤪

格式化文本的翻译…… 其实就是把内嵌代码拆分合并下，预制一下术语表。聪明点，只用和tg的 text+tag format 一样拆，再设定 :is(code,a) 不翻译就够了。
插入 %% 匹配位置和长度不行吗？ AI还是能把 hi **bold** [world] 正确排序为 hi %bold% %world% 的，其中文本也能缓存，比如：

loads=(s, ...tag)=>(i=>s.replace(/%/g, m=>(i++, tag[(i-1)/2>>0]))  )(0)
loads('hello %gg%, %world% !', '*','_',)

https://github.com/telegramdesktop/tdesktop/issues/5795#issuecomment-612471703
——AI解读tg markup https://x.com/i/grok/share/bFv4gWxreN5s4OYds3e69UNh4

我竟然都找不到这种实现？！
求AI帮它门保持md语法，而自己却做“行缓存”，那要"Agent"干什么？？
难道.html DOM 心智模型有这么晦涩吗，需要差别对待短代码vs代码段？

#failed
# MS家的各种报错没F12可调试 docker run --rm -it --env-file .env -v "${PWD}:/work" ghcr.io/azure/co-op-translator:latest -md -l "zh"
# 总报错Provider阻止 https://github.com/smikitky/chatgpt-md-translator
# 只支持DS https://crates.io/crates/mdbook-translator/0.1.0
# 只单文件 https://tools.newzone.top/en/md-translator

#bash 牛！ https://x.com/i/grok/share/Q7VnKtuR45Ti2t3DFIJWppqNT
wc <<<hi
echo "hi" &> >(wc)

#tool
https://x.com/i/grok/share/skxv5PCsPXGA5H5RLFA0kLtjF
shopt -s globstar
tree2globs() { local s="$1" d="$2" f;
[ "$3" = "==" ] && { s="$2" d="$1"; } # a__b -> a/b
for f in "$s"/**/*; do
[ -d "$f" ] && { sed "s/[^\/]//g;s/./ /g;s/$/$(basename "$f")/" <<<"$f"; continue; }
u="${f#$s/}" #prefix
[ "$3" = "==" ] && {
install -D -- "$f" "$d/${u//__/\/}"
} ||
install -D -- "$f" "$d/${u//\//__}"
done;
}

https://x.com/xin_pai88825/status/1985364138827321399 #design 小米 😒

#life #ai https://x.com/imxiaohu/status/1985174703976435861

医院想把这笔钱“算进慈善减免”，
因为那样可以维持他们的免税地位。
说白了，就是做做样子。
如果“虚假的账单”是为了支撑“虚假的慈善”，
那整个系统就是虚伪的。

----------

在 Claude 的帮助下，我写了一封信，
详细指出他们的违规计费，
并威胁要采取法律行动。
信中我故意埋下 舆论、公关、合规 的陷阱，
然后问他们：“你们觉得什么是公平的？”
我明确告诉他们：
我们不是来申请慈善的，
我们是在谈价格。
而且你们被抓了个现行——
无论在法庭上还是舆论上，你们都站不住脚。

别发出自己不敢兑现的威胁。
我们敢。
结果，这招管用。
他们回信，说愿意降到 3.7 万美元。

----------

我把谈判结果告诉嫂子，建议我们再压一点。
她担心被催债，问我为什么不直接接受对方报价。
我说：
“因为那四千美元是你自己的钱——
他们不该拿走。”

于是我们折中，提出 3.3 万美元。
医院接受了。
这就是我从整个经历里学到的东西。

如果你有钱，而他们想要你的钱，
你比自己以为的更有谈判筹码。
账单不是圣旨。要敢于抗争。
但要带着知识去抗争。😒

我每月 20 美元订阅 Claude，
这笔钱赚得值。🤭
是的，AI 有时会幻觉、胡说八道。
所以我没有盲信。我亲自查证 Claude 的发现，结果它是对的。

我还订阅了 ChatGPT 一个月，
让它帮我审查信件内容、检查事实。
结果它一字未改。完美。

我一直以为 #AI 的水平是不错的。因此，偶尔遇到「不好懂」的问题，甚至是自己的灵感自己做不出来时，都会去grok/gemini一下，它一般能在细化追问后让我明悟

比如，今天我回顾 #math #algorithm FFT，我想起了一个质疑：FFT和cos,sin有关，为什么能用于整数乘法？🤯

grok3:

13 → [3, 1] （个位 3，十位 1）
21 → [1, 2] （个位 1，十位 2）
结果 = [3×1, 3×2 + 1×1, 1×2] = [3, 7, 2]
→ 解释： 3×1=3……（个位、十位、百位并行处理，即“卷”积）
→ 273 ✓


(e^{iθ} = cosθ + i·sinθ) 复数次数只是等价变换的工具，卷积定理 + 频域点乘 这个数学魔法才是优化技巧（中间虽然用了 cos、sin 和复数，但数学上等价）

import numpy as np
a = [3, 1, 0, 0]
b = [1, 2, 0, 0]
c = np.fft.ifft(np.fft.fft(a) * np.fft.fft(b)).real
print(np.round(c).astype(int)[:3])  # [3 7 2]

换句话说，10进制(10e1~~个十百千万) vs cossin(vec2)频谱本质上是一样的，都是“[钢琴键×响度,].sum()” 的形式😒，因此有 NTT 这个玩法。

#blog https://hexo.limour.top/Solving-equations-using-postfix-notation 把逆波兰写那么丑么…… 还是要学递归啊。 原文就在这医学生的博客里 #dalao

https://github.com/Limour-dev/qrjs #tool 无网络靠二维码传文件

#security CSP沙盒(tool)居然不是默认的？ 任何一个富文本也可能导致 js/html 注入😒
这比C的 buffer[N] as code 牛逼多了😅 确如 yinwang.org 所说，把代码加个引号就当成数据、参数、用户输入，还在test出问题时"escape"，怎么想的。 一开始就该用代码模板(ES6``)嘛

libc侧的RCE至少还能用 noexec/-fPIE 防一下，栈溢想利用就需要libc.so的地址，js呢，都是字符串……

CSP沙盒其实已经能弥补跨源访问的限权问题了。
https://x.com/i/grok/share/GUx6ecaPUw74qofZcJsdkGAfW
https://x.com/i/grok/share/Lsd5JIEsDhS6viLWEwtVpvRv1

PHP实践：
https://x.com/i/grok/share/ofPQ4RCdQHOfN1PznpzRKepxc 😅 CF竟然不支持 strict-dynamic SRI，还被开源社区打脸
https://x.com/i/grok?conversation=1986619246538072327 unsafe-inline

系统内核(syscall)的本质不是沙盒或sched，是区分接口授权， CSP的初心也不是禁止origin，是记录正常用户的行为清单与界限

#linux https://x.com/i/grok/share/CPvgiMgM7i6i2dMScVN5QfyJX

提问： syscall基本被libc封完了，以最小权限原则，linux完全没必要接受libc.so以外地址段的caller，除非对 gcc -static。 为何要允许c语言的抽象被击穿呢？

#statement https://x.com/i/grok/share/J2cYWmSk7CbtOdS8D9WpBswat
https://forum.butian.net/share/2288

程序员没有对用户输入的感知能力，写不了健壮的代码， 这些沙盒手段都只是亡羊补牢， 尤其是sanitize本质上只是对ES6模板字符串的侧面弥补。

再比如，PHP,Pickle, FastJson, yaml 都因为能暴露type构造器而出现RCE。 这种漏洞也是能写出来的？
正常来讲，typed deserialize 是需要标明的，甚至是需要instanceof限制子类的，而不是默认。

好吧，可能这就是设计者vs堆砌者思路的差异了。 是根本性上的。😒

https://share.google/aimode/H5Xh1f2JR18pcKJJm #web

说到了escape的问题
我觉得http动词的设计也是有问题的，其实只需要 get put post 三个（但不是说定义GET，方便地址栏访问or拼接url.query就行了的.. 那是一种可选别名😃）

patch 完全就是扯淡，put已经有了按key更新的语意，而把 post(rpc call)泛化一下，就是按初始值 or key 设定用户/文章等对象的意思
有些spec规范的设计越多，它的表意反而越少。 less is more.

不过这样 REST boys 就不能推广他那套 jsonHttp/RPC -> 按options自动判write权限的“跨端跨站ORM” 了？ 哈哈。🤪

#design 软件幻灭 后续
😃 给tg团队 t.me 隔离设计的技术栈打个心~

“我们已经不指望软件能长期稳定工作了。”
“大家都充分认识到复杂之荒谬，简单之美——简化可以让事情变得更好。”
“程序员们忙着把简单事情复杂化的同时…… 电脑游戏却变得连最基本的事情都很难实现了。”
——https://www.gcores.com/articles/110509

这里 Blow 给出了他对于“软件明显在蓬勃发展”之直观感受的解释：软件正在享受硬件能力提升的红利，它只是“看上去”蓬勃发展而已。

Blow 的要点是：软件正在倒退，而人类，空前依赖软件。尽管，这和我们置身其中的用户的观感是相反的。波音飞机掉下来的主要原因，就是软件问题（没有针对极端工况测试）。文明衰退的速度如果很慢，我们能意识到这个衰退么？

机器学习是最明显的例子。一方面，它在二十年前不能存在主要是因为GPU性能无法支持而已。比如，我们使用软件给自己AI换脸成明星的样子，或者配上打赏挂饰，这个有趣的部分，只占那些app极小极小的部分，而UIUX的部分非常简单，另外的极重要部分却又极度复杂，包括把你的脸加载到屏幕上，以及处理你的点击，等等。

电脑上一切软件都经常 bug，以至于用户对于一切软件“重启试试”成为不假思索的操作？！包括 Emacs 的问题、Visual Studio 不能处理最最简单的指令，只能连续报错，微软 Word 的字符换行 bug 二十年后仍然没有消灭，像幽灵一样此起彼伏；于是他为了缓解自己的愤怒想打游戏，打开 Epic Store 和 Steam 又连续遇到 bug……

Blow 从游戏图形计算的角度给出了一些“最最基本的，但你不能直接做的事情”，其中一个好懂的例子是，把一个程序拷贝到另一个设备（就像C++深拷贝一样，安装并不是单纯的复制文件内容）
安装程序不是为了对接 CPU，而仅仅是为了解决操作系统层面不可思议之多的兼容问题，其绝大部分是我们不想打交道的。你不能直接编写一个独立程序进行编译和容器化的 linking。而微软为了能让人这么做，专门设计了一个 vswhere 的软件。

这些库/服务本身可能是在变化的、并且没有被中心化地存储和管理，这样一来我们就陷入了无穷无尽的debug的、重启服务的、互相同步的……我们自身所不能掌握的问题海洋之中。

现在，大家竟然在积极主动建设着这样一个SDK！程序员们忙着把简单事情复杂化的同时……
电脑游戏却变得连最基本的事情都很难实现了。

“第一代 TTL（逻辑门电路）是那帮胡子花白的老头子做的，他们知道其中的道理；现在的工程师都是毛头小子，学校毕业过来搞生产，他们不知道内部组装的改变，会会产生磁场，而磁场变化的相互干扰，没有被设计者纳入考虑，因为他们不理解。

这就是科技退步的原因。代际之间的交流和传承，需要巨大的努力，这过程中有损失。
——如果代际的传承失败，文明就灭亡。

Blow 从正面描述了软件的结构：抽象层次的序列。机器语言、汇编语言、Fortran/C/C++、C#/Haskell/Javascript……在这个序列里，绝大多数工程师在最高抽象层次进行工作，因为这是“聪明、省力、高效率的”。

在这个抽象从低到高的序列里的某些位置，问题就出在这里。
Blow 认为，全行业的高抽象层次工作，多数人的“高效率”的另一面，是失去（或者从未拥有过）能力。
考虑 Facebook 作为一个软件的功能增加，和它要多雇佣的成千上万的工程师，二者相除得到的平均每人的价值创造是趋近于零的！这和“抽象层次越高，效率越高”明显矛盾。

#js 嗯…… 我现在就在PoC一个比 Prismjs.com,CodeMirror,Monaco(VSCode) 更正确的span高亮方法，基于2021之后的DOM
PGO得出的结果是，即便不考虑HTML parse开销，Range API 也比堆叠<span.高亮类型>好😒， #code 见下
https://x.com/i/grok/share/6EUWYNSsyq7Ixk6BvdVoFdxV3
https://x.com/i/grok/share/vwCog17kkAn4lD58VEDgjxgrF

让Blink去计算 contain: paint ，显然是比JS background-clip:text+canvas Worker 绘制彩色矩形要好了(我也在gh上PoC过)，而且百行代码即可😄

#AI 看不到的是更多的文档
https://microsoftedge.github.io/Demos/custom-highlight-api/
https://htmlspecs.com/css/css-highlight-api-1/#range-invalidation

我对这个实现很乐观，虽然它明显比 span[ContentEditable] 要考虑更多区间更新的问题，但结合js侧配套的增量compiler，或许以wbr分词的 new Range(#text) 也是能自动延展的？
希望以后能自己创建相关的工具链。😃

#draft #vibe

这个高亮parser基于 eat(字符流),Bisect(区间链表),ast; 2+4+3 个接口，只针对(字面量or函数)的层面增量解析

s=eat('hello'):
`s(1)==s(-1) ='h', s(1)=='e'`，可结合 s=df(eat)() 打印调试关键语法
`s(/.*/), s(JSON.parse)` ，支持 s.ws=/\s+|#.*$/ 等，当 s.hl=='', 读项前自动跳空格（字面量内不跳），并保留 s.wsPre+='其空格'

s.by=Bisect(基于H5 span[attr],Text 等, 通过PahQL(el)设置):
'he llo'
by(0, s=>eatVar); by(0, s=>compileDef); 注册区间更新，肯定不能和parsec/递归下降那样return，咋搞下面会说 也有CSV(C=列A+B)的demo
by(2, '[BYGRP].'); 添加字面高亮(2字表示)。 BYGRP{vgbl}共5x4种基础颜色
by(5, {metaROW:0}); 添加函数上文，重复时只留最外层
by(3, '\r3\r-3'); 选区增删。\r开头即删掉llo一词，并显示 'he \xBB' 以指示当前区间和光标

s.env: 为动态作用域。当文本指代相同变量时，替换为第一个 DOM Text
s.fun(id,kv?); s.ret.pop(); 维护def或{}命名空间
s.var(); 注意，函数统一为 [body, args, void 0, locals, {kw}] 格式
s.exp('-', args): 创建(赋值)调用。在PahQL结果上可以 .As({'-':({k,v})=>v }) 或 .AST({}) 转换

ast:
s.inHole().As() 编译时快照候选值， ho.As(u=>u+1) 单向绑定， inHole((A,B)=>A+B) 可多路监听候选
PahQL提供 eatDef=(s,at二参数)=>at.ret(自动重解析) 的简写。在QL里，会将exp调用加入最近的 s.fun('-forif'?, 静态attrs?) 基本块，但无视 [/:/, s=>的值]，需通过eatSym()(s)手动组合递归返回
调用约定为 -return等语法 --forif等块 /全局调用 ->具名函数值 。s.fun('-for') 后可能要调用 s.ret.push()

code[ontruncate,text-spans] 在全局更新时应检查 s.by{.errs .body} ，你要在此对 `"正在插入 \" 哦", /**/` 等读时断尾/读后有余的input单独容错
.sloc 可以在def节点保存报错位置
.scmPutback[''] 基于行首/变量名来匹配def内的注释, unparse时缩进 ['\nindent']='2 '
基本块(span.def)在被增量splice 后，会聚焦其id，方便简单遍历.body时做剪枝。
REPL和补齐需要在input不完整，或含'wtf.\xBB'时做print(PS1)或 .show(elems) 提示
二进制input，无需Bisect！直接解析引用: new Blob([bytes, [嵌套的struct数组], bytes]) ，unparse时flat()“序列化”输出

#post #bin #os lib.so是库对象？是C模块？ 谈谈纯函数、全局表容器、Worker线程模型

随着React的火热，大家应该都听说过「纯」函数式编程(#FP) 这个规范了。纯意味着不更改变量和外部状态（例如stdIO），但它和 .c 的ABI(.o 和最终输出的 .so) 有啥关系呢？😅

在点出关联之前，我要发表一段很典的评论： 90%的PFer不懂FP。 考虑一个 node &>/dev/null any.js 的环境，简单的 "log IO" 真的是“不纯的代码”吗？ 请注意，stdout没法回环到原进程。

pure fun 一词，不是说把所有 loop variant 存在栈上跳来跳去(伪递归tailrec)，或是做 全局深拷贝+顺序执行转隐式this调用链("Monad") 的文字游戏就纯。
Haskell? 若要论“如何处理所有调用以 make dev happy”，Promise才是多任务届的顶流，CPS捕获栈帧闭包、捕获回调也不算什么。

😒让我们重新 interface 纯函数: 不得破坏全局状态(可以复用执行容器); 默认单赋值(状态树集中，CPU缓存友好); 限制变量树的深层 &mut (即，值类型，==就是equals，根本不需要“地址相等”来优化Map.get，禁止地址)

换句话说， def y(x): n=x*2; n=n+1; OK(n) 等效于是纯的，因为等号对变量的修改可以inline(n=2x+1) ，甚至 id=setTimeout(继续,1s) 也是纯的，因为每个app拿到的id并不会互相影响， random()>0.5 也是纯的，因为随机seed能被进程级重放…… 让我们用本质而非「字面形式」理解这些新概念(yinwang.org ...)😅

当然啦，用 chkstk=(n, r=0)=>(n==0)? r : chkstk(n-1, r+1) 代替含糊不纯的 for(r=0; n!=0; n--,r++){} 在理论上很赞（哪怕是死递归，都比随手卡死调用栈 or libuv 的while(1)可控，因为有闭包！）
用 n=ref(0) 取代 mut n=0; 就更定义式了。它是真的数学组合器(n=1 vs 1=n, 代码也能有交换律)，巨适合UI框架，能消除不少对可变量的需要。
但咱不在这里对 #FP 大做文章了。综上，FP没Reacter们想的那么抽象，到处加memo和freeze，它才是OOP的另一半或后继。
#AI锐评 https://x.com/i/grok/share/KlHa2s9CLU2VwnLH8kS3HvFnt

大家应该没听说过 .c 编译产生的 .o ELF 是什么结构。好，我们看看：

`file /lib/libcurl.so*`
/lib/libcurl.so.4.8.0: ELF 64-bit LSB shared object, dynamically linked
`readelf -Sh $_ |tbl-hl 'text=代码;rodata=字面量;bss=mut全局;data =val全局;dynsym=dlopen函数链接;'`

注意， PROGBITS 代表这一个Segment是系统级单实例的，仅存的 .bss:NOBITS 会在库构造器里'\x00' malloc，剩下的都被C虚拟机无视，只用于 gcc,gdb,pref 除错。
AI展开： https://x.com/i/grok/share/jyixQkW0SNiIKtpGboy5LFUsG#:~:text=Linux%20动态%20PIE%20进程执行的绝对核心，
中科大真人快打： https://lug.ustc.edu.cn/wiki/user/boj/linkers-and-loaders/#38-目标文件中的数据结构

#tool 高亮注释
`tbl-hl() { sed -E "$(sed -E 's|([^=]+)=([^;]*);|s/\1/\x1b[38;5;208m\1\x1b[0m(\2)/g;|g;' <<<$1)"; `

lib.so是库对象？是C模块？ 这里就有了答案： .bss.size==0 and .tls线程局部==null 时是模块，否则模块也是新对象，和 __import__('numpy').sys.argv 一样。😝

点题了：如果你没绞尽脑汁的尝试把32G的游戏塞进8G内存里，这个区分确实很难理解。 但能理解\=能实现。

先说回libc生态。系统级单实例，0拷贝或CoW缓存，听起来很快！ Web Workers 和 Rust 线程模型也都基于此。

它们使用 post_onMessage队列 + SHM共享状态(SharedArrayBuf) 多线程互调，性能和安全兼顾，有3大好处

1. 顺应http微服务、Docker容器化的潮流，通过给消息id注册回调，即可实现+1CPU的请求响应或+N的计算集群，比pthread.join高到不知哪里去了😒
2. 每个线程都是变量隔离、代码共享的，不存在 @ThreadLocal 这类需求，无关于多线程、IPC、RPC，一次部署到处调用
3. 因为不隔离内存段，Worker进程间的协议非常好写且快 (aka. Actor模型)

但1个诅咒就足以让大家敬而远之了：

首先，共享运行时依赖树，并不能提升首屏速度，冷启动并非代码的瓶颈(除非 import jieba 等极端个例)。
而 py,js,lua,java,rb,... 包括它们依赖的DLL，这么多代码，怎么可能不做进程沙盒呢？

C 的模块和线程模型是脏的，不纯的，就像一开始没有提供HTML模板${}转义的PHP，也就像一开始没划分 ES Modules 的js。
让lib.so学习Worker，全局单实例，这不是处理 segfault，it sets your house on fire。 Vue服务端跨域请求污染如此，上文 setTimeout() 的id真的不隔离，又如何呢？😱

Shared Objects, 无疑是理想的，但真正能服务于系统上的所有App时，却需要一个函数白名单。
HTTP GET 其实就是纯函数的概念：它不改变状态，哪个源调用都能共享全局的cookie， 但是，就连tg大牛的BotAPI都破坏了这个约定。

从操作系统的职责看，真的需要跨源共享模块时，复制独立的 JSContext() 等全局环境或许不可避免，但可以用进程快照实现热替换；另一方面，编程语言也要接纳“默认final/const”的设定，而不是在(深拷贝vs浅拷贝)的鱼和熊掌上打折扣。

纯函数，更需要「化堵为疏」，就像OOP用this替代全局那样，去demo，并解决模块全局的开发体验痛点， 而不应将 Functional Programming 当神教或“银弹”去崇拜吧 ？😅

#huawei #dev https://x.com/i/grok/share/0HQMPNpuUgLIAliXKVRe2VW6M #plt 仓颉 过程宏

4大 IO demo: EchoArgs(针对表单元素), Counter, Checklist_with_Deadline, ForkJoinWalkDirs

重新预期了一下一年前的蛤为版 React #ts （Stage模型😅）， grok 给的代码还不错，说明框架质量和 Vue SFC/Compose 平级，砸钱投资，还是获得了人才的回报（比几年前 滥竽充数的抽象行为 好多了）😅

从 "DCORS" (Data, Content format, Operations, Resources and Styles) 的组合角度来看，ArkTS 推的写法语序是 "CSO;D 独立D类型(@State)"，相较于H5的 "SC;DO" 还是长进不小，
像 Div(){AddChild()}.color(RED).onClick(()=> thisStruct.str.show())
像 TextInput({placeholder:"模拟H5 tags"}).onChange((s)=> this.str=s)

明显是为了 Tag(){} .cssXX.onYY 的Tab补齐做了优化，但其实补齐位置很多的，不必全靠调用链啊…… style 的外提和模块化也成了问题，安卓XML反而没这个缺口。
😅： Compose 作为 Declarative 编程风格的应用，可以说不可能比XML差。 你看 HomoOS 不是解决了此问题么

学习H5，静态化js那一套是正确的方向，但华为在生态方面有咕狗那样的开放心态吗？ 语言和框架只能是鸿蒙的专利？

MDUI.org/docs 设计语言，是全平台的， Flutter.dev 和 Chrome PWA/Electron 这些，更不是局限于安卓自家可用。
即便代码质量可以配得上是「在2023年做好技术选型」的SDK，吸引不到dev入驻，或是拿钱买数据，没有DX和客户粘性，有什么好预期呢？

其实“新”平台SDK比较适合的战略就是，通过优秀的系统兼容性或自动化refactor工具，甚至是靠方法论层次的“侵略性开源贡献”，从 DOM/CSS、android.view、WPF 这些老东西那边偷Devs，另一边，自家的工具也要易学好用： 文档自己是demo，代码自注释，免费云资源😒…… 这方面还有改进空间。

ps. 蛤为家的MVVM比较奇特的点是把 div,p 含糊的堆叠方向搞成 Column纵向, Row([横,向]) 这种中文语境更含糊的了……

#AI锐评 如何创建新平台生态 😝

https://x.com/Cangjie_Lang/status/1950850660573798814 😅
https://aliftrs.github.io/cangjietutorial.io/#:~:text=Match%20expressions #learn

.cj过程宏 比起Rust好太多了…… 也不像从Zig抄的 ，但是，还是不好生成 a=[f(1),f(2),..]; a[i]=f(i) 这样的东西吧（宏的卫生性.. ES6 Symbol().. 其实这是相当简单的问题）

仓颉嘛…… 其实抛开 #kt 来看是好的，但结合起来看，就有“汉芯事件”或“木兰 muLang 编程语言” 那种山寨感了。 说的要支持 py java lua/C FFI 也不知道咋用。

如果对这个领域没什么自己的见解，只是为了「自主可控」，最好还是不要通过混合几个别家的范式来起家罢……😅

不过，新东西总是好的。 对蛤为在编译原理领域投资成果感兴趣的可以来学学，尤其是对 Kotlin+Rust 的老前端友好……
比起 moonbitlang.cn ，.cj 的好处是更简单

#design #dev 从认知心理学看代码可读性
2025-10-15
……
比如：直接去处理这些状态转换会很复杂（高内在负荷）。但如果引入"状态机"这个概念来理解，问题就清晰多了。
虽然学习"状态机"需要一些时间（理解难度），但理解问题本身变简单了（内在负荷降低）。这就是好的抽象的价值😝

为什么设计模式有价值：它们提供理解复杂问题的"心智模型"，降低问题的内在复杂度。比如 Observer 模式让"多对多的依赖关系"变得容易理解。领域驱动设计（DDD）的价值也在这里：找到合适的领域抽象，让复杂的业务逻辑从"一团乱麻"变成"清晰的概念组合"，有对代码可读性的贡献。

我们就能明白什么是好抽象，什么是过度抽象。好抽象是降低的内在负荷大于引入的理解难度，总认知负荷降低了。反之，比如把简单的 5 行代码拆成 3 个函数需要跳来跳去才能理解，为了"可扩展性"引入根本用不到的复杂设计模式

认知心理学的一个有趣的发现是 Miller’s Law（7±2 法则），它告诉我们：人的工作记忆容量有限，一次只能处理 5-9 个信息单元。

为什么要拆分函数，为什么要封装类？
它们的作用就是信息压缩，把占用多个工作记忆单元的信息压缩成 1 个信息单元，显著减少工作记忆占用。

命名为什么如此重要？当命名足够准确时，我们只要看到变量名或者函数名就能直接判断它的行为，这样可以做到完全不占用工作记忆。

不要使用过深的嵌套。这是因为在阅读过程中每进入一层嵌套时，外层的信息作为 context 需要保存在工作记忆中，嵌套过深很容易导致工作记忆不够用。而 early return 模式能很好的解决这个问题

工作记忆有点像 CPU 的寄存器：容量很小，但处理速度很快。而长期记忆更像硬盘：容量大，但访问速度慢。读代码时，我们主要依赖工作记忆来理解逻辑，如果工作记忆装不下，就得频繁去"硬盘"（长期记忆）里翻找之前看过的内容，效率就低了。

读代码时，我们需要在脑海中记住：变量的值、状态、分支条件、上下文等。如果超过了工作记忆容量，就会忘记前面的内容，需要回头翻看，思维流程被打断，理解效率急剧下降。

这法则可以用来解释许多常见的代码编写规范。

…… ——https://disksing.com/cognitive-code-readability/

ps. 我不赞成作者说的
if (result1 := validate(data1)).Error: return result1.Error
不符合DRY但可以接受。 他的例子维度不对😒，比如kt没有异常自动冒泡，也可以写 validate(data1)!! ，这就叫做买一送一，重构做到底。

另外，这个作者自己自创术语说的也挺多的，各种“负荷”给我绕晕了，最后看来是(成本<效益)的问题，疑似没有结合自己的文章意图来整理自己的文字……🤪

#post #learn 当我们谈“无需同步”时，是谁在哪里异步？
#锐评 https://www.manjusaka.blog/posts/2017/06/07/some-note-for-asyncio/#1-4-async-await

（接下来又双是暴论时间了。我希望这是我最后一篇讲单线多任务的po，不区分pyjskt等卡线程or单线多路IO实现，也不谈goroutine这些商业术语）

“耦新客async” 也是咱们三番五次批注过的“新”技术了：软件只要从bash或curl那边一次性拿不完参数，比如要在按键事件时反复计算输出，多少沾点异步。
在实践上，异步调用不与当前线程同步，它会post到另一个线上，完成后再onmessage回来，因此async总是与「事件监听器或回调链表」绑定，如 get(A=>eat(A, B=> 我吃掉了B)) 本应为 A=get; "我吃掉了${eat(A)}"

不过…… “第二次计算”却不是异步编程的特征： CtrlC->SIGINT 信号也算“事件-重新计算”(只不过SIG们受pthread而非H5支持)，它甚至能中断 while(true)，但却不是App开发里常说的并发、非阻塞。

之所以异步，是因为「回应用户点击的UI线程」怕被sleep或curl“卡死”，这等于是说 UIUX/http 框架如同REPL的循环，一“山”不容二虎。
是框架与你可能死循环的代码间要“异步”，即 [回应式编程reactive]：

正本清源，“异步”一词是从“音画不同步”的情景延伸而来。
设想一下，声音和画面有时会各自卡顿，为什么不是“播放1s音频，再播放60帧视频”？ 因为音画处于不同的「IO上文」，mp3数据包有着独立的分块和顺序。画面卡顿，不意味着耳机要破音了，这就是多线程的好处：不是让程序变快了，而是让“等待的时间”不再浪费！

线程即调用堆叠，基础是帧；就像数据包或“自黏便签”，它也有后续（黏在return后的包）
只要从代码树里消除靠死循环监测的事件处理，就能拥有线程无关的，干净的多任务模型（async: migrate from poll to push）
这“自黏便签”可以传入、可以组合、可以排队、可以取消…… 高并发就是玩这张纸的花样。

就像在肯德基，从“排队取餐”，变成直接返回取餐牌，“好了叫你”。 这当然不是说Queue就不存在了，只是从人来等，变成让「不会暴躁的取餐牌」来等！

没有REPL式的监测循环，你的代码就没机会“第二次计算”，但异步是比"onClick(注册)"更基础的技术。Java的override可以模拟事件，但它很难“异步”（即保证单线程，却不担心被某个while(1)卡死）。
别阻塞，阻塞会让Linux来帮你「分时复用」CPU的算力，引入IO上文的切换开销！😒

那这就值得让 sleep 1; echo 变得很麻烦？ 通哥会拿烧饼摊和顾客队做对比，老六要畅谈纯函数式编程的IO类型和 f"map"，张友人觉得 async def 只是 def: yield 的语法糖啊！JVM是已经选择了 Thread.ofVirtual(用户态线程aka有栈协程) 来阻隔await的传染性。

但最贴切的，还是JS： new Promise(ok=>创建延时(ok, 1000ms)) 结合 Promise.all([3~1].map(i=>{delay(i*1s); echo(i)})).then(进程退出) 不变应万变。

# 异步的单位一
没错！「异步的最小单位是任务对象」，无论回调、协程、yield，甚至多进程/RPC，本质都是对新任务对象的「超链接与组合」。 它们模仿的是 赋值+跳入+赋值+返回的[栈stack]，即线程aka调用层叠。

为何框架与 sleep 1; 过不去？因为它作为 new alarm(now+1s) 时更快！
但根据栈的ABI，C语言sleep()时，进程容器与一段>4K的栈内存被卡死了、白嫖了。 除了SQL注入和segfault，C又做了另一个恶……

初学者通常以为，进程还是在执行 sleep() 的？ 错，而且这正是异步难以理解的原因。
sleep之于libc，就像setTimeout之于nodejs，它们是无法被polyfill的原语，而这类"系统调用"执行的时候，你加的代码是完全没有占CPU的。
进程在哪个Worker里计算，内存段在不在swap文件里，这都不是App开发者会考虑的问题，但又不可或缺。

或许你好奇过time命令为何不是几秒，而是3个数字，即 real=sys+user，那么现在就试试吧：

`time ruby -e 'p (1..1e7).sum'; time dd if=/dev/random of=/dev/null count=$((10**6)); time seq $((10**8)) | wc -l`

当你的电脑被卡死时，你会不自觉的去查手机，等待恢复，那么，你就必须记住回调(刊题留挨行)，记住方才「针对电脑的调用栈」。这时候，你就已经在做「内核时间的工作」：异步组装返回，线程间平行

电脑又是可以分屏的：假设有许多个窗口，时不时的卡死，这也不会影响到你任务单线的连贯性；而假设有多人分管多个窗口，你看视频卡，也不影响他们刷聊天的效率。 假如你就是Linux，你就能看懂这个故事了。

await 不止是“类型标记”一个函数，更是在提醒“它本来应该卡死你的进程，js帮你 time slice 掉了”，通过可以在([].push,Map.set) 中保持的[回调链表]

Linux被视为一个 device -> libuv poll 循环的的分时轮转工具，它的作用是给「多进程」的IO轮询喂数据； 从这个意义上，C语言 cat|head “奇妙的”当 `write(cat)调用-read(head)返回` ，管道和行缓冲，其实一门编程语言之内就能实现，不是靠它“多路投喂”。

只要能通过Worker容器隔离掉 while(1)，分片好 file buffer(靶扉填满-切换进程)、http Promise(Future)，1CPU应该只有1个“进程”，没有抢占 or “协作式让出”，抢占本就是C函数接口的副作用。

这就是协程，它可以实现 yield、await、await next(异步生成器)，但核心还是，节省C语言的线程、提供更规范的「多任务返回值数组」。

#术语表
访考栈 func call stack，考查CPU对一些题型的解算法，回填解值
靠拜客callbacks 需要以“拜客”提供的资源为解值，回拜一次为await，拜多次为Event
谙新客async 不使用js等语言的访考栈，通过new回调链表，允许非局部

待客deque, 记住Looper中已列队的函数，方便外部添加任务，无需等待当前函数完成
叩融听coroutine 轮询(polling)后触发多个监听，比如inotify文件变更和 import selector
刊题留挨行Continuation CPU对此题型需要新参数，await到不能再.then后，方可回填解值

https://gagalab.tech/2021/09/22/Chromium多进程模型/
Chrome还有这样的 云原生！ https://www.cnblogs.com/gurenyumao/p/14721035.html (https://peter.sh/experiments/chromium-command-line-switches/, https://github.com/Kapeli/cheatsheets/blob/master/cheatsheets/Chromium_Command_Line_Switches.rb)

#习题

1. 回答： 是什么代码？在哪里异步？
2. 哪些类型的软件包，做什么时，会卡死1个C调用栈？ 为何sleep()不影响C自己？😒
3. 在你擅长的SDK上实现setTimeout和(Promise.all)
4. 计算 `add(A(),B())` 时我们的语意仅仅是求和，其实无关于“调用栈”。😅
然而在 android.view 里A调用curl期间会假死，js里B获取confirm()会让模块之外的定时器暂停
这些都是对C语言IO上文的复用被击穿，导致副作用泄漏的恶果。 副作用还能干哪些坏事？ 阻塞调用的本质又是什么？
（提示：最简单的替代品 就是事物的本质）
5. 如果由你负责沙盒化pthreads并监测字节流IO等事件，你更亲近于 DOM,asyncio, 还是 gevent?
你又如何避免“1个def不返回，整个App假死”，或因跨线程对象被乱改，导致框架“真死”？🤪
（提示：这是libc的多任务模型引入的问题，先辈的罪）

#AI锐评 #os 操作系统成夕阳领域了？
https://chat.librechat.ai/share/vPc8MOKeU1yhUJCGIDZLd 又扯到CPS了！
https://x.com/i/grok/share/RKEHbVFriVHqaIfEaqSz3cNiv 😝

ps. 友链 ip.skk.moe/#从零重构，全新升级！ 七年无任何广告的IP/大厂CDN/RTC网桥测试 #tool

https://blog.cyyself.name/first-3-years-undergraduate/ #dalao #cs 微电子 😝

了解 SSL 算法
https://gist.github.com/muink/0765f90c98c0c1259de7 回顾 clowwindy #china

https://x.com/i/grok/share/MdfkapfsqM5iWSqi6oIFAW4E2

#ai 说的道理 😅 只要不需要带有主观色彩的问题…… 一般都答的很到位

想知道没有相关知识的小白问AI会有什么结果可以看看：
https://x.com/i/grok/share/RDTgkElWIeDCMDcZP32FJUhnL

感觉无愧于「大贤者」之名，实用但是也比较生硬…… 只是偶尔超过人类

你（UI线程）在餐厅点餐：
同步：你站在窗口等厨师做好菜 → 饿死
异步：你点完餐就去玩手机，厨师做好了喊你 → 正常生活

btw. 上一位游戏开发大佬的严选文章
https://disksing.com/understanding-rust-ownership/ #rust #learn

https://disksing.com/dry/ (我依旧不支持此文观点……)
https://disksing.com/programming-quotes/
https://disksing.com/go-composite/

#ce py3.14 线性解释器(C实现)的新优化😝

- Tail Call Interpreter 是py3.14优化字节码解释器（大 switch(int) {case opcodes..} ）的编译期优化，因为CPy跑def里的每条指令都有利用，PGO提速15% ，而且，perf现在能看单条opcode的开销了！

- [tailcail,兄弟调用] 就是跳转地址不在自身的 [tailrec,伪递归]。因为伪递归==改参数goto开头重来，而且，这种优化非常常见(相较于 [Computed Goto])，所以被 Ken Jin 君用于加速.pyc的执行。 而JVM在到JIT阈值前使用的技术，[bytecode template interpreter] 虽然依赖机器码拼接和mmap(..PROT_EXEC)，却能少一次分支预测😒，更具“科技感”

- 冷知识： gcc/llvm 有个非常抽象的操作，就是对于 switch(v){ case A: case B: ...} 这种「硬编码的函数指针dict」做查表优化(computed goto,共4大类)。 你可能预期switch是被弄成一堆 cmp;jEq (if goto)，但实际上，对于连续的码表它可以 O(1)，甚至二分查找，总之这种没有ABI，针对“编译期dict值”的「C++魔法」让人摸不着头脑 🤯。 试问写对应pass的人无疾邪？ 连组合复用和API化都不会写戈矛编译原理

- 冷知识： JS里可以用 trampoline 假装实现tco， 但从算法角度看，运行期用户态实现也是实现啊！

trampoline = f => (...a) => { let r = f(...a); while(r.call)r=r(); return r }
chkstk = trampoline(function dep(n, r=0){return n? (_=>dep(n-1, r+1)) : 0})

提示：基于Promise.then($_+1)也可以做到！🤪

将 case 拆分后， -O3 编译更不容易犯错。 在77年的一篇论文《Debunking the ‘Expensive Procedure Call’ Myth, or, Procedure Call Implementations Considered Harmful, or, Lambda: The Ultimate GOTO》就提到了，高效的过程调用可以和 Goto 性能相近，而在实现上会更简洁。

利用rip寄存器而不是goto回填有三好： 减少分支预测 fallback 的代价；指令缓存局部性上更优；减少了 cmp 指令的数量和ALU开销

> 这算是 3.14 中和 remote debug 一起并列为我最喜欢的两个feature，可观测性万岁！
Link: https://www.manjusaka.blog/posts/2025/07/02/tail-call-in-3-14-interpreter/#%E6%AD%A3%E6%96%87

#AI锐评 https://x.com/i/grok/share/9Z28EHsrA2R12IUldEG7pjpCD
🤬把我的讽刺理解为追捧LLVM大佬了😅 我也很喜欢可观测性的优化和算法！

#pingbk https://blog.reverberate.org/2021/04/21/musttail-efficient-interpreters.html , next_tagswitch, ABI开销(unlikely 等优化)

https://x.com/i/grok/share/vW8if393OgPDDWk5SgItJxCJC
#ai锐评 把4大IO demo 成8个了，我重新理了一下：
EchoArgs, Counterdown, Checklist_LiveSrch, Dirtree_MapReduce

ps. #statement #plt
https://www.30secondsofcode.org/js/s/math-expression-parser/ 是🤡么？我可算知道为啥写 #parser 牛逼了，这是在解决表达式问题，还是在给递归加虚拟机壳？

咱们用 RPN树状数组+PEG递归下降组合器时
既可以显示求值步骤，又没有损失在(+-*/)上继续组装语法的能力，也没这么快1k行代码啊，说实话是<30行 😓

你们看看，这叫经典学院派？这就是大学生比小学爱好者的长处所在？ yinwang.org 骂的对不对？？😅

ice1k 的那个“扫地僧学院派” 也不太行，总是说些让人不懂的话增加负担，其实trick背后的心智模型呢？它没有太小众，甚至不应该独立命名，这就自我限制了。 你们何必如此呢？
这点坏脾气yin也一直在吐槽，他也并不是没搞过PF和“组合数学”的那些鬼画符。 人的存量智商啊是有限的，必须开发新编程技巧来提高效率，才能发散智慧总量！ 😒

形式主义者总是想不透彻：如果你真的聪明，应该要么对trick不以为然，要么为了"just for fun"而鞠躬尽瘁，朝闻道夕死可矣…… 又如何会自觉聪明、谈吐出众、超凡脱俗？

如果比烂，我还是觉得经典学院派更误人子弟。虽然他们「桃李遍地」，但那不是 BNF(CFG),Lex+Yacc“机” 的功德或「有科学价值」的表现，而是有咱们这些上游应用！ 🤯

价值观扭曲到什么地步，才会把心智成本 × codebase的行数当成自己的“智商总量”与编程产出呢？ 小农思维害死人啊！

会磨刀算什么理论，会做菜才是思想的所在呢。 连菜系的hotspot都归纳不透彻，又如何去设计厨具呢？🤪
ps. 用 $$('code>.line') 数了下是460行…… 我是不是该道个歉？ 不过说起来，会写parser \= 能够设计出 CSS matcher 组合器这样有智慧的代码工具

#ai锐评 https://x.com/i/grok/share/Jk8XIKMjZH4IKRa1vUZMrBzTT

😅 我还没让Gemini来观望总结，但我发现， Grok Expert 不逗比，但他反而缺乏创造力和批判性思维 还很慢……
以后就不调这些参数了，就当帮看不懂原文的大家breakdown问几句吧，省时省力。