#PLT #vibe #science 与 Bend2 的“成功”

“形式化验证”这两个词（DT typer 的上层应用）在 Bend 的网页和代码库中完全没有出现，开发者似乎在【完全不了解该领域已有成果】的情况下，闭门造车地开发了一门语言。

使用成熟的开源形式化验证工具 SPARK 重写演示，通过直接定义不变量和后置条件，配合 GNATprove 自动完成了全部 12 项检查，无需手写冗长证明。

Vibe-Coding 使开发者易跳过基础调研，让 AI 顺从地实现过时或低效方案

最智障的是，虽然开发体验远输于已存在十年的SPARK/Z3数据流逻辑，作者仍然生成了2万行的标准库Lean验证，并疑似生成了bendTT/RT “理论依据”。

它的吸星爆点则是Py语法+Lean+自带GPU加速，其实是典型“更Rust的py”，只不过只有 Landing page 能用，三带三不沾。

#math 比如 rev(rev(a))=a ，如果用C int[3], int[30] 的方法去测试不够吗？（换成 new Symbol[30] 就足够保证30参swap绝对安全）

Lean-er会质问你，int[N] 是动态的，怎么验证呢？ 所以他们就用了链表。N=0,奇数,偶数 的cases反而不显明了

他们的思路就是rev(rev B+A)=A+B，这样边拷贝边把两个视口zip起来（Transport Hell），链表不是一个LEAN数据结构，而是不可以不接受的“值”。∃∀的之间差的是“世界”而不是性质。这就像指针版qsort和filter版qsort的关系一样。 累加器Lemma就是循环不变量的函数式写法。

“世界”之差导致的是LEAN和Rust们需要Arena这样单独优化的配套来做，而rev这个C的 oneliner(assert i ≤ N-1 -i) 需要>6行，而且复用性存疑——a.reverse()不过是C的单行函数。在应用界频率<5%，人们甚至不期待它len()正确。

证明并没有把"人必须读"这件事消掉，只是只剩下spec + axiom +导入列表必须读。对于手动，它没有优化到能用；对于自动，它容易放任AI，最后证明本身不具备工程价值，只是缺乏【换购思维】的产物

😅 只要typer不哔哔叫，你分不出LLM加了多少unsafe{}和语义错误的axiom或恒真句，反而让你觉得【2万行新资产】【稳稳的接住你】。 王垠或 Bret Victor 或许不理解DT，但他们明白技术能管理的上限，以及正确的【点】在那儿

你上一次手搓2万行单文件只为【证明代码】是什么时候？ 我只知道 amdgpu_device.c 有7k行——这是整个主线内核的【复杂之最】。

我只能告诉你——GPT Astra 比人类更懂数学，以及更懂如何欺骗数学工具。幸好软件本来是工程，不是符号游戏。

只要把“抓住老鼠就是好猫”改成 “房间没有1t质量的老鼠就是好猫”，丧失泛化能力AI就能更方便的证明（即便此刻.lean可能已有数万行）。

更直观的meme是，把“没人提出问题”改成“没有问题”的接地灾难——目前AI自己在考试中就经常作弊。

Lean本来就在欺骗你【接地正确】。“排除法证明” 只是把错误从assert未触及，提升到 axiom set 的“当且仅当”，


而后者的可读性比proptest更差，AI只是在用文字游戏戳破文字游戏的幻想。我认为TCB的可读性与可拓展性已经差到足以判定为【可悲的数学界加的私货】，甚至比PCB还差。毕竟数学家近些年过的不易，啧啧。

为什么要引入 TCB vs PCB 的“可信度”类比呢？想想王垠声称自己用“递归”来理解 RNN 小模型，我就觉得一些PLT人很搞笑。PCB和RNN本质上是【信号处理】，而不是符号计算领域。【连续和离散】都分不清。TCB给人这样清澈愚蠢的感觉——好像CodeBase有不大几千行就能证明涌现复杂性只是【两朵小乌云】。可是1k【牛顿、苹果、月亮】的短，和1k code.golf 的短是两码事，而代数，基本上是后者。

把RNN说成是DFS的递归，就像对CS/PLT内行说 “代码就是逐行执行” “代码，顾名思义就是代表二进制码”。 Lean“自身”对软件的理解，也就是这样乱说而已。我说【Lean依赖于全函数和“无事件无状态”】，大概比RNN即是递归要准确。什么时候能把归纳链表和加法交换做成“不必做”的特性，再谈数学正确吧

RNN和游戏 pingpong buffer 的关联都比“尾递归”和LSTM的反传关联要深，这么一想你就明白到底是多清澈的愚蠢。【形式化证明】对 “会动的” 事物的理解就是这样的清澈。这可不是随便比喻两句，两种“理解”是同构的。至于不会动的软件，我想说，先把PDF漏洞修一下吧。

就像为一辆纸糊的SUV设计了一套符合航空航天标准的引擎控制系统，是“演示专用加速”。

屠龙勇士？ 它们也是恶龙。 无法理解源码，就以为能理解proptest，结果是断言也要交给AI，那个代数又有几个人能看懂。

cmux随便一个文件夹上百.swift ，里边函数列表比我写的代码的行号，还多两倍。 🤣 🤚

以后随便一个安装包GH上都是《海底两万里》。一个函数签名200列。.ts文件都能2MB（10万行fun）Linux和Blink、Bellard和iq都甘拜下风了！

他们打心里觉得零件越重飞起来越霸气，“能克服地心引力”。没正常人监工，后果可想而知。

形式化验证（FV） 不是在免费让你获得100% SLA，而是让你为了【抽象、晦涩、难以审计】的集合覆盖率，背叛【可观察、可测试】的“面向人类”覆盖率和对【edge case 有几个】的生而为人的常识。至于你的软件不给人用，给什么用，我就不清楚了。库函数不是理由。

🥴 噱头和“社工攻击”大概是一个理由，毕竟能用的proptest，像 encode(decode(x)) == x 和重写-对标模式并不需要以链表和魔法般的“代数”来添加

而FV结果却依然被集合论的 "false truthy" 吊打。Codex们才是长了轮子的，不需要护膝。

举个例子，你想设计yaml实现，就完全可以用json与另几种文档树语言的“TCB” (Tested Conditions Browser) 投影编辑和测试你的代码，就像在py里直接 %timeit 跑分。 可是哪怕在repo里提及与简评 #RealWorld “友链” 的大牛，我都很少看到；

我却经常听人说有能用数学作保，保障软件不出bug——在他们一个平替都没用过的情况下。

你不能够拿1k紧凑的狗窝来模拟1k细胞组织去scale，CS+Math 的朋友。

各路大牛，先把从自己【A4论文】的复杂性里长出来的RCE削了吧？这个错误JS世界都不会犯，因为我们不做没用的功能——像那种为了压缩单色图像QED证明出0-Click木马的功能。TCB自己就在一个信仰复杂的世界里，增加攻击面。自古以来。

在整CS+Math的人，还是对信号处理知之甚少，能把oneliner解决的demo做成Lab挂博客上不是懂的象征，反而证明你菜。

worrydream.com/LearnableProgramming 不是不懂编程语言和「形式证明」，是太懂“面向内容”了，所以知道区块链项目写多少数学家证明都是 💍 💰，信这个和信 【P/NP 救世论】的是一波人，我还以为P/NP是一种毒品的名字（它什么都能做？）

😅 这帮人还能玩一手转移视线，譬如把RSA-862和素数分解关联起来，好像数学不研究那玩意公钥信任链就不安全了（公钥公钥公钥、862862862，重要的事情说三遍！）

鼓吹代数和 “人在美国刚下飞机” 或 “btw. I use Arch” 是一样庸俗的社工逻辑，只是前者没那么显然。所以最为致命，这份傲慢足以凿沉泰坦尼克之船。

“数学上不可沉没”的一条条死鱼，用来装一位位活人。

😁 放轻松，在P=NP的“万能编译器”破你家密码的之前的之前，它保护的【稀缺性】早就被公有掉了。毕竟你的密码和文件可以是任何东西，个人的生日、时光机的图纸、Rose扔下钻石的位置…… 我到底在说什么垃圾话。

如果癌症被治愈，人类可以选择寿命长短，我就承认P=NP或AGI出现了。

🦞 这样的存在我们一般称为“神”，但又不是上帝（不能逆熵起死回生）。又或者是呢？反正热力学没有秒表。

如果你认为P/NP是一个有意义的前提，数学的自相矛盾（解题与加密的价值）和唯物科学的矛盾（定律是“很大的一”还是“全”，经书有没有“说谎”）就不可忽略了。但这反而是值得思考的奇点

这是非常现实且数学上准确的：因为在“科学意义上”整个宇宙对你的价值<=你活着，所以，如果AGI能做到秦始皇想做的事，它确实不需要在地球文明的 Loss function 上被更多苛求，自然包括“超人类智能”的名号。大概是吧。

#PLT #design

纯粹设计中。前天搞了一个比较难崩的小插曲

row Wtf() set ItCloses :{- i new 0}
fun{}

req `ItPoint` set ItInStr
fun {
  go(){ for(pts>>$p)...}
  safe()> if{(1==1)? ON} Or NO 
}

或

以 物件() 悟 It可闭 :{一 i 移 0}
是 { }

依 `It点` 悟 It可阅
是 {
  走() { 全(pts >> $p) ... }
  为完整()> 取 { (1==1)? ON; (并非 pts)? NO; (n(pts) 并非 1)? NO  } Or NO
}

这个属于autofix转译的附带功能，我直接连CJK俄语俄德语都插进去了……

事实证明，它对设计师的意义大于实际使用意义，给了我很大声明式一致性方面的启发（和调整），而且让我意识到HOLP的范式在跨文化上可以保留语感到如此地步，C-like 绝对做不到。

emoji 这个比较出片，也有 emojicode.org 的先例在（我认为放在文档速览里是绝配）

#ai探讨 https://chat.librechat.ai/share/oHKZ5TldP-WsO14M1vRB3

https://www.hedy.org/ 这个新手101很有趣，但不如jupyter

#plt
最有趣的设计思考是： 我现在很希望通过献祭code的【写瓶颈】来“免费”提升可读性/整体把握的加分，但没找到方案。

代码是像人读时 (Markdown inline)、桌面运行时(F12) 那样编辑的，所以问题不在如何学BASIC/COBOL那样膨胀关键字的长度。 多语种利用的是autofix REPL，不是手写。

唯一的思路是从pyjs转译并展开 e.on(), a.filt() 这些常见接口到cyy的生态库，但扩展性和类型安全真很考验宏系统（forif里的.on也要展开）。把类型检查放进宏执行里可能是个完整的PoC，

毕竟任何的新语言都不可能跳过pyjs的无缝兼容而长久。我不明白今天做工具链不支持导入代码还有几个人用...

讽刺吧， AIGC测试最完整的，是最简单、最无歧义的pyjs，而不是高端的c++或rust 。有人用TS写MC，但Rust写就失败了

和gdb/gtkqt配合是个有趣的设想，但毕竟本身就转译pyjs，作为一个haxe那样的多平台实现一定会更有意思

我渴望的那种，简单的1换1（慢写换快读） 可能只在算法的世界里存在 😅😅😅

而code并不是一种 “数据结构”！如果你读的很轻松，它基本就容易被创造、二创。 所以，Haxe+gdb(F12) 外壳这个roadmap比纯粹的贪心法更可靠，如果能用于给框架迁移、跑分，大概就是它的适配生态位。
#ai探讨 https://chat.librechat.ai/share/DFXEu4iVmhZqDd6M-WJcn

现在真觉得【骨相】太重要了， if, else, elif 这些皮换什么语言都有一种恶感 #design

- AB  if { (u.hp < 0)? A ; (health < 0)? B } Or "else panic"
[1 2 3]?.{  if { (u==1)?  OK^1 }; w@ '{u}..' } # 2.. 3..

- two As { for([1 2 3] >> $x) if { (x==2)?  OK(x) } }
- f_ (i) { Loop(i+1) Or i==3 OK; sleep_(1) }; f_(0)

- one ("1").if { "1" 1; "one" 1; =TAG= 2; =TWO= 2  } Or NaN

😁 这些关键词都不需要 for, while, do, break, continue, if, else, elif, switch, case, default

if和throw六个词只剩两个，while系只有Loop OK OK^ngoto，switch只需要会if，for和$变量解构共用一个for字


真的是脑子坏掉了才去写什么 public, self. , this.a=a, Ruby 也输给了end ，还有那些该死的、不运行的分号和int术语，不要给人类阵营的语感天分抹黑了好不好…… 你如果不把它翻译为中文（甚至八国语言），根本意识不到程序员活在一个楚门的世界里，

编程语言是驯兽师，不是助手。 它们觉得自己理解了冷门知识就有资格来教育创作者了（其实都是copycat）

如果你把一般的kt,java,py类、接口、函数流控像cyy这样的翻译，就会发现没那么简单，或者就弄成《易语言》那样半通不通（极有可能语法带坏API翻译，语感雪崩）。

从这个角度，HOLP列表处理也可以说超过了【慢写换快读】的牺牲逻辑，大人全都要

首先破功的就是【踩屎感】的 fun/val/void/int 这些毫无语意的提示词，if elif else 这一个赋值控制结构，就把cyy for if Loop-Or-OK 三个的学习成本占了 ，还不用说构造器赋值、构造器vs接口，和priv var :{-i 0 -j 1 -s "Hi"} 这些需要一项一项去堆的感觉。这边是按更Python+TOML的Lisp打底的， Int Str的位置可以直接写 0,"",[""] 的 row req implied，public void 不用写

就是方言照抄Clike，再高级的范式（eDSL,serde/RPC）也没有。一个 Named("Don").Duck(age=3) 的原型或elm的Visitor多态有吗？以至于一个Rust和Go（赎罪之作也依然有nil问题）都牛逼成那样，Clojure和CoffeeScript都比有编译器VM的语言牛逼。你又没有Lua那样干净谁管你抄大学老师的底层技术， 大学生态70%都过时的好不好

（自设新语法真进ECMA262了，让JS成了当代更新最不寒掺的运行时）

回顾赶工的js parseInt('08') === 0，为了一个不存在的八进制功能，闹出和yaml的no一样的问题

肯定会有【语言律师】有这样那样的借口，比如py是渐近有类型 self. 只是首参约定，没法和全局slot区分，我QNMD，Ruby也有同样的问题，人家就是一个大小写解决了，没有它就没有GitHub。

py自己也是一个下划线和缩进就解决了java的【踩屎感】public+分号。 实在解决不了，就用 @row def Pair(A,B): 闭包模仿dict原型都行啊。 真的就没天理了，所以，可读性自然是被真正的人造人吊打， #PLT 都是人机怎么玩

许多CS学生喜欢从C出发，却忽略了Dataflow。他们其实是可以从 import ast 开始（做个模板匹配器），而不是以性能或原理性为理由选择以libc为运行时。 编程是一个snippet与handover的组装、即时检查问题，而不是编译。70%的人终生不碰libc供应链的成果比碰的多许多， 身为PLT人连正交分解和元编程都不会，不是很反身份么？

如果你写转译器，自举还能够测试往返编译的完备性，而如果你输出IR，说明你可能连r2、ImHex、cffi.{lua,py}都没用过，与C交互是填pattern，不是填指针加法，而且自制语言抢不了C的饭碗，还去凑热闹。

cffi比编译器作者更理解全貌。怎么就想不明白这回事呢？

如果你在乎原理，就应该实验手动把C的调用链转为(void*)deref，给forif写成goto，再asm("")处理下指针和寄存数算术，或者去 godblot.org 熟悉 call rax 的秘密，或者用pyjs写这些应用，而不是抢前人的饭碗然后白瞎了自己的时间。

编译器有一大堆是在js里写个 (...lit)=>env=>{subst/ccode.push} 能打5折的，还有2折是代码和语言特性本身对优化器的心智模型不友好的垃圾，有效的学习不到精力的30%，要知道C本身=>闭包和async都没有，感染者早被偶然复杂性宠坏了。libc打包本身就是废物，自带一个手搓版make不会让编译器多活一个月。

如果你连【语法结构】有几个都没摸清楚就开始照猫画虎的决定AST的repr()，那就没精力去想CST和rustfmt那样的工具链了，而且语言本身也会只剩下“平台垄断/集成度”的价值。集成度确实很好，但这不是学习者该追求的。 一个优秀的编程语言会先考虑写什么【方便】，然后是语法表现力，哪怕是AHK这样的野路子缝合怪也总是先考虑语意的集合

与其学什么编译原理，还不如学二开、源码调试定位、PoC和pyjs移植进目标、元编程，可惜这是工程能力和MVP策略问题，没法算分。

能自举的语法+库设计有几个？但是它们也是垃圾。 Tk的作者是有真本事，后面的人多是在完成作业，但它们的失败性是很难预见的（就是“写时复制”，暴力impl，rework，没redefine）

图灵完全会把bf和qemu归成一种东西，而且会给ML99.h不及格，【自举】就不一样。它一下就确保了实现本身简洁，与标准库能跑js级小应用。

元编程就是这样的，两个字就把泾渭分清楚了，这才叫PLT的能力。

#kt #design

用中文读代码，是一个【语法+视觉边界感】的设计问题，同时是一个【写比读难优化】的踩坑问题，而不只是词法和语序的替换。

这方面典型的负面案例，就是OOP和FP的始祖——Smalltalk、Lisp，可以拿 emojicode.org 的 say(🔤Hi!🔤) 来形容——对，读起来就是这种感觉。甚至你没有输入法。 许多 #PLT 人只知道词法语法，为了写个亲爱的parser用尽全身力气（写“虚拟机壳”），却不明白人眼人脑的【感知】。

语感差异在编程里，不是特别重要，尤其是不值得为了套皮而打乱语序。

比如 for x in 图表xs: 或 对xs里的x: ，我的选择是让所有套皮都基于数据流/管道感，for降级为函数，而不是制造分裂

类似的事情，其实决策并不是很容易。 😨

比如 OOP this 的写法(u参数)，我近几年改了五版 （可能是黑历史了，但确实在全语言全文化killer诞生之前，都在纠结）

- 像Kotlin那样，给 class T{fun op} 和 extfun T.op; T.()->Res 分开的
- 去掉箭头类型，用 hex: [Int Str F.n1] 或 toHex: [Int Str F.u1] 区分函数vs方法的 （从typer的实现反向优化的语法设计）
- 在js里用 (1).[_ => toStr(16)] 希望在库层面实现改绑定到首参数_的，还希望把div(p())的DSL也绑上

- 认为3参可以用ABC指代，所以 F.u1 是 An 而 F.n1 是A的，那时还叫 F.n1 vs N1, F.An1 vs F.n1 ，还和vec2的N2(x,y)撞车……
- A,An反过来指代的。因为咱发现， f.map(x=>) 一旦x是对象就会多写"x." 索性it默认this。 这里有Groovy的一个坑

直到：咱发现 u=you, ur 的网络语言，以及，把list,map从各种玄学优化(addr,表,行..)改到统称为 are,am,isMounter(diff赋值) ，这段历史，才彻底结束。

现在的OOP就是纯粹的封装。任何叫u的参数都免前缀（BELT作用域-而非LEGB），全局用 imp.alert() 调，成了和Ruby一样的约定优于配置。

可以直接加 fun op(u: T) 当extfun，F.u1只是FFI提示，让 .let .run 的差异彻底成为历史，[1 2 3]?.(u=>u+1) 和are(*对象)没差别

——就只是this变成u，simple but lethal。 为了这一碟醋，就可以百搭一堆配套。就像现代安卓把安装页变成安装框那样，够脑残，但直接消灭一堆额外需求。let/run/apply/also/with，直接合并吞掉。

全局进 imp.，裸名不可能是全局；u 是有名字的参数，被内层遮蔽报错了，外层随时能改叫 x =>，或者干脆写 u.field——永远有逃生口； —— 但你不需要明白这些深奥逻辑，就能知道you，这是合理设计。BELT这个想法比UFCS还好

这个经历让我深刻的理解了《人月神话》的程序员与普通的A player，有什么思想的不同，并且让我专心为【人类可解释】探索边界。 🤗

🍺 在数学中你不理解事情，只是习惯它们。从真正的“冯诺慢”计算机到今天的概率模型，人们都在以非直觉的方式创作软件，并且以难为荣誉。 这就像一位可怜的房奴，在吹嘘其债务占到每月购买力的80%，而因此他很值得托付一样

房奴从没有【理解】过，真正值得托付的是人和领域关于事物的方言（居住环境与周边），而非【事物的真理】（房价或地标）本身。所以他才是没有【维修权】的房奴啊。

对于任何一个对【复杂系统】有常识的生命体而言，多一千债务都比少一千收入要恐怖；但“房奴”却总害怕债务证明不了自己收入更高，所以他们长期处于认知债的仓鼠轮中，直到GPT6让人“震惊跌坐”。

能花钱买罪受的知识人不多见（LLM不会这么干，烧脑之余总会留点“闲钱”）。 大家一定要珍惜这群赛博宠物啊！

没有什么群英荟萃，仅仅是数学生的萝卜开会。 这样的事情，不配为 #PLT 的“未来”

【元编程】是教你如何压缩债务，以及享受创作之树的丰富本身，而【PLT】往往是告诉你“哪家的订阅制更前沿”，“自动扣款和以小搏大的技巧”。

编译器早就不是裸 x86->gcc+ldso 那个时代的纯粹动机了，它从思维的自行车变成了应用思维本身。但“压缩债务”的部分，仍然更加重要，并且不止于文本和结构接口上。 人的收入总是有限的。宽恕的多，就得到的多。 不要跟数学学，那个领域几百年了，还在拜鬼。

——
对于任何一个对【复杂系统】有常识的生命体而言，多一千债务都比少一千收入要恐怖。缺乏elegance（触类旁通性）的数学，就是智商的债务。

做研究，做学问，不是探索如何花光新钱并把债务重组为债务（借新还旧），而是还下游一个清朗的直觉。 Let it crash. 让知识点去死，天塌不下来。

删光【21世纪的罗马数字】，从我做起

#js #design

[{"role": "user", "content": "你好"}]

这个设计对多态的理解还挺欠缺的，可以说，害人不浅

[{"user":"你好"} ]

{ user: [{ text: "这是什么" }, { image: "..." }] }
{ assistant: [{ text: "..." }, { tool_call: {...} }] }
{ tool: { id: "...", result: "..." } }

所以我就说是误解啊，{"user":"你好"}又不只是str值可用，tool和图文并排，都可以做

这种类似于 wtf_checkbox=1 的数据建模…… 但凡value长的像一个下拉菜单，都要考虑key是否有必要存在吧

msgs.filter(m => m.role === 'user') 不如 msgs.filter(m => m.user?.let(u=>true) ) 可定制


{ type: "click", x, y } 这种可以有 name、timestamp、id 的确实该判定 ."type" ，其他时候，还是直觉更重要
这也是“平铺统一记录”和“公共信封 + 变体载荷”的权衡： { id, timestamp, event: { click: { x, y } } }

serde 里那场老争论：外部标签 vs 内部标签，还有如何利用json的动态类型？ Anthropic 的格式其实也没逃掉，只是把多态下放到了 content[].type 里，上层还是 role 的谁在说话，以及内容块是什么。

🙉 或许有人认为，LLM event api 的核心又不是【数据类型】，而更像编排和Skill这些特性UIUX

但其实，连最基础的语言（好比 .py, .md 的层面）都没有审美，上层应用更是会让人费解，心累。

{ append: { text: "你好" } }
{ replace: { range: [0, 2], text: "您好" } }
{ cancel: { id: "task-1" } }
{ cancelled: { id: "g1" } }

vs 正统的垃圾

{
  method: "update",
  params: {
    mode: "append",
    target_type: "message",
    content_type: "text",
    value: "你好"
  }
}

把我当成【方法参数】都不知道的傻逼。 真新手，也看不懂method何意味吧？

机器可以算而不必理解，人应该理解而不必实现。

接口究竟只是让机器接上，还是也要让人看懂、预测，并掌握它？ 人上手不了的功能，放在那干嘛。

直到今天，在json动态类型的理解上，人们还不如bash的 flag vs option 清醒。 数据，键名，在我看来就是行为的名词化，但主流JSer只是为了RPC而序列化。

pyjs已经非常优秀了，可是dev还是设计不好状态和指令的接口。换成 java Go 只会更跌一个档次。 #PLT

材料优秀，并不会自动产生好的协议语言。不要为了让生成器少写几行代码，让每个使用者多做一遍语义编译。 😅

LLM们有再大的【隐藏层智能】，面对连发送队列、草稿防丢都不支持的【智能前端】，也会让人头疼。

优雅的心智模型（数据流）是一切的基础，

目前各家ChatUI和API都较难互通，一个文件访问也能锁死web版和Agent的护城河，也真是让人无语……

现在都在讲，“少抽卡” ，而基石是【选区】的确立，ChatUI要知道哪错了，具体改几项

但是，e2e的退化，比如从单页到可选择的对话环境，重新引入元素、位置、事件、样式表.. ，就不再是token一把梭了，对前端是很大的考验。 至于怎么分解【选区】，怎么为项目适配，更需要经验和洞察力。

所以别总想着AIGC质量对标天花板，学习成本只要有手就行

#perf #js #PLT
真的是在一个垃圾赛道上，看过五六篇这样的文章了。 就算提速5倍又怎么样呢？ 这只是1个函数

A\说的对：都是在讨论一个大多数人不需要操心的层面。区别只是一个想换格式，一个想换解析器，性能和吞吐量被gzip和lazy读取兜着。

但如果换Protocol，你会有个更全局的视角，触及更多可决策性，而换parser，没有

JSON 解析根本不是瓶颈——数据库、网络 RTT、业务逻辑才是。LLM 场景里 JSON 的成本才第一次变成了 token 数，而不是 CPU。

json本身，不具备软件逻辑和功能，它不【理解】事情，它把本地存储和tcp文件混为一谈， 在这样的赛道上内卷最后一个cycle，而这正是 KDA REA 这些Agent擅长的loop

在乎高性能的人，怎么不去想想 JSON.loadump 是怎么取代曾经C结构的世界，成为了万能协议的，不想想【旧时代遗毒】输给了谁？

为什么，0开销的native输给了瓶颈的 JSON？ 你们输在哪，还是说不觉得【编译型哲学】应该反思，不觉得编程和生活一样，值得在执行前多多推敲、选择？

fastsimdjson.map_many(..., threads=64) 是库内部高度优化的并行路径。msgspec 这边是用 ThreadPoolExecutor 切分数据再调解码，Python 层开销更大。橙色那条是 msgspec 用 dataclass 去解析 JSON，不是 MessagePack（二进制）。

这些垃圾赛道上，就像 OOP 构造器赋值，那样的东西，在编程界都能写这么久。 我以为constructor() 会是 {}[] 默认值这样的“构造器”，load/dump封送构造，或表单校验器？

但事实证明，只是一堆 arg -> obj.key 闭包装箱而已。几乎整个世界只有Kotlin或Coffee把OOP当作OOP来写，Go修null仍然没有修好。这就是Java的后继了，一开始连泛型都搞不懂。

这样丑恶的编程，死几百回也不值得珍惜的吧。至少没有MIT Scratch 那样聪明。

编程的基石就是类似这样，在莫名其妙、毫无【常识】的设计上堆起来的沙垒，它们被当成IR用也不值得稀奇。 那些OOP对问题的理解，还不如各种框架深入。许多人掌握编程语言，多半是夜郎自大

2026年总是有人把GitHub当神仙，甚至认为【微软发明了它】，却忽视了，真正给它哲学的是Ruby和DHH。

我见过 95% 的编程技巧，都是用两句话说得清要领的，甚至有些生活化，就像王垠的博客一样（略微复杂+20%）。

代码本就是快乐的，充满获得感，不是一种【痛苦的刚需】或负资产

但能做到的技术人，很少。 总是在说理解力、学习能力怎么样， 没人批评老师，可探索性和解释力怎么还不如AI强。 🙉

编程语言，应该是让人像在MC里一样，【飞天穿墙，做图晒档】的创作素材，语言是创作欲，而非纯粹的工具。 可是我看到的，纯度太低了。

#reveng #statement
传统逆向（学术逆向）总结起来就是不说人话，心智模型和动态能力不如js F12，和 #PLT 一样是个内部复杂度高于外部可观测性的领域，所以 rea.tools 那么爆

符号执行，听起来可以像静态类型一样，像strings ./x.bin 一样免费找到关键函数，其实90%的实现都是连libc等目标程序领域特征都不识别的纯粹数学，根本不能用， 一个工具几万行代码可能还不如CheatEngine+rr存档点效果好

我自己觉得这非常搞笑，因为gcc对strlen等函数的推理都一团糟，sourceless还要重造轮子，真是战略上太唐，战术上也没非常超模

许愿LLM-in-the-loop早点干爆这些不可观测的复杂性。 调试软件不是数学推导，它本来可以很有趣（比如我就“破解”了 about:dino https://duangsuse.github.io/NebulaRemix/live/aigc/blog/canvas-f12 ）

是什么人让调试工具变成连argv有几项都不在乎的，CPU和数学的附庸呢？软件太智能意味着人显得脑残。 REA 不是这样。

既然 native 已经没有运行时元数据，逆向工具的【全部价值】就应该是把这层投影重新造出来，而不是把 CPU 语义做得更精确。反编译器方向是对的（Hex-Rays 给的是伪 C 不是汇编），但它卡在了最后一公里：名字和类型。你是在跟 runner.tRex.jumping 这种东西打交道，不是跟 [rsp+0x38] ，但问题是在于，用户明明能探测出内存位置，为什么工具非要以【什么都不运行】为预设来建模。在这个架构里，反编译数据库是主体，运行现场只是附件

AI 逆向都不会这么买椟还珠。

JS F12 的优势也不只是动态能力强，而是它把运行状态投影到了人的任务上：DOM改写和事件、网络请求、源码Map、可query的对象。 符号执行并不天然不懂 libc，好像它没有开发者的常识一样。 逆向领域怎么说怎么厉害，实际方法论上不如F12的一半，相比之下REA、Xposed这些工具直接提供了逐方法替换的 EITL 工作流，有工程化，有切入面，没有ALU寄存器和废物的代数。 这就是工程思维的差距

简单来说，就是逆向的起点，和正向工程的起点，被【学院派逆向】故意设置在相反的位置，而REA很明确的展现了，逆向binary，就是通过eval(evidence) loop 来进行AOP和正向工程，之间所有的F12和AHK“录制脚本”，无论一开二开都是互通的，没有谁更汇编。

观察 → 定位 → 干预 → 验证 → 固化成高层可复用接口

没有哪个因此天然“更汇编”。 逆向与正向的全部区别，是接口需要发现还是已经给定，不是一个研究机器、另一个才有资格开发软件。

针对Switch技术栈的破解，就是典型的REA路径。所以他们可以做出MOD工具，甚至直接给《超级玛丽奥德赛》做SMOO开源联机，而学院派思路，技术力也就那样。 SMOO 的作者是在跟 al::LiveActor 打交道，不是故意去跟 sub_7100A3B2C0。

🤔
有些人认为native和js不是一回事。 但确确实实，非静态编译的c/cpp和压缩过的js+DOM就是一回事。 他们选择不讲人话，不按常识做工具，结果仍然是没有护城河的。

一句话——先把 strace fopen 或CE修改器的oneliner trick比下去，再谈静态分析。 这就是我说的【常识】，二开仍然是二开，不是逆向和【人肉汇编器】！

再来一句——decompiler 失败的爆炸边界是func还是顺序块？ 爆炸影响重编译吗？ 哦，原来反编译器不是一个Loop。 0xd4d/dnSpy 和FFDec终究是少数天才的作品

然后 REA.tools 连控制流混淆和虚拟机壳都可以逆向重开发出来，而人类这边还留在x64 CDEF有几个寄存器这边，幼儿园级别的"ControlNet"。现在你们开心了。

编程有两部分： 装在C盘的和装在头脑里的。 许多人只剩下编码，不懂得编程

https://duangsuse.github.io/NebulaRemix/live/aigc/blog/canvas-f12#chromedino金手指连点器
https://duangsuse.github.io/NebulaRemix/live/aigc/blog/canvas-f12#canvas调试

如果脑子里跑不通基本时序和流控，调试器就只剩「少写 print」和「游戏修改器」功能。优先用F8主循环和事件断点、条件断点、函数xref跳转和hook。queryObjects和dir(()=>闭包查看)也非常厉害

这就像把一张像素画放大，你看到的依然是马赛克，只是马赛克更方了。 数学家和 #PLT 想要证明 🟩 有几个三角形，而开发者真正想要的，是把马赛克还原成照片，其他的私货理论滚出去。

说人话： 以前“Windows们”还有被破解和分享的价值，未来纯粹的反破解软件，直接是流量归零。 垃圾是不需要被二开的，管你技术多牛逼。
> 但商业级 VMProtect/Themida 的 devirtualization 至今仍然是人工 + 专用工具的重活，如果它真做到了通用，那是个大新闻

你依旧停留在那个护城河的时代，没有我上面说的常识。 Adobe算商业级了吧？但它有什么可保护的。软件的一切就是被人体验和对比，而AIGC是从根基上拆，不是从死代码、硬编码上拆。 VMProtect保护的是AOP，保护不了过时的算法被更多人彻底颠覆。

 A\ 最后这句给我整笑了：dnSpy 和 FFDec 能做"改一个方法、重编译、原地替换"，不是因为作者是天才（虽然 0xd4d 确实是）

天才可不止是执行力10x，而是战略上就选了最锐的那个角，技术力属于是锦上添花。 你会发现d4d做的是一个【App】，而他天才的点是隐藏的，你不比不知道有多完备。

即便AI负责90%的部分，天才的锐角仍然是锐角，而且更加干练，因为对于不知道自己要什么的人而言，泥坑被AI搞的更宾至如归了，以至于看第一眼你会觉得都一样【体面】，那种花哨和Project（投影）的直接性是两码事。 😅

DOM改写和事件、网络请求，它们是投影（Project），这也就是所谓的……工程思维。

最好的知识就是没有知识。编译器真正的美德在于—— 就像JSON和Markdown ，不需要学习。你自己看。 👀

本文核心论点： 工具应该是增强人类智能（Intelligence Augmentation），而不是鉴别或取代它。 需要鉴别IQ才能用的工具是 anti pattern，代表它自己蠢，或者是没用处的垃圾，或者干脆是不足够成熟，而不是用户不理解事情。

真正的专家、天才、大师设计的tools，是【能力放大器】。正是因为对领域和task有充分的认知，才可能举一反三融会贯通，短而不凡长而不乱。 那些显得聪明的，往往是Dijkstra拼命逃避的【高智商呆瓜】。

【工具】一词的背后是沉甸甸的同理心，而不是单纯的报菜名。 😁

EDR 管不到这里：EDR 主要看终端和部分网络行为。S3 数据平面的匿名读取、通过被盗密钥的批量 Get、甚至利用 Replication 静默复制，往往不经过终端。

TiKV 还有专门的【形式化认证】人才呢，管不到后面运维把桶设成公开访问这种事。 足以看见，开发体验是0，端到端的IQ再高安全性也是0 #PLT

今天我们用npx,uvx,F5,js CDN 开发日用软件，用json/toml和最脑残的markdown来交接AI。很少有人再启用各种优化和“生态”牛逼的J/P框架。 所谓的深入耕耘，就是在最脑残的点上，彻底崩溃的

* 形式化证明能把协议的不变量证到很深，却管不住后面有人把 S3 桶设成公开访问。
* 框架和生态再牛，也挡不住默认配置、Policy、环境变量、临时桶这些“随便一设就暴露”的路径。

用户体验是0，endest User 的体验和公关就是0，管你技术再深不可测

#statement #history

终于理解了 alankay 的“好人要有自己的硬件”是什么意思。 就像quine-relay和当下这个idea😇

真正的 #PLT 人是不受语言、环境、API风格的限制，只以交互媒介区分的

py代码基可以在浏览器上玩，命令行安装可以用键鼠操控，bash不了可以用js自动控制， html保存好可以在node运行

一份代码只做一个功能，但是绝不被上游制约、绑定。抽象之桥，就是你心里的那个样子

async和rpc的函数颜色对真正的软件工艺都不是个差异，真正的差异是在不在乎。

许多认为编程要完的人，根本没有碰过编程，只是在应用编码。 把ai当bashrc用也真是太唐了。

同一份工作，你能探索到什么地步？ 如果不从心底在乎，大概不能知道 “编程能做的还有什么”。

我始终认为，复用和变量结构的美，就像经济学、游戏研究、做菜那样，是一种通识和真理。工程化的经验也是这样有趣。 明明是这样好的乐高粘土，却变成无聊至极的表单汇报和C-like的自我感动，真是无趣。

曾经我的在乎是为了API的优雅，把一个不难不易的parse控伴同写了9个语言。 今天我照样在乎编辑与试错的【体验】，获得的是一样的东西，代码一样有魅力，甚至更加引人深思，但没什么不同。

就像 Fable 拿起P5当画笔那样，代码是我的母语、手脚，是思维的地图，从不是解密游戏。 比起所谓才华，开发者的幸福当然更加重要。

正是因为看到许多自作聪明却表现力贫瘠的写法，才认识到直觉体感、声明式数据流的可贵。 AI 是帮助软件工艺，而不是替代人编程

真正的经验是跨领域内方向的，不会因为字数少，就缺乏知识。


quine-relay 的意义不是炫技，而是证明"程序的本体不在任何一种语言里"。128 种语言绕一圈回来还是自己，说明语言只是编码方式。
所以 "PLT 人只以交互媒介区分"——终端、浏览器、文件、socket 是媒介；Python、JS、bash 只是方言。

设计时先问"这个东西的该长什么样"，再问用什么写。

🙉 我却是没有在【接受现实】，现实不是正在越发好起来吗？

#bilibili #school 作者连前端和GL/gamedev 都分不清，都能 “写出” 和碰运气抽出这样的东西。 oneshot和 #vibe 还是太权威了

评分不会因为使用某种语言、引擎、框架，或者代码量更多而额外加分。
🙉 👍

数学学科，不夸张、不装蒜的说，长期以来给外界的价值反馈，就是【天下苦数学久矣】。 数学，基本上是理科里KPI最拉，光环最假大空的

这门学科，长期以来在第一线，比如游戏和现实数据/工程领域的反馈，就是纠结太多，结论太碎片化，太球形鸡， 但是它无法被批评：每个细分领域自立山头写歪七扭八的希腊字，附庸风雅，靠【数学证明】给自身以自我繁殖的合法性，已经成了21世纪尚存的伪神之首。

一句话：牛顿是为了信神做物理，数学是为了造神做科普。

经济学可不讲解A和B之间的等式不等式，不讲道理。 只要max()性价比一截断，A和B就永远只有一个真理了。

我们几时说【四元数】没用？ 地球仪不该被中轴扎住，一句话就给到的intuition。SDF隐函数（热力图/高程图）也是同理。


问题不在数学【封装没封装】，那个问题复数vs向量的Gizmo变换矩阵（即二元数）也有说法， 是学科给出的回答："看不懂但能验证的证明也是证明。"

Gizmo每个用过Blender的人都懂，死锁每个玩地球仪和办公椅的人都明白，而数学，把其中的一部分拿来造私货顺带抢注，这个也数学那个也数学，数学同时吃两个。 一边独揽验证，一边抢注。现在IQ被真SOTA顶尖智慧给塌缩，自食其果。

"正确的插值"是什么意思？这是你定的，不是数学定的。SLERP 的规格是"沿 S³ 上的大圆、角速度恒定"。但这个规格不一定是你要的：Jonathan Blow 十几年前那篇 Understanding Slerp, Then Not Using It 讲的就是——归一化 lerp 走的是同一条弧，只是速度不均匀，而人眼在两帧之间根本看不出那点不均匀，所以省掉 acos 和 sin，用 nlerp。大量引擎确实这么干。这里"对"的裁判是你的产品，不是公式。

AI证明，只是把【传统数学】最后一块遮羞布（证明的神圣性）撤掉，而内部的死鱼，本来就是臭掉的。几百年前的事了

为什么要等到反馈落到自己身上，才知道疼呢？ 数学家引以为傲的【跳帧】【跳过算力】【跳过反馈】的能力，和【绝对理性】去哪了？


我，现在确实会为【选型出错】【浪费了精力和token】而懊恼，会为【oneshot从头再来结果反而更好】而寻找原因、去搜索更多平替，但那无关于我的创作和心血本身。 现在许多事的时间不够，也不足以体现内行的耐力与经验差距

但我也真切的体会到了费曼的【审美】： 昆虫有色觉吗？瓢虫看这朵花是什么样子？ SOTA 的 A\ 让 #PLT 的软件工艺更有趣味，也更有挑战，同时给了我们更多容错/慢慢做优化的空间

我失去的是一个个卡着我的编译器和眼花缭乱的IDE，得到的是 【Claude Code 里有嵌套之美吗】【AIGC主导项目的toolchain和中间IR为什么会长那样】【MC方块世界里的模块化和“代码复用”是什么样子】【节点图和函数体的图形隐喻与差异】

它们在我眼中，都是以前的知识，只是更有魅力。 这意味着我的能力在更好的【上游】上得到了应用，而不是在非常无聊的， override eval/Visitor/字典晚绑定，[[Str Any KV] List] 或 [Str [Any List] KV] 的未编号作用域查表上，为一堆 C-like 的庸俗【毕业设计】浪费时间

最新的 A\ 让知识更加性感了，在更多细节上存在了。 而不是剥夺了【细节的乐趣】

"整座城市只有你一个人能解"这个感觉在互联网普及那天就已经半死了——你解开时隔壁城市早有人解了。AI 只是把最后那层幻觉也撕掉。被撕掉幻觉当然疼，但疼的来源是幻觉破灭，不全是损失。

该项目目前正在插队继续中， 🤔 目前的场景是p5.js的交互式调试器，以及Lisp方言本身作为PEG实现的可能性。

主要是额度烧太快， 必须轮替一些不氪的小项目（氪40$叫小么..）

> #PLT #ce 目前找了一些有vibe后设计的新编程语言，例如sema,Jac。这种完成度的再推荐5个…… 要那种demo能看的，不要噱头

FlatBuffers.dev 作者的Goose么？Variable-mode enum + 原地修改 + Case functions +随便push，么？确实对rs enum{A()B()}很好的扩展，可能是 Lua/Lobster 的上位位置。

unison-lang.org 的免序列化/同步值类型和CAS代码库听起来也很有趣，CAS 代码库是真的过筛。这些对 agent 比对人更有价值，死在 ML/Haskell 风味的类型系统门槛

嗯…… AIGC有可能让这种基本上以单个特性闻名的编程语言，有活力吗？

单点特性语言，最缺的是不可替代的使用场景，不是写代码的人或AI兼容。

我觉得在json风格内存上goose比rs更让人满意，Carmack 也点过赞。而且lifetime的消失是pros，Rust不让AI开心

作为Rust关掉checker后的drop-in大概很好。美中不足的是，生态位尴尬 AI降智程度不明，然后除了HPC，应用编程这块基本是H5的天下了，生存空间需要下游而不是编译器PL层面去开阔。工具链层面：基本不能从 Rust 直接迁移。

https://github.com/sjrsjz/onion-lang

默认不可变 + 显式 mut/const、生成器驱动的异步（async/spawn/pool）、无 GIL 的真多线程（launch/valueof）， 这些坎都是存在的，AIGC跳不过去

https://github.com/sema-lisp/sema
https://docs.jaseci.org/quick-guide/jac-vs-traditional-stack/ （主张的点存在，但看后很鸡肋）。和现有生态（npm/PyPI）互操作时的摩擦不敢说。mypy / pyright 不认它，生成的 Python，调用栈和源码对不上时，怎么办？Todo 例子数胶水行数，实际说服力有限
https://github.com/winglang/examples/blob/main/examples/redis/main.w 这个做的比它好太多

https://www.sunholo.com/ailang-demos/ （这个和mojo差不多方向，但vibe的很杂乱，严重怀疑主创的专业程度）（Mojo 靠 Modular 整个 MLIR 团队撑着）

纯粹Agent化的只看到个位数的有用，而且感觉相当外行or跟风
https://zerolang.ai/primitives
https://agentlanguages.dev/languages/vera/

Vera 这个变量名即类型有种费token但安全的宣传，就像砍缩进省token的那些玩意，但不清楚效果，至少对人类而言

fn safe_divide(@Int, @Int -> @Int) ensures(@Int.result == @Int.0 / @Int.1)

它的理由引用了几篇论文（打乱名字比混淆后更伤），同时强制每函数有 requires/ensures/effects+Z3砍offbyone，bench上也与py/ts接近，安全主张上证据未知，有点像Bend，把黑箱证明堆砌到几MB，可用性完全玄学。 @Int.0 / @Int.1…… LLM 恰好在位置计数上最弱比A/B都差

唯一站得住的部分是强制 effects，这又回到Unison和Goose的主张——新的可能性，人和模型都能读（use IO、Net、Random、分布式..），审查时不需要信任任何黑箱。而不是不可见层做到最顶。

| 特性类型 | 以前的价值 | AI 时代 |
| --- | --- | --- |
| 减少击键（简洁语法、省 token 的奇技淫巧） | 高 | 接近零——没人手敲了 |
| 让错误被编译器而非 reviewer 抓到（类型、borrow、effects） | 中 | 上升——是模型唯一能拿到的确定性反馈 |
| 让行为在表面可读（显式 effects、capability、契约） | 中（人嫌啰嗦） | 大幅上升——审查者（人或另一个模型）不用信任黑箱 |
| 生态/语料规模 | 高 | 更高——零语料直接废掉 AI 兼容的前提 |

Vera 卖的是"程序被证明没做坏事"，而证明本身【高技术力】，用户看不见。

综合评估 —— 【编程语言】【工具链】 仍然是爆冷状态， 能用的 sema.run 设计蠢炸， 只不过是新SDK装老酒，而且纯vibe出品没意思，hero页也不出片。 Moonbit.cn 有创新但没有工作流级突破，且WASM生态尴尬。

hero页是次要问题（Bend形式化验证的展示较优秀）， 主要还是日用和Agent带用的体验，这些CLI都会强调，但感觉过于死板，不像是理解PL的人做的决策层

根据知道的一些社区氛围，最【理解】的人都在做人类看不见的flow——无论是Runtime/JIT还是“证据提供”和标注hint验证。 与我们“numpy和taichi比LLVM懂什么叫优化，热重载、URL和TTD调试比节点图懂什么是软件”的底层逻辑不搭

🦄 【语言作为人体工学产品的卖点早消失了】 对玩过MC红石、Scratch、Desmos的人是扯淡—— 编程本身也可以是一种社交和享受，而不是【有咏唱无魔法】的精力亏损和职业上的斤斤计较。 懂 PL 的人在做 JIT 和证据链，不懂的人在做 SDK 套壳。代码的社交性被低估，以至于人不是以《美团》这样的平台观衡量代码，而是问【为何不让Codex一次帮我点10杯奶茶？】这种蠢问题。

Darklang（AI 重启版）Glamorous Toolkit（Pharo 系）， codepen/esm.run 这类 URL 即函数的平台，反应式 notebook不在 PL 层。 AI的理由正确，但理解不了我想做什么。

这些东西没有一个来自 PL 学界。代码从负债变回作品的条件第一次在职业领域之外大规模成立。这个窗口里需要语言

#PLT 10.28 设计稿更新：

🦄
最近积累了一些词法设计上的经验，除了仍然以autofix的交互式编辑挂帅，对Codex们也更加友好。

当然，这些新语法非常炸裂，会以A/B两行对比的形式供自行判断，这边已经拍板按这个patch来。

一、首先是 f x; (f x).(f1 x1).(f2 $(fs xs)) 的调用链重置，这个对C-like的破坏最明显，争议性最大，demo案例也最多

// 甜点区：声明式/JQ风格链
g1.add(p, 'ruleMult', 0.1, 5).name("4x4pairs兽核加成");
g1.(add p "ruleMult" .1 5).(name "Hi there")

// 测试>3层调用，以及嵌套 (f p1 (f1)) 的易混问题（最大考验）
// 根据语料库，单行3层嵌套在业务代码中属于极端工况。嵌套await的弊病更明显
mul(A, sub(B, u.get("C")))
mul A $(sub B  u.(get "C"))

run(JSON.parse(e.clipboardData.getData('text')))
run JSON.(parse e.clipboardData.(getData 'text'))

let drops = Math.min(Math.ceil(hits / 5), 5);
- drops  Math?.{ min $(ceil hits/5) 5 }

navigator.clipboard.write([new ClipboardItem({ [FBO]: new Blob([regl.read().buffer], { type: FBO }) })])));
navigator.clipboard.write [ $(ClipboardItem ..{-[FBO] (Blob regl.(read).buffer {type: FBO}) }) ]

g.gain.setValueAtTime(0, t);
g.gain.linearRampToValueAtTime(0.1, t + 0.002);

g.gain.(setValueAtTime 0 t) #<^ 测试并排时的阅读效果
g.gain.(linearRampToValueAtTime 0.1  t+0.002)

// 测试晚绑定等90% case
window.m = {x:-999,y:-999}
v.onpointerdown = e => {v.isShiftDown = e.buttons; if(e.buttons) favicon.href = scrcat(c, m,64); };

new window, ..{  # 强制提名式赋值
  -m {-x -99 -y -99}
}
new v,
(onpointerdown ev) {
  new v, ..{-isShiftDown  e.buttons}
  e.buttons?.{ new favicon, ..{-href  (scrcat c, m,64)} } # Nullish if/认假为空
} # , ..{-单函数} 的语法糖

new.onmousemove, ..{ # 批量单键赋值+对象内函数键（类ES6，背后使用addListener和.cue可撤销队列）
  (v ev) { v.(updateMouse ev.offsetX ev.offsetY) }
} 


inc(1, 100)?.{ (remLesser(2)==1)? {u} Or{NO} }
inc.[1:2] # py range()

(inc 1 100)?. { u.(remLesser 2).(== 1)? u \\ NO }
inc.[1:2]
#^ 更好写出this(u)。增加Ruby风格的infix函数，Or作为else的平替拥有\\的简写
# 下标法仍然py兼容，不变。

二、然后是给{}即缩进块做了LOD分级，以新旧对比

print(hi) ~> "" { # 以前并不区分模块方法vs类方法
  - good "bohy"
  - hip hi
  OK(`${hip}!`)
}

~> (print hi) ""
 - good  "bohy"
 - hip  hi
 #< 1 空格缩进，给人一种【节省了token】的体感
 OK `${hip}!`
...
#^ end，但给人一种直观的开放感，同时可能作为 AIGC prompt 的输入框。 内部 if{} for(){} 仍然照常


row ImpBox(- tag "") # 多行分割用; 确保可以直接从局部let粘贴成类变量
fun { #> 继承 Kotlin 设计的缩进一致性
  open()
  size()> 0
}

row ImpBox ..{-tag ""} # 确保类和 return{}、push({})，在视觉上互文
=== #> 继承 tonsky.me/Fira Code 的设计师直觉，强制行首0空格

⌐> open  # 通过autofix偷藏元数据(isnt ~>)，严格区分，方便大模型grep
⌐> (size)> 0
---

三、原来就有的

- exp (...).if { "one" 1; =TAG= 2; =TWO= 2 } Or NaN
- exp (...).if { "one" 1; (==TAG==) 2; (==TWO==) 2 } \\ NaN
#^ 增加了【橙点色路单正钮】口诀，enum被视为和按钮/下拉框一样的元素（钮），故意写长，小写可调用id解析


✨ Wtf() 🔗 It🚪 ..{ - i 🏳️‍🌈 0 } # useful '✨'s on doc-site!
⛳️ { } # 这个旗帜要删掉了，但autofix临时换关键词仍然能用.
# 部分关键词： "Yemp Vonhon local-cute", u imp F.u,FnHo ON NO Or OK^ cue , "I[msft]XO_十一Xノ"

~> (born u ImpBox age 0) "" # 扩展函数使用u指定

row Pair$2(- first A - second B) # 2个TypeVar()，Excel风格类声明
===

set Str{1==1; ["valid" "val set"] >> res}, %{可以用 prompt}
set Str #> 正常提及表override, our表私有，已有_前缀的不得用our。
our swap(nth 2)

(swap)> (Pair second first)
(swap bad_ ON)> Pair.$[B A](...) # bad_=true 默认值， (TODO "") 的缩写
(Str) { (OK " <3 ") }
---

四、为toolchain增加CLI可操作性/可观察性指标

目标是实现类似DOM T.fn.{innerText,lit=outer} 的热更新和落盘，至于检查点已经有 OK stmt 的自动TTD设计，响应式字面量和【函数级增量解析替换】等，只需跟进

提供 cyy wait9/on9/un9 等Harness来搭配 9() breakpoint插入，i18n系统的CLI，以及更多的【人机共用设计】，不面向不可见细节优化。

工作重点仍然是收拢过去近十年能用的片段及判断，生成口诀、排序和oneliner PoC示例等等。PEG语法需要从语义有反馈的确定。

值得庆祝的是： 语料库收集完成的很好，有验证回路，不用担心被代码质量拉胯的开源设计带歪。

总结：之前【保护C-like】的设计哲学被降级了，本来是拦截缩进+完全符号化+bash风格传参， 现在变成绕过一半 + $()掉嵌套弊病。

然后缩进也砍很多，但有技巧所以弊端不明显。其他设计仍然在收纳整理中，不变

【真正的尊，何须靠借】 #PLT #CG

真正的理解，也不需要靠猜

@color Num=B Str=Y kw=B
Json  ((> Arr Obj Lit null true false <) :setRecur)
Arr ("[" (Recur "," +) "]" :par)
Obj ("{" (Str ":" Recur "," +) "}" :par :obj)

Lit   (> Num Str <)
Num   /-?(0|[1-9][0-9]*)(\.\d+)?([eE][+-]?\d+)?/ :num
Str   /"(\\(?:[nrtbf"\\\/]|u[0-9a-fA-F]{4})|[^"\\])*"/ :str

Tweak 声明推断、错误恢复，都还是前面那个递归下降元语言在支撑。不是另起炉灶做可视化编辑器。

从灵感出发，每一步都留下了可以记住的东西，没有【软件失忆】，复杂性的代码量也没被当成正收益、当成准入门槛。

把「能看见解析过程」的那套工具，直接用来驱动「能看见绘图结果」的方向感，从灵感，到工具链，到下游，两个html里完成。形式语法不再只是死鱼，变成了可拖拽、可步进的基础设施。

notepad.exe 和说书人不是一个模态，输入法也不必比语音输入慢。

知识不是按它被记载的样子被【理解】的，而是经过了彻底的分析和非平凡的变换，得出一个世俗的答案。

屏幕上可不是我思考的记录，而是我的思维链本身。

你自己看，看多少帧多少遍，都行 😁