那我就照本宣科地念了：
+ （信息）声音：就是物体的震动，振子的振幅，就是信号。
+ （信息）图像：就是一堆『像素』的二维矩阵xy……
+ 24bpp：（色彩深度）24个二进制位per pixel
其中一般是 R(8bits), G(8bits), B(8bits); BGR 也有
最多显示 1677万 (R*G*B) 种颜色
+ 32bpp：（色彩深度）一般是带Alpha混成像素色值的颜色
+ 灰度：心理学灰度公式（线性）

Y = 0.2126R + 0.7152G + 0.0722B

显而易见地，数学不好是不能做计算机视觉甚至数字图像处理的……
+ 信息学、熵(shang1)、电子(electron)、热
密码学、加密、隐写、编码技术、千年虫、64k-intro、DEOM技术、huffman算法

最小公倍数、最大公约数(gcd, greatest common division)、fibonacci、函数变化率

我也不知道为什么有这些东西，大概是我看小说看到的，我物理和数学都不好

+ 谈谈 Base=64 是啥意思
这还准备教 Base=1000 呢
后来我觉得我佛系了，我就扔一个公式就走人。

2**(8*n) = 64**x where n, x in N+

看起来这个等式不是很好解啊
两个未知数都在指数的位置
一个解是 n=4; x=3

那Base=1000呢

2**(8*n) = 1000**x

只能用miniKanren解了呢……

https://codon.com/hello-declarative-world
https://github.com/nd/mk.java/blob/master/src/main/java/MicroKanren.java

可是我不会啊…… 这里也有两个未知数呢

def solved(n, x); 2**(8*n) == 1000**x; end

上枚举吧, n=(1, 10]; x=(1, 10]

(1..1000).to_a.combination(2).map { |nx| [solved(nx[0], nx[1])||solved(nx[1], nx[0]), nx] }.find_all { |it| it[0]}

好像还是不行呢…… 可是第一个表达式是有办法的

[[3, 4], [6, 8], [9, 12], [12, 16], [15, 20], [18, 24], [21, 28], [24, 32], [27, 36], [30, 40], [33, 44], [36, 48], [39, 52], [42, 56], [45, 60], [48, 64], [51, 68], [54, 72], [57, 76], [60, 80], [63, 84], [66, 88], [69, 92], [72, 96], [75, 100]]

hhhhhh好无脑
+ 依照CFG(Control Flow Graph) 谈 return early

虽然我好像已经谈过了（而且这次显然我不会扯到SSA的PHI……），
就是说可以要在一个函数返回前添加固定的步骤，所以不能直接 return 这样
我们这里谈的不是和 calling convention 里栈帧末的收尾代码。

说点抽象的，如果我们一直用 if (p) {…} clean(); return;
实际上不管怎么样 if (p) 里面的东西，除非return跳转都会 fallthru 到 clean(); return; （隐式return也一样）

但是如果你

if(!p) return;
if(!p1) return;
clean(); return;

就不一样了，显然直接 return 会跳过 clean();


那该怎么办呢？C宏（辣鸡宏）你可以很dirty的搞个

#define clean(x) { clean(); x; }
void do_sth() {
  if (!p) clean(return);
  if (!p1) clean(return);
  clean(return);
}
#undef

很甜吧，但是稍微有点常识的人都不会用
还有，内联(inline)、嵌套(nested)函数是不允许的

C++ 你可以用 object + finializer，直接RAII(Resource Aquring Is Initialization)
可是 C 里面貌似没更好的解决方法。
一般来说都是

if(!p) goto out;
out: clean(); return;

+ 语文课上居然都谈到区块链
第一时间
《区块链离我们有多远》

我只知道金仨字面意义上的书记有一大堆，所以单单一个书记想伪造敲诈公款是不可能的……
别人说什么造假成本高于造假收益，反正就是密码学啊计算机网络那一些（可信计算？）的东西？


+ 我做梦居然梦到华为EMUI的计算器应用升级
居然还能递等式，还把括号里的东西加了箭头…… 其实我本来可以学学画dot图的，还是直白一点算了
大概是我想 Calc.kt 的二元链解析算法想过分了。
1 + 2 * 3 (梦里比这个复杂得多，我记得当时还是设计质能公式的一个略繁琐的物理算式…… 居然能那样)
= 1 + 6 — 箭头指着上面的 2 [*] 3……
= 7 — 还是有箭头……

+ #book
《文章|书 名》 作者
《她是龙》 小狱
《手机城》 最安神
《盛夏方程式》 东野圭吾
《莫言谈教养》 任万杰
《生气有啥用，还不是在原地转圈圈》 程智超

+ 谈谈知识付费

有时候看到知识付费呢，总会觉得是『知识』要『付费』，付费修饰知识。
可是总觉得，很多人心里会是这么想，实际上却是理解为『能够付费的知识』呢。

就是说，『付费』以得到知识。
『付费』比知识更重要。

付费的东西一定比不付费的强吗？其实这是很大程度依赖上下文的，无法作概论。
知识付费其实不是新概念，实际上学术界也有不少不得不向出版社掏钱的情况，但付费从不是目的，只是为了取得知识不能不拿出来的一点小代价。

如果还看重的是知识的话，就要明白呢…… 不要叫『知识付费』，叫『付费的知识』。

+ 谈谈Calc.kt现在的（基于ADT栈的）解析算法错在哪里

比如，解析词条流 a + b * c + e % c * a
（优先级自己从下面我列的结果推）

(a + (b * c)) + [(e % c) * a]

这是正经情况。
然而实际上，解析器会认为是这样：

a (+) (b*c) (+) [(e%c) * a]
(a + [(b * c) + (e%c * a)])

看到区别了吗？ADT Stack 是右结合的，即便 (+) 的左优先级更大也是一样
只是因为，a+b*c 里要先解析乘法，导致栈是这样：

a (+) (b*c)

如果过一会又出现了加法会怎么样？答案是会归到 (b*c)里：

a (+) ((b*c)+a)

如果又是加乘呢？

a (+) (b*c) (+) (a*c)

所以遇到这种连续两次 (+) 的情况，就都会变成右结合(参考Recursion的reduce方法)，实际上应该是左结合的
Expected: (a + (b*c)) + (a*c)
Actual: (a + ((b*c) + (a*c)))

+ 写两个递推式子
我也不知道有啥用，但是笔记上有。

y_0 = (inputs)
y_{n+1} = let x = y_{n} in f_{n+1}(W_{n+1}·x+B_{n+1})
—
0! = 1
n! = (n-1)!·n
当然也可以这么写，可这好像不是递推式了？
0! = 1
(n+1)! = n!·(n+1)
好奇怪啊

+ PL/0 实践的重点『难点』
1. 实现内嵌函数的作用域嵌套(nested function, leveled stack storage……)
2. 『一个好的解析器应该接受所有输入的所有部分且不能抛出错误』这个不算难，实现『「同步」的keyword token』也不难，就是跳过认不出的token
3. source map (指令序列pc到源码)（其实原教程没有）

+ PL/0 实践教程上的扩展题
虽然我觉得很废

—基础
注释：加入C风格 // 和 /**/
数组：多维数组
函数：传值调用
控制流：加入C风格 for, return，if elif else、exit
判断：(1) 短路求值 (2) && || ! (3) 表达式非零即为真
—提高
提供函数：print(_), print(_, _), random(), random(_)
提供intrinsic：CALLSTACK()
数组多维初始化，var i, j 快速初始化
函数：传地址调用
函数：传procedure调用
do while, switch 和 break, continue 甚至 goto, label
C风格表达式：比如 &, |, <<, ? : ternary 三元表达式, 赋值表达式（愚蠢


虽然照本宣科而且语言设计的也不好，但可见编译原理还是比所谓的『精通』强太多，因为编译原理就可以直接把 if else, do while, swich, break continue goto 什么的结构直接枚举出来，精通还太浅。

#c #PLT 一般情况能用 condition 表达式还是不用常量 while+break/continue. （哪怕提前声名量或是用 do while ）

说要用的情况就是 main loop ，C 里没闭包就只能用函数指针，或者宏，不优雅不高效，只能选择 while(true) 。 当然是否 #define forever 也是看复用处有多少的。

for(;;) 不喜欢，因为它本应是 for(init;cond;update) ，而 cond 在理论上省略默认 1 是不优雅的（这是语言设计上的不对）

原则上我是讨厌 1 替代 true 的，尽管对许多机器而言非0即真（不过说起来，所谓真假也就是控制流跳转与否而已）。

有一次我写 C 的时候
#define cyclicInc(i) (i=++i % max)
草了半天改成了 i=(i+1) 的形式…… 时序上这么弄还是不太优雅，分析起来麻烦

#algorithm 我可能会做也可能不会做，但最近显然是没时间想了（
不过我可以总结下题面：
() 是合法的括号序列，生成这种序列可以先弄出随机 1:1 对开 shuffled 的 )( 序列然后遍历求和(测试匹配)，显然 ())( 是不合法的，那么翻转后 2 char 即可
易不解在于翻转优化的插入-删除操作—— )()( 翻= ()() ，我不熟悉逻辑学所以不知道为什么，反正序列项只有两可能呗（
问题是，判断给你的 len(s) == 2*n 括号序列，为以上算法输出的可能性。

array<bool, 2*n> s;
int nOpen;
#define ACCEPT nOpen += s[i]? +1/*'('*/ : -1;
for (i=0; i<n;) { ACCEPT;
  if (nOpen >= 0) { i++; continue; }
  for (i1=i+1; i1<n; i1++) { ACCEPT; if (nOpen == 0) break; }
  for (; i != i1; i++) { s[i] ^= 1; }
  i = i +1;
}

（突然发现怎么有 i++ 和 ACCEPT 两处重复逻辑）
刚开始还写出了 forall i. s[0:i].count('(')==s[0:i].count(')') 甚至 s[i-1] (len(s)>=1) 我是怎么想的…… 序列归纳啊

#cplusplus 嘛，为了避免有人说我指点江山 🐸我就写几行证明下 fcntl() dnotify 是超级简单地。
Android 除了 RootFS 和 libc 结构外本质就是为嵌入式优化的 Linux ，而 DNotify 是 Linux 2.4 引入的目录变更监听机制(为兼容性, in_ 是 2.6 feature)，所以我用 C++11 lambda 不需要几行代码就能实现「文件变更的监听和删除文件的保存」

众所周知写程序先写测试：

touch a b; echo 1>b
rm a b
cat saved/b

预期 ./fsw_amd . 输出 Aa Ab Mb Da Db 行。
#cplusplus #code 草，居然不支持文件名…… 真的只能看目录么 那样只能 fstat() readdir() 扫 dirent 了，而且也没法知道具体什么文件有变更，非常草。 之前还以为是不能递归监听

#include <fcntl.h>
#include <csignal>
#include <unistd.h>
#include <cstdio>
const int sigPrior = SIGRTMIN+1;
#define notNeg(v) v; if (v<0) return -1
void printFPath(int signo, siginfo_t* si, void*) {
  auto o = *si;
  getFPath(o.si_fd); printf(" %s\n", fpDesc);
}
int main(int argc, char** argv) {
  auto fp = (argc>1)? argv[1] : ".";
  int fd = notNeg(open(fp, O_RDONLY));
  fcntl(fd, F_SETSIG, sigPrior);
  fcntl(fd, F_NOTIFY, DN_MULTISHOT|DN_CREATE|DN_MODIFY|DN_DELETE);
  struct sigaction dnAct = { .sa_sigaction=printFPath, .sa_flags=SA_SIGINFO };
  sigemptyset(&dnAct.sa_mask);
  sigaction(sigPrior, &dnAct, NULL);
  while(true) pause();
  return 0;
}

fs watch 是 Ruby/Node 系 CLI 应用重要的特性，包括 jekyll, inotifywatch 在内支持者不在少数，封装好的东西例子就不举了 睡大觉😴。
https://www.linuxjournal.com/article/8478 #linux #dev
https://github.com/NexusBots/Umbreon-Rootkit/blob/master/readlink.c
关于 dnotify 如何取得 path 的问题可以 readlink /proc/self/fd/0 ，看这个

#DontKnow MAX_CANON PATH_MAX 第一次知道 canon 是指 termios 意义的…… 难怪 termcontrol 会有相关常量名 😳

https://gist.github.com/duangsuse/a8984950c563894eea54fc2f537b5003#file-inotify-cpp
唉现在想着初学时不知道 stdio, fcntl, unistd, stdlib 这些 header 都是干什么的呢…… 不知道怎么选。不过，或许新手会觉得 C 的 std in/out/err; fprintf,fscanf; fread,fwrite 比 Java 的 I/O Stream 要方便些，其实 libc 的确更不方便呢

为了避免被认为是在指点江山我就简单 PoC 一下，真的不需要十行代码。 毕竟这个「反破解手段」门槛也太低了，只需改动 .h 文件&重编译，其它都自动兼容了。
而加密 bytecode 的各种方法全都逃不过内存 dump ，因为「原原本本」的程序文件是虚拟机要求的，总是要还原。 hook 一下虚拟机的 load() 即 luaZ_undump() 就都出来了，代码保护唯一有效的是削除命名标识符的本义，或者对程序做些预处理和切分什么的(对这些，基于符号执行的 smalivm 类反混工具也能消除)，但是大部分有「产权保护」意识的人 意识不到吧😒。

目标只是得出两版 #Lua 指令号直接的对应关系，也就是只需做指令id 数组的读取，得出的对应关系用于 patch 给 chunkspy 等工具。

本来说是可以用 getOpcode(buf, i) 的，忘记数组迭代需要长度的问题了，就用迭代器吧…… 也是惰性计算的😒

首先自编个 lua luac （实质都是 liblua 的命令行工具
curl -O http://www.lua.org/ftp/lua-5.4.2.tar.gz
tar xf lua-* &&cd lua-*/src/
make luac lua

#sysadmin 科普下 lua.org 的 doc 里 curl/tar 的 -R/-z 是 设置文件mtime/gz解压

看看 https://bbs.pediy.com/thread-250618.htm
https://tttttt.me/berd_channel/1647
可以参考

Luac chunk 文件是比较标准带 insn size 的二进制结构， size_t 一般为 4 (int32) 大端字节序，因为只需要读取 opcode 我就做个比较 hack 的操作——hexdump diff 断言指令数组头的偏移量，本来想可以直接取每条指令首字节，没想到这个好像是仅 7 bit ，那就只能 import struct 了😓
然后指令集也不必写完整的，反正也没有 unluac ，源码手改的，自己验证意思意思够了。

lopnames.h 对虚拟机无意义， lopcodes.c 只是定义指令格式的，所以要改 .h 里的顺序，稍后 grep -r 'ORDER OP' 还会发现必须同时更改 .c 的顺序，而且还得修正 lua.h 的一处 #define 🌚 (不过和 lcode.h 的 OPR_x 以及 ltm.h 没关系，因为 opr 是以 OP_ADD+i 及 TM_ADD+i 的方式两向对应的 )
其实如果不改 ltm.h 而想保证元表事件正常派发，那 OP_ADD 到 OP_NOT 直接的顺序都不能变🌝
不过这里就随便点，反正没用到～

用于乱序的 py 脚本：
同时 shuf .c array 和 .h enum 的索引号，总之就是先搞出 index mapping 再 apply 它两次。 🌚

用于对应的脚本(见下下条)：
d[op[i]] = names[op_orig[i]]

胡话：呃，好像是 d[k] = d1[d[k]] ... 不对
其实变的是 k 吧(re-associateBy)， d[k1] = d[k] 其中 k1=d1.keyOf(k) ，因为 v 都是复制过来的。

#plt #ce #backend 反破解小指南 🦜
嘛，其实这个还是有强化的方法的。 只需这个有强烈愿望🧐并且敢动 C 虚拟机🌝实现代码的人 对他的每个单个应用 重编译乱 opcode 的私有版 lua
同时更改下 LuaVM 指令格式 bitmask 里操作数的顺序，并且以自有算法加密常量池(必须由虚拟机层来解密，最好是惰性完成的 内部传输性 loadk 只传常量编号不解密)，这样对 naive 的破解者就非常棘手了，只能从外部 API 分析某一特性点的实现方法惹🌚

自有版虚拟机的代码文件看起来符合规范(因为你改得少)，但是完全无法被通常工具读取，一些虚拟机壳也是出于同样的意图(which 我没在 Android 上见到过，设计这种加壳器需要一定编译原理或状态机的知识 需要预处理 bytecode)

最关键的一点就是孤立自己利用到的技术，让破解者无法使用针对性工具，然后增加破解者自写工具的难度，尽可能用没工具的 native 平台叠加难度。单机程序用惩罚机制来反动态分析？可笑。程序状态是不可信的，稍有常识的坏人完全可以保留某 fork 的整机状态，你检查虚拟机都不行，有的是机会给检测方法 hook 光光；用别人的反破库，也容易被找到针对性反反破工具。😒
其实嘛，越是简单的代码越接近真理，越往程序的根基走，手段越能令破解者头疼。

其实用私有版 luaVM 不暴露指令号对应关系就已经很安全了(当然坏人🌝还是可以用生成 code 看 vm state 的方法甄别指令，虚拟机状态就不是纯二进制领域的人能魔改的了🤪)，但最好还是用预处理给 luaV_execute 的 opcode switch 每个 case 加点随机乱代码，防止被源码相似性搜索（这个只需要反汇编字符串匹配 破解者就能完成）。

介于 C 的静态自动分析尚无完整解法，对每个模块都要还原虚拟机指令才能反编译出真实逻辑，就可以说是「无法破解」的软件了🤣。
你掌控程序流程，你掌控无物；你掌控程序码解释，你掌控一切。
越是在根基做限制越难破解，但是外部 API 和 memdump 依然没办法对抗，但至少，这样反调试代码就不易被分析了🌚 这些代码能造成巨大的麻烦，让破解者不知从何下手，例如反外部 API 断点和管理加密的常量池，制造 garbage String 来混淆 memdump 。

什么叫做欺骗系统，「系统」这个概念都是针对软件运行时而言的，运行时可以是带trace/hook的实机、虚拟机或者静态分析器，这些都是合法合理的运行时，因为，程序只是数据而已。「我的代码，我的权利、我的私产」？谁能想到那么多啊😅。
除非有一天 DRM 会无法被模拟复制破解，不然最实际的方法是把软件做得足够大，然后诉诸法律或己方威权。

#learn #cg 《OpenGL杂谈》 🔬
GL提供了特殊类型 vecN (xyzw/rgba/stpq 来引用/自由重组均可;可iub前缀表示类型)和matNxM (m[i<N][j<M])以及 texture(sampler2D,xy) ，支持严格 int/float percision ，支持struct和传统C的控制流及GL特有 cube/shadow，代码的特性由 compile 环境/GL驱动决定(比如GLES就不支持break,许多不能?:和%=mod,**=pow,不同类型?:)。SL能计算frag颜色和vert点-geom顶边，对应渲染和物理计算(一个很草的事实是，基于GL计算的渲染引擎在CG界遍地开花，各有各好 🤪)

SL是没helloworld却有计算力的语言，和CSS一样，明明print都写不了却能定义动画
尽管SL能保持个buffer-state，不要尝试只用SL完成一个功能机械的app，不然就太丑了。SL适合写动态壁纸和滤镜类的东西 #建议

除了社区不重视代码质量(冗长或空语义的极端,如uv=uniform=readonly graph-arg)、不善用struct、场景与渲染不切分、和复用/可配置力问题、shader含字符位图硬编码(GLSL不擅长的用途)等人的问题，也关于计算领域 🤔

为什么GLSL看起来和C很不同？不谈多out 函数和内部gl_物理变量，显卡的计算和CPU的单线模式差异很大。比如画个圆吧，g.arc(x,y,l, 0,2PI);g.fill() 后它就出现在画布(或用SDL/VGA)上了，因为这里有个“显示缓冲”位图的概念，所有图形存留在这里直到clear-SwapBuffers(一个冷知识,glFinish计数比FPS适合图形学跑分用)，画圆可以迭代xy=(sint,cost) t=0~2PI 来累积圆上点，这个过程是线性的，多核CPU一次能画几个?尽管能LUT(查表)优化、能模拟Vec来复用同半径的结果，一次也只能画一个。对于几万个粒子来说就更鸡肋了，
因为执行顺序根本对时差更新/绘制结果毫无帮助，你逐个往画布叠对N叉 tree 好用，可对数学分形 还不如把“端点迭代”完全打散，越散越适合GPU计算。

显卡计算是没有顺序和“整体图像”的，几何都必须能按xy-颜色来“绘图”，因此着色器和 Painter 完全是两种东西，当然也有办法把arc(x,y,l)->float 峰值clamp 封装成函数，并且用数学方法mix()

#define v1 float
v1 circle(vec2 P, vec2 p, v1 l) {
  v1 d = length(P - p) - l;
  return 1.-clamp(d, 0.,1.);
}
void mainImage(out vec4 bg, vec2 P){vec2 L=iResolution.xy, p=P/L;
  vec3 c = 0.5 + 0.5*cos(iTime+p.xyx+vec3(0,2,4));
  bg=vec4(mix(c, vec3(.87,.37,.23), circle(P, L/2., L.y*.3 ) ) ,1);//试给圆半径 *mod(iTime,1.)
}

矩形xywh也可用类似手段。不过shader里这些形状不是必需品(paint里确实是)

数学(此为几何相关)应用相关命名随意已经是普遍现象了，
>“ s一般用来代表一个"scalar"(标量)。所以是一维数字。t是因为字母表s后面的字母。不能继续用u和v是因为uv已经被他们用来作计算用的坐标了。因此就用了向前的字母了。(strq)淡然，后来他们发现r与rgba的r冲突了，就用p替换了r。就是stpq了。
动画工具一般用t来表示时间的概念，所以就不用s和t来表示纹理的坐标了。因此，他们就用了u和v(UV贴图)，因为他们根本不关心相关的计算。
s和t的命名来自于对平面的描述：r=r0+sv+tw (r0是平面任意一点，vw是定义向量，st随选)
uniform 意义也非常迷，它的意思是CPU和GPU间统一，许多人拿 uvec,uv 简写这ND座标/颜色/etc.,但SL里真有uvec2的类型-照传统编程早该改了,SL界硬是成了传统，想学图形先换术语，脑子里没对应表100%看不懂 😟

这是在GL(带一张 ShaderToy.com/new 贴图)显示 hello world ，带着注释里的问题阅读

float l=.06;
void mainImage(out vec4 bg, vec2 P) {
int[] t = int[](72,69,76,76,79,32, 87,79,82,76,68,33);//"Hello World"
P = P/iResolution.y - .3/*为什么能调x位置?全屏试试*/; P.y += .05*sin(3.*P.x+iTime) -.4;

for(int i=0; i<int(iMouse.x*.02)%12;i++,P.x-=.1)if (length(P-l)<l)
if(false)bg+=vec4(1)/*<能解释了吗? .5调成1.试试?>*/;else bg+= texture(iChannel0, P*.5 + fract(vec2(t[i],15-t[i]/16)/16.)).x;
}

答案：P的0值是确定点，for(i)if() 是为确定当前P对应的t[i] 。 P*.5 是因为原字体图太小了——那为啥P/2 呢？不该是有t[i]的位图yx偏移，就够在当前P画字了？ 作为只懂g.fillText 的程序员不会考虑怎么从像素级别对应！ P缩小了，同高区间就只含低 texture 视口，于是贴图放大了！ 和数学函数缩放一样。类似写法在SL里很难规避，也没法文档

SL的逻辑不能用常规迭代/判断来解释，在进入图形学公式前，需要先习惯这种思维方式。许多程序员这辈子没机会，你看到了就是有本事。 所有平台,Web,Android,DX/Unity/Xorg 都支持OpenGL ，机器学习框架也开始GPU计算，不想黏合点特效装逼？看不出咋调参可不行！

你肯定会吐槽：逐点贴图？肯定很慢吧！ 其实GL是最快的图形方法了。计算量大但都易优化，它是很低层的绘制API，和各种层次的painter不在一条赛道
在迈向并发的时代，一头什么都会的牛和一大群只会+-*/的鸡 硬件选择发展后者，应用层各有各好，但在图形上答案显然还是简单的-简单比线性好

#math 这是一个曼德博(朱丽亚)集的分形图，在SL上反而比在JS更合适，不需要手动迭代虚数P(x,y)

#define cxmul(a,b) vec2(a.x*b.x - a.y*b.y,  a.x*b.y+a.y*b.x)
#define R iResolution
//#define JulC vec2(.383,.13)
void mainImage(out vec4 bg, vec2 P){
  vec2 z,c = P/R.xy *4.-2.;  c.x=c.x* R.x/R.y +(.2-iMouse.x/R.x)*15.; c/=1.2+iMouse.y/R.y*20.; z=c;
#ifdef JulC
  c=JulC; //v 猜猜看，怎么调参数.
#endif
  float i=.0,N=abs(sin(iTime/32.0))*64.0, v;
  for(; length(z)<2. && i<N;i++)z =true? vec2(z.x*z.x-z.y*z.y, 2.*z.x*z.y)+c : cxmul(z,z) + c;
  v=i/N;
  bg = vec4(v,v,v,1);
}

这是一个”老相片“视频滤镜，展示了GL无所不能的inputs... ，猜猜它是怎么处理颜色的

void mainImage(out vec4 bg, vec2 P){
  vec2 p = P.xy / iResolution.xy;
  //p.y = 1.0 - p.y; // invert
  //p.x = 1.0 - p.x; // flip
  vec4 c = texture(iChannel0,p);
  float c0 = (c.r + c.g + c.b) / 3.0; // grayscale
  c.rgb *= abs(vec3(cos(c0),sin(c0),atan(c0) * sin(c0)) );
  bg = c;
}

以上三个示例里，大家都能感受到GLSL对向量(元组)计算 帮助是很大的
应该也能感受到数学计算里不需要太多边界判断，靠sin,mod 等就能展示复杂的图形。比如这个 fireworks. fascinating graphics, made eazy, 类似的有效作品120多个
OpenGL着色器杂谈今天就到这里

ref:
https://zhuanlan.zhihu.com/p/32788146 Py julC
https://blog.csdn.net/cuckoo1/article/details/108083508 js分形
https://www.shadertoy.com/view/Wtt3Wl OTF bezier
https://www.shadertoy.com/view/XsyXzw 音乐粒子
https://www.shadertoy.com/view/7dKGDK 基础着色
https://www.cnblogs.com/chen9510/p/11447292.html UBuffer 跨着色器传递

#algorithm UnionFind、三角分形(精简版)

如果要实现 Set 你会怎么做？每次 add(x) 时去重遍历 uniq() 吗?
现在按数组Array(N).fill(0).map((x,i)=>i) 实现 Set<Int> 。每位与一个索引关联，初始是和自己
当加一对 a-b ，把它们的位置赋上彼此，就能知道在不在同集合内——不行，如果还有a-b-c 咋赋值？
答案是 a->b 关联 b->c 再关联，因此 find() 变成链表遍历后最终同一。然后 add(a,c) 先找这个"b"，把它->c
最终这个 Map<Int,Parent=Int> 会变成树状数组，只是不被遍历。UF集也有a-b小size侧优先-> 权重,和max()时顺便合并快查法

UF=(N,up=Array(N).fill(0).map((x,i)=>i) )=>(a,b,eq=true)=>{
let max=i=>{for(;i!= (i=up[i]);); return i}, iA=max(a),iB=max(b)
if(eq&&iA!=iB)up[iA]=iB; return eq||iA==iB //不上obj,写不好..
}
let o=UF(3); o(0,1);o(1,2)
o(0,2, false)==true

//给不懂的同学：N是(Map状数组)项个数,up是“父数字” ，eq代表不仅查询还建立a-b 连接关系。 UF算法与up[] 是1:1 ，所以随便起了个o=UF() 数据来功能test
这个相当于List<Set<Int>>
另外 UF,BFS 都是在节点图上判断两点是否联通，如果需要路径则用 DFS ，如从节点 2 的[+3,*3]边怎么走到 "9":
dfs=(link,flink,out,chk=(e,e1)=>{let k,k1;if(e==e1)return[]; if(!out(e)) for(k of link){k1=chk/*找!*/(flink(e,k),e1); if(k1)return k1.concat(k) } })=>chk
ten=dfs(["+3","*3"], (a,k)=>eval(a+k), a=>a>10)


ten(2,9)

->+3*3 (chk完还应reverse下.)
//当然比较hack,如果是专门讲我就会用正经let函数
然后最短路径可以用Dij狄图算法(也可优化权重边)，也有A*啥的寻路法。 pip,apt 等依赖工具就是简单BFS可达搜索搞定；我不搞OI懂的不多
#inm 比较喜欢的数字论证生成器可以是这样 11 = 11*-4+51+4

我找了两个与算法解读比 较差的博文:
https://blog.csdn.net/dm_vincent/article/details/7655764
https://www.cnblogs.com/SeaSky0606/p/4752941.html
还有正经算法解读: https://zhuanlan.zhihu.com/p/63123489
大家可以比比它们的信息量。
—
你要咋画 Xecades大佬的三角分形 (三角内接倒三角，其三边与我顶点继续如此)？
本来是要在中线拿3点(shift遍重组,或者手写配对)和带深度递归的，可看起来只需要
#js #code
document.write`<canvas id=eg>`
{
let sq=Math.sqrt, dim=(e,[w,h])=>{e.width=w,e.height=h}
y = Math.min(innerHeight, innerWidth * sq(3) / 2)
g = eg.getContext("2d");
g.fillStyle = "blue";

let P=[[0,y],[y / sq(3),0], [2*y / sq(3),y]],p=[...P[0]] //左顶右
dim(eg,P[2]);dim(eg.style,["100%","100%"])

setInterval(() => {
let j=0,i = Math.random() * 3 >>0
for(;j<2;j++) p[j]=(p[j]+P[i][j])/2 //随机选方向游走
g.fillRect(...p,1,1)
})
}
//g;画布,dim:宽高wh ,sq:三角(点->点)xy距离的计算, j:仿造向量的计算同时应用于xy

就够了。GLSL 里画三角

#define v1 float
v1 PI=3.14;
v1 ply(int N,vec2 p){
//多边形. 三角[0,y],[y / sq(3),0], [2*y / sq(3),y] 都没了..
v1 d, TURN=2.*PI;
// space to -1~1.
p = p *2.-1.;

// Angle and radius from the current pixel
v1 r = TURN/float(N);
v1 l = atan(p.x,p.y)+PI;
d = cos(floor(.5+l/r)*r -l)* length(p);//distance-shape

return 1.0-step(.4,d);//也可smoothstep(a,b,v)模糊锐边
}
void mainImage(out vec4 bg, vec2 P){P/=iResolution.xy;
P.x *= iResolution.x/iResolution.y;
bg=vec4(0,0, ply(3,P), 1.);//左中 蓝三角
}

// 这个我没法注释，因为SL图形和数学几何关系大。有的时候看不懂也不是因为故弄玄虚，而是那个领域本身难懂。比如我define v1=float 和rld仨变量变 degRee(不用a因为编程有数组要命名),length,distance 后对第三块代码难度影响不大，因为核心不是浮点有几个字

(不过要画三角分形就会难许多了,而且Xe的游走三角是靠边点累积来的，SL不支持累积..)
可以看出，物理的矢量是非常高明的代码复用，少做了很多结构性的事，却照样实现图形效果，而且更可调参——例如靠点集计算就做不到 ply() 边缘模糊的效果

谈谈命名问题。圆座标系(POLar)上，角度和距离一般称 theta-rho , angle/arc-radius 即a-r，这是物理采用较少的几个希腊字
我的物理命名法则用 rl:rotation-length 表示这个，因为编程上a理应代表数组..而一些人也会用r标记角度a记面积 真混乱

对同一个像素图，可用直角(xy)和圆座标(rl)自00点等效描述其上每点位置(座标系的意义就是编码位置)，这样就容易进行变换，例如圆翘曲和拧转
->rl=(atan2(x,y), sqrt(xx+yy))
<-rl=(lsinr,lcosr)

画半径=3圆就可用点迭代式(参数方程) lsinr,lcosr (r=0~2pi, l=3) ，这等同于在pol系生成一堆点再映射到xy系。当然位图上不好确认dr=rStep ，所以可用 length(p-p0)<l, r=atan2(yx) 处理圆内点。这个yx是配合 (lcosr,lsinr) 顺序的，具体为啥正弦反在余(co-)弦后我不清楚(补: 因为数学把 正右作0点, sin,cos 的00是正上

比如，笛卡尔心 rho=1-sin(theta) .极座标式 r=a*(1-(sint)) 直座标式 (asint,acost)-(.5sin(2t),.5cos(2t)) t=0~2pi

#define pol(f) float r=atan(p.y,p.x),l=length(p);f;p = l * vec2(cos(r), sin(r));
void mainImage(out vec4 bg, vec2 P){
  vec2 p = P.xy/iResolution.xy - .5;
  p-=.1;pol(float d=(1.-sin(r))/3.9 -l) bg = vec4(1.,step(d,.001) ,1.,1.);
  //pol(l=l*l*1.5)bg=texture(iChannel0, p + .5);
}

为啥笛卡尔能画出心呢？在 funcplot.com 画 1-sinx (即-sinx+1)和 x=2pi 和y=1，对照 r=1-sint 你就能找到答案. 注意数学pol系是从正右逆时针算弧度..天哪 难怪 r=1-cost 是向左的

附带物理命名法表/补上次的:
Array B-paired Config Distance Element Func/File-path Graph
h w y x/item i j-i内i n m-n内n Key/比率 Value Length
Object Predicate条件 Question真假 Rotation弧度 Str/stream Text/template模板
u-二进制 z-深度

记忆法：26字母背一遍，把符号配对就行了: hwyx (h)ijnm (ij)kvl (uvwxy)z，你会发现 for(y in 0..<h)for(x i 0..<w) 正好和 y=i, x=j 对应

呃，我觉得这位和顶楼的工程式讲法比较好：

在输入信号的每个位置，叠加一个单位响应，就得到了输出信号。

卷积的重要的物理意义是：一个函数（如：单位响应）在另一个函数（如：输入信号）上的加权叠加。
^”书上先反褶再平移，把输入信号当作一个整体(去翻转平移相乘积分)，一次算出一个时间点的响应值；而楼主把信号拆开，一次算出一个信号在所有时间的响应值，再把各个信号相加。两者本质上是相同的。

顶楼：
令f(t=1) 衰减是种卷积，如t=1敲锣，锣面震幅随 tNow-1 衰减。接下来 1.2 ,1.4s 也有同样的敲锣。将它们叠起来就成了系统的输出
无论多么复杂的输入信号，我们都可以将其分解为一个个连续的冲激信号

用符号'*'表示卷积，关系式：输入*系统=输出。上面的图2在t=0.4s时的数值，是由图1中蓝、红、绿分别对应的3个单位冲激响应相加得来，
蓝、红、绿3个信号进入系统的时间分别为：t=0s，t=0.2s，t=0.4s，仔细观察，在图1中3个冲激信号对应系统响应的值分别为
系统响应在t=0.4s，t=0.2s，t=0s的值，对应的时间顺序刚好相反(因为.4s时0s 的还没消失)，所以要翻转

😅不过有件好事：在计算机图形学 #cg 上 Sobel 边缘检测和各种锐化/平滑 都是无关方向的，如果只是 dot 乘积(各位之和) 其实就是普通列表处理；需要处理声音和图像不需要理解信号处理 #sp 学的术语概念

我想起了滑动平均拨弦声
https://tinyrave.com/tracks/67/remix
#js #code audio

kPluck = 470.0 ,
a = Array(44100 / kPluck >>0).fill(0);//FIFO frequency
a.forEach((x,i)=>a[i] = Math.random() * 2 - 1)//white noise
cyc=(a,i)=>i%a.length,
runAvg=f=>T=>{
  let i=cyc(a,T*SAMPLE_RATE>>0); return a[i] = f(a[i], a[cyc(a,i+1)])
}

buildSample=runAvg((a,b)=>(a+b)/2)

当然音质差也可：

kPluck = 470.0 ,
a = Array(44100 / kPluck >>0).fill(0);
a.forEach((x,i)=>a[i] = Math.random() * 2 - 1)

buildSample=T=>{//没平均相邻
  let i=T*SAMPLE_RATE %a.length >>0; return a[i] = a[i]/1.01
}

卷积核就是权重，#AI 学习的正好是权重，把权叠到每片像素，所以图片分类器能学习出核的特征，对识别项求和后判断归类
在每个xy 叠加卷积核，就得到输出颜色/灰度 等信号

应用于位图参考 https://zhuanlan.zhihu.com/p/76606892
shadertoy.com/new #GLSL #code
#define v1 float
v1 lumAt(vec2 p){
return dot(vec3(.2126, .7152, .0722),//亮度
texture(iChannel0, p.xy / iResolution.xy).rgb);
}

void mainImage(out vec4 bg, vec2 P){
vec4 c = texture(iChannel0, P / iResolution.xy);
v1 gx,gy, d = sin(iTime * 5.0)*0.5 + 1.5; // kernel offset

// Sobel Kernel
//x
// -1 -2 -1
// 0 0 0
// 1 2 1
//y
// -1 0 -1
// -2 0 -2
// -1 0 -1
#define k(x,y,P,a) v1(a)*lumAt(P+vec2(v1(x)*d,v1(y)*d))
gx=k(-1,-1, P,1) + k( 0,-1, P,2)
+k( 1,-1, P,1) + k(-1, 1, P,-1)
+k( 0, 1, P,-2) + k( 1, 1, P,-1);
gy=k(-1,-1, P,1) + k(-1, 0, P,2)
+k(-1, 1, P,1) + k( 1,-1, P,-1)
+k( 1, 0, P,-2) + k( 1, 1, P,-1);

v1 g = gx*gx + gy*gy;// denoise in the video
v1 g2 = g * (sin(iTime) / 2.0 + 0.5);
bg = c+ vec4(0.0, g, g2, 1.0);
}
lum滤镜 . 这次让我学会了位图擦拭渐变外 的边缘和模糊 以及边角画扭曲 💭视频粒子特效可能需要
我这里还有个中心模糊的：
#GLSL #code https://www.shadertoy.com/view/4ts3Ws
float amount = 5.9;

vec3 shadow(vec2 P){
return texture( iChannel0, .5*(sin(1.)+P) ).rgb;
}

void mainImage( out vec4 bg, vec2 P){
vec2 pC = -1.0 + 2.0 * P.xy / iResolution.xy, p = pC;
vec2 dCopy = (iMouse.xy/iResolution.xy - pC ) / amount;

vec3 g = vec3( 0.0 );
for(int i = 0; i < int( amount ); i++ ){
vec3 c = shadow(p);
g += smoothstep( 0.0, 1.0, c);
p += dCopy;
}

bg = vec4(g/ amount, 1.0 );
}

#code #cpp 🌚👍 应该进疫情贡献博物馆陪着支付宝健康码？！
#define FOREVER 0 (exit值) 这人估计是个反串黑
return NEVER 可以理解为永远跟党走，但 return forever 就是一直倒车的意思 👌🏼🤡

中国很悲伤的地方，就是反串黑和无脑挺分辨不出来，「清风不识字，何必乱翻书」呢。
https://tttttt.me/dsuset/10243

原來暖心小粉紅們的自信，是需要靠別人歧視他們体会出來的。❤
--https://m.youtube.com/watch?v=3VqT-uxt2Ec
“公開場合有權利拍任何想拍的人‘’跟“罵人是我的言論自由‘’一樣暖心。
不是说了sorry we have a break...個人有權要求不被拍攝。

到底有誰嗆人的時侯會說，我是哪裡人啊？
用其他種族的名義 侮辱別人，然後又要所有亞洲人站他們那邊，中國在給全世界製造仇恨真的是第一名欸。

#zhihu #PLT 又看到有趣的中文编程设计 ，做些科普。 👀

1.打这些太极 还不如就叫真假，另外，加语法糖并不是以混淆基本语法，以编程的一致性为代价. PHP,Ruby,Py2 和VB已经玩烂过这套“大小混写”了(你怎么不用神奇GPT编译呢?)

2.子类型对应的是强制兼容，而非隐式数值转换。 进制只是表示法，SQL那种类型只是验证位数
你说的不需要看(隐式新建类型变量)、运行时可见，Haskell、Kotlin也支持，但你对连 List<T>,T->R 都还没懂的人弱化类型，就利于他们学用新接口了？别把隐类型当成无类型

3.其实，只要编码统一，最常见的bytes.replace和非空split都OK多字节字符。即便你想像Perl那样囊括万物，得出的语言可能就是一个Str运算的节点图
4.GC引用和Str/Builder的隔离不就是？ 你还混淆了编译期和int*两期变量绑定 (x86 ABI -O0 就是用esp-4-8栈指针传参的, vararg 就是靠这个)

5.JVM每天都在跨线程 (volatile Object)vars=新引用 ，C#还支持并行For，numpy 则支持GPU,SIMD ，为什么要把废话说得像真理一样啊啊啊..

6. #define str char* 后 str a,b; 你就会发现C的类型运算符本身有问题
另外，int(int,int) add 不适合写类型推导
7. 文字游戏。 add(a,b,&c) 的汇编叫无副作用？
C有函数指针啊，而且Linux还用它“实现OOP驱动”了
只是没 a=>new(b=>a+b) 闭包对象而已，C的落后并不是只在写法上，是GC,API,types,memsafe 的全面不足，但是把C的错误当宝就是程序员的问题了

另外 看见贺老锐评#js 函数式提案，发现很多都被现在的EQ设计过了…

Iterator helpers

[1,2,5,1].Q.firsts(x=>x<3) //基于waitFun,故同时兼容 [],func*,async

Record&Tuple
when(class{
  User(name){表单验证}
})

Stage0：ADT Enum, tail calls

when(class Either{ //EQ继承很多绝句里的语法
  A(v){} B(v){}
})
noOp=(a,b=0)=>nest(b=>{
  if(a!=0)loop(a-1,b+1)
})

Stage1：Observable、Emitter, Extensions, Partial application,Pipeline operator,Memo
前两个是 obj.it.xx 的核心特性

user.to(_=>{name="Jack"})
Str.it({
  cap:_=> _[0].toUpper+slice(1)
})

compose管道也是

num=(a,b)=>a+b
it.n([num.it(+1), x=>x+'%'])
is.ST({num}) //memo

模式匹配，不就是EQ的基石嘛

when(res,
  [{status:200,body}, body!="", fn(bodyVar)],
  [Some(x), x],
  [None, 0]
)

「前人造过的轮子就有点像是数轴上的有理数点：稠密，有序，无穷无尽。但是真当你用的时候，你会发现，你的实际需求有着几乎100%的概率落在有理数的缝隙里。」

看到个有意思的， #android 夜间切换特效
>GLSL https://www.shadertoy.com/view/4sBfRd

#define circ distance(P,iMouse.xy)
#define swing(x) cos(.5*(1.-x)*radians(180.))
//混成AB两版的main, 对B版用圆选区, transition: --len_vw 4s ease-out
void mainImage(out vec4 bg, vec2 P) {
  _mainImage(bg,P);
  bg=(circ< swing(iTime/4.)*iResolution.x? bg:1.-bg);
}

背景也可以是波浪。忘记 sine scroller 的关键词了 🥰

用HTML-SVG 做的话，在clone出的 #app.dark 上剪裁 clip-path:circle(var) 很方便，但如果想用更灵活的mask:radial-gradient(var) 就只能靠自定义filter了
但无论如何 都比canvas或paint的方法好移植且快

Android上，深色主题如果是靠bg/fgcolor 切换，除了 transition: 不是一等公民，需要自己填Animator

还有复杂的自定义“复用”Recycler.View失效问题 🥰 而 clusterize.js.org 呢？往table调一个函数就能优化，安卓那种复杂度，对它够支持瀑布流了

可能，还需要手动setAttrValue 什么的

H5里做排版的XML，安卓做style
H5里做交互的JS，安卓做排版.. Compose 等于是简化下HTML的语法，却硬是让View框架被“重新定义”了
H5里自带的Web平台API，安卓靠Gradle.. 依赖地狱什么的这不就来了？

#cg 用了半天AI都不能创建一个shader
纯frag shader 要想画粒子特效，只能用vec4图片编码vec2 来模拟gl vertex (本质是全局数组 https://stackoverflow.com/questions/48384564/webgl-glsl-time-variable-similar-to-shadertoy)
https://www.shadertoy.com/view/Nty3D3
GPU 每个线程只1个rgba矩阵可变，禁止手动for(;;)全局变量。 GLSL设计的这么僵化，还不如numpy和taichi呢
GL人都是作品靠试错就摆好了，即性粘贴型画师，比jspy还复用白痴 😅可见编译太快联动性会变差
包括Unity等有建工程的
其实是不配称程序员的，和gpt一样 代码没有复用度，全是脚本 用完即弃
但是数学家和物理学家就是这样，不重视自顶向下 复用

https://developer.mozilla.org/zh-CN/docs/Web/API/WebGPU_API#:~:text=像素的颜色

pacaur -S intel-media-driver libva-utils

后访问chrome://flags/ 查看支持度

>编程用 frag Shader 绘制爱心跳动， 心形的内部是白色， 背景是白噪声
>create a 2d ball particles collision demo in ShaderToy
> update BufferA & mainImage separately; note: shaders won't save state
它只会用 matplotlib画..
不过，圆角矩形什么简单图像，AI依然是有可能写出的。需要几个宏

#define time iTime
#define resolution iResolution
#define main mainImage( out vec4 gl_FragColor, in vec2 gl_FragCoord )

> 用 re.sub 去除 "www.bilibili.com/?" 这样链接的 query参数
qwen 实在是太逆天了正则 match group 连AI都不会弄
脑残 我是说全文替换 该死的垃圾AI被双引号骗了

"http://baidu.com\n".repeat(2).replace(/http:\/\/(.*)/g, "ftp:\/$1");

#code #cg #apple 等待光标 🍬 https://www.shadertoy.com/view/XljXzV

#define hsv(c)  ( (c).z * ( 1. + (c).y* ( .6 * cos( 6.3*(c).x  + vec3(0,23,21)  ) -.4 ) ) ) // golfed

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    // Position normalised into (0, 1)
    vec2 P = fragCoord.xy/iResolution.xy, M=iMouse.xy/iResolution.xy, d = 1.0 - (P * 2.0);
    // Rotation
    float L=length(d), r = acos(d.x / L) / M_PI, lv=M.y*50.;
    if (d.y < 0.0) { r = M_PI-(r + M_PI); } // Sort out the bottom half (y=-1)
    r+=sin(smoothstep(-M.y,M.x*2., .9*L));
    r =  floor( (r)*lv)/lv; 
    fragColor = vec4(2.*hsv( vec3(r/2., 1.0, 0.5)), 1.);
}

带夹层

// Position normalised into (0, 1)
vec2 P = fragCoord.xy/iResolution.xy, d = 1.0 - (P * 2.0);

float r = length(d), a = atan(d.y,d.x)/ 2./M_PI;
a+=cos(.6*r);
fragColor = vec4(hsv(vec3(a, 0.5 + 0.25*sin(iTime*a), 1.0)), 0.5);

哎，没有心情看 #kt #book
看了下codegen技法，只能说近十例子里anko的风格相对优越，和html一样是用twig(类似erb)模板，然后作者函数复用还行，但也没有到90分的程度。

例如“贯穿全文”的DeepCopy(x:T)吧
js里相当于x就是T的反射，又一切皆可变，可以直接读写{...x}[ID], 只需
mapEachMember{if(it.isPrim) it else DeepCopy(it)}

kt里需要用构造器复制，先拿到 T.vars[ID].get(x)而非 x[ID]，但依旧是 mapEachArg{getattr(x,it).primOrCopy} 的模式，这个至少适用于 Tuple$N的toMut和url参数绑定
这就是个小学算法，反射和List API 的良莠不齐却让它很难看。

重要的是独宠XXpoet 真的无力吐槽，和那个 https://tttttt.me/dsuse/17514 一样，就一个不用导包，然后自带formatter。简直可以说是一碟醋级别的算法，甚至应该叫搞错重点

和我的tkgui https://tttttt.me/dsuse/19768（py基于getattr等元编程，运行期生成等效调用赋值图代码）
都没法比，何况最近我在设计表达式级(fun{}内计算图)都能建模的跨语言、带裸类型推理、动静合一OOP元编程范式了，这种拙劣的"xml模板"实在写不起来

java确实是“病态类型”，而非什么静态检查。 连数据树的验证和walkDeep都要靠魔法，有什么资格谈类型签名的那些好处？
靠被默认值参数替掉的重载吗？

只能说，如果手头有电脑，我应该去吧那个sql dsl写了😒 而不是在这看java人像手写sql或xml那样拼接字符串
不知道 unquote(ast) 这种函数式代码生成，起码吧 quote(litOrID)做一下，免得被注入弄出无效代码啊

再说说全书结构，首先就没有谈元编程是什么，而是java老三套：环境配置、难题、抄代码

好吧，可是一个优秀的老师应该选循序渐进，但却对知识体系至关重要的例题： #learn #plt

- 为什么是靠C的#define 自主研发出易语言？预处理比str.replace多了哪些？ 高亮分词后，灵活解释“常量字面”吧
> eval("[1,$x]") 是一种JSON解析器，可是x="][0]"时似乎有bug。 修好它，然后把js爆改为你希望的“易”语言（复用猜数游戏的REPL）。 完成后类似的bug应该仍然存在！
其实，js源码也有它的JSON.parse，它就是反射的原型。
- 比较下SQL的'?'、C printf、ERB/ES6模板，kt元编程最缺少的语法为什么反而是"$str"? 控制变量，就能明白pwsh和ts为何比bash和js有长期编程时的优越性

- if os==nt6: class: 与#ifdef _WIN7 凭什么是同构的？ 动态类型，依旧是Java式的类型。宏，并不需要魔法
- 为什么Java8让 invokedynamic负责创建lambda，getMethod不也能.invoke吗
- 局部fun 一定要 ::引用的背后，藏着一种元编程，T.(A)与(T,A)->、(T?)!!的强转背后也是！ 原来除了消除重复，她还让语言提供更有价值的“值类型”
- 为什么“闭包是穷人的对象”？ C语言里回调函数去哪了？SAM接口又为何比到处new.object{}流行？ 原来返回函数、重写接口也能费内存啊

- 为什么pyjs里很少人研究元编程，但却又有 python-future.org 与vue,babel这样的全民应用。 二者有何区别
- Proxy(obj)掉包属性，是动态类型元编程的专利吗？ reflect.Proxy 能生成函数，还不止于DSL或AOP！
- 能不能通过函数重命名，用py风格的反射API实现KAPT的 @decorator ？哪怕只是封装Reflect？这能让你学习跨平台移植，收获超越本次需求的心智模型和视野
- Kotlin对dynamic类型表达式链条的“零修改”生成规则可以怎么实现，numpy里也可以吗？ 这能帮你理解DSL和编译优化的本质

- “优秀的程序与其读写数据的结构直观对应”。纯函数式编程(例如rust的enum和if let) 做对了什么？ 为什么你仍然选择不够纯的Kotlin？ 这种enum能表示JSON乃至HTML的序列化结构。
- bash风格的参数有3种，其中一种如 ls -ar(all reverse) 传入enum:BitSet。用fun demo()出完整函数签名
- 以上问题和codegen无关，也没有教你具体怎么生成url/json/sql绑定类或函数，却给你了设计相关框架的能力！这次由我来回答，为什么javapoet是对pyjs里闭包list/dict的拙劣模仿，以及反射调用为什么就是在codegen！

所以。。 虽然《Ruby元编程》教你的只是一些OOP特性的“工作原理”，而案例较少，但我更喜欢它 --它让读者真正建立起了对"class"这个dict的理解，加上dyn(*arg,**kw) 本就可以用名字动态查，让读者对“把def和class 视为一种constObj去查询、实现复制粘贴、...”有了把握

而不是一个看似什么搞法和IR,ASM都贴出来了
实际上对你没有用，只是让工作失去焦点的troublemaker🌚🌝

#algorithm #防自学 🤓 让我来示范一下怎么概括算法思路
要介绍的是在stdlib里，用于组织集合类、JSON的3个重要结构: b"ytesPtr", {K:V}, sorted([0 2 1])=[0 1 2]
它们对各种app和其他算法性能效能的重要性，好比json(cbor.me)之于REST、zip之于jvm和pip。 因为是涉及SDK实现的内容，也主观评价下语法设计

下面用胖指针(x64上void*是8b, 胖指16b)、链表、快速排序简单的实现3者 #code

#define Col(...) typedef struct{__VA_ARGS__;} T;

#define T Str
Col(size_t n; char* buf) //C的类型本应默认为指针, *胖指针，像kt那样对Int等类型免链接化。简洁的UNIX里，Type* 快成为public那样的形式主义啦

#define T_Link(E,T) struct T{E x; T* xs;}
T_Link(int,Nums)  //template<T> 允许类型推理，即一致化调用和返回处的<T>。可怜gcc/clang无论对宏还是模板的报错皆如内容农场，不具有可读性

https://colobu.com/2023/06/29/replace-std-map-faster/chunk-index-memory.jpg
用例和 #haskell #code https://gist.github.com/duangsuse/26b80c39e1d8f7549b9cf244d8de1ce4
题外话，闭包值和 x.interface_cast(T) 的双指针&dyn 随结构传入T的函数表

qsort :: (Ord a) => [a] -> [a]
qsort [] = []  
qsort (x:xs) = 
    let smallerSorted = qsort [a | a <- xs, a <= x]
        largerSorted = qsort [a | a <- xs, a > x]
    in smallerSorted ++ [x] ++ largerSorted

UmbraString 和上文Str{n,buf}胖指针一样是16b，但它的.n和jvm一样只寻址[4b:int]的长度，其后最少随4b的免链接char 用于比大小
对于n>12的buf，剩下8b换成指针，指针的高2位用于标记GC信息： 持久pin、临时ref、用后即焚val

很明显！这是一种灵活利用了x86内存布局的b"length"实现，和x32压缩指针一样，节省了sort解指针的时间

SwissTable 是对Hash预分组查表的免链接。我们知道， dict/HashMap/lua.Table 这样的{K:V, K1:V} 单映射常被用于查找和缓存，在C++里更是会区分 unordered_map, rb_map(以排序radix,SortedSet,而非hash作为预分组线索)
它的最简实现是lisp里的链表 T_Link(struct {int A,B;}, int_LnKV) ：没留任何线索来减枝！

即便8b hashCode，也是一定会冲突的，哪怕是int.hash也会因 buck[hash%nBuck] 有限而退化为线性查找，负载因子(kv/nBuck 过大)，这时就要扩容。Go的扩容基于一种空间换时间的优化(图1, 为了减少求余数的冲突，除数都会采用2的指数)
扩容后的冲突集，可以用链表(UnionFind)或数组(slot), 从那往右找
Swiss 更聪明，它对每slot对应1b的元数据，最高位0x80=无效项 ，0xFF=null结尾 ，低7位用于存储hashcode的高7位，这么摘要是为了SIMD128bit 1次对比8个KV
不仅仅只是CPU CACHE友好，这样的结构配合原子操作，相信很容易做出一个并发版本的hash table

快速求余(x,n)= uint32((uint64(x) * uint64(n)) >> 32)
#dalao https://init.blog/fast-newton-sqrt/

float InvSqrt(float x) {
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

最近的一种基于partition(区间而非idx)的快排也很有趣： less than pivotL | between pivotL and pivotR | greater than pivotR

#FP #c https://github.com/hirrolot/datatype99/blob/master/datatype99.h macro
https://halfrost.com/reactivecocoa_macro/

tag union: enum { A(int) B(str) } in C 😨 无需任何编译器插件
implemented upon Boost/Preprocessor
冷知识： gcc 宏是可以通过CPS延长递归展开 到1024步的，而宏又包含 if defined/eq 等常规流控与##-concat等运算，意味着即便没有 template<> 魔法， for if 甚至 eval() 也可以 static_assert

// 9, 2, 5
static int lesser_than_10[] = {
    ML99_LIST_EVAL_COMMA_SEP(
        ML99_listFilter(ML99_appl(v(ML99_greater), v(10)), ML99_list(v(9, 2, 11, 13, 5)))),
}; 
// 用例: 1+(2+3)
datatype(
    BinaryTree,
    (Leaf, int),
    (Node, BinaryTree *, int, BinaryTree *)
);
int sum(const BinaryTree *tree) {
    match(*tree) {
        of(Leaf, x) return *x;
        of(Node, lhs, x, rhs) return sum(*lhs) + *x + sum(*rhs);
    }
}

ML99 是一门在 C99 预处理器运行的lisp https://metalang99.readthedocs.io/en/latest/list.html
尽管如此，有大佬说「元编程」要三思 https://lotabout.me/2018/think-twice-before-utilizing-meta-programming/
btw. 看到文心一言禁止F12， 有人贴了个反制 很有意思😂

for (var i = setTimeout(";"); i-->0; clearTimeout(i)); 

利用宏展开和递归实现貌似不可能的链表处理，其实也只是手段巧妙，利用f.nArg这样的const拼接代码， 效果并不会比过程宏甚至简单的codegen好

#define AND(X, Y) AND_##X##_##Y
#define AND_0_0 0
#define AND_1_1 1

#define IF_ELSE(C, T, E) JOIN(IF_ELSE_, C)(T, E)
#define IF_ELSE_0(T, E) E
#define IF_ELSE_1(T, E) T

#define IF(C, T) IF_ELSE(C, T, )

我还是觉得，如果不限制工具链，编译期反射或运行期记忆化eval 比模板巧妙的多。 体操只是被编译器驯化的结果而已，比递归+模式匹配巧妙的算法有很多。

https://github.com/hirrolot/datatype99/tree/master/examples/derive
https://github.com/orangeduck/CPP_COMPLETE
https://netcan.github.io/2020/11/06/C-Rust元编程之BrainFuck编译器（constexpr-过程宏解法）/

n=a=>a.length
add=(A,B)=>A+B 
curry=(f, N=n(f)-1, ARG=Array(N).fill('').map((x,i)=>'_'+i) )=>eval(`p0=>(${ARG})=> ${f.name}(p0,${ARG})`)

curry(add) 
p0=>(_0)=> add(p0,_0)

完全有能力生成任意的vararg，并且可以加泛型