#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，需要尽可能简洁，因为复杂的功能和哲学，往往带来额外的编写时心智开销

#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到算法的思想， 会发现你仿佛见过那些“全新流行”的文本，过目不忘。

#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 了

#py 周刊阅读笔记
https://t.me/NewlearnerChannel/12060
https://t.me/NewlearnerChannel/12097

https://www.kdnuggets.com/why-you-should-not-overuse-list-comprehensions-in-python
#code

primes =lambda upper_limit: [x for x in range(2, upper_limit + 1) if  x > 1 and all(x % i != 0 for i in range(2, int(math.sqrt(x)) + 1))]
primes(50)

#拆分后

is_prime=lambda num: num > 1 and all(num % i != 0 for i in range(2, int(math.sqrt(num)) + 1))

primes = [x
  for x in range(2, 50 + 1)
  if is_prime(x)
]

后面

def flatten_matrix(matrix):
def find_prime_indices(matrix, flattened_matrix):

求和排序的我不想写，因为明显可以用 yield和np.vectorize

# Parse&flatten the JSON string with deep"inner_key" into a Python dictionary
这个也不想，因为用match和递归更常见吧，elif isinstance 是什么py2地狱绘图

https://bernsteinbear.com//blog/simple-python-repl/#:~:text=readline%20API
https://www.skywind.me/blog/archives/2761
如何利用RegExp/创建REPL

出自 https://docs.python.org/3.11/library/re.html
#js #code 当输入 "3 hello 1world" 时展开缩写，并且补齐出现过的词

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)

buildAry(rep.bind(0,"3hi 1end")).join('')

因为JS部分都这么长，还是懒得移植到PyExecJS了，总之分词器、括号配对啥的可以靠正则，提供补齐列表也不难

就用 <body ContentEditable>+CSS.hilights 示例吧？
https://jsbin.com/kamufijomu/edit?js,output 😅

参考^回复，这样就有分词和括号配对高亮了？

—续周刊
https://github.com/stickfigure/blog/wiki/How-to-(and-how-not-to)-design-REST-APIs
十多项 REST API 的最佳实践规则，解释了规则的含义及实现
作者嘲笑了几家公司被广泛使用的 API，将它们作为规则的反例。

[Django 5.0 发布了！](https://docs.djangoproject.com/en/5.0/releases/5.0)
新增`Field.db_default` 参数，可设置由数据库计算的日期等默认值；`GeneratedField` 可以创建由数据库计算的列，简化了表单字段相关元素的呈现
FastAPI 已经支持 python-dependency-injector 实现依赖注入的方法。

[kolo VSCode 插件：查看 Django 应用的执行过程](https://github.com/kolofordjango/kolo)
具有帧可视化、漂亮的火焰图、显示执行了 SQL 查询的代码行
[autometrics-py：函数级的指标监测工具](https://github.com/autometrics-dev/autometrics-py)
只加一个装饰器，可检测函数的请求率、错误率和延迟，开箱即用仪表板、自定义告警、运行开销小

https://dev.to/taipy/new-open-source-vs-old-open-source-33k7
10 组在 Python 社区很知名的库的替代库，这里最没争议的估计是 Ruff 替代 Pylint，
其它则还有：Taipy/Streamlit、Polars/Pandas、Dask/PySpark、PyTorch/TensorFlow ……

[Python 借助 Gopy 库实现调用 Go.whl 包](https://last9.io/blog/using-golang-package-in-python-using-gopy/)
https://preslav.me/2023/11/27/python-is-easy-golang-is-simple-simple-is-not-easy/#:~:text=also%20at%20the-,core%20of%20Django,-%2C%20which%20speaks%20to

[对比 Python 与 Rust 的编程习惯用法](https://programming-idioms.org/cheatsheet/Python/Rust) 有意思的网站，可比较不同编程语言在 300 多项习惯用法上的区别
就像 https://component-party.dev/
https://kobzol.github.io/rust/python/2023/05/20/writing-python-like-its-rust.html
从 Rust 中学到的一些编程习惯：使用类型提示、使用数据类代替元组或字典、使用代数数据类型、使用“newtype”、使用构造函数、使用互斥锁等

[Python 工具箱系列文章](https://www.cnblogs.com/shanxihualu/p/17391082.html)
这是一个系列文章，目前包含 31 篇文章，最近介绍的几个工具是数据库相关的：Neo4j（一个 NoSQL 图数据库，使用 Py2neo 操作）、PostgreSQL

[trogon：为 CLI 程序生成友好的GUI](https://github.com/Textualize/trogon)
[当在终端输入“ls”后会发生什么？](https://www.warp.dev/blog/what-happens-when-you-open-a-terminal-and-enter-ls)（英文）
有一道很类似的常见的面试题：“当在浏览器输入 google.com 后会发生什么？”
[solara：一个纯 python、React-风格的ipywidget框架](https://github.com/widgetti/solara)
[用tkinter、PySimpleGUI 和 Jupyter Notebook 播放 GIF？](https://www.blog.pythonlibrary.org/2023/12/05/viewing-an-animated-gif-with-python/)
https://toga.readthedocs.io/en/stable/tutorial/tutorial-0.html#:~:text=()%0A%0A%20%20%20%20button%20%3D-,toga.Button,-(%22Hello%20world
Toga是跨平台的pyGUI
kanban-python：终端中的看板应用程序，和Vue TUI 一样

#js #code 上帝说，要有光？ https://rcuv.hkbs.org.hk/CUNP1s/GEN/21/

// ==UserScript==
// @name         圣经高德
// @match        https://rcuv.hkbs.org.hk/CUNP1s/GEN/*
// ==/UserScript==

$(document).on('keyup', e => e.which == 39 ? $('.nx').click() : e.which == 37 ? $('.pr').click() : null);
(function(){$(document).on('keyup',arguments.callee)

setTimeout(function() {
    'use strict';

let AB={'耶和华神?':'高德', 那人:'亚当',女人:'夏娃'}
// 遍历所有文本节点，将其中的"a"替换为"b"。基于RegExp 和js字典提供一个 replace({a:b, A:B}) (str) 的方法
function replace(str, dict) {
    const keys = Object.keys(dict), vals=Object.values(dict);
    const regex = new RegExp(keys.map(key => `(${key})`).join('|'), 'gi');
    return str.replace(regex, (s,...m) => dict[s.toLowerCase()] || (dict[s]= vals[m.findIndex(x=>x!='')]) || s);
}
function replaceTextContent(node) {
    if (node.nodeType === Node.TEXT_NODE) {
        node.textContent = replace(node.textContent, AB);
    } else {
        node.childNodes.forEach(replaceTextContent);
    }
}

replaceTextContent(document.body);


},1000); })()

评价：缩进不对的地方是我手改的， 85% 是AI生成的
我一般只用 ()=> ， 但用上 on('keyup',arguments.callee) 也挺有意思

AI提供全文替换的方法超过SO上的全部回答（虽然只是dfs
—
上帝的“帝”是一个相当世俗化的人间概念，用来形容一神教中的那个绝对之神很不妥，属于以凡人之心度god之腹。
关于「耶和华神」「上帝」 有个更贴切的翻译：高德 太原

把god 翻译为“高德”符合基督教中上帝是至高的善的定位，也有利于占据道德高地。
有人说“基因”这个词的翻译是非常绝妙的，“高德”这个词有异曲同工之妙。 😂

// ==UserScript==
// @name         括号树图
// @description  支持括号格式思维导图
// @match        *://sketchviz.com/new
// @run-at document-body
// @grant unsafeWindow
// ==/UserScript==

//onclick=()=>console.log(式=read(prompt('括号嵌套')||'1 (2 3) 4'),图(式))
const
read=cod=>{let tok=cod.split(/\s+|([()])/).filter(x=>!!x).values(),
par=s=>{let a=[],x;for(;(x=s())&&x!=')';)a.push(x=='('?par(s):x); return a}
return par(()=>tok.next().value)//^ 一般需配对。此省行数
},
图=t0=>{
  let sb=[],写=a=>{
    let x0=a[0],x; if(x0[0]!='_')for(x of a.slice(1))sb.push(`${x0}->${(x instanceof Array)?写(x):x}`)
    return x0
  };sb.push(写(t0));return sb.join('\n')
},
hook=(o,k,f)=>o[k]=f(o[k].bind(o));

let it=unsafeWindow, _1=1
hook(it,'fetch',f=>(url,c)=>(0>_1--)?0: (c=>{
  hook(editor.getSession().getDocument(),'getValue',f=>()=>`digraph G{${c[0]} ${图(read(f()))}[shape=${c[1]}}`); editor.setOptions({wrap:20,fontSize:20})
  hook(it,'updateGraph',f=>()=>c[2]?f() :0)
  it.onload=()=>it.$(".logo").removeAttr("href").click(ev=>ev.ctrlKey? (c[2]^=1) : c[3](prompt('Font,Node0')||'Sans,cds];rankdir=LR;') ); c[3]("Handlee,Mdiamond];")
})(["","",true, function(s){let[fnt,sty]=s.split(',',2);this[1]=sty;this[0]="graph,node,edge".split(',').map(k=>`${k} [fontname = ${fnt}]`).join('\n')}])
||f(url,c))

#algorithm #history 方脸：为计划经济诞生的「线性规划」 https://youtu.be/1cLWzo78Q5g?t=900
#code

import numpy as np
import scipy.optimize as lp

# 优化目标函数：maximize 2X + 3Y
c = [-2, -3]
# highs限制条件：5X + 8Y <= 50, 10X + 12Y <= 120
A = np.array([[5, 8], [10, 12]])
b = np.array([50, 120])

# 设置变量的取值范围
x_bounds = (0, None)
y_bounds = (0, None)

# 解决线性规划问题
r = lp.linprog(c, A_ub=A, b_ub=b, bounds=(x_bounds, y_bounds), method='highs')
val,x,y=-r.fun,*r.x
print(f"最大利润为 ${val}，此时生产 {x} 个产品 A 和 {y} 个产品 B。")

在列宁格勒呢，有一家胶合板生产厂。它有80台两种型号的机床，生产5种不同型号的胶合板。而不同型号的机床生产胶合板的能力不同。

那么，如何合理的分配每台机床的作业时间和物料投入，使得胶合板的产量最大，就是胶合板问题。这个呢，看起来是一个简单的数学问题，和我们日常做的一些高考数学题呢是类似的。当然了这对一个高中生来说，只要好好学数学，这个问题呢，并不难解。但是问题是这里面我们能解出来是因为我们只考虑了单一工厂的前提之下的。可是苏联的实际情况却不同，

就比如这个胶合板的生产。除了要考虑自己的工厂怎么样生产效率最高，它还要考虑胶合板的原材料，比如木材的供应量。而考虑到木材的供应量，除了要考虑伐木工人的数量，还要考虑到伐木机的生产数量。而伐木机的制造数量又要考虑到钢厂的产量。此外，胶合板的生产还要考虑到使用的问题。胶合板有的时候用于房屋建设，有的时候呢也用于飞机制造。因此，还要考虑整个国家的房屋建设数量以及飞机制造数量。而飞机制造数量房屋制造数量又牵扯到非常多的问题。所以一个胶合板的生产规划是远比我们想象的要复杂得多的。

而根据苏联自己的记载呢，在1960年代，苏联国家计划委员会要对苏联及其加盟国的10,500个商品实施生产计划，而统一规划生产的工厂更是达到百万之多。想要分配这些产能在没有计算机的时代是一个非常困难的事情啊，甚至在当下有计算机这也是一个非常困难的事情。而为了优化这个计算，苏联时期还诞生了不少的知名经济学家，比如列昂尼德坎托罗维奇，他就在优化上面提到了胶合板生产问题时提出了线性规划，从而获得了1975年的诺贝尔经济学奖。所以这个计划经济虽然是个笑话，但是实施起来并不像我们想象的那么简单，只要国家一声令下就可以搞起来。

我们看历史总说中苏交恶之后苏联撤走了原子弹的专家撤走了这个那个专家导致中国的科技发展停滞。但其实对于当时中国最为致命的不是撤走专家之后原子弹发明不出来，而是撤走专家之后中国的计划经济搞不起来了。苏联因为有一系列的数学大师和经济专家，虽然他的计划经济呢可能会因为生产规划的问题导致大饥荒，但是，起码在有数学家和经济学家的前提下，这个计划经济他是能跑起来的。 🤓

#java #code serde codegen
用jshell API 实现了一个ini序列化，大概比直接靠javac 简单
>以下代码实现了 dumps(Pair::class) (Pair(0,0), mutableMapOf("first" to 3))

fun dumps(T:KClass<*>, ld:T=JS("(void)(${T} o, java.util.Map<String,Object> m){"+
  T.memberProperties.joinToString(""){"  m.put(\"${it.name}\",o.get${it.name.capitalize()}());"}+"}")!!
)=fun(o:Any, m:Map<*,*>)=ld.main(o,m).let{m}

所以说py真的太解压了.. setattr() 就算动静态隔离，typehint还能做格式验证
js稍微乱点
java 连个规范的元编程方法都没有，一群魔法师

我是觉得一个老古董语言就不要和jspy 比面向event和类型反射
Compiler 和 JShell API 就是tools.jar里的，做不到比 CLI更强的功能，就是调用快点
JS("") 和runtime其实是完全隔离的，它的classpath 相当于是编译期的，你可以把生成的代码按行号缓存下来，不需要defineClass
vs

// 定义一个 data class
data class UPair(val A: Int, val B: Int)
@Mapper
interface UPairMapper {
    // 定义一个映射方法，用于将 Map 转换为 UPair
    fun mapToUPair(map: Map<String, Int>): UPair
}
val mapper = Mappers.getMapper(UPairMapper::class.java)

mapper.mapToUPair(mapOf("A" to 1, "B" to 1))

https://github.com/mapstruct/mapstruct/issues/1672#issuecomment-969265894
https://gist.github.com/duangsuse/d022c7ad037bb7fed446f72ec9b38ef7

#py #tool 浏览器缓存 图片 爬虫
python a.py 'x\.com' 200 ~/.cache/chromium/Default/Cache/Cache_Data/*

python imgdump.py 'www' 100 `ls  --sort time --reverse ~/.cache/chromium/Default/Cache/Cache_Data/*`

#code

import re,struct, os

def ls_cache(urlRegex, kbSizeMin, *cache_files):
  key_marker = struct.pack('Q', 0xf4fa6f45970d41d8)
  def deco(b):
    # header is 8+4+4:keylen+4+ bytes[keylen]
    key_len = struct.unpack('I', b[12:16])[0]+4
    key = b[20:20+key_len].decode()
    body = b[20+key_len:b.find(key_marker)]
    if len(body)>kbSizeMin*1024 and re.search(urlRegex,key): 
        return mstrip(100,re.sub('[\x00/]','', key)),body
  mapFiles(cache_files,deco)

mstrip=lambda n,s: s if len(s)<n else f"{s[:n//2-2 -2]}..{s[n//2:]}"
def mapFiles(a, fOut):
    os.system('rm -rf png;mkdir png')
    for i,file in enumerate(a):
        with open(file, 'rb') as f:
            if f1:=fOut(f.read()):
                k,v=f1
                with open(f'png/{i}-{k}', 'wb+') as out_f:out_f.write(v)

if __name__ == '__main__':
    import fire
    fire.Fire(ls_cache)

你可以逐文件夹拼图： #bash 各种相对路径真的吐了

vcat() { cd $1;a=`find *|sort -n|xargs printf "-i %s\n"`
ffmpeg $a -filter_complex vstack=inputs=`wc -l <<<$a` ../$1.png ;cd -;}
for f in `ls`;do vcat $f;done

for f in find * -type d; do thunar -B $f/*; done #按文件夹 批量重命名
cp-id() { i=1; for x in "$@"; do X=$(basename "$x"); cp "$x" "${i}-${X%.*}.${X##*.}"; i=$((i+1)); done; }

最开始考虑了 https://t.me/dsuses/5305 和binwalk但太慢

mkdir a tar
cp `grep 'x.com' -FRl ~/.cache/chromium/Default/Cache/|find -size +200k` tar
binwalk -C a -D image:png tar/*
find a/ -name '*.png'|nl

#cg #code 国产剧《点燃我，温暖你》/110w 里面的一个桥段，天才程序员男主李峋期中考试中完成的爱心代码

效仿评论区就自己写了个…… 另外GL里字体/for循环是较难的

float heart(vec2 P) {
float t= mix(.3,.8, mod(iTime,1.2)),//心跳
r=pow(P.y-pow(abs(P.x),t), 2.)+pow(P.x,2.) -1.;//灰度函数
return r<.3? mix(1.,4.,-r) : r; //黑心换白心
}
在 https://www.shadertoy.com/view/llGSzw main尾部加上
fragColor = heart(fragCoord.xy/iResolution.xy/.2 -2. - sin(iTime)) ;


原up清华毕业，加州工作，微软码农 收获5w播放， 我寻思这好像也不难…… Shader试错比IDE还容易
B站大佬也挺多的，这种开源易懂的少
其实glsl会 desmos.com 都能模拟的
https://www.geogebra.org/calculator 这些工具超好用
主要还是靠工具和html,svg 这些基础知识
现在numpy+opencv 也普及了，PIL那样的canvas库也会慢慢淘汰吧
一切皆向量 一切皆矩阵

canvas就是一个比较装B的
但学了svg后 就真不是啥
反而gl滤镜更有趣
因为现在对app程序员的要求太低了
转个str, list 绑下sql就能用， 涉猎范围都被框架堵住了

#plt #code 谈到RPN，我昨天有个灵感想把js做成缩进的形式
就回顾了优先级算法（嵌套深度包括h1~h6树本质上也是优先级）

示例算法 sexp(tok('1 (2 3) 4')), exp(tok('1*2+3'), optab)

optab={[';']:-1}
"=;+ -;* /".split(';').map((a,l)=>a.split(' ').forEach(x=> optab[x]=l ))
exp=(s/*token x单项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
}

sexp=s=>{let a=[],x;for(;(x=s())&&x!=')';)a.push(x=='('?sexp(s):x); return a}
//^ 一般需配对。此省行数
sexp=(s, a=[], f=()=>{let x,i=0;for(;(x=s())&&x!=')';i++) {x=='('?f():a.push(x)} a.push(i) })=>(f(),a)
//'(a (b c) d)' 换RPN [a b c 2 d 3], 可显示步骤

tok=(cod, s=cod.split(/\s+|([()]|\W+)/).filter(x=>!!x).values())=>
 ()=>s.next().value

https://t.me/dsuse/19097 圆括号解析, CSS代码高亮
https://t.me/dsuse/19320 各种正则替代lex,trie 的妙用
https://t.me/dsuse/17410 带步骤 四则计算器

https://t.me/dsuse/19387 类型推导科普, 动态和词法域,SQL的方言, 转译器 sourcemap
https://t.me/dsuse/18139 bing挑战各种算法和BNF

我还想了个有意思的鬼畜kt翻译，只用 忆一事悟疑实 6个字：

忆一 忆 Pair(一 x:数, 一 y:数)

忆 Main(一 a:行<Pair>): Events {
悟 事 onInit() {
一实((x,y) 于 a) 疑{ x==Z -> 不输别玩 }
}
说的 废物 一 Z=0 //inline private
}
忆悟 Events {
道理 事 onInit()
}
可惜kt没支持 for(..a) 和 a.forEach{} 平权
不然还能更好玩
📝 明天写出来会贴gist