#py 周刊

在单核情况下加快 Python 代码速度，提速 2339/554us=4倍
提速一个低色深保真算法，涉及的一些概念：指令级并行 （ILP）、分支预测、单指令多数据（SIMD）、内存层次结构等。

6 件可以用 Functools 模块做的很酷的事
@cache 缓存、@total_ordering 让你少写排序方法、@singledispatch 函数重载、partial() 颗粒化传参、@wraps wrapt装饰器、reduce() 函数。

7 个极佳的 Python 身份验证库
Authlib、Pyjwt、Flask-login、Django-allauth、ItsDangerous、Python Social Auth、Flask-security

Python对象模型（大部分）由语法糖组成
Brett Cannon 写了一系列关于“语法糖”的博客，并创建了MyPY，解析了 80 多个语法糖特性。locals(), 闭包赋值所致的 nonlocal 问题, type(X).__neg__(X); type(X or Y).__add__(X,Y), raise 替代break

为什么有这么多 Python Dataframe？
Pandas、Polars、Dask 和 PySpark 的区别在哪？作者认为是电子表格、关系数据库、二维数组/矩阵、对象 的便利性不同

用$ Radon 来衡量计算圈复杂度等指标
计算圈复杂度、原始指标、Halstead 指标、可维护性指数，可用于 CI 集成，可与 Jupyter Notebook 一起使用。（star 1.5K）

CPython 在处理字符串时使用了布隆过滤器，比如 splitlines()、strip() 两个函数（不到 50 行 C 代码）
Python 中 UUID 的使用
from uuid import uuid1() 利用系统 MAC 地址与时间戳生成 uuid；uuid4() 生成完全随机的 uuid；uuid3() 和 uuid5() 基于常量命名空间和变量名生成 uuid，前者使用 MD5 算法，后者使用 SHA-1 算法。

深入理解 pytest.main()：Python 测试框架的核心功能解析
这个非常实用的函数，用于从命令行运行测试集或者以编程方式运行测试。文章探讨了它的用法和一些常见的应用场景。

toml-bench：在 Python 中该用哪个 toml 库？
比较了 toml、tomli/tomli_w、tomlkit、pytomlpp、rtoml 和 qtoml 这几个库，考察它们在处理数据时的行为表现以及性能。

迎接更快的 SymPy
SymPy 是一个用于符号计算（symbolic computation）的库，可以处理代数、微积分、离散数学等领域的问题。

使用 import-linter 让你的 Python 项目架构更整洁
在依赖关系治理方面，通过提供各种类型的“契约”，让我们得以将项目内隐式的复杂依赖关系，通过配置文件显式的表达出来。文章介绍了它的入门使用，以及 6 种修复依赖关系的技巧。

# 分层：resources -> clusters
# 调整前
resources -> clusters
clusters -> resources.cluster_utils    # 应该是 clusters.utils

quasiqueue：管理长时间运行的多进程作业。
可处理进程创建和清理、信号管理、跨进程通信

logparser：用于日志解析的机器学习工具包
自动从非结构化的日志信息中提取出关键的表格信息。（star 1.2K）

llama2.mojo：纯 Mojo 版本的 Llama 2 ，将性能提高了近 250 倍
作者将 Python 版本的 llama2.py 移植成 Mojo 版本。（star 1.1K）

所以说py的结构设计10条基元，非常符合直觉 🥰

- 1,f"abc",True? 单项值和[{容器}]
- fn(x,*arg) 和 x=, return
- def f(bind_x于栈0): nonlocal 捕获外部“变”量. 词法域是保证 a=> (b=>是对象)&不同函的'x'不会相覆盖

流控
- def f(): yield 让f协程随便调异步 delay(res=>next(self函续, res))
- while 可以避免(伪)递归的冗余，也是yield要恢复的
- 函数内联，早够取代层级跳转了 c=a+b(); do{ ret=1;break/cont }while(0); c=a+ret
- try: throw 的级联返回，可以用 异步/Either<R,Err> 实现
delay 也可以决定是否回调，甚至选择next 给哪层catch("setjmp")，毕竟ret指令本来就不必是1层的

#PLT 变量域和函数/跳转是从C到FP(CPS,Y)里都有的结构，都是在“往回做”，但越定义式，就越倾向抛弃while break

循环比递归更适任，但完全可以用(双层)内联ret表示 continue break。这是块函数与尾递归的融合

不过 x+=1 也是可换为 (set! x x+1) 的，就像 nonlocal x 必然引入的cellvar(栈转堆.此处无关GC/复制传参)一样
如果提供 Var<T>.operator= 和隐转，那赋值和解构也可以消灭

#design 但离我理想的编程语言，还要删掉一些
- 内联取代break,tailrec 。{}块支持的跳转才自然
- Nd(矩阵) 规避循环
- 协程规避catch{throw},yield 。回调天然能“级联返回”和暂停
- Var.= 取代赋值解构。“可变量”是闭包里就存在的。六七十年前Lua,Fortran,Lisp,Prolog 都支持的协程矩阵DSL解构(即类型推导)，今天拿出来加点不良不莠的术语😅居然能算高级特性 ，心智模型和发展观被Java,C++荼毒成什么样了

既然catch,while,= 都被消灭了，就只剩 abc123YNO, at k=v, - fn(x) return(:赋值+跳转) 这三条是基元

#statement 这么一点笔原理竟浪费我两三年去积累和筛选，真的是垃圾堆里找兴趣😓，PLT圈牛逼！ 所谓邯郸学步，大概就是懂完了C语言会FP会Math，便忘记自己的母语 是四方通行却严谨有序的人话了。

为了70年前的酷语言，竟不愿组织自己内心的语言，甚至去忘掉更贴近问题的定义式编程,节点图，只能说玩具还是比扳手有魅力。
编程无关代码，就像天文无关望远镜。 透过金镜筒，星云依然是星云，它不会因为时代或抽象用词的不同而增加价值，不会因热门或孤傲而改变本质而割裂。那不该叫科学。

当然，原理所对应的语言“产品” 是有设计优劣的，比如如果无印痕的CPS是流控回调化，那就不说它是状态机或变换或"需要await的函数"，比如：

Py对局部变量的无印痕语法非常正确(在PHP前遥遥领先同行,1989还领先JS6.年)，可惜Guido没有在class上坚持他“违背祖宗的决定”，继续搞大新闻(害的Mojo这种竖子有机会成名)。这烦死人的Java构造器 😡

绝句因为有 at: a 1; b 2 和at now: 可变量， at nonlocal=Var() ，就不能简单写a=1;b=2 ，以及直接val=1与'- 函数' 对齐上稍稍冲突
所以就没 for x: delay;print(x) 只输出最后一次的nonlocal歧义: ((b := x for x in range(5)), b) (0~~5):it

只有 at k=v新建变量并赋值; (Fn0:k=v1)捕获到cell; - map(f, Arg<T>,Cont<R>)=算式; 内联return/Err(返回到catch)/loop(条件)
这4个块级结构('-' 是词级)。跳转闭包和协程(惰性生成器,就是让yield(1,cont保存待恢复) )都齐了
btw. 书里有词, 词的定义是算式套着块 Pkg>Def>E:Fn

函数化ret()很容易实现异步流，这是跳转做不到的-因为调用栈和浏览历史CtrlZ一样：唯独活着的能指明方向

用 Arg,Cont,return 重载来做vararg,yield,throw，就不需要星号,next,await,catch地狱
把loop视为另一种return，就不用在“函数式”尾递归和“工业糖精”循环break 间做选择

（实际也没人把filterMap,takeWhile(firsts)一族当成“循环”.. 流控，纯粹是种理论）

btw. 上条作者的理论也不算好.. x + (lambda A: A)(y) 这种能常量约掉的，是函数指针也无所谓吧。中科院的 MuLang 都知道a=>b=>要外提为 def: ret def 或者说 class: def call
del obj.k 不太常见，但我觉得JS里 undefined(UNK)可枚举才是最混淆的。JS{}唯一的优点就是检查弱到不担心报错+性能全凭JIT了

#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页纯示例 http://rigaux.org/language-study/syntax-across-languages.html#:~:text=Bags%20and%20Lists
http://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 被墙