#life #dev duangsuse 落实 10:30 准时睡觉『政策』。 🐱

考虑到健康原因（不让自己的努力白费），每晚 10:30(h:m) 必须立即睡觉

== duangsuse::Echo 参考 #Telegram hashtags

duangsuse::Echo 常年利用 hastags 标记消息所含知识领域，并且，这也会为未来 Echo 频道进行简单准确的数据统计带来可能（不然，我也有其他手段，比如 NLP、统计预测）

以下是新的标签实例（不区分大小写、不能保证消息只含这些标签）：

== 消息平台部分
#Telegram #zhihu #Github #so #Coolapk #book #wiki

== 注释部分
#life #China #School #Statement #lib #recommended #low #fix
#project #blog #share #Learn #paper
#dev #tech #art #meetUp #conference
#Moha #Haha
#gnu
#Microsoft #Mozilla #WeChat #QQ #Weibo #Tencent #Baidu #Ali #Qihoo
#tools #code

== 程序设计语言部分
#Kotlin #Java #JavaScript #JavaScript_ES6 #TypeScript
#Rust #Go #Swift #Dart #Crystal
#Ruby #Python #Perl #Tcl #Lua #PHP
#C #D #Cplusplus #CSharp #Objc
#Pascal #Fortran #Delphi #Ada #Basic #VisualBasic
#Scheme #Haskell #Scala #Clojure
#TeX #Graphviz
#Octave #Matlab
#Shell
（有些写出来是为了鼓励我去写，其实不一定真的写过）

== 软件平台部分
#Android #Windows #Win32 #MacOS #Java #Java_JVM #CLR #Qt #GTK #Tk #WxWidgets
#CSS #XML #JSON #KDE #Postgres #dotnet

== 软件技术领域部分

#backend #sysadmin #frontend #sysadmin_net

#OI #CS #IT #Informatics

#stat #ann #ann_dnn #machl
#math #math_linearAlgebra #math_discrete
#se #se_dia #se_ci #se_ee
#comm #net #www #web #http #html #mail #wireless
#circuit #embedded #os #db #db_relAlgebra #SQL
#bin #encoding #encoding_audio #encoding_image #encoding_video #encoding_text
#hpc #parallelism #distributed #simd #gpgpu #crypto
#pl #pl_plt #ce_vee #ce #ce_optimize #fp_monad #fp_proof #fp #oop #oop_arch #sp #parser
#algorithm #struct #lists #maps #sets
#security #security_lowlevel
#signalProc #nlp #phonetic
#cg #cg_dip #cg_3d #cg_2d #cg_lowlevel
#gui #gui_animation #gui_layouts #cli #visualization

#Go #Qt #Cplusplus 🤔 让我想到了 int main(int argc, char **argv) { QApplication app(argc, argv); return app.exec(); }

#Go #async 🤔 不知道此例有什么意义，原子性操作？

唉，不知道是不是 snake_case 更适合人类，我中国人可能没有什么感觉

但是世界上其实也有不少出于好的目的做的事，最后却事与愿违的例子，但愿不会有这样

不过我是真觉得 #Kotlin 的 fun 比 #Rust 的 fn, #Go 的 func, #Python 的 def 好看，总感觉就这一词的选择，不谈 val/var 的对仗，已高下立判。

或许是因为那个“乐趣”真的很吸引眼球吧，对子程序的利用，本身就是非常有意思的事情

#java #zhihu #go #typing

https://github.com/wkgcass/Latte-lang#%E4%B8%AD%E6%96%87%E7%89%88-chinese-version-readme #recommend #plt #jvm Latte ，记住了. Java6 的class编译实现

zig,red; scala.js RustPython moonscript nelua jsweet java2script
https://zserge.com/posts/jvm/ 这个是 #go #bin 实现读classfile常量池&栈执行
https://github.com/axkr/symja_android_library #math #android #tool 符号代数/绘图工具
https://github.com/JacksonTian/stone-lang/tree/master/src/chap12 适合小白读物配套（确信
https://github.com/enso-org/enso 图形编程,可视化, enso.org
https://vlang.io/ 类Go C目标语言，默认no-mut,支持内部序列化. 作者貌似做了C的双向翻译
https://github.com/lclang/LittleCat 用法不错，支持闭包
https://github.com/tern-lang/tern 含游戏示例. 文档太细节
livescript.net 含IDE插件示例
https://github.com/tonysparks/leola 支持协程, namespace: 是啥鬼

https://github.com/cqfn/eo 奇奇怪怪的XML语言.. jolie-lang.org 奇奇怪怪的 Swagger??


https://www.zhihu.com/question/27831730 RednaxelaFX大在这里手撕 #java 编译与反编译器，🐮
你R大永远是你R大🤪

https://www.zhihu.com/question/39400401 还是R大谈CLR-JVM=真泛型&in-out,delegate,P/Invoke&unsigned&Valtype,unsafe和受检溢出,无classloader 树 ，其他人就知道tailrec和jit,gc这些还说混了

不愧是R大 真不是盖的
一己之力拉高 #zhihu 编译原理水平

https://zhuanlan.zhihu.com/p/385042207 #ce
看完我算是满意但又比较失望的。 其实他的AST可视化(是用 pyecharts. 一个children;text 的结构)做得好，但就最开始的那篇博文就走偏了
我以为那个计算机是逆波兰栈的(据说现在一些大学这样教, iseki 表示他上过课来问群朋友，当时吓得我以为是几百行代码才能做,赶紧抱紧那个民科优先级算法... 😂)

他的计算器只能算 "1+2", (很可惜递归下降不适合解决优先级) 但把分词/解析的职责和求值流程教了下，感觉鸡肋(因为30行parse()就算个加法..)。我不满意的是这个Python 实现没有简洁性， interpreter 会构造大量 dataclass ，故这个人每期代码都4,5百行

https://zhuanlan.zhihu.com/p/24035780 这是 #JS React 的爱好者写的，他举的 Expr+Factor=>Expr+'('+Expr+')'=>1+(2*3) 展开和 if Expr then BB (else BB)? 很实际，Java 里 if() if()a;else b; 的else是就近原则，但 LL里要写明 if() WithElse else Stmt 这样
然后左递归 A='a'|A'b' 就是 A='a'|'a'A1 ;A1='b'A1|null
可惜这种写法有多少层优先级就要有多少调用栈，在 Kotlin 里都有快10种，规则不重要，最终代码你要全部手写我敬你 😐
而且组织AST的方法也有点怪，是用 let p1=new Node("Mul"); p.push(p1); readTerm(); p=p1; ，没有用参数 也没提及 p=p1; 得每次readXX 重设
最后 visit 的方法也是依赖 + * 的层次性的，不可能推广到同层次 +-或 */ ，命名也不简洁

200赞。。。应该说在流行编程界教这些东西会更好…… 贺师俊 hex老也来了
https://zhuanlan.zhihu.com/p/208906640 #Go .这个的原理一样，但解析时求值了
https://zhuanlan.zhihu.com/p/331794661 他们的那套编译原理的真理论( 🤷‍♂️
https://zhuanlan.zhihu.com/p/26660940 #JS 这个和我最近设计的一个有点像... 不过也不够简洁(20行深拷贝... 30行都能实现miniKanren了)，但非常直白

#learn 那我就讲下 N/D Finite Automaton （状态机,别瞎听他们加绝对前缀,没意义），下简称 N/D
N是一个状态列表，从列表:起始/begin状态号到含完成/final 状态，一次匹配就成功。 每状态有 CharClass 对应，成功则转移到许多?状态，否则原位
abc , a[be]c , \d\w+ 都可写成字符类的状态机，^$ 蛮特殊的，它断言当前在输入首尾

N不如D适合 match ，N的所有状态是平级的，ab?c 时状态会回退a，类似 when 变 if-else 会更实际些f
a[bc]*$ 里， (S0 a (S1 [b b1-S1] [c c1-S1] ) $) b,b1 这些"连接态"是等价的，a和$ 是等价的
把 通过S0通过a 能走到(transit)的态记为 q1, q1通过b 滤出q2 ，而只要q里包含 finalCell 就是结束态 ，继续下去可把N转为D。
“ 在这里是 {n5} 。之后求它的边界， 即每一个元素都通过 ε 走到能走到的所有状态，记为 q1 的闭包。” ... 其实就是BFS/DFS
“不动点算法：算法可以提前运行终止，因为状态数是有限的” ...

while(que.size)   
    q=que.pop()
    for(c in q)
        G[q,c] =t=dfs(links(q,c))
        if(t not in Q)// Q = {q0, q1} , workList = [q1]
            Q.add(t);que.add(t)

得到 (S0 a (S1 [b [S2 bb bc] ] [c [S3 cc cb] ] ) )

在mivik的正则库里，NFA.from(append="a").oneOrMore 是 NFA的Builder ，StaticNFA.toDFA . CellList=StateList ；因为 outs 是 BitSet (IntSet) 还支持序列化所以很乱，但这个算法就难..
在流程构造里 begin,end 是常被extend()的， link(cell, final)是状态尾部
repeat(1..2) 是最有趣的，repeatAtLeast 只是把 m.copy() extend N遍然后 m*，rep(a..b) 则是在a后放 b-a 个可跳end 的单元，遇到不在内的自然就跳出了

讲不完... 🤪 没有精力了，图形学应用还鸽着呢

正则能不能直接变DFA？ a(b|c)*$ 转NFA还好， a 喂b,c 或$ 会转移，而 cb,bc 是互相转移的
最魔怔的就是直接替换为规则集的规则 a=b|c|$ ;bc=c;cb=b; 还有cb$ ，'b' 本身没喂对可以不转移，也能等价它link到的字，这是什么构造.. 1字符1转移都没会还要整理这个 🤪

#Rust 的 struct/impl-fn 设计非常好(好像还能作union.. ) ，也支持闭包
std 有一些 box,ref,Vec,Map 的对C++ 习惯也很直接，而且有unsafe 能取代C
值类型&mut和(i8,i8)、流控匹配， FFI 和 Emscripten 也很好 (尽管不如Kt重视语义性
总之和 #Go 这种民科语言是完全不同的，mivik/kamet,rin 都是以rs 为原型（尽管不支持匹配解构）

但是设置环境是要花时间的，如果你的程序就那样，用什么语言其实没必要。 Rust 的分配期推导越来越好了，语言工具也完善内部。基本可以直接从其他语言翻译，但是什么语言其实都一样的..

#Java #android #reveng 其实Rhino 等利用了Java代码生成但在android兼容也是用这种临时去dx翻译
https://tttttt.me/Ralphonograph/4393 #go SVC模板

https://tttttt.me/kotlin_cn/25220 #kotlin #go 面向job/task计算称 #concurrent ，和完全平行(如滤镜图片)不同

bench=repeat(10_000);o=Any()
c=Channel<Any>()
runBlocking {withContext(Default){
  launch{bench{ c.send(o) }}
  launch{bench{ c.receive() }}
}}
//c.close(); launch.join()

Channel 和调度器 Dispatcher ，在浏览器有 worker.postMessage 和 onmessage

var wg sync.WaitGroup;wg.Add(2)
var token struct{}
c:=make(chan struct{})
go func(){
  defer wg.Done()
  bench{c<-token}
}
go func(){
  defer wg.Done()
  bench{<-c}
}
wg.Wait()

defer WaitGroup 在凑齐2项时传输(循环看错位)？其实是用计数看是否有job存活，都Done掉退出时再继续主线程

runBlocking{//limitedParallelism,newFixedThreadPool,single..
val produce=produce(Default){
  bench{launch{send(1)}}
}
var n=0
produce.consumeEach{n+=it}
}

也有把 Channel 异步序列变得友好的做法

线程切换 >> 函数调用(没有线程切换下的协程切换) > batch之后的函数调用

>分别对应于代码实现的Dispatchers.Default + 无buffer (如果你写对了的话), coroutineScope + 无buffer , coroutineScope + buffer
Exectors singleThread asCoroutineDispatcher
>wait是指blocking的wait么?没看到channel的代码,但是可以断言里面不可能线程停住等待
>不， 是指协程底层在无可调度时的wait；能看到一半是无锁链表，一半是LockSupport.park
之前和他的差这么多，估计是被调度到一个线程上去了，不知道Default里边的策略是什么样的

#learn #ts #kt 子类型 vs 组合, in/out参数
https://tttttt.me/dsuses/5194

总之，trait类型的交集 还是需要in/out，这不是子类型带来的麻烦。
a=append(a,x) 与 copy(a,src) 类型上是一样的，前者也并不能“把a修正为更窄接口”。 Go必须把list+=单项 写出来, 因为缺少型变

func main() {
var src []interface{} = []any{1, 2, 3, 4, 5}
var dst []int = make([]int, len(src))
copy(src,dst) //错:没有共同接口

func copy[T any](dst []T, src []T) {
for i := range dst {
dst[i] = src[i]
}
}

更多关于 #rust #go #plt 的原理
https://tttttt.me/kotlin_cn/74484

https://rustmagazine.github.io/rust_magazine_2021/chapter_4/ant_trait.html#向上转型upcast #recommend

https://rustmagazine.github.io/rust_magazine_2021/chapter_10/lisp-in-rust.html

举例， #ts 上有”交并集类型“ （有人认为 hs, Rust 没有子类型所以不存在集合论的，确实如此但 in-out 形变是Racket子语言里也有的,我找不到原文但TRack 是有）
(我一点也不羡慕没有重载和this模块等多态技术的圆括号 😅, 模型的缺失是拿宏手动兼容 a.b.c 所弥补不了的, 就像 F# 的 |> 比不上 xx.let{}, kt 的元组 destruct 比不上 ES6 let[x,y]=P, ES6的解构又不如 Prolog 的 unify [x,1]=[2,y]...

观摩王垠《别再欺负我们读书少》:
- int -> int | bool ->bool 表示的确实是一个intersection type(^)，而不是union type(|)
- id(itself) “同时”是int->int和bool->bool，而不是表示它“有时”是int->int，而另外的时候是bool->bool。
- 所以，id(1)一定是int。如果你输入id(True)，它推导出的一定是bool。
- 否则，调用id(1)会报错，因为id的类型有可能是bool->bool，不能接受int的输入。调用id(True)也会报错，左右不是人。


但我习惯拿 成员交=union ，成员并=insect ，绝口不提“同时”“有时” 这种抽象说法乃至术语
- int -> int | bool ->bool 表示的确实是一个重载，而不是Either
- id “必须”是int->int, bool->bool ，而不是“可为” int->int | bool->bool。 when(x) { is Int, is Str } 这种情况才是“x可为二者”
- 否则，调用id(1),id(True)都会报错，因为id的类型有可能是bool->bool，不能接受int的输入，或者反之。

严谨性绝对是次于创造力的，况且，含糊的说法对同时使用和实现不利。
虽然这些都是小小的细节，但每个细节都注重可读性，随着设计的步进，最终会形成巨大的差异。即便都是用AI，我的实现也会有很多不同

#linux #hack VSCode Alt-S 同行数多光标可以列粘贴，但在 #telegram desktop 里编辑、导入导出长的富文本，就完蛋了 😅 Bot还被限制了2个链接截断

web.telegram.org 是用 $('[tabindex]:read-write').innerHTML 表示消息的，bot markdown 所支持的格式勉强能F12粘贴
不知为何Qt与Chrome,Wx的剪贴板不兼容

xclip -selection c -o -t TARGETS

xclip -selection clipboard -o -t text/html 剪贴板接口也不是旧版 application/rtf text/uri-list，很明显与Qt没有关系😅
或许它独立于DOM自己定义了Paste,DnD这类手势？（其实是数据类型

搜了下API,找到 setMimeData Linksparser application/x-td-forward 这些符号，但其实还是一个按区间的格式 x-field-{text,tags} 😅
tdesktop.FieldHandler 渲染了 FieldTagMime 的消息, td消息格式的源码都搜不到 🤮 但确定不是 MTP (#Go protobuf 定义)

hexdump -e'1/4 "%X" "\n"' 可以看到是基于int区间的

#learn #dalao async https://lutaonan.com/blog/my-coding-road/
#go #os https://accidentallyquadratic.tumblr.com/post/113405561337/debian-sbuild

异步，就是在此Thread之外完成res=sleep()等耗时任务。不在一个调栈上，它的retAddr就必须转回调参数；因要建多个Task监听res —如FJP式并行，调用者就该用 event queue "epoll"而非 while(!res.ok)
C线程就是内核调度的协程，即「有栈协程」或虚拟线程，好在没await传染性
OS内核使用分时「抢占式调度」，协程则主动休眠并pass出自己的回调，是单核并发 无「上文切换」开销

TS使用的async 是从yield协程co()得来的平等协程，它在yield Promise的位置，传入状态机即续体NEXT
假若 yield(x) 的续体没被写死为 self.value=x,next=NEXT ，异步可直接传入回调NEXT
co-routine 和closure 都是靠栈转堆 “把编译器当OS内核用”。经典模式 while()yield 就取代了class Iterator{}，这类似Linux cat .txt|less 毕竟文件流有时相当于SIG{HUP,CONT}
续体的局部变量+语句指针堆上分配，不占调用栈。语句走完后，触发then(retAddr)

占1线程应该 当队列 当CPU cycle。Go和Kt支持waitGroup,select "epoll" 也就是Promise.all,race 了，它们都给了协程作用域即错误边界
^FJP: ForkJoin, MapReduce
^如果 int waitpid() 能发扬fork()的魔术 返回JSON的话，多线程或许都会晚些到来呢？

JSDOM的并发撤销很保守，“用不到=不用学”，而某些新语言和Rx移动端的很狂野，好像《我会自己上线程池》是智子加锁的API一样
所以JSPy简直后端界良心

#learn #cg #go #bilibili #algorithm
> https://www.bilibili.com/video/BV16g411B7Ff
尝试实现下视频里的”大一“代码，感兴趣的话可以深耕

并不天才啊，就是 https://www.desmos.com/calculator/ 里像素化个灰度函数 (y-abs(x)^c)^2+x^2=1
可以把每个运算当成对样条的变换，例如删掉abs(x)不会对称
https://mathworld.wolfram.com/HeartCurve.html
推荐这个超好玩的 https://www.shadertoy.com/results?query=Boids

https://golang.google.cn/tour/moretypes/18
你可以 在Go入门试玩一下
或者下载 Jupyter , p5js
推荐 https://jupyterlite.github.io/demo/lab/index.html?path=p5.ipynb
> 我记得大学的时候，我实现一个水波纹，搞了快一星期
那是因为你的工具没用对

只要降低五花八门IDE的杂音，只交互式写代码就可以了
创作式编程就是需要注意力
https://codelabclub.github.io/blog/2020/06/28/当我们谈论编程时，其实是在谈论玩乐与创作/
就是吧，你用jspy写，不关心杂七杂八的部署问题
就ok了

> 像素着色器才能并行，利用GPU的性能
当时就是C++写的，有个很垃圾的国产引擎（cocos2dx）
numpy,torch也行啊…… GLSL也不是很难
性能不是最重要的，主要是效果好

其实你在墙外，会搜关键字就能比许多人强了

因为编程的本质是摘抄缝合
像百度那种垃圾搜索引擎是不用看的
用那种工具搜那种圈子的程序员没有进步能力
https://coolshell.cn/ 已猝死的陈大佬说的很清楚，程序员的第一工作就是拉黑内容农场

陈大佬自己也开公司呢，不过去年猝死了
挺可惜 他也是个公知
他明明是个很广的全栈程序员
可惜天妒英才， 每次都是优秀的程序员死，称职的活
然后七大姑八大夷拿这个去劝退称职的程序员

>那么要用哪种搜索引擎好？墙外那些吗？
duck.com bing.com 什么的啊
反正不能用墙内的
对程序员来说一手资料是最重要的
英文wiki都比中文全面
其实不要以为只有抖音快手在洗稿，GFW只是内对外的墙
中国内部各圈层的资讯都是极不流通的
所以张雪峰这种人能火

#rust #go #algorithm UmbraString 是对带长度指针(py.bytes, rs.slice) 的(免链接inline)，而 SwissTable 是对Hash预分组查表的免链接！

我们知道，Java 存在(装箱boxing) 一说，也就是int,char等字面值的堆分配 (这是泛型擦除 vs template<>化新建的编译期细节)，因此JDK8用class Stream.OfInt{}缓解了reified泛型的缺失

那么，(拆箱unwrap) 其实就是在值的内存上内联，像C++栈分配。 除了禁止null，拆箱在运行时有省内存GC、免链接、CPU快取等好处

这么好的算法升级，实现难吗？
map采用预分组查表,哈希值冲突(哈希值一样)的键值对会被放在一个桶中，查找桶=hash(key) mod size，然后再遍历桶中Eq的元素，这里有通过额外的bit做更快的检查。 #dalao https://gufeijun.com/post/map/1/

一旦map的负载因子(键值对个数与桶个数比值)过大，查找需要线性遍历多个桶，性能会退化为O(n)，所以这种实现需要更频繁地对桶进行扩容，保持负载因子在低水平。
拉链法是大多数编程语言的选择，每个桶后面跟上一个链表，所有的同义词通过链表中节点形式串联

SwissTable 使用一种称为Closed Hashing的方案。每一个哈希值都会有一个自己的槽位(slot),槽的选择是由哈希值决定，从hash(key) mod size的槽开始查找，一直往后查找到空的槽(null)
SwissTable也是和内建的map一样采用短哈希(8b hash),以便支持快速检查，但是它的元数据却是独立存储的，和哈希值存储分开。

把hash值分为高7位和低57位：
高7位用在control byte中解决hash冲突 (这7位只是以很低的代价，减少了90%键与键的比较。)

低57位是slot的指针，每个slot对应一个1一个byte的控制字节。

Control byte的高1位用于表示状态 0xFF=undef, 0x80=null值 ，低7位用于存储hashcode的高7位
128bit对齐的连续8字节的control byte称为一个group

使用这种方式，可以通过SIMD 指令并行比较 16 个短哈希，比 std::unord_set 快两倍 （map只是K:V元组按K搜的set）
Flat hashtable不仅仅只是CPU CACHE友好，这样的结构配合原子操作，相信很容易做出一个并发版本的hash table

#dalao #go https://pandaychen.github.io/2023/05/01/A-GOLANG-BYTEBUFFER-ANALYSIS/

#os #go #py 协程 https://lucumr.pocoo.org/2024/11/18/threads-beat-async-await/
作者似乎想用Scratch里没有await传染性的例子，说明return的自动回调化是骗局。 说真的，JVM和QuickJS应该有「有栈协程」，但程序员对它的控制太低。
IO异常耗时，应当被最小化、隔离，是很难理解的事情吗？

https://editor.p5js.org/p5/sketches/Image:_Load_and_Display_Image #code

setup=(
  cat=loadImage('assets/moonwalk.jpg'),
  P=createVector(width,height).div(2)
)=> {
  createCanvas(720, 400);
  draw=async()=>{
    for(; P.x<2000; P.x+=5, await sec(.1)) {     
      clear(); image(cat, P.x%width,P.y);
    }
  }
  'BAD'?? (draw=()=>{
    if(P.x<2000) P.x+=5, setTimeout(draw,100)
      clear(); image(cat, P.x%width,P.y);
    //如果用伪递归做 for x in range(0,2k) 这很自然！其实
  })
}
wait4=f=>(...a)=>new Promise(ok=>f(...a, ok))
sec=wait4((n,ok)=>setTimeout(ok,n*1000))

回应式(Reactive)只是给你自己管理单核while(1)的机会，挂起到函续是为了灵活复用触屏鼠标等流资源，调用栈=函续链表，yield=将caller的(retAddr捕获到.then)的空函数。 前者是魔法是驱动，后者是回调，是数据值。
回应式>卡线程，就像@装饰器>C宏 ，默认final>默认mut ，理所当然的严谨，不留模糊的余地。 trust me, Thread.ofVirtual() 和点号前面那货有代沟！ 60年代为编译器的，竟比y2k为UNIX的API强。

至于async所“严重”缺乏的waitGroup，实际轻得多，而且 Promise.all([]) 能返回[]， try{} 可以捕获内部await， Thread.join() 却啥都没定义，这安全吗！
他们只是看不惯JSer们对「OS后端的专利」有所突破，打破了NonlocalJump的魔法次元壁，把IO、设备流信号、缓冲区为己所用，突破了轮询+回调地狱的框架而已。
作者似乎想用 neverSettle = wait4(f=> 'never f!') 证明回调的依赖倒置是错误的，是泄漏的，但谁都知道 longjmp()和fork() 坑更多、更慢。不知哪天设备信号或驱动syscall就把UI卡死了！

因为就连Linux长年的八股“非惊群”evpoll，也是DOM「Reactive富二代」玩剩下的。
他应该想说 https://lotabout.me/2020/Back-Pressure ：

60fps达不到，是卡帧or丢帧； 网卡流丢了几个包，是等待TCP or 佛系UDP； cat|less 的端点SIGHUP了，由谁持有cat已print\n的行？或是让cat卡在SYS_write()，甚至直接panic？
对N:M task来说，线程池里每个Worker，比如它们的write/sendto()，都有瓶颈。这就像在2核CPU上 make -j8 ，最终不是慢在切来还去，就是内存占满。 用户态调用栈(async回调) 忽视了N资源M监听反会变慢。

作者批评了 asyncio writer.drain() 的不默认，和超过SQL瓶颈数量的并发(缺乏 CapacityLimiter API)
作者建议，在 HTTP 中，您可以发出 503，它还可以携带retry-after标头，告诉客户端何时重试
其实，受到速率异步问题困扰的不仅仅是 async await 代码。 例如， Dask是数据科学程序员使用的非async Python 并行库，仍有因拥塞而缓冲区耗尽的例子

值得一提的是，作者引用这篇把 go func() 证明为goto的Rustacean文。 这种思想(其实就是 Thread.join)也在 py async with: 和 kt coroutineScope{} 里
https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/
https://docs.rs/async_nursery/latest/async_nursery/#basic-example

#recommend #go #dalao
https://halfrost.com/go_reflection/#toc-7
https://halfrost.com/flatbuffers_flexbuffers/
https://halfrost.com/halfrost_2017/