#Moha #Kotlin #functional
duangsuse:
Kotlin 怎么没有一级函数了， Kotlin 连 fun plus(a:Int) = fun(b:Int) = a+b 和 val two = { 1+1 }(); two == run { 2.0.toInt() } 都支持呢

Would ‌‌‎(oldosfan):
但是没有apply，没有eval，就不符合Librechair的要求

duangsuse:
怎么没有 apply ，但是那也要按照面向对象和 reflect、按照类型推导，去确认…… 不能说见得风是得雨，语法树要调用是错的，你再帮它 apply for processor 一遍，你等于… 你也有泽任吧！
将来程序的运行一旦出了差错，你也是要负泽任的！ I'm angry! 🐸

美国的 Haskell ，那比你们高到不知哪里去了！也没有 eval ，但是我与它谈笑风生！我觉得你们些人呀… 还是要学习一个！
所以这个人啊，就要提高自己的…解释器化复用、规范化可扩展 姿势水平！

你们国内圆括号教就有一个好，就是一谈到要拿 Lisp 系之类的概念设计程序，跑到 Emacs 上写代码，写得比西方程序员要快！但是写来写去的 intuition 啊，都 too simple ！ Something naive ！这样子编程太 trivial 是不行的！
今天算是小小的冒犯了你一下！ 🐸

#functional 序列生成 交替流

parser-combinator-koans #parser #cs #functional 🤔就是难以理解传来传去的 pure parser(CP -S style)...

interface Parser<out T> { fun parse(input: Input): Output<T>? }
data class Output<out T>(val payload: T, val nextInput: Input)

data class Input(val value: String, val offset: Int = 0) {
val unprocessed = value.substring(offset)
fun consumed() = copy(offset = value.length) // 改 offset 处理完了调用下
}

#Kotlin #lib #recommended #functional 小值/验证 IO 库
https://github.com/fork-handles/forkhandles/tree/trunk/values4k#show
这个作者感觉可以，尤其是他也很重视程序的一致性(对称性)
In order to maintain symmetry (and to ensure that we can support inline classes), this method is present on the ValueFactory instance.
Little strange but actually consistent because the display and parse logic should NOT be part of the Value itself, but be separated logically.

像 fun transferMoneyTo(amount: Int, sortCode: String, accountNumber: String) 是不安全的，因为它有 Int,String 值但值无格式(如非负数什么的)
可以手工验证但这不好看，根本解决方法是定义并引用新类型

inline class SortCode(override val value: String): Value<String>

尤其是可以 inline (新 Kotlin 限定)，然后这种方法强化的类型(格式)安全还可以保证 toString() 时把密码码掉什么的(取原值就用 SortCode.show(c) 了)。

class Money private constructor(value: Int) : AbstractValue<Int>(value) {
    companion object : ValueFactory<Money, Int>(::Money, 1.minValue)
}
class AccountNumber private constructor(value: String) : StringValue(value) {
    companion object : StringValueFactory<AccountNumber>(::AccountNumber, "\\d{8}".regex)
}

然后就可以 Money.parse("123"), Money.of(123), Money.of(0)/*throw IAE*/, ofOrNull, ofResult4k/*库自定Result<T>类型*/ 这样
原来 Factory 在 Kotlin 的标准是 ofXXX(_) 😋 很好看

https://www.microsoft.com/en-us/research/uploads/prod/2021/01/GIF_LAMBDAS.gif
#microsoft #windows #ce #plt #tech 之前 Office Excel 不能的其实是写出不停机(non terminating, 如死循环)的程序吧… 其实如果已经提供了基于表达式语言的函数，理论也早图灵完全了，这
一拨简直是蹭流量。去年 12 月的事情

也就是说现在仍只支持常量定义，以及标量(数字/真假/字符串)值，不支持聚合量么 😒 我觉得首先应优化性能吧...电子表格而已，但新特性也可能带来新生态
这一波几乎没有语法上的变更， M$ 的命名分词语义还是像以前那样烂（真不知道他们那么左是怎么维护项目的 好吧虽然这是 Excel 🤨
=LAMBDA( X, Y, SQRT( X*X+Y*Y ) )
=LAMBDA( X, Y, LET( XS, X*X, YS, Y*Y, SQRT( XS+YS ) ) )
等价 (x,y)=>Math.sqrt(x*x+y*y) 好像是勾股定理吧
(x,y)=> { let xs=x*x, ys=y*y; return Math.sqrt(xs+ys); } 😨 #functional 做这个的人脑子怕不是有毛…病， xs 和 ys 里 -s 是随便乱叫的？！xx 数学并列就能叫 xs 什么鬼？

#functional #Scala https://github.com/Ray-Eldath/whatever/blob/master/main/src/main/scala/cats/Show.sc 范畴论实践，有 Boolean, Number 等

https://github.com/Ray-Eldath/whatever/blob/master/main/src/main/kotlin/ray/eldath/whatever/dsl/MeetingDSL.kt #Kotlin 新特性回顾，初入 Embed DSL

https://github.com/Ray-Eldath/whatever/blob/master/main/src/main/java/ray/eldath/whatever/LambdaBytecodeExampleJava.java#L26 #Java annotation 语法于数组的小细节 #PLT ，话说作者写好多 bytecode example... 编译看字节码的么

https://github.com/Ray-Eldath/whatever/blob/master/x86/protected_bubble_sort.asm#L52 #asm x86 冒泡排序， :internal 和 :external 是指 while {} 内外，后方可见 inc eax, cmp, jle 指令。

https://github.com/Ray-Eldath/whatever/blob/master/mips/fib.a#L40 #asm MIPS fib(n) 计算，话说 fib(n) = (n>0)? fib(n-1)+fib(n-2) : 0; 这种方法我之前都没用过，一直是 (n<=2)? n : recur(n) 的，思维定势

不过说起来也只有会写 C 的人能看汇编😋 GC 和 libc 用惯了会不知道栈空间 jal&j $ax、segment/mmap、interrupt/ivt 是干什么的说。
不过这么看 C 也解决了很严重的 sizeof 整数长度问题啊，这样代码就可移植了，虽然不能像 Java Python 去 Run Anywhere 。

作者在 test/kotlin 下也有写评测
还测了 IntRef+ parallelStream() forEach, reduce 的正确性🤔
当然也有 reflect MethodHandle 的测试代码
他真的对语言 Intrinsic 很了解啊

#java #cs #DontKnow Integer.valueOf 的缓存机制 (即 (Integer)x==x 的左范围)

#functional 妈的，函数式和 SICP 现在自造词还不一样了，应用序 vs. 传值、正则序 vs. 传表达式(或是传惰性?)...

#JS #CSS #PLT HTTP #backend #blog 大佬的面试经历 我终于知道cs是学啥了🤔 杂学

#rust #PLT #tt https://edward40.com/tagless-final-in-rust 呃... 看来Ray说自己很菜是有道理的，是我见得少了，没想到同道这么多🌝

https://9bie.org/index.php/archives/635/ 超星邀请码... 这又一个 pwn #Security 的

https://cnblogs.com/Dillonh #oi #dalao 是 cnblogs... 上次一个 commajia 大佬也是

#cplusplus #English #PLT #ce #parsing #llvm https://zhuyi.fan/post/write-a-bf-compiler-with-joy.html
🌝🌚 看来是 CS ，爱了爱了

https://raptazure.github.io/posts/purs-react/ #functional #JS #tt #English 草这又是个大佬... 类型论大佬都喜欢英语

#oi #school #life 这位同学亲切一点，好像还在学德语🤔

#parser #cs #ce #functional 🤔 du naot walideit

#web #js #typescript #Microsoft 最知名 Web 代码编辑控件 Ace(ajax.org Cloud9),Monaco(which powers VSCode) 二者之一， https://microsoft.github.io/monaco-editor/
js,ts,clojure (一个 #functional JVM 语言) 的示例都是 Conway's game of life (当然已经82岁的他已死于去年的新冠) 😋 #listing #ce #tools

https://tttttt.me/mokeyjay_channel/1941 的 github1s.com 用 GH API 下载仓库，即可在用虚拟文件系统的 VSCode (fork ver.) 中打开
对喜爱自定编辑器和编程展示的人 必须了解一下

相关代码：
workbench/contrib/welcome/page/browser/welcomePage.ts#L75 下载
code/browser/workbench/workbench.ts#L403 打开文件夹
extensions/github1s/src/github1sfs.ts#L175 下载插件支持 Unicode

#PLT #Scala #Java #Ruby #Rust #learn https://ray-eldath.me/programming/thoughts-on-rust-1
总结几句：
Java 是主流的托管(managed) 语言，重量级的 GraalVM JS 甚至比 v8 更快，尽管有 valgrind, cppcheck 等工具， 90% 的 CVE 都是 #clang #cplusplus 内存不严谨导致的安全问题，所以托管更适合实际应用。

Scala 是重视语言特性可组合性的函数式语言，它连 enum class 都没有，而用 enum 的本质 newtype (受检的 typealise) 和直接的 extends 解决枚举类型；它的类型都是 higher kind 上的星号实现的，而构造函数类型的箭头是接收任意(包括函数)类型的二参操作符 #functional

Ruby 是一个灵活优雅的脚本语言，你可以 mokey patch Int.+ 运算符让 REPL 都爆炸，它也支持 case when guards
Ruby 的 {|x| x} closure 即闭包语法也被 Rust 使用，连 for 语法本质都是用 .each do 闭包，运行时很少阻止程序员执行能解释的代码（但没有 JS 的疯狂隐式转换）并且支持内省(introspect)

Rust 是 be explicit 的语言，它重视内存片的所有权等比 C 方便而失严谨的概念，但同时也加入了 format!() 等编译期 macro 的支持，也是一门重视严谨性、定义一致性的语言
Rust 的 Copy 和 Clone (深浅复制) 都是作为 trait 显式的，而浮点数判等 Math.EPSILON 也是应显式的

嘛，比起『子语言』我可能更倾向『语法集』『语言功能点语法集』这种更精确的描述

#functional #Haskell Elm 🌝

#zhihu React 屑 Elm 屑 #functional

#日常精神分裂 #relation #functional
A: 那个亲戚关系计算器，你还说人家做的不好，这不，你不也没做成了么
B: 是鸽后面了啦，今天又有一些新想法，可以改进特性而且保持程序接口一致
B: 首先是关系的，如果认为「父父子」（大爷的儿子）也是「父父」的话（兄弟的孩子也是一家的孩子），「姑姑」这样的称呼就跨单个的亲子关系了
A: 这还真是难以理解
B: 这个不重要，关键是反向称呼的本质其实应该要自动处理才对： 「父父」是爷爷，而「子子」就是反向「!父父」，「孙子」才对；对「我子」来说，「我子子」就是「子」这样。（有点 relative path 的意思了
B: 我还发现 notation 可以有更多变换， 父^5 和 长=哥|姐 外，还可以引入「姊」「娣」自动加「长幼」的前缀（不过，这样就要预处理过程 flatMap 展开缩写了
A: 最后这个被否决了，理由是「亲孩长幼」四个字组成的也不过几十条，复杂化算法不值得？毕竟代码是给人看的。
B: 我觉得可以考虑一下在查询语句里支持 姐|妹的儿子 这种……
A: 那子程序的返回类型就有点麻烦了，用途也小，还是不要麻烦了（孤立支持一下父&母 这种并称算了），支持 父^n 这样的缩写就够了吧。
B: 反向关系很重要，规则是 (父父 爷爷 !孙子) ，如果我用 !父父 能查到反向称谓，为什么更合理的 子子 就查不到了呢？其实反向不应该做在 妻父子 (=岳父的儿子) !_=(爸爸的女婿) 这样的称谓里，而应该做在 妻父子 !_=(父女夫) = (爸爸的女婿) 这种
A: 那么具体怎么操作呢？这种自动从数据构造反向关系的方法？
B: 我觉得应该定义 (反向 妻父) = (女夫) 这样的关系字典？
A: 首先，这么做是对反向称呼的扩展，因为数据里只有 (妻父=岳父) 的对应关系，当然可以利用别名系统增加反向称呼 (岳父 !女婿) ，问题是你要知道「如果以岳父视角看，我和他是什么关系」，答案是 (反向 妻父) = (女夫)
B: 那我给你「女夫」，如何答我「女婿」？
A: 把反向称呼的数据填一下， 孩(子女)/亲(父母) 为相反关系，查询 (反向 女夫) = (!妻父) 就成了。
B: 你可真是个小天才 :P 那就这么愉快的决定了。
A: 对了，那你之前说的那个人是怎么实现的
B: 噢，看了一下，那个是同时定义了 (d,h=女婿) 和 (w,f=岳父) ，对他们来说 ! 这个运算符反而是特别做的(不像现在 的安排应该是直接查询)。
我们之所以这么麻烦翻来翻去的就是因为数据结构格式不同(同时有正反向称谓 就避免重复定义关系链条了)，其实目前的模式也就是它的模式，没做「对方称呼我」而已
B: 总结的说，就是一个先支持反向关系再支持反向查询，一个先支持反向查询后才能实现反向关系。
A: 这么看你的在方法思想上也没有什么更高的地方啊😒
B: 是呢，不过我的数据集比较简单，单字符切分(js的之所以必须留逗号就是因为作者没法支持不定长的并列单项，不会写 tokenizer)，后期也可以加预处理替换来压缩什么的 功能能做到一样 可以试试🌝

#kotlin #PLT #tt #functional 🌚
顺便说一句，上面 Lua 指令重编号的如果有 luac 就很简单，因为指令号是「编译器和虚拟机里一致」就透明的东西，想要获得反处理算法所需的 new=>origin 映射表只需要两版 luac 编译相同代码。

之后查一下 prototype 里的 opcodes ， assoc ops[i], opsOld[i] 按序数就能拿到指令号对应关系了，然后 mapBArray 就能翻译过来。 整体命令都不需要十行代码或 indexOf reverse 😒

#日常精神分裂 #Haskell #functional #relation 推荐不要看的胡言乱语。
A: 听见人说 Rank N Types 可以弄出 p(p==not) (: forall x. p(x)==not(x)) 的关系式
B: 不过这个你自己也不明白吧，说白就是 p(q) = not q 时 q ，正确答案 q 只有一个，但是 q=(forall x. px==notx) = True 时 p=False ， p!=not.not.not.not q ... 还有一大堆 not ，就是这里没法得到答案吧
A: 为什么有一大堆 not 呢
B: 为了保证 p=not 的定义， p(p==not) 应该里 p 的定义是不一致的，第一次是 not True 但导致 p=not.not=itself ，第二次又变成 not False 而 p=not，我们想做的是用比较形式化的方法从某一面「判断」这个东西是无解的，但它到底是等式，还是关系式，还是别的什么？
A: 那还是看看 rankn type 是什么吧。
B: 最简单的说法，对 id :: a -> a 里 a 有 Int, String 等可能，但是如果有 f :: a -> (a -> a) -> a ，f 里 a 就只能是任意一个类型，而在括号里加 forall a. 那 f g = 后面就能同时 (g 1) (g "") 了，但这只是 Rank 2 type 。 Rank 是「重评估」的意思， R0 t 是单态 R1 就是正常多态，如果要更多 Rank ， (forall c . (forall a b . a -> b) -> c) -> d 就是一个 Rank 3 。 我之前还说不可能 forall a. forall a. (a -> a) 呢（没意义 a 已经在类似上下文 绑定过了）
A: 话说 type 和程序体有什么关系啊。
B: 一个常见的误会是系统化的类型和程序是相互依存的，比如完整的程序带来了类型信息，其实除了 type inference ，程序的组织结构和类型标记是两个独立部分，类型只是限制程序 它自成体系，甚至可以说能检查程序只是它的副作用。
A: 说起来 haskell 的 a b c 到底是怎么检查的啊
B: 类型就是符号之间的关系，符号绑定了语法树的模式和其它关约束条件。 hs 里这很简单，只有一个性质—— consistence 一致性，比如有 (+) :: Int -> Int -> Int ，那 1+"1", 1+0.0 就是无效的， 1.0+1.0 也是无效的。作用域单一没有同名重载，只能约束 (t,t) -> t ，如果各处的 t 是一致的就没问题，否则就错了。 typeclass 也是类似 trait ，其实类似一个小插件，是 (Show t) 拿到实型去查对应 instance ，查到就能选择多态 找到的实现版本而已。
A: 真的不明白 RankN 和有什么关系呢，毕竟 rank 是 polymorphism ，作为 type constraint 为什么会陷入死循环呢🤔，要不谈谈 rev rev=id 吧
B: 那个就是把 0 和 iLast-0 对应吧…… 和 xs.rev()==xs.rev() 不一样，是要 xs.rev().rev()==xs ，怎么解构呢，我区分不出 foldl 和 foldr 啊，函数式分不出调用顺序 理论上不存在栈这东西呢， foldl f v xs = foldr (flip f) v (reverse xs) 啊
A: 问句题外话，为什么不能 add :: Int Int Int 啊，而且遇到 f not p 时中间也得加 $ 或 <$> 的
B: 一个是并列一个是 infix 了，编程语言可没你聪明不知道 not 不是一参数 要加括号
B: 你到底有没有见过正经的 Recursive Type 啊
A: 递归类型是什么，为什么要递归？层数有限制吗？是不是有限性？在无限序列上有限计算 算不算用了递归类型？ Py typehint 里 -> "self" 算不算？
B: 肯定不是啦…… self 是 py 作用域设计的问题，3.7 lazy 勉强解决了，和 recursive type 是无关的，这个大概和 Kotlin inference 一碰到就要 workaround 的递归返回值有关吧。
A: 当然基于 car cdr 的 apply transform 我都会，C++ template<T, ...Rest> 嘛
B: 那还真是好普通啊
B: 别灰心嘛，还是需要你们这种布道者的

A: 有时候感觉我们这些做同级翻译或者 LLVM 前端的人写的编译器本质是元编程的一种表现形式，有时候觉得完整的编译原理课又是照本宣科，除了后端都是重复，到底怎么样是好啊。
B: 我看到一个有意思的视频，一排柱子一根根升起，给你一个 i 你能不能做出动画来
A: 动画师估计挺麻烦吧。 普通人可能要求 timerup 后移 单个动画 ，但这个应该建模成 [0, 0], [1,0], [2,0], [2,1] 这样的「逐列递增表」，实际依然靠 i ，但是可以拿到过程中的所有状态。
B: 最方便的大概是直接一个乘除法吧…… 批量计算好
A: 感觉还是做到 assembler 前比较好
B: 你是说 SSA Value 和寄存器分配吧。 分配是独立的算法，但我可以告诉里不分配，完全溢出到栈上也是能实现的。只是要生命期内所有引用，局部 unified 就可以。 作为 stack ptr 参数还是 opcode reg input/out 的区别而已，如果用栈，也无所谓有几个 operand 或有几个AST前层，唯一又能统一的输入输出地址而已。

#python #functional #cs #statement https://tttttt.me/py_zh_real/14351
依云:
看完了。是完全由函数构成的算术系统呢。

daquexian:
（没仔细看视频）就是 church encoding 吗

duangsuse:
church encoding 貌似是拿闭包做 data N=Zero|(P1 N) 皮亚诺 Peano 数来的
two=P1 (P1 Z) 和 two=(f,x)=> (f (f x)) 好像是，后者有没有x我忘了但记得是调用嵌套 类似 two(P1,Z)

纯函数构成计算嘛，其实就是 Abstract/Apply/Subst 三项构成的形式化模式，也即 Func/Call/ArgN
其实就是 lexical scoping 作用域下函数复用。什么语言不可以写成这种形式啊，反正 +-*/ 本质是利用 prim operation 的 operator 函数

这一块的基础没有什么 都是绕来绕去的无聊名词和没有用的旁枝概论，要学的话基本是元编程的扩充 有些学习价值。

这一边的理论和实践基本是脱节的，很多时候一大段变成代码只需十几行，当然也有简洁的理论，但很多人看不见。

有意思点的东西对工程完全没用，只和数学/逻辑有关，也很少看见有人拿这些东西写成实际软件 且基本都是 DOM。
DOM 不是不好，但是用法单调 不考验可移植性和程序序列复用力(基本都纯函数 无重赋值的)，要是能移植到其它地方算是 real-world 一点。

所以说比起这些东西 还是研究怎么复用、参数化好代码 比较有意义。

daquexian:
church encoding 没有闭包吧

duangsuse:
可能吧，不过只要有 \a. (\b. a+b) 这种形式 引用了 upvalue a ，就算是有闭包

因为 lambda 演算都是单参函数， curry 实现多参，所以只要有两个参数都是用了闭包 而不止是嵌套 apply

当然所谓存储可能也就是程序解释期间的一个结构表达法，不一定和真闭包有关。

噢， Reactive 就是 c=a+b 自动更新 c 呀，我之前想了几次呢。 一般不用 onresize 之类的事件很麻烦呢 #Web #DontKnow #JS #lib
而且还能做到数据变动视图自动更新，耳不仅是单向的视图更改数据，有点意思。 #functional #ce
然后对于控件的 computed() 用了特殊语法 $: a+b (label statement) 表示，应该说也是很实践性

“ 在「古典」React 里，你不得不写 shouldComponentUpdate, 在现代 React, 你同样需要引入 useCallback 和 useMemo，手动地缓存函数，来避免性能问题。

同样是使用 Virtual DOM 的 Vue 却没有这个问题，因为 Vue 的机制（依赖收集）决定了它不必重新执行整个 UI 函数来换取新的 Virutal DOM 树，当某个状态更新的时候，它明确地知道应该 diff 哪些节点。

这么看 React 真是傻逼，不过是提供了无作用域的 state ，竟然要重渲染整体 UI？难道不能收集出有哪些变量节点用了被更新变量么，这不是基础操作？

#statement #functional #js #GUI #dom
再说 Reactive... 等等这不是 Rx 类框架的招牌吗٩(๑`н´๑)۶ 看来 -ive 的词性都容易后宫起火啊草。
React 用 functional MEMO 提升控件更新性能根本就是弱智措施， memo 即备忘录，用 hash 表实现函数输入输出对应的缓存，这样对类似 Text 的控件，同输入多次调用不产生额外计算和内存开销，应用在树 render() 上时相当于自动实现 shouldComponentUpdate() ，尽量复用旧的渲染结果，对树遍历减少重建操作量，相当于仅重建了真正变更的控件。

经典版暴露 shouldUpdate 已经很没水平了，说好的面向 state 编程呢？在我看来这个 Reactive 所做的就是「把所有控件的所有变量暴露到一个 state 里方便读写操作」，那么凭什么程序员要操心什么 update 啊 memo 啊，记得很像 还有 SMUV(state,message,update-event,view)模型，实际上根本不能便利地 handle 多少东西，就是个秀儿。

当然，其实真正的 relational 编程也是这样，关系式 state/var/eq/both/either 靠 enumerate&filter 可以解出 x+1=2 这样的线性方程，甚至能得出 a+b=9 的所有可能性，只是需要 interleave([a,b]) 两个变量先后递增构造 state 迭代，然后 unify 一下同步恒等关系(双向版变量引用)而已

可是这和 DOM 有多大关系？比如我有个
class Main: DUI() { fun view() = el("il", withNone, Counter(0)) }
class Counter(var n): DUI() {
  fun view() = elDiv(withNone, elText(ref(this.n)))
  fun inc() { n+=1 }
}
其实渲染 Main 的时候连给子控件注入其路径都不需要！也不需要专门分析 DOM diff 的哪个 tag 哪个 attr 还是 text ，直接拿住自己的 HTMLElement 的引用就够完成全部 update 了，所以说搞那么复杂？

要是想兼容 haml 或者 E4X 内联 XML ，直接做个中部翻译成 el 调用就行，反正 DOM 元素动态创建最好是 createElement ，逃不开运行时开销。

想实现控件属性事件到 update 代码的方法很简单，因为 js ref(a.prop) 并不会传入 a 相关的信息，编译期把 op(ref(a.prop)) 变成 refAddRel(a,"prop",v=>op(v)) 就可以了，这种方法换成处理全部代码，引用处 a.prop=x 自动更新就变成上面那个 框架S 的实现方法，接口上是兼容的，只不过 refAddRel(o,k,op) 从 defineProperty 变成编译期打监听表。

变形方法很简单，walk 到 FCall 节点记作基点，如果是 op(ref(o.prop)) 就把基点变成 refAddRel 的调用，如果是 ref(v) 这种不知道 receiver 的情况就请换 Array [v] 报错，反正框架函数可以随便加没必要特别支持 a=ref() 这些语法，兼容的少，反而更优雅。

#statement #dev #design 编程者像舞蹈编排者一样，就是什么时候做什么事情而已。 什么时候是指外部输入和环境变化带来的事件入口及传播；什么事情是指对数据的处理与判断。 编程就是总结物上之事的客观规律并加以主观控制，实际一步就是美感地设计代码/项目的结构和利用下层接口。程序的设计和科学一样，只要习惯了所处的这个死板的「世界」，明白目标的流程和时序/存储关键点、灵活复用代码，无论看起来多么复杂或强大的程序都能按部就班地设计出来！

#functional 程序序列 生成/归纳 ，比如对第一次/第一项的特殊处理或重复语句
数据序列 操作/绑定  恒等关系

嘛，很多方法，我能说出它在编程领域的技巧名，但却不知道它具体是什么，都是经验，甚至赋技巧模式以名字本身也是经验

#math 编程相对于数学最好的一点就是懂把重复的规律提取为常见易懂的子程序

r.stepCount(nStep).zipWithNext().reduceWithLeft(y) { (acc,x,yL)
  Rect(x,0,x+r.step,avg(yL,y(x))).area
}
(求和曲边梯形面积 定积分)
Rect 要是带算法可视化的副作用就更好🤔 #cg #statics 觉得建模易扩展十分有必要！ #DOM Rect 还带 x,y 的就很灵性，其实是 Area 吧

#net 想想写局域网聊天测试，tcp recvfrom 和 sendto 两 buf ... 不，其实是两方的 recv buf ，没有主动方或从动方

#relational 关系式, 不是我读一次你，而是我与你相关，双向的关系 (双边 setter )
不过这个不算真关系式…… 但关系式的内心不止是求一个满足等式的变量表 state ， React 这些自动更新的、甚至数据库查询都算关系式。

#game #python 想弄个真心话大冒险，当然游戏逻辑本身太简单了，作为 web 应用应该要 9patch 背景图(工具?)和动画什么的

fs:scan/read/save 9patch async-quest-loop xhr-gists&files expand[a,b] listanim

datasets=dict(enumerate(basename(fp,".txt") for fp in listdir()))
selBanner=" ".join(f"{k}{v}" for k,v in datasets.items())
while(1) print(randPick(datasets[input(selBanner)]))

#windows 同学居然做出一个 winform 还是啥的 C++ form+table 『疫情登记表』…… 回头也想做一个
#web #js push&update, form Date, table sort/filter/select, export, grid-opto