https://ray-eldath.me/programming/three-important-ideas/ #statement #PLT
Ray: 我的一位朋友如此评论这些文章：他说真正理解抽象的唯一方式是通过抽象本身，而不是通过并不准确的类比。
「为了充分地（"有用处"地）学习这些抽象，你必须去学数学，而不是通过一些糊里糊涂的文章，它们除了类比还是类比」
Dr: 要找到 “哪些代码遵循此抽象” 并不是必须的。像 Monad 这样的概念是非常抽象和通用的：它是一个描述了一套广泛的编程模式、数据结构、库和 API 的概念，其强大之处在于它们，是对如何设计和使用这种抽象的指导原则
成为高效的程序员并不需要理解全部的联系。其他人自然会强烈反对 :-)

Ray: "可仅仅知道 JavaScript 里的 Promise 本质上是 Monad，而 Functor “又是一个盒子” 并不能帮助你成为更好地程序员，而在你自己的库中使用这些词语只会让你的下游觉得不舒服"

...概念是非常抽象和通用的
等等，
逻辑学告诉我，抽象是通用的反面，就像社会是丛林的反面： 您的知识若是通用的，它一定能与各应用领域紧密联系，学生如何觉得它抽象！？

人们就是讨厌空谈，所以设计各种简洁而通用的API；人民就是讨厌丛林，所以组织出了社会。 现在竟有人觉得存在通用抽象和丛林社会？？ 这就像是说javadoc等机翻的玩意，比各种demo, test甚至产品更能展示项目的价值！
“靠代码行数来衡量软件功能的进度，就像是凭零件重量来衡量飞机制造的进度——Gates
靠知识点的难度衡量价值，同理。😅

我看这种观念者，确实是够抽象。 “类比”的本质是抽象，而「学习」只是用自己领域的思维，去「组合」「代换」出别人说的那种东西，带给你工具和知识图谱上的价值。
大家来到世上都是白痴，没有谁拥有无法被代换给别人的知识「原子」。写文爱用「未定义就使用的概念」，想设计新的抽象，却不谈理由？那就是 lier
无论我们用什么领域的「原子」组合出了CS的知识点，那都是潜在的价值，为空洞的术语绑定了新的语意，更摒弃了其中被“凭空捏造”的哲学。让IT人说话，天塌不下来！

难者，不会也。作者已死，凭什么说的道你就是「高等抽象」，大家能跟上的就是"糊里糊涂"的抽象？ Einstein, Feynman 说物理的最前沿应该教高中生搞懂，难道你们的方法论比爱翁还科学？
人们给车设计的引擎，能达到原理极限的98%，那么 #CS 对IT的指导，除了让空指针反复造成十亿美元bug，就是让功能不变的软件，随着更新越来越臃肿和慢？ 这算什么CS！

Monad很图论，很优雅啊！ 但它能从 x+1==2 得出x=1吗？ does it run backwards?
数学的精度是无限的、数学的等号是有交换律的。 #Haskell 里有模式匹配，但有"Var(x)作为值"吗？
只要变量是值，模式匹配、类型推理、响应式，甚至函数的编译，就真是小孩都会写的栏大街了。让 let(['x','y'],a) 生成 x=a[0],y=a[1] 谁不会啊 也配叫语言特性
FP们连正反函数如 show-out(1, "1"); show(res, "1"); res==1 都没建模，无精度int、向量、矩阵和微分都不如numpy sympy，也好意思谈数学性？ 起码把Fortran的矩阵搞明白再说吧

https://arendjr.nl/blog/2024/07/post-architecture-premature-abstraction-is-the-root-of-all-evil/#:~:text=achieved%20through%20a%20much%20simpler%20function

费曼家有一套《大英百科全书》，父亲常让费曼坐在他的膝上，给他念里边的章节。

有一次念到恐龙，书里说，“恐龙的身高有 25 英尺， 头有 6 英尺宽。” 父亲停顿了念书， 对费曼说，
“唔，让我们想一下这是什么意思。这也就是说，要是恐龙站在门前的院子里，那么它的身高足以使它的脑袋凑着咱们这两层楼的窗户，可它的脑袋却伸不进窗户，因为它比窗户还宽呢！”

就是这样， 他总是把所教的概念变成可触可摸， 有实际意义的东西。

“个体的经历，不过是一个庞大的（形式主义）系统下极其表面化的闪烁而已”

可那个闪烁对某一天的用户来说就是一切。 自然原理，亘古不变。如果只是发现他们就能改变世界？ 工业革命可以提早数百年。
人一思考，上帝就发笑。 你们的抽象，永远概括不了现实的领域、具体的人所提供独有的组合与可能性。

知其变，守其恒，为天下式？
穷其变，悟不穷，以明我志！
不能为每个人产生普世价值，是理论的悲哀。

#PLT #learn 文中提到一个Futa对应关系(第一类二村映射 first Futamura projection)， 展开讲讲还蛮有趣 🙉
首先，js人都会写计算器的，和 echo input/server 一样的难度

1+2*3
十(1, X(2,3)) -7

十=(A,B)=>A+B

这被称为「前缀式polish notation」，是Lisp的国是
教个小诀窍：js里函数只是一种字面常量，可以被for生成

Object.entries("十一Xノ").forEach(([i,x])=>
  this[x]=eval(`(A,B)=>A${"+-*/"[i]}B`))

为了更像“语言”，可以用列表(进一步就是"1+2"的代码)实现语法，便于糖化

Eval([十,1, X,2,3]) -7
Eval=([f,...x])=>(!f.call)? [f,x] : //基线返回两项，递归就都是两项
  (([A,b]=Eval(x),[B,c]=Eval(b))=>[f(A,B), c] )()

Monadic递归下降是这样AbBc的，因为不能右移流指针。不如逆波兰好看！不过这种程度的递归可以学学。

再看下「解释器interpreter」比计算器强在哪： 能够“在调用时传值”，也就是要有 argument[0] 这种“环境变量”
很厉害！现在有常数外的“语法”了，有变量了，高阶了！或许你需要学动态作用域(原型链?)、调用栈call-ret、惰性求值如&&|| blabla，还有深不可测的编译优化呢！

不就加一个箭头么。

十=(A,B)=> (env=>A(env)+B(env)) //现在知道为啥该用for生成函数？
Lit=x=> env=>x
Arg=i=> env=>env[i] //PHP写作 $x, 模仿bash的$1~$*
Fun=(n,f)=>f(Array(n).fill(0).map((x,i)=> Arg(i)))

env被称为运行时，它可以是JVM, import dis 或者别的bytecode解释器，这能减少tree-walk对递归栈的频繁依赖
这种 formSytanx.bind(consts=lit/arg/global/Types..) 的"部分传参"函数，称为编译器，而它的返回就是classFile等类型。
编译器并不需要与DSL这些技巧隔离，如果我们把 env=>x 写作 JSON(x) 而 env=>env[i] 写作$i ，既 Lit=x=> gcc? CBor.dumps(x) : (env=>x)
以这种人类或机器可读的结构序列化一些函数被"bind"到的lit，就得到了对应的代码。jvm的 lconst 1, aload_0 this参数, iadd (2->1)甚至是自动分配参数寄存器的！
https://www.yinwang.org/blog-cn/2014/01/04/authority#:~:text=partial%20evaluator。其实并不是特别神奇的东西，只需要在普通解释器里面改一两行代码就行，可是有人

二段求值。代码是流动的数据，内存是暂停的程序。本文甚至比赢王更直观： https://www.yinwang.org/blog-cn/2012/08/01/interpreter
定义个“元循环加法”吧？

十1=Fun(1, ([A])=>十(A, Lit(1)))
十1([232]) -233

//[Lit(f),x] 补丁下Eval"解析器"。计算器、解释器、编译器间，其实并非泾渭分明
Eval([十,1, X,2,X,1,3])[0]([2]) -7

如果你乐意，还可以支持基于全局表的递归 fib=f(x)=x<2? 1 : f(x-1)+f(x-2)
这一切都不会突破以上的定义框架。 If 不会，Call(f,x-1) 不会.. 这就是java的反射嘛。
我不想再写什么了。 我看过许多“编译原理书”，他们连这个=>都写不明白。 更何谈用Visitor实现(反)序列化 这些既理论又实践的approach
#haskell data Val=L Int|Op Char Val Val deriving(Show)
(Op '+' (L 1) (Op '*' (L 2) (L 3) ))
这类基于list或class{子类多型} 的 Eval(e=^^, env={proto:{..}})，与本文使用的闭包法是等价的。「闭包是穷人的对象」，Promise 给它暴露到了 obj.then(Continuation)

> 高阶的思想或许是本文的所有思想中最为重要的那一个 https://ray-eldath.me/programming/three-important-ideas/
你们知道函数的函数、类型的类型、语言的语法，却难以创造「语言中的语言」—跨越用途与界限而一致的语意。
我看numpy和 taichi-lang.org 就用的很好，比LLVM好一个世代
顺带一提，上文还使用了 Tagless Final 和 De Bruijn 索引 😇 。只是…… 你甚至不需要知道它们的名字。([A])=> 经常被实现为KV["A"]，但点明它的本质，却比写解释器更简单！

说到底，元编程也只是编程。就像“学会学习”只是一种策略，它对学习而言，并非例外情况。难者，不会也，譬如在谈"bind(x=1)后函数值字面是否改变"时提起「颗粒化curryArg」 当然会让人迷糊
node,graal会编译js,jvm代码（这也是为何Chrome页偶尔会segfault）； JVM会使用汇编模板+JIT 的混合式优化，Cython则把“甜妹语言”翻译到C，LLVM则是个伪装成NodeGraph虚拟机的codegen
如果只用"是否该调用javac"来区分语言，认为C类型总比python更快的话，你会发现程序员钟意的都是freak！

宏，macro码可揉，是传入与生成class{}等字面的函数。和+-*/一样只是函数，而函数、类型，只是值，别被“静态分析”骗了，它们送你的class只是病态类型。
入，lambda栏目答，看x,A,B等栏目回答的算式
这点篇幅放前言都觉得寒碜吧？ 可就是没人做到啊。 扶她投影？不知道的还以为是HP projector 的娘化版呢。。
PLT能对dev点化到的可谓寥寥， 但100%都是必要且急需的知识和"抽象"，像Prolog的模板与响应式html编程("FRP") 什么的。 Monadic错误处理我不想吐槽什么，只能说不怕不识货，只怕和Kotlin比！

跑题了。当然，聪明的你会发现Fun的返回违背了"基线指明了递归的类型"这一原则，没生成 env=>
那C语言函数指针是这样的，env由*rbp[0:2]=[retRbp,retAddr]这些CPU变量提供，但JS里的闭包可以从env偷变量(Var作为值,mut ref)，所以说「闭包是穷人的(单方法)对象」

C里还有"函数符号"，那是由ld.so实现的全局表，让.o对象能先被mmap到任意地址，再去回填calls
真正的那个全局表叫 $PATH: ，以及没定义main的对象的 $LD_LIBRARY_PATH 。

#china #android 魔幻现实 ：阿里郎
http://www.bilibili.com/video/BV1oZYRetEHN

Firefox 移植到 Haiku

2024-08-13 16:56 by 巴比伦Ⅲ：终结

开源 BeOS 操作系统 Haiku 有了 Firefox 移植版本。Firefox 有被称为 Bezilla 的 BeOS 移植版本，但那是几十年前的事情了。Haiku 的原生浏览器 WebPositive 表现不佳，因此有开发者不断移植其它的主流浏览器，最新的努力成果就是 Firefox。目前移植版本还是处于早期阶段，没有可下载的软件包，感兴趣的用户需要自己去编译。移植版本是 v128，比最新的稳定版 v129 落后一个版本。

https://discuss.haiku-os.org/t/progress-on-porting-firefox/13493/143
https://discuss.haiku-os.org/t/progress-on-porting-firefox/13493/148

#Firefox

#china #life 起个变量名都要有证有手续😁
但是，这种『漫长的戒严』能持续多久呢？
https://m.youtube.com/watch?v=fLc2fwqG90s
- 朝鲜化以加速师的智力，实现不了
- 文革所需要的三年饥荒、权力内斗，没有出现。反而是李克强声望更高，这就像刘少奇把毛泽东关牛棚一样
- 拉美化的可能性最高，但一旦被转移矛盾的义和团调转矛头向内， 拉美化就会停止

- 它们很想让中国成为《1984》，也很想用超国民待遇卖国，换自己的特权永不变色，但经济上不允许！
- 从现况分析，方脸对中国人的未来是乐观的

>火之魔女: 不过unification我是想写好久了（应该按年计）但是一直没写的（
https://github.com/duangsuse/mkey 写过，不过落后很久了 #sql

这算法就是 unify(a,b); unify(a,1); unify(1,a) 得出 a.v==1==b.v
reify([a]) 解引用一下=[1] ，其实也挺有趣，包括npm也在牵强附会这玩意，真让人搞不懂从哪看的

http://minikanren.org/ 使用了一个自有的def: yield 实现，对 a&b 顺序执行，a|b 保存a的回溯以及交替yield ，但 inf(a,x): a=x|inf(a,x+1) 这种递归好像要套一层

append-out 生成加法表是比较知名的范例 https://www.adamsolove.com/microScopeKanren/
https://tca.github.io/veneer/editor.html https://swish.swi-prolog.org/
https://tomstu.art/hello-declarative-world

logicalVars 的真正力量是用在AST里实现函数参数、类型参数及推理等等，比如 vars(x=> Fn([x], [x 1 +])
所谓的HOAS ... 还真挺搞笑的，PLT人怎么会用字符串表示变量？？

可以在js里直接解释，也能被整齐替换为为 iload_0 之类的编译
也包括推理 fun let(:[T Box], :[Fn1 T R]): [R Box] 了， unify([T Box], [Int Box]) 一下就出来了，再给[(R=Any) Box]做一个freeze(reify)，比模式匹配不知道优美多少倍

然并暖。 国内讲这个都都是局限于那几个术语和过程，真够无聊的。
unification(变-量叠合) 不是解方程的办法(不能取代sympy.solve)，但React都在用它，只是在用一种很低性能的赝品(Svelte和Compose也是,快但丑)

PHP拼接SQL而不是用 (?)生成匿名函数， 一群PHD也这么搞，结果现在搞出个 AST v2，就“数学且高阶”了。指望这群人纠正IT界的错误实践？ 呵
Prolog已经50岁了，Lisp计算图和深先遍历则更久远，它们的思想稍微补丁一点，就能对今天的编程产生巨大的改变。 只是把"变量"这个概念初次写对，就说是Higher-Order tree了，真幽默啊PLT
(Lua lparser.c 在第一遍历就会查好栈/闭包/全局表的具体地址，这是所谓“不理论”的算法人，人家的var最开始就不是str，更别说Ruby和C符号呢。 PLT人只是目标更简单，并非语意更明确！)

如果ES6支持模式匹配时直接把Prolog的变量作为值学过来，React就可以带着它随地大小变的"FP" memo消失了
full: https://t.me/dsuses/5341

https://blog.jim-nielsen.com/2023/examples-of-great-urls/ #web #design

#OOP #plt 学点设计模式
https://iota.huohuo.moe/OO-in-C.html#:~:text=一种设计模式对应一种语言特性%20%20By%20千里冰封

函数式人有许多「过度设计」，例如美 kotlin.Any.let 其名曰 #FP Functor.fmap (Arrow-KT.io)。这种(私货+算法)的泛滥，给IT带来了灾难，让许多初学者不明觉厉，也当然不能提升其应用能力（毕竟只是"指针别名"嘛）
https://kotlinlang.org/docs/scope-functions.html
https://www.ruanyifeng.com/blog/2017/02/fp-tutorial.html

但OOP也有自己的“私货”——用于弥补语法不足的“优雅的”设计模式
例如 Builder,Utils,Adapter,Delegate.. 它们是对this参数、对interface扩展不够灵活的变通

这个长文，我会用短 #kt demo 让大家看到 refactoring.guru 🐿收录的10种流行 Design Pattern 掩盖了哪些语言特性的缺失
以及科普"OVDEP" Observer Visitor(深先iterator) decorator(单参compose) EitherAB Proxy 等不逊色于箭头函数的，超越语言的优秀工具

## 创建性-Creational

这些模式是 new 构造器() 的变体，在Rust里被 fn new=Pair{A:1, B:2} 构造字面和 impl T for T1{} //mixin T1: T 混入取代

1. StructBuilder

有一个很长的SQL row需要new，可以使用默认值，插入前也有检查

class RwCol2<A,B> {
  var A:A?; var B:B?
  constructor(x:A,y:B){A=x;B=y}
  constructor(){A=null;B=null} //默认值
}

我们把构造器中A=x;B=y; 拆成 newThis.A(x).B(y) 两个函数，就能实现初始值的解偶
填完数据可能要验证，如编译期验证不可变 fun build()=this as Col2

与它对立的是默认参数
和 RwCol2(0,0).apply {B=B+1}.B; buildList{} this参数上扩展 apply(T.()->*): T
K2 value class{init{}} 也实现了构造后验证，不过大部分人仍在使用专门的反序列化和data verify框架

2. (Abstract)Factory

常见误区是，Factory类似 Pair.of(1,2) 是为了重命名掉new，或者只把构造器集结起来: doc.createElement("div")
安卓 content.Context 与Button等View(ctx)的关系更像工厂的本意： 基于(操作系统)上文验证和保留数据

interface DataJVM {
  fun <A,B>List(a:A,b:B): Pair<A,B>
  fun <T>List(vararg x:T): List<T>
}
val kt=object: DataJVM {
  override fun <A,B>List(a:A,b:B)=Pair(a,b)
  override fun <T>List(vararg x:T)=mutableListOf(*x)
}
//val py=object:DataJVM{}

与它对立的是全局对象、元类trait。
全局fun弥补constructor钉死了 open fun 且难于校验的问题。当然！它也消灭了 object Singleton{} 和“双检锁”的样板
元类允许了 static (类名上)接口，而不是让可覆盖的函数代理一下构造器：
https://docs.oracle.com/javase/8/docs/api/javax/script/ScriptEngineFactory.html

3. Prototype

Linux对pwd等环境变量的fork()是最著名的原型模式，这使得父子进程间有了T1继承T 的关系
JS里 {} 等价于 {__proto__: Object.prototype} 函数表，函数表也可以随时添加继承。有 new.target 的构造函数()只是设置原型+赋值到this的简写
一切皆对象，除了 Object(1).valueOf() 里装了又拆箱的1。无原型的，只有更慢的 Obj.create(null)

data class 会自动实现 fun copy()，但它不能继承，因为无法拷贝父类的变量。Java里很难把对象加构成更大的子类(除了 inner class)

sealed class Box<T>(val A:T) {
  inner class Pair(val B:T): Box<T>(A)
}
val x=Box(1).Pair(2)

按道理是x.A=1，那么Box(1)单例就是这些Pair的原型

#cg https://firedancer-lang.com/ 可以和 Pi day https://t.me/dsuse/19402 结合看

#ai #game https://nicholas.carlini.com/writing/2024/how-i-use-ai.html#simpleapps
py flask 🤔#code 都是完整代码

## 增添性-Structural

这些模式封装了既有对象(如 Reader(InputStream) )，提供一致的接口

4. Adapter

又称Polyfill或shim，例如将Typec插座转为USB：
客户.手机.charge(USBcAdapter(livinRoom.table.USBA[0]))

interface DataInput {
  fun read4(): Int
}
class DataInputStream (x:InputStream):DataInput {
  override fun read4()=x.readInt()
}
//class ArrayList <T>(x:Array<T>):List<T> {..}
fun IntArray.asList():List<Int> =TODO()

不难看出，JDK8里很少写明"Adapter"一词。就像class的构造签名一样，Adapter只是toStr这样的类型转换，本不该太复杂
与它对立的是trait impl。 因为(statics)接口不能外部扩展，ktx可能要手写 Int.serializer() 等奇妙的序列化配置API https://kotlinlang.org/api/kotlinx.serialization/kotlinx-serialization-core/kotlinx.serialization/-k-serializer/
而不能像 enumValues<RegexOption>() 那样"工厂"化
见 https://discuss.kotlinlang.org/t/extension-types-for-kotlin/1390

override class InputStream: DataInput {} //^讨论区
open InputFactory by DataInput.Companion {
  fun url(:URL)=..
}
impl DataInput for InputStream {
  fn read4..
}

好吧，已经有了一种写法，但没法自动调用 fun InputStream.as=object: DataInput{..}

5. Decorator和动态类型Proxy

上面的Adapter，如果是转换到相同类型(如 InputStreamFilter)，就是『装饰器』了。
Python 里，使用@修饰def ，其实是在模仿Kotlin的花括号参数如 val by lazy{}

xs=range(0,10)

@kt(xs).map
def ys(x):
  return x+1

@kt(xs).filter
def even(x):
  return x%2==0

def flip(f):
  return lambda x0,*a: [* f(*a,x0)]

import dataclasses as D
@D.dataclass
class kt:
  o: None
  def __getattr__(o,k):
    f=getattr(o.o,k,None) or flip(vars(__builtins__)[k]) #py里小写类型没__dict__ var
    return lambda*a: f(o.o, *a) #bind(this)

与它对立的是高阶函数(let{}等处理函数的函数) 和编译期生成函数
你可能觉得这像javapoet那样复杂，它实际却和 for(k of "ABCD")eval('obj.${k}=()=>1') 一样简单。在Python里可以这么写：

class Echo:
    for k in "god bad boy".split():
      def f(self,x,k=k): print('主=6' if k[0]=='g' else x)
      exec(k+"=f")

Echo().god(42)
Echo().boy(42)

在JS里一句话省new： mk=new Proxy(self, {get:(o,k)=>(f=self[k],f.call? ((...a)=>new f(...a)) : f) })

6. Facade

非静态Utils，可以混合多个this

typealias V=Any?
class JSMap(private val a: List<V>, private val k: Map<String,V>)  {
  val size get()=k["length"]?.toString()?.toInt() ?: a.size+k.size
  //对于连续键用a 否则用k
}

与它对立的是 f: context(Home,Str).()->Str 这样的扩展函数

## 切换性-Behavioral

这些模式应用性很强，如 Iterator 被ES5用于集合和协程，Event向上冒泡实现了责任链

7. ListIterator

var a=List.of("Amy", "Bob");
var s=a.listIterator();

void dd(Object x){System.out.println(x);}
while(s.hasNext()) dd(s.next());
while(s.hasPrevious()) dd(s.previous());

var mo = Object.class.getModule(); // java.base
mo.getPackages().forEach(x->dd(x));
mo.getLayer().configuration()
 .findModule(mo.getName()).orElseThrow().reference()
 .open().list().toList()

def cat():
  x=None
  while True:
    x=yield(x)

s=cat(); next(s) #忽视x=空
assert s.send(0)==0 #回应给yield, continue
assert s.send(1)==1

8. Interceptor责任链

import json,sys #典型用途是hook系统函数

@lambda f: f(eval(f.__name__))
def print(f0):
  return lambda*a: f0(*a) if isinstance(a[0],str) else (json.dump(a, sys.stdout) or f0())

print(2,3,sys)

可以多def几次，你会找到bug，所以责任链是用一个dict传递上文环境的。
与它对立的是 list.firstNotNull{} 。你可能听说过 ClassLoader 模式，它其实用链表(super优先)的方法实现了 export PATH=$PATH:./new

就像上文的getModule，这种模式已被可反射jar/树的Jigsaw取代
对热替换来说，不同PATH的同名类不能自动转换，但像jshell那样从头调用最后一个版本就可以。

9. State状态机-也叫DFA

一个视频稿件只能在有草稿的状态下发布，在修改后，需要重新审核

enum class State{Edit,Mod, Real}
class BVideo(val av:Int) {
  var st=State.Edit
  var text=""
    set(v)=go(Edit){text=v}
  fun 发布()=go(Edit to Mod){}
  //fun onPoll(s:ServerResp){st=s["state"]}

  fun <R>go(to:State, f:()->R)=let{st=to; f()}
  fun <R>go(req:Pair<State,State>, f:()->R)= req.let{(A,B)->
    require(st==A){"state $A"}
    st=B; f()
  }
}

class Player {
  fun play(speed: Float=+1.0)
  fun playlist(pos: Int=+1)
  fun lock(ui:Boolean)
  val onplay=mutableListOf<(Float)->Unit>()
  //val play=Observer<Float>() 对既能修改又能监听的值，更准确的建模
}

最典型的例子是MP3播放器的RadioButton(播放-暂停-停止并seek0)，很明显，它们是对播放速度和列表的调整。
不难发现，用 var draft: BVideo? =this 也可以实现此状态机。
实际上，状态机有很多等价物-fun Scanner.nextInt 这些调用对class Lexer{}来说就是状态编号

10. Strategy函数值

让我们重新思考@override：之前提到的 new Proxy(js) 在Java反射里也有效。

import java.lang.reflect.*;
interface HiMap {
  fun Amy():String
}
var ks=(HiMap::class).java.let{T->Proxy.newProxyInstance(
    T.getClassLoader(),arrayOf(T),
    {o,k,a -> k.getName()}
)} as HiMap
//括号外的部分相对于<HiMap>是可复用的，很明显。只需外提为 inline fun<reified T>

ks.Amy()=="Amy"
ks==ks //cast fail

这说明，Java的class{}本质上是一个默认函数字典(kt添加了var get等语法糖) ，准确点说是两个Grouping，因为支持static和多写查找(overloads)
而 override fun 就是向它的copy().set(静态赋值)，但只能写入 open fun(虚函数) ，不为空(子类>父类)

与filter,map 等函数式编程对照，不难发现 class T{open fun f} 其实和 fun T(f:()->Unit={}) 有基本相同的语意，区别仅仅在是否仅提供 invoke()
这也是为何PyJS里少有类，却总能描述相应的需求
那么，如果我们有很复杂的操作组合，可以用这class{}函数字典，而不是更易复用的默认参数：

val Jumping="""
Σoo=0.5
主=6
中专数学：83分
""".split("\n")

interface FilterMap<T,R> { //铁杆 Javaer 一般是用 abstract class :)
  fun accept(x:T): Boolean
  fun add(x:T): R
}
object 主6Strategy: FilterMap<String,Number> {
  override fun accept(x:String)= '=' in x
  override fun add(x:String)= x.substringAfter("=").toFloat()
}
operator fun <T,R>List<T>.invoke(f:FilterMap<T,R>)=filter(f::accept).map(f::add)

Jumping (主6Strategy)

class{}本质上是一个默认函数字典，就像filterNotNull{}的默认参数，所以OOP和FP的能力相同，而 fun 与 data class 间的差别其实也很小，只是var引用在栈还是在堆上
如果强制添加 User(age,name){name!="Jumping"} 这样的验证函数， data class 其实就是能修改参数再执行的普通fun

单方法的能力比大家想象的强。就像println() 利用多写对Int,Str值分别优化， 一个准确设计的系统，其实不需要那么多fun，多写几个class当参数或许更易复用呢？

以上就是主要内容啦
"OVDEP" Observer Visitor(深先iterator) decorator(单参compose) EitherAB Proxy 里还有3个没写，大家自己搜吧
毕竟读完本文就很厉害了~

https://youtu.be/aEELfOcJ22Q?t=117 🤓 🇨🇳 #china #news 谐音也完蛋

粉红最爱的文革时间来咯~ 可惜，就算牢胡那样的爱党爱国也活不下去……

Apple Intelligence被发现存在安全缺陷，可通过提示注入攻击成功操纵AI

在MacOS 15.1的Beta测试版中，开发人员Evan Zhou发现了重大安全缺陷。通过提示注入攻击，Zhou能够操纵Apple Intelligence绕过预期指令，使AI对任意提示做出响应。这种攻击方式可以导致数据泄露、生成恶意内容和传播错误信息。OWASP组织将提示词注入攻击列为大语言模型可能面临的主要漏洞之首。技术安全专家Bruce Schneier指出，这种安全问题源于数据和控制路径没有分开。Zhou在GitHub上分享了他的代码，演示了如何通过特殊token覆盖系统提示，成功实施攻击。

此外，Andrej Karpathy在推特上也指出了LLM存在的类似SQL注入的安全漏洞，建议不要信任用户输入的字符串，并始终使用两个附加的flag值来处理特殊token。Karpathy强调了可视化token和测试代码的重要性，以避免LLM漏洞引发的安全问题。

新智元

☘️ 关注频道 @ZaiHuaPd
📮 投稿爆料 @ZaiHuabot

#linux #design #statement
最近在设计OSon(一个基于JSON的类lisp计算图语言) 的一种强类型根rootfs 标准，打算用cbor(json zip),flatbuf 作为sysfs和etc的标准编码，它们的标准很简洁， cbor甚至只用0b111(7)种情况编码了可变结构
https://cstriker1407.info/blog/cbor-simple-note/
https://flatbuffers.dev/flatbuffers_internals.html#:~:text=scalar%20data%20is%20stored%20with%20a%20variable

这对JS是有用的，因为要搞 await uu.com.google 即 //com/google //$http//google ，也要想办法修改各种语言作为shell，像 coreutil.cat(/txt/a) 什么的
//$http/info/cstriker1407/blog/cbor-simple-note/ 上面的链接看起来就会更跨平台
幸运的是，http和本地文件类型(MIME Content&file magics) 普遍被程序员尊重 👍，让网络和本地路径、音视频等格式的API统一化不太难，我只添加environ.T_PATH='array' /sys/T/*.flat,ALL.py 两个和一些util就能完成

不过我要吐槽一下UNIX的多用户和权限： 这根本就是废物，就像 ls -l 里跟在mug(drwx--- root root) 后的硬链接数一样。
就连UNIX自己的 /lib 也不用硬链模式，也包括 /sbin 不是su, /usr 不是user..
实际上，硬链接只是 protected Rc<inode> nlink; 而已，对任何UNIX外的文件系统都无用，是实现细节！然而tar;cpio 都包含了类似的变量，真不知道照着文件管理器画瓢为啥那么难

绝大部分情况下，UNIX是“双用户模式”：PID1(root)+UID 1k(wheel) ，最多加个普通用户做后台服务 😄
UNIX的“先知们” 则是幻想着youtube集群该调用 useradd 去创建数据库用户，或是让http跟着unix的属主属组鉴权…… 然而，它只留下了 chmod +x

http ftp 没人这么玩，甚至http都被 {code:,msg:} 篡了。Windows的公共/本地视频文件夹 被xdg抄过来了，但只有前面一半，所以Linux的安全只是区分root么？

$ id 会显示用户和组——基本上gid==uid，就像进程组和多线程，用 strace echo 你会发现调用的是 exit_group(0) ——所以设计exit是干什么？
syscall 这些东西倒无所谓(libc,msvc 都被Python.NET淘汰了)，groups 我是要用docker容器名换掉了。 实际上，即便如此，组的权限也没有用处
HOME/视频 现在分为 ./my.v/ ./.prot.v/; 除了 .{local/bin,etc} 等隐藏文件外都是public

这样UNIX的用户/组和权限就都有意义了： 用户=app, 组=依赖的服务。 对于uid<1000 的容器可以自动支持setcap httpd 什么的
/a pwd路径
/blk/a pwd字节(均覆盖无扩展名情况)
///google 网络路径,基于HTTP类型和编码
//$http/com/google 完整URI

./{my,prot}.[agevzmM]/ 用户,小组的 a音频 g图像 e文档 v视频 z下载和压缩 m项目 M设计和3D 。自动带有.前缀
//{sys用以支持引导和PATH里的CLI/API/UI, dev编程虚拟设备(系统级ffmpeg支持),v服务(根目录叠加层sndo),etc配置,UID/家目录}/ 运行时五项堆叠

整个内核只隔离两个地址空间： app+Chrome等解释器 在受管， Apache等可信ELF+WASMbpf等解释器+驱动+调度/分配器 在Ring0
整个系统只使用四个权限： //USER/*/.{*,prot.*} 是711和771 其他不含//sys/bin,lib64是777，反正也会被容器随便覆盖掉。
"可执行权"其实已经被setcap位细分好了，SUID这些trick被用于决定是否可信
- 任何对sys,dev,etc的读写总是允许的，只是有不可见项且限制于shell，要用 sndo -U 应用到用户
- v,HOME照常鉴权，只是照上表弱化UNIX的文件本位

大家都知道，对于OS这样历史悠久的app，ancestors' evil 真的不可修复，也有些人吐槽mp4编码容器设计得很烂，webp压缩率很好，但小白只知道mp4和png

不过，假定有JetBrains或荷兰人那样的技术，实现 kt=javaAPI, java->kt; py3=2, py2to3 的前后兼容虽然麻烦，但也是可能的 😅

//$http/ 被设计为实现URI的另一种字面，不与URL冲突(href=//example.org/ 总是带点)，可以借助浏览器和编译器插件实现
不过 /txt/a ./HOME //sys 这是与旧格式混淆的，但它们仍然比(ls -a 只添加俩 . ..)优雅。URL似乎不需要./

很少人知道 overlayfs(Dockers) 的功能甚至是Linux自带的：
https://github.com/openthos/printer-analysis/blob/master/移植/PRoot一种用户态chroot实现简介.md