#py #learn 语法的背后
class C(A,B): 是元类type的单例(在这里C:B.元类) ，语义是 exec(body, globals(), locals:=T.__prepare__(k,[T0],Defs:={})); mro=types.resolve_bases; cls = {*Defs, *decorator(meta())}
而def 们在globals+__class__下执行，还要设置qname,doc(第0行""),type annotations。 (教科书式的“反射”接口)
- @staticmethod f 是利用实例/类 getattribute 时调用的 f.get(obj,T) ，因此 (str.strip)(" ") 仍然正确(没有"js".bind("") 那样自由又强制..)
- getitem(slice(A,B,step)|tuple), getattribute 混淆就是JS对dict 的做法。当然JS没有tuple可以滥用，也没Pair(AB)，没可重载的 isub -=
- is 用于检测id()相等，对abc123YN? 显然是一致的，而 eq,lt 是另伙，支持交换律的。@functools.total_ordering 可以从<支持<= (btw. 怎么连缓存eval都莫得啊)

再谈声明
- @decorator(f)(litArgs), with enter exit 是我最讨厌的一种def， 是因为Python对(多行)lambda算式的轻视：以为Excel+生成式能表达一切，和Py2时的 print>>file, 一样。想发展，不够用吧？想省1字的括号 😅因IDE妥协
- lit={}[] 也是要创建 dict((k,v),) 调用的，和JSON读写器很像，所以“序列化很难”
- importlib, sys.path 是这个语句实际修改 globals()的方法。注意 a.b as b 是模块而 from a:b 是类，from PIL:Image 为啥可行呢？因为包init的 import ..sub 是公开的
- coro.await() 是一个靠next()的"Thenable"，但它没有ES6那样的默认(最异步的DOM)执行器，甚至没规范 yield Promise，只能 aio.run(main())

while(p){} ok() 实现的if在汇编是 A: if(!p)goto B; goto B;if(p)goto A; B:ok ，加上init有三块BB，就像 a||b, a? a:b 一样。直接做break理论和switch一样（你该知道工程界只有when ，也没if elif）

报错的显示，当然是从调用栈 cause 链表出来的，而JS更像 sys._getframe() 。 finally: 加在return前面，或者说 try catch 都是闭包而finally调用它们

#PLT #design 一门语言，如何从70年前推到今天🌝
刚开始，我们有个功能

say(1+1, end="\n")

^汇编(带数值类型,参数宏)

创建变量

-- pressF2(x)
  say(x, end="\n")

明确类型

- sayNum(x:Int)
  say(x, end="\n")

再用类型里的词汇去改进，乃至重新组合
^结构化(带list,GC,方法封装)
^面向对象(仅接口多态)
^函数式(非纯)
^面向对象
^定义式编程(ADT)

#js #code 再来说个有趣的：动态作用域 🥰

a=3
- f(a)=a+1
f(1), a //2, 3

>请把程序写成数组的形式 (也就是“更易做”正则替换)

with(DSL) $dyn=[
  [a,3],
  [f, [[a], [0, [a],1,['+'] ]] ],
  [r0, [0, 1,[f]], [a]]
]
DSL=new Proxy({},{get:(o,k)=>k, has:(o,k)=>k[0]!='$'}) 

在这个解释器里，$=, ()=>[] 就是内联宏啦，反正函数不能跳转 无需语句外提。
这里有3个深先规则，猜猜看？

[rv], [rv, vs] 引用-重赋值
[[args], funs] 箭头函数
[0,rv, fn] 向箭头赋值

对不会递归的人：

when- Sum
  Pair(A:Sum,B:Sum)
  N(x:Int)
  - as=when this:
    N:x ; Pair: A()+B()

PairAB不需要单独考虑两边即下一层，不要去匹配 f(a,b,没有123) 等特例。 你要归纳函数的返回类型；从基线条件去举例
如果在递归后顺便修改.A.B，就能显示求值步骤

对不会 parse() 的人：
就是正则解构+转换。吃流吐KV，调用者组合出数组，实践上就是调用栈: File(s.{i=0})=[Stmt,.]=AST
流.next() 相当于 str[i++], 拿C写也一样，而ANTLR用虚拟机避免了递归，更慢

附近几条消息，会提及如何实现+-*/与调用链、语句块和更多同类解析算法

当然，用[a,1] 赋值是表示不了 a,b=b,a 解构的，最好是支持变量作为值，那无关动态域。
()=>[] 宏借助了编译期的变量。但若通过“语法树模板化^^”， 编译和内联/推导类型都是方便的。 编译的本质就是重排重构，不是查表

先简单地映射到js词法域: eval(`(a)=>${'a+1'}`)
kv={['+']:(a,b)=>funcSignature} //全局定义

//生成JS eval()，来实现此数组的语义
cg=([e,...v])=>{let N,f,x,
opc=[ //折叠(非函数/变量)语法
(a,r="",st=[])=>{for(x of a)x=see(x),
((f=x.v||x)&&f.call? r+=call(x,st.splice(n(st)-n(f),n(f)))
:st.push(x)) //N元运算^逆波兰
return r}],
call=(k,a)=>/\w/.test(k)? `(${k})`+vs(a) : a[0]+k+a[1], //具体执行f(ab),a+b
vs=(a,p='()')=>p[0]+a.map(see).join()+p[1],
see=x=>n(x)?cg(x):x, n=x=>x.length //递归辅助
return e.substr? ( // [v], [v,valOrFn], [,tuple]
(N=n(v))==0? Object.assign(e,{v:kv[e]})
:N==1?(v=see(v[0]), v.call?(kv[e]=v):0, `${e}=${v}`)
:`${e}=${vs(v,'[]')}`
) // [[arg], ], [opc指令, ]
:e.push? eval(`(${e.join()})=>${vs(v)}` )
:opc[e](v)
}

btw. SQsu 也是基于深先遍历
逆波兰算符重排=易解析的四则计算，但一般只把「动态域」和求值序算作解释器，理解它的好处是可以破除性能迷信、作为你“滥用”闭包/yield/async 的背景知识
解释器并不特殊，它的转化&解决、局部化哲学和节点图,Scratch 很搭。而“游戏指令语言” “机器人脚本”即便支持变量也叫做shell。按下文just()式接口就能做它们

cg($dyn) 生成了 ()=>(a=3,f=(a)=>(a+1),r0=[f(1),a]) ，运行正常

- just(a)
  - f()=a
  f
just(0)()

那再来一个

with(DSL)$lex=[[],
  [just, [[a], [f,[[],[a] ]], [f] ]],
  [f,[0, 0,[just]]],
  [0, f]  //“类型推导”差到不能直接调用
]

()=>(just=(a)=>(f=()=>(a),f),f=just(0),f()) 是0而不是3
实际上，()=> 的值会捕获上1层参0='a' 。在动态域里，大家会把"自由变量a"连着全局表整个copy一份
设想下 cg.bind(kv={},ast) 每层都有一张“表”是什么图景。算+-*/可都是要递归的

列表处理不熟的人都能想出 List<Map>, Map<K,List> 并觉得后者“很快”，而C++《龙书》则建议单个KV、每层调用栈暂swap()下冲突的K （这么简单的做法 却放错顺序了）

而JS是以前者链查找重写重载 [{a:1}, {b:2},kv={c:3}].reduce((A,B)=>(B.__proto__=A,B))

这些算法，都是在一个错的心智模型下选择的技术。 参数/局部/捕获的数目是固定的，只有$0$1 的指针可言，AST里哪里有全局键(导入)外的“变量名”？？在通过bash,Lua.org 弄清这点原理前做事，会把一切搞砸。
🌚 但这也是知 名的GADT+HOAS(的最 通 用 的 De Bruijn 指针). 一个给EQ前端框架提鞋的“可变量作为值” #recommend

>请把 at a=1, a+2 写成匿名调用的形式
a就是一个可以重绑定的“洞”, Vue都会:

add=(a,b)=> ()=>[a(),b]

(Fn1:[x] add(x, 2)) (1)
f=assign(()=>[0, ()=>arg[0],2,[add] ]),{arg:[]}) //用“语法树模板”表示箭头函数

call=(f,...a)=>(f.arg=a, cg(f))

call(匿名f,1)

#statement 变量关系式编程天天用 文化输出成解构+类型体操+Reactive响应算式/约束逻辑后就变🐮逼了，而函数式的闭包+回调(栈转堆,return地址转闭包) 输出变成协程/yield{(then=>),} 后也TM🐮逼了，内联return变goto变尾递归时,又比break更平等了，纯的 if(a,a,puts) a&&puts() 又和自动闭包宏不一样了
文本-AST-Scratch VM_IR-SSA-节点图 又隔离了，AST就不能是赋值图了。 这叫原地踏步式的前沿🥰 怀旧你🦄呢
(Kt 1..2对int,long 乃至Iter,Seq都有不同的(模板性)重载 ，连(Java8 stream 里也有的)去除装箱都没推广到语言层面。a=x?.f() 的?像一个修饰器，在f代表语句时外提为(Cont的捕获:switch化也需要) _f=x?f(x):x; a=_f

而反观那些ANTLR,YaCC 会逼你再来浅先遍历1次，以解析栈内存，否则会增大解释器开销
--因为它们是靠LALR等“虚拟机”而不用现成的调用栈递归。 小众领域的白象总是揉杂到夸张

其他玩法:

$=(...x)=>cg([[],...x])()
with(DSL)$([x,3], [a,1,x])
with(DSL)$([0, 1, [[x], [x]] ])
with(DSL)$([0, 1,[[x], [0, 2,[[y], [0,x,y,'+']] ] ]] )

cg() 短的原因是，它只是把语法解构再构了一遍(或者说穷举了输入=>输出的对应性)，就像 noop=(a,b=0)=>a==0? b :移动 一样基础
但这就是编程语言的本质： 如果抢了应用或功能点的风头，沉迷于无尽循环的轮子，那必然是种设计错误

想测试自己元编程能力，可以做些改进：
1. vararg和可选参数, forEach, 自动支持await
2. 把“静态”检查的f(a,b,c) 回退到弱类型 [..,3,f] 且不与既有AST冲突
3. 把重赋值扩展到py式 (,自动新建变量)=>,, ，变量表可以直接用原型链，注意 f(a=[]) 是能被f修改的
4. 常量折叠，循环展开 [for,x, [[1,2,3]], [0,[x,print]] ] 为3次print
5. 用词法域，把调用和递归转为push；|用CPS，把调用栈闭包成堆内链表 ，转化到这一步代码就剥离开JS的ABI了

台湾的翻译的heap,stack就是从 malloc(), alloca(stack) 意译的吧
函数级的存储空间就像push(struct)，是能静态计算。
btw. 惰性Proxy(可变<函数>) 是环形依赖的组织方法。 f=>(a,b)=>a? f(a-1,b+1):b 你可以试试用 fref(f=>f).set( Y组合子) 和蹦床函数(伪递归) 计算下

如果不会写，可以用「费曼算法」：上面说了
>请把程序写成数组的形式
🥰GPT就是费曼算法的一种实现，但它不能替你踩坑啊。

很想给点引文:mal lambda书, decaf-lang C书, Craft 书, 闭包详解, JVM R佬科普, c4:极简栈解释器,minipy
Lox实现图解, js工具库, astexpo, godbolt.org , tio.run , 语言花名册

👍20页纯示例 https://rigaux.org/language-study/syntax-across-languages.html#:~:text=Bags%20and%20Lists
https://rigaux.org/language-study/scripting-language/#:~:text=compile%20what%20must%20be
其他 code.golf:
重构浣熊 多语言
https://blog.vero.site/post/noulith#:~:text=The%20Cube
https://github.com/eclipse-archived/ceylon-lang.org/blob/master/blog/2015-10-27-why.md#reified-generics
https://ruslanspivak.com/lsbasi-part1/

但那么多都TMD在讲BNF讲分词，还有人把py的缩进往回{}改 😅中文圈就没个做基建的
(正则吃数|读树)都不会是吧。 BNF也就比XML好看一丁点，单知道输入数据长什么样，对理解语言做元编程帮助很少

#haskell 上也有
https://okmij.org/ftp/tagless-final/index.html#:~:text=class%20Symantics 称为GADT https://stackoverflow.com/questions/33928608/typed-abstract-syntax-and-dsl-design-in-haskell
我是说
Lit(Int): T<Int>
Add(A,B): T<Int>
toStr(this:T<*>): T<Str>
本质是把fun提升为class。套一层Lit<R>是方便另加接口，比如统一能eval():R ，当然这也是OOP比FP扩展性强的一个中心思想
能直接DSL或弱类型when就不要做无意义的装箱套壳，建起来终究是要执行的

甚至 fun<R> lit(:R): ()->R 组合器都能起到和AST同样的效果，OO和FP只是复用参数的一种手段，重点是你对目标树型有没有最常见的心智模型

Postman 推出了 VS Code 扩展，可直接将 API 构建和 API 测试带入代码编辑器中

通过这种无缝集成，告别工具之间的切换并简化您的工作流程。

来源：Postman

Via Hua Hua

投稿：@ZaiHuaBot
频道：@TestFlightCN

ChatGPT 现已支持联网功能

ChatGPT现在可以浏览互联网，为您提供最新和权威的信息，并附带直接链接到来源。它不再局限于2021年9月之前的数据。

Plus和Enterprise用户现在就可以使用，很快将扩展到更多用户。
要启用该功能，请在GPT-4下的选择器中选择使用Bing浏览。

投稿：@ZaiHuaBot
频道：@TestFlightCN

#py #code #recommend 说到有趣的py接口，有个 iself()
def read_as_io(f):
class T(io.TextIOBase):
read=lambda o,size: f(o)
return T
-匿名对象
之前写贪吃蛇 snk.c 就用到链表
不想缓冲区溢出的话Vec还是好的。C里你要实现[] 需要懂链表/strcat， rust 里你写 Vec<i32> push 就好了
Rust的生命周期现在基本不需要考虑（尤其是对应用开发时）， type infer 是非常自动的

# 匹配左右括号 paren
_c01 = {'(':')', '[':']', '{':'}'}
def eat(s,c1):
  for c in s:
      # 如果是左括号，就把它压入栈中
      if (c1:=_c01[c]): ifErr='行号'; eat(s,c1)
      elif c==c1:return # 如果是右括号，左括号便与之匹配
      else: assert'','多余项而栈空' #仅支持纯括号文本, 否则要_c10,反向
  assert c0=='eof','栈尚不为空'

-S表达式

optab={[';']:-1, "=;+ -;* /"}
exp=(s/*token o算符x单项*/, l/*evels 大则紧,深 *<+ */)=>{
  let o,x=()=>add(Number(s())), ord=[],add=x=>ord.push(x),
  at=O=>{let A,B; x()
    for(o=s();(A=l[o])>=(B=l[O]);)if(A!=B)at(o);else{add(O);x(); O=o;o=s()}  add(O)
  }
  at(";");return ord
}

-运算链

叠加整理了下思路 一个 T(x).f(arg): T 的链，并试图兼容还未f()的T

data Adder(list:Ln<Int>)
  - add()=list(Sum).sum

- [].as( Sum(0, (A,B)=>A+B) )
["x"].as( Sum(it, (A,B)=>A+B) ) 就相当于 reduce,fold的 ，不需要class封装，用于支持分组过滤

在没有this的语言里调用链挺好玩的，但java里都有 new ArrayList(){{add(1,2); add(3)}} 这种用法
Player.MP3("")|:
time=length*.5
title=" hello ": "## ${trim()}"
start()

有趣的脚本语言：
Vlang (Go+Rust)
Esno (滤镜图)
Gravity(Kt)

class Vector{var..}
var v1 = Vector(1,2,3)
"\(v1+Vector(4,5,6))"

Wren(ES6+C#)

class Wren {
  flyTo(city) {
    System.print()
f=Fiber.new { //有点像Duktape
  ["small", "clean", "fast"].each {|word| Fiber.yield(word) }
}
while (!f.isDone) System.print(f.call())

coco Py(函数式)

def int_map(
    f: int -> int,
    xs: int[],
) -> int[] =
    xs |> map$(f) |> list

Latte

class User(id: int, name: String)
object Singleton
interface Supplier
    def supply
fun sum(a, b)
  for i in 0 until a.size
    println(a[i]+b)

val (x,y) = Bean(1,2)
o match
 case People(name, age,Bean(x, _)) if age > 20 => ...

分词器
Lexer=kv=>{
let re=Object.keys(kv).map(x=>`(${x})`).join('|'), mf=Object.values(kv),m,i,j=0
re=RegExp(re, 'gy')
return (s,ontok)=>{
for(m of re[Symbol.matchAll](s)) ontok(
mf[(j=m.findIndex((x,i)=>null!=x &&i!=0))-1](m[j]), (i=m.index), i+m[0].length
)
}
}

f=Lexer({
'\\d+':parseInt,
'[a-zA-Z]+':s=>s,
'\\s+'(){}
})

rep=(txt,on, n=null)=>f(txt,x=> (x==null)?on(' '):
(x.substr)? (on(x.repeat(n)),n=null) :
(n=x)
)

buildAry=(f,a=[])=>(f(x=>a.push(x)), a)

rnSel=(e,A,B,o=new Range)=>(o.setStart(e,A),o.setEnd(e,B), o)
rnHL=(e)=>
e.oninput=()=>{CSS.highlights.clear(); f(e.textContent, (x,A,B)=>{
let on=tag=>CSS.highlights.set(tag, new Highlight(rnSel(e.firstChild,A,B)))
;(x==null)?0:
(x.substr)? on('str') :
on('num')
})
hout.textContent=buildAry(rep.bind(0, e.textContent)).join('')
}


document.write(`
<style>::highlight(num) {
background-color: #f06;
color: white;
}
::highlight(str) {color:red}
</style>
<div contentEditable id=hl></div>
<mark id=hout>
`)
rnHL(hl)

#PLT #algorithm vs Moonbit 结构化编程 🥰 无印痕流控+内联可变

pkg
dbg
- Ln<Int> qsort=zero{this}:
this[0]:[p]
this{<p}.qsort+this{!<p}.qsort
- main
d=[2 3 6 8 1 4].qsort

Mistral AI 发布了 7B 参数的模型，击败了 Llama-2 13B，采用 Apache 协议。

Richard Stallman reveals he has cancer in the GNU 40 Hacker Meeting talk (🔥 Score: 164+ in 52 minutes)

Link: https://readhacker.news/s/5QFDD
Comments: https://readhacker.news/c/5QFDD

#security VP8视频在WebP后出现 RCE

#linux pacaur -Sy chromium firefox #chromium-117.0.5938

pacaur -Qi libvpx|sort

依赖它 : ffmpeg ffmpeg4.4 gst-plugins-good mplayer qt5-webengine qt6-webengine shotcut
依赖于 : gcc-libs

#kotlin #statement 🤔 新身份：Java黑、React黑？？😓

duangsuse, [2023/9/30 22:17]
感觉自己最近有点狂了， 看见有人问2D矩区的问题，我的第一反映居然是「这提问不会是认真的吧，xywh加减乘除是简单的吧」
问了下AI，发现这种 Image.crop()也没有直接给出思路或代码，它们变蠢了

应该改改了…… 真的有点奇怪，说不出是哪里错了，可能是反感流行框架不直白吧，但 我不应该教人做事

不过 java awt 确实有点过分，连类似Pair<AB>的模型都没有，许多人都是单独处理 width,height 的，
连 size=2w,1h 这种都要写两个赋值……和numpy太不搭

JDK这些人物理单位都不懂，却搞一堆设计模式，真是在买椟还珠的时候就格外努力……
Android呢，什么 AnimatiableVector, 向量根本不是动画（卡过点的属性渐变）所专有的概念， 要支持就直接起Vec2这种规范点的名字。 还歧视H5和CSSOM的模型。 编程就是被这群B搞坏的，真正的屎山框架代码。

duangsuse, [2023/9/27 15:56]
还是H5 <meta name="viewport" 好，就只有基于dpr的 px vw wh, 然后 sp=rem, @media(device-pixel-ratio:1)
不会因为放大到200% 就蹦出一个更新的单位。SVG里都一样

一个毫无意义的区别，让设计师拿来作为特色竞争力，妙呀

duangsuse, [2023/9/30 22:42]
唉，我现在在设计的前端框架，包含一门用于滤镜图/RPC的解释器， 真希望以后就不要再接触JVM界， 完全弱类型好了

感觉配合Java（哪怕Kt）界的窄模型思考，真的很费力。 许多对现实生活的简明抽象、比数理公式更优秀的写法，它们不去收纳整理，反而搞出与其他用途会冲突的抽象， 这样循环互害下去…… 大量学习成本就出来了，总是有新版本能+bugfix+feat

他们根本不懂如何写文档， 有些该单靠demo 传达到的被写成一锅粥，文档主要是原理。但 demo-文档-代码 给它们写成 文档-实现-汇编了……

duangsuse, [2023/9/30 22:50]
py 甚至全局用obj.dict ，这有什么影响。 人的脑容量才是限制IT进步的瓶颈。 优秀的算法和API移植，比8个byte 优化的效果多几百倍
总之对我而已，语言和runtime 只是实现解决方案的工具， JVM是可有可无的，只要它的libs我能自由调用。

一个lib 所提供的价值，等于其 public API+struct 的价值，不含运行时，因为具体实现可以被别人换掉。

库所用的结构是对领域模型的摘要，而API是对应地，实现功能的选项和途径
语言的语法和stdlib，需要尽可能简洁，因为复杂的功能和哲学，往往带来额外的编写时心智开销

总结： 现在，我更喜欢站在“代码之外”，解决编程问题
我看见的不是代码的文本，也不是框架的范式和API，而是「为了操作心智模型、实现示例，所必须存在的惯用法」的各种选项。
所有的知识和技能栈，在语言需求面前只能是平等的，无历史无印痕的；所有的需求受制于项目，但它们的大类，堆积在我心里了。
1.代码都是多余的，只有创意和描述是必须的。我懂的越多越严格，最终的(代码)语言就越少越简明、且复用而具体。
2.是我定义软件，不是框架定义我。太阳不是鸡叫起来的，一群鸡也叫不起。
3.程序员的幸福比CPU和堆栈重要，诚恳地学习直白符实却“缓慢”的做法，是接触到更好更快代码的最低门槛。

我不会只充当需求-框架API 间的「翻译器」，我会溯源、会代换与合并，至少我知道“更算法” 和“更人性”的实现会涉及哪些技巧和变量模型。
而我越是 diff 完整的领域模型, 热门实现 ，就对Java和android界越失望。

尽管，编程界九成惯用法和API，用语文的标准看，都是赘词和不当归类 ，而从软件工艺去旁观，框架作者们看不见「自己的、当前的需求」以外的复杂度，他们缝补堆砌了太多坑送给新手。
因为他们看不见「文本的语义」和那些「领域的心智模型」，才会被规范和最佳实践蒙蔽得那么理所当然，就像以前调两个库就觉得好多功能的我。

写框架，首先要当好「0框架」的用户，也当一个自己的用户。
程序员于全世界，1/60亿。 在意抽象设计的成功，或是被唱衰，缺少一份人生苦短的清醒。 相对于那些永恒的物理公式，把技巧捧上神坛或藏着揶着，是如此片面。

J2EE确实解决了PHP的无类型和性能问题，但从FB,GH初创于PHP,Rails 就能证明，“奇迹”不免费，这种「企业化」是以十几倍的慢速原型为代价。
我讨厌React VDOM ，但就连React的boilerplates也比Java少得多，起码它没胆把"fiber conciler" 放在接口里，而反观Spring,Hibernate 的每个变量名都有“自己的专利”，你得服从它的性格来写一大堆默认值！

它们还在把Kt,py 乃至JS变成新的Java， 想消灭编程里的乐趣，真是群脑子缺根弦的专家呢。

#statement #dev readability :
@duangsuse 其實我覺得你的 code 有個小缺點：不好讀
太像 minified 的程式碼了……

duangsuse, [2023/10/2 19:48]
欸，是啊😓
像 min.js
或许我应该写文档。因为，我是把贴文里已经说了的eval规则，直译为JS了，没有把细节写得很明确

我这个贴文主要是讲原理， 写示例的时候，并没有把它视为应用代码的，就写得比较急，随意😓

duangsuse, [2023/10/2 20:09]
加几个换行只会让程序看起来逼格更高吧…… 没有注释也一样难读
或许是我的分词语感更紧凑， 我觉得?换行: 这样让人找不到重点，更别说满屏幕 if else{} return 取代 when 和“map=>重写”等意图

duangsuse, [2023/10/2 20:12]
所以我一般是不写代码，只说明心智模型的。 当然有时间的时候也会写点注释

我是觉得， 如果Devs只是看到了很合规的源码，「能够准确分词」，但get不到语义的话，是不能继续添加功能的。 能用和懂之间的差别，不是在是否 syntax error 上。
只有对自主默写有用的代码风格，那才是实质上的读懂

一般来说我写代码都是 quick prototype ，像这样重写…… 我做的设计很多，所以拖得很后很后

ram:
我们对于可读性的认知的偏差，应该是来自于参与过的软件工程项目。
在我的理解里，代码不仅仅是为了自己此刻的理解而写，也是为了 reviewer 和其他 contributor 甚至是多年后自己的理解而写。

没有 abstraction layer 的写法我只在 code golf 里面见过。code golf 的大部分人是先写 proper code 再手动改成那个难读的样子的

duangsuse, [2023/10/2 20:35]
我的原文里，这是用来把

- just(a)
  - f()=a
  f
just(0)()

语法结构：

with(DSL)$lex=[[],
  [just, [[a], [f,[[],[a] ]], [f] ]],
  [f,[0, 0,[just]]],
  [0, f]
]

对应到JS：
()=>(just=(a)=>(f=()=>(a),f),f=just(0),f())

为此请判定3种规则：
[refval], [rv, vs] 引用-重赋值
[[args], funCalls] 箭头函数/整个文件
[0,arg, fn] 向栈变量赋值

如果抛开作为示范实现的 JS，可读性还可以

duangsuse, [2023/10/2 20:18]
因为贴文里，我主要是讲原理，不能贴长篇代码👀。我的抽象层就是「中文」。 以后有机会转Web 我会写明确命名版
我都不知道贴文有几个人阅读，是笔记。 我每天背后有不会发的设计，都在耗时的……

这个真的就是快速开发的问题 ，我从来不以JS,Py 这样的代码的有损形式「维护项目」的。 都是设计稿。

duangsuse, [2023/10/2 21:38]
编译原理有一大堆应用层用不到的概念， 或者说「意义未知的算式」。
当你想要跨界（尤其是直接上手写能用的 interpreter ），就要做好增加词汇量的准备。 像SQL那样禁用缩写，只是新手入门的辅助记忆法，晚点也会被 BaaS,GraphQL,ORM 那样的技术替换

我是挺希望有编程语言，能同时照顾新手的迷茫和老鸟的读写效率，
因此我的绝句里有规范 - Str.as(regex:Str.RE, :[Fn1 Str.RE.Paren]-Str) Str, -'T' swap (A:[Var T], B:Var“or @T”) 等等缩写法和约定俗成，不要因为没 boilerplate 而不易读

主要是我要反思自己的设计 ， 因为能提升的还有太多（我现在看知乎，唯一就是要寻找「灵感」，真的很有效）他们的理论或许很绕， 但给我了一个切入点思考自己的
Kotlin 正则的 "abc".toInt()?.let{} ?: 0 甚至比 bool 有效。但正则不是模块化层面的问题…… 它就是「有缺点的战士」

duangsuse, [2023/10/2 20:43]
还有种可能.. 我自己的代码在用『物理命名法』 来写这个第一版的👀，它标明了类型：
a数组, e树叶 v值 N计数..
许多人没法用这些单字断言 变量的含义，阅读时就会很迷糊。
但如果我不用物理名字，我就无法快速地完成代码，而且会各种 type mismatch 。 😱

物理命名，这种对「编程世界」的归纳对我个人而言， 是种革命，让我的代码能横跨更多平台/博采到更多文章🦄 ， 无视变量间无谓的术语差异、减少新功能的代码量

但美中不足，它与其他程序员的习惯相悖🙇🏾…… 许多人不习惯单字符， 更没有 '所有可索引值都叫 aXXX' 这种认知 。 如果有一门主攻语言的话，是不需要这种「超出文字」的编程模型，来解读代码的

我没法在教 tree walk 的帖子里，教读者JS原型链是怎么一回事。 我以为在这时缩短篇幅，会让读者抓住重点，
—
谁知道大家都是「通篇阅读」我的代码，而不是：找出code和我贴文所述概念的「联系」

就像视频有「60fps vs 关键帧+弹性动画」，音乐有「441k vs .midi+乐器包」，图片有「500px vs SVG+滤镜」
代码也有「1个月5万行 vs 100行的'定义式框架'+keypoints」。极简主义者都属于后者。 我告诉电脑怎样漂亮，不是它命令我'必须500px' 或怎么写。

编程界确实存在一种频谱，能无视术语和范式，绕过一切的烧脑的刻板印象，只量化每个函数本初的比重，一统工程和学院派： 在写到纸上/内存上之前，我们对代码已心如明镜。
只试两次对错，是没法在第三次发现进步的。方法论总会反转，与其嘲笑旧的不好，更要明白它错在哪、又好在哪！

— 🤔💭
我们程序员对一段功能的「设计力」，不是按「能读懂的术语表」来计算的，小心伪理解。
你要建立的思路和关系，是： 变量|此问题的领域，而非 变量|仅有名字相同的常识 。只懂常识难有创作

我已经习惯于用「必须要定义/调用的API」来解析代码了， 我看不懂的代码是不会逐字猜测的
是我先站在作者的视角， 去推测他的选型和「私货」， 然后慢慢把我的猜测与实际合一 ；这时短的魔法是不影响理解的👀

对不懂中文的人来说，优美和丑陋的中文词汇/文章结构 都是难读的， 你要先熟悉语感。 对任何编程项目也一样。

CSS规范就像这术语表，但设计的实质，是 tailwind 那样“有规范地杂乱”。我的文章是教你规范，代码仅供示范
如果你是为了用现有的心智模型，看懂代码， 那你的收获只会小于 Google 爬虫对文章做的关键词聚类。 而当你get到算法的思想， 会发现你仿佛见过那些“全新流行”的文本，过目不忘。

24小时投稿精选 #每日精选

Cloudflare 1.1.1.1 被GFW封禁

Minecraft正版验证api域名遭反诈中心屏蔽。

目前部分网站中国访问出现问题的情况梳理：

汽车企业会收集并出售你的性行为、基因信息、智力等敏感数据

Vercel 被墙

>如何看待著名编程软件 VSCode 官网跳转国家反诈中心（目前为无法访问）这一现象？ 👍
“ 我不想每天都讨论敏感话题，但是敏感的东西正在每天向我靠近，如同深处液压机之内”

#china 方脸：恒大债务比鹅爹的国债总量还高 🥰
- 通过期房，向消费者借钱
- 通过商票，向生产者借钱
- 通过理财，逼员工们借钱
- 通过收购银行和自融，借「不用还」的钱

为何这时才爆呢：
- 地价泡沫是从2015股灾开始的，让地方政府和当时的中产爽到了
- 但中国的土地本身并不值钱（更不可能一直涨），开发商也只能是比谁会借钱（养蛊），没什么技术力
- 维尼说房住不吵，但既要不卖地，又要给公务员发高额工资，最后到2022开始用各种政策逼得房价跌停，但导致资金无法回笼，白手套就爆了 😅

教训：伴君如伴虎。与虎谋皮，许以为只是谋中国低阶人矿的皮， 但泡沫破灭后最终被「抓典型」的还是买办不利的自己。就像蛋壳公寓，丛林社会即便「民族企业家」也随时都是「美帝资本家」，「[解放]军首长」也会随时消失。
如果恒大的电动车挤进Top5，或许就被细颈瓶的下属们保了呢！ 这大概就是「舔功与实力不可兼得」的教训 🕊

小郑：我的個資被曝光 #statement
玻璃心的人，会把不相关的批评(eg.业主反对物业涨价)和不幸，理解为恶意伤害自尊心；对不够正能量的现实，触发精神胜利等复读机技能

玻璃心常常分不清批评甚至比喻的主体(就像咬House的狗一样)，这需要「过度控制」。只要只剩一种声音， 大雄就会以为自己是用胖虎的声音在讲话了

巨婴的人，不敢直面缺陷和成长， 甚至会把欧美日韩台有后续的「社会新闻」也当成不听不看不说的正能量宣传部 ，试图让正常人不比烂就也要把负面事实删光光， 直到自己被不法的权力 暖心强拆强欠的那天 🕊

冷知识：
-「上海铁路局主任」省略了部处，应该说「中铁某局副厅局级干部」
-小郑是2022年6月4日开始做yt
-日本没有「寻性姿势罪」，只有有XX罪和无罪，没有「莫须有」罪和「不能触犯党没告诉你的法律」的道德
-🇹🇼🏳️‍🌈 台湾无法避免辱华，因为有全民健保劳保的中文人，即便是好好活着，就已经在揭示三皇五帝们的丑陋跟底细了


#ai #jp 月租版 GPT-4 TTS ，可以解答「老鼠生病能吃老鼠药」「只剩一个心脏还能活吗」这类问题
#net #ru 鹅爹 马上全面禁止VPN 😅 之前就叫嚣不让国民传播网络代理
#news 迷笛音乐节惨变 零元购 ，文革大爷大妈的传统哄抢 教育了那些没吃过苦的小年轻 🥰
左派冷知识：☺️

波士顿清茶是为了涨价？实际上：
目标 为了抗议英国议会对茶叶征税， "无代表不纳税"。

而且中国农民的水果，运/卖不出去也会喂猪的,不倒，运费你出
经典社会主义的税收和公务员，都是免费的， (永动机)政府来做是不用花钱的，无(透明资)产阶级政府是高尚的义务劳动。

美国是有 food bank 的，日本我不知道

#FP #math 的一些 #statement
#tool html bookmarklet data:text/html;utf8,<body ContentEditable>

—10÷3=3…1
被大佬建议写成 =(3)3+1 即m=qn+r (r<q)形式的“短除法” ，理由是...没交换律
“理论家布尔巴基有个笑话： 1+2当然是2加1，因为整数对加法构成阿贝尔群”

当然，纠结这些除和除以工程意义不大
ax+i=b; x,i=divmod(b,a) 的可变量元组数学里可是没有。函数只是“关系”，没有sympy那种条理分明的元编程化简法，py那种无论匹配或访问都易懂的“类型化数据”

a%b 余数在进制计数法,KB MB单位，乃至红绿灯🚥 ,猜拳、[123]*3重复 里都可以用到，四则符号的推而广之是很方便的
但GL的vecM和距离函数, 对偶的cos atan2才算是真正的「函数图像」

对软件来说，值之间的关系、算式的归类、代换(元编程) ，都是值得思考的，这远比重复流行的技术栈重要。 形式化的语法，正是物理和编程比数学广泛的一点

— 纯函数的不可变吧…… 不是类型上'final' (btw. KT-override class 理论讨论)
意义真的不大， 无非是把堆里的变量放栈上来重赋值，或者栈变量换伪递归，拿能够DFS的写法却只做列表处理， 有什么用…… 又麻烦又慢 😓

变量关系式编程(LP)里， 函数式的 Memo f()=x+1 可以直接表达为 f(out y,x) 的细粒度重计算，解构时也一样！ 不仅不存在“赋值”，也不需要那些纯函数的过度检查

一些人觉得 React是什么FRP，functional响应式 。但其实把可变数据，理解为含Var的不可变， 比纠结于List纯不纯好玩的多

类型姑且还是对心智模型的硬化， 纯度这些可都是虚无缥缈的风格格调了。有趣的软件未必靠FP来写。某些函数式lib的样板代码不比rs,go的少 ，代码质量只能是看人，是否憎恨冗余

—我想用 for()await varAssign; 替换组合力很低的 for await(x of {async*f(){ }}.f()){} 异步迭代器，也方便RPC/跨语言 的对接 #PLT
异步流每次next()只是Promise，但换成两个async()赋值--单监听, 用 var.Saw.to(x=>新值流)+AbortSignal 更一致

async()=> 的实现要调用 yield。 s={*f(){ res=yield }}.f(), s.next(1) 里f的yield会把值和'自动回调'赋值到s.next，交给调用方调度。throw也可以直接next回调链表(CoroScope)里有catch的那层。
Iterator显然只是调度的一种特例，是把i++等流控 继闭包地从栈分享到堆。不能牵强地把等待恢复、迭代混为一谈

在ES5里，可以用一个 co(asy()) 来遍历 task.then(next) 并搭配 yield* tasks(下级) 。#Kt 协程则是直接把回调交给timer()等待，无遍历：

#js #code

wait=(n,ret)=>setTimeout(ret, n*1000)
we={*f(co, ret){
  setTimeout(co.nt, 1000); yield //函续已经交出去了，现在该返回 就像f只是登次记
  wait(1,co.nt); yield
  alert('2s'); ret()
}}

_await=(f ,c={},s=f(c,()=>Job完成))=>(c.nt=x=>s.next(x), s.next())
_await(we.f)

把f变成大switch并不难，但Lua,Rb,Py依然在用运行期魔法实现yield:

we.f=(co)=>(co.nt=()=>{[ //先把f(yield)外提为x=
  ()=>setTimeout(co.nt, 1000),
  ()=>wait(1,co.nt),
  ()=>alert('2s')][co.i++]()
  if(co.i==3)co.ret('like,co=Promise')
})()
we.f({ret(){'此谓调用约定,ABI'}, i:0/*func*则会等待1次next*/})

把co暴露给调用方更像JSPy (缺点是要由main调度then(next))，而把co暴露给下级 更Kt,Lisp (虽然更像回调, 但太隐式, 比如yield(x)需向Iter对象赋值 脚本没这作用域)
到了OS这级，键鼠事件，异步只是赋值+触发回调

—翻译一下， suspend fun f() =f1()+1

首先f()要是一个闭包（即 匿名class .new ），kt,Java ()->会自动实现这一步
然后，f1接受第二个this: (Int)->Unit 实现其return 。这就是JS的Promise.then 。你说的local vars 就是指 Promise or Continuation函续 or Async状态机(大switch) or Future..

f的执行也不能卡线程栈了，它也要靠回调，比如runBlocking等待其他Thread的信号量，或者在IO,Main等 Queue(函序) 调度

这么说，call queue 和单CPU多线程本质上都是分时复用，只是设备中断/SIGTRAP 被改为更高层的函数回调，CPU cycle 换成主循环(监听轮询poll)。 因此王垠觉得Lisp比C更适合写OS

Go,JVM,Ruby,Lua 的 stackful 模式允许不标明await 且仍支持返回值，而基于CPS回调的协程则兼容性好
不能把await 调用理解为有返回值的多进程，相反，函数自身是消息队列内的Task(即线程,可sleep)，才能去"非阻塞"await

语句就是种顺序表达式， val x=1; f(x,x) 本该也能写成 f(x:=1,x) ，往往只是外提为val，所以await()就像 f(a?.let{return} ?: b) 是可以的

还有coroutineScope, sequence, select 等复杂的结构化信息。 这样能实现大goto(call/cc) 的功能，比如直接resume给某个 caller 的 catch(IO Monad) ，或者 yield 到 gen .next() ，DFS防止栈溢出等

yield的一种用途就是遍历Rx流，但它们生成的流却非异步(尽管它能"push"无穷项)。 另外我觉得RxObserver=next 比async yield 更合理

—「值和引用」别扯到C上
栈就是“非常容易做GC”的堆， 只因为在堆上就叫ref不算值 是不太定义式的，这暗示了 N2(x,y) 这样的数据“不该可变”-即便它说了xy都是变数
别把JVM当成C++的框架。调用栈是内存的一部分，函数值和对象都是“栈转堆”，return在内联后只是赋值;goto，参数并不配特立独行

copy和ref 的区别，只应在于后者是Var(mutable v:T)。 含var的struct也能纯复制，List也可以存栈上(调用在栈顶时，可以追加 int a[num])
只是对集合/事件/闭包等应用层共享，就必须有GC,Rc 来修剪对象图

绝大部分val=struct 的实现依然是堆内共享，与内联函数相当。只有int这样机器mov的值不用传指针

—编译和优化
>AI没答到点上。 我觉得synchronized和Mutex有什么区别， 就是取消 object.wait()才隔离出的

>竟然是让 withIndex() 驱动 get(it).. kotlin-stdlib 里的一些实现是自己在 for each 外 var i = 0 计数的……
智障，就像标准库不写 val x get() 写 fun getX
自己破坏自己提供的特性

>list set stdlib 里的这些集合库的indices属性都有优化
我说的是一般的 for (a in list) 优惠成 indexed for loop 去掉迭代器这种

都能让你手动改写法优化了， 要编译器和有两种IR的虚拟机是干什么？

编译器已经是优化了，虚拟机还要JIT， 结果应用层还是不能满足……
是啊，我就是觉得这种现况很可笑。kotlinc 还特别自己弄了一个内部IR，不知道是用于翻译goto 和协程还是啥

编译优化全都是不可见的， 你也不能知道llvm,ktc 执行完优化是啥样子，非得反编译
当然，clang,llvm 是可以导出IR的，但许多优化用的表示IR层级太低，正常人看不懂

这种情况的解释，就是IR的语意不能用语法来保存了， 但其实 loop/重复算式的外提，并不会破坏程序结构，甚至DCE都是要由IDE重做一遍

玩编译器那帮人根本不懂如何做交互式编程、图形化框架。 这一点 dnSpy 一个反编译器都比90%的编译器做得好
更别说同时有TUI,Qt,Web 三种界面，支持无数种bin格式的 radare2 了

#history #china 为何力量掌握在文明手里😡：
一个「伟大」的国，是让人甘愿拖家带口过去纳税，而不只是单枪匹马、只能够捞钱

西班牙、英国、美国的科技繁荣，不是因为抄对了老大，而是真正有力量的人，更需要一个开放包容、能用法制抵抗剥削的社会化生活环境。
医生对抗完疾病，回家还要对抗窘迫的存款和寻衅滋事罪；这样的国能称为的家，是那种赢了1位，挡住一切的野心家。

这种时候 旁观到国外国内的不公是羞耻、是笑话，而没人会搭把手，

他们教自己的最后一代 变强， 直到被更强的浪潮吃掉，
只好把这种压力倾倒给海峡之外，一群同样有家庭和事业的，他们从没见过的“坏人”
明明让他们相信「一切都是阴谋论的」，是自己身边的环境！

1.Leonard
2.小郑
3.方脸 “
按照马克思主义的理念呢，国家是应该被消灭的压迫者
基于数千年的儒家传统思想，和当前的普世价值观来看的话
国家应该就是人民。所谓的爱国应该就是支持人民，反对国家独占的集体利益

当你学会了爱自己、爱陌生人，其实你就已经做到了爱国
而如果你坚持中共宣传的爱国观，你只能学会仇恨。 当前达不到的标准，不敢明着说权衡利弊，只怨天尤人

小粉红肯定说了你都支持国家分裂了，你怎么还能说爱国呢
但如果你把爱国看作爱人民，事情就会完全不一样

他们心里确实也并非真的把对岸当做同胞
很多时候，我在他们眼中看到的是嫉妒。这一点在香港问题上最明显

很多小粉红，嫉妒香港人身上的特权
嫉妒他们，能自由自在的翻墙，能享受一定的言论自由选举自由

甚至现在还有些极端的小粉红呢
对于台湾问题，还会喊出留岛不留人的口号

这就体现出来：他们根本就不爱台湾人民
当然这种分不清楚到底什么才叫爱国的现象，绝对不仅限于两岸关系上
这种观念，存在于中国的方方面面， 对高楼大厦和联合国席位的执念
”