#Life #Tech #Dev #Android #Coolapk #Lua #Kotlin #Java #China #Statement

...刚才本来已经准备收拾书包去学校的，可是准备从自己十几本 IT/CS 的书里选出几个要带的书时
一直总是担心买到的书可能会丢掉，所以就拿我妈的手机想查查之前买过什么书（我发过 Gist）

华为的内置浏览器好像屏蔽了 Gist.GitHub.com，虽然没有说无法访问或者 404 什么的但是加载不出来，等了很久，没有响应，进度条一直满的但是页面就没渲染出来
不知道是不是压根就没有下载主 HTML 数据。就是想让用户知难而退的。

打算找另外的浏览器的时候又翻到了 launcher 的下一个 page，这页有酷市场（现在已经更名酷安）和一个木函（Androlua 应用），以及我当时根本没写出来的“树”工具箱（Beanshell 应用，虽然没有大佬包装，我那时根本不能算是大佬）。

我内心突然产生了一种想打开木函看一看的念头和一种复杂的，不想打开这类应用的情绪。
我最终还是逼迫自己打开了木函看看... 为什么我不想打开呢... 我知道其实我有点羡慕一个木函，嫉妒到不至于。

木函给我的感觉和各种别的应用都不一样，因为它的开发者可能就比我大一点，差不多也是高中（或者高职什么的）大概
而且界面布局和装饰构件交互动画设计的是真的漂亮，令人眼红。
大概这就是所谓的同辈压力。

进入界面就是两个圆形缩放 bezier 插值动画，每次色调都不一样的二元渐变背景加上零散规整的花印
，应用简介里 MBE 风格，大概就是这样了吧，有点半个阴阳师的设计风格，小清新。

返回键退出的 snackbar，不使用透明渐变动画进入退出，别有一番风味

随机半透明圆形层叠序列装饰的 navbar 显示每次都不一样的诗句，强化了设计风格
只有两个图标的 navigation button

推荐工具、工具收藏和快捷方式创建，最近使用、最近更新、未使用、工具箱 分类，完全为用户考虑的设计
使用高亮色强调特殊的工具，被推荐的工具 entry 都有图标附着之上

一种简单的单文本输入单文本输出类型界面，MD + MBE 风格，Floating Action Button 放置位置特殊别有一番风味

图片转文本，现在已经变成了文本蒙板图片，虽然我第一眼就看到了可行的算法逻辑，还是觉得莫名失落
文本处理，支持 Java 的正则表达式和 Lua 字符模式匹配，@Java() 这种简单的二义性区分词法，觉得设计真的... 自己还是太弱了
设备信息，虽然我也写过类似的... 这个稍微安慰一些
各种网络 API 绑定如翻译，界面排版美观
网络服务 HTML scarper，我觉得我可能是之前有看轻他们的意思，所以现在才会觉得羡慕 Android 应用开发者？
安装包清理什么的，才知道以前我以为菜的 Androlua 用户也有不菜的

总结起来，就是有基本系统管理的能力，Geeks 都有，怀恋以前玩机的时候
和程序设计语言标准库函数封装的能力
和网络 scarper、JSON HTTP API 访问的能力
和图像处理的能力、Canvas 能力、Android UI 布局能力、Andoid UI 动画能力
和文件系统处理能力、简易异步能力、找到后端大佬的能力
Android 扩展多媒体 API 处理能力、Lua inspection API 使用能力

我知道不都是自己一定会的，一定理解的，可能是网上能找到的，可能是花了很多时间的，并且也经常以此安慰自己，但还是羡慕一样的，即使按理说寒歌也算是朋友所以不应该羡慕的
我自己也很喜欢做这类小工具，比如我写过，目前也只写过 MinBase64，我自以为是设计独特的...
别的应用，什么文件管理器什么别的系统工具 utilities 是不会考虑的，应用的组合可能性太多了。和底层的万年不变完全不一样，况且，底层也有很多的，没十年学不完何况应用层

如果不是寒歌只有木函和 FusionApp 两个我看的上眼的应用（其他的那种我两天能写出来的那种），我还会更自卑一些。

到了酷安上，一大堆赞美扑面而来，却是那么刺眼，但在这评论中我却莫名其妙地问自己 — 你做得出酷安这样的平台吗？
使用酷安的 Android 开发者下载榜上徘行第二，第一是 Via 浏览器。别的开发者、团队、公司的应用很多都不能和酷友作品相提并论。
酷安的开发者一直都是双重优秀，或者至少是界面设计优秀的风向标。没有第二。

”渺小的身材，承载了无数 App 的智慧。” —《一加手机》
“你的手机上有哪些有意思的 App？”  知乎 25K 回答 —《知乎 @Alpha》
”App 界的瑞士军刀“ ——《ZEALER》

”拥有很多，不如有我。“ — 《一个木函 7.0》

....

其实嘛，感觉自己除了英文组句和偶尔的单词拼写、技术上系统安全网络安全、乐理 VFX 特效 3D、打字、异步并发问题、高等算法、高等系统/系统集群管理（是的，大部分服务的部署配置我会）、初等计算机网络、人工智能、高等数学、高等程序设计语言理论、嵌入式系统、中等游戏开发、企业级应用、横向复杂度很高的 GUI/TUI/CLI/PromptCLI 应用什么的外 还不错，够用。够用。

有时候会自己总结前端设计的最核心最核心的理论，觉得排版设计应该取决于交互，装饰可以来源于生活。（很突然啊）

大概是理上还是工上都够用的那种情况。

不过还是掩不住对应用层的羡慕，就是那种吃不到葡萄说葡萄垃圾太菜容易自我满足的感觉。

即使是理科做到怎么样的层次，设计出最好的编译器、编译器框架、独立设计各种各样的理论工具之类的
又怎么样呢？
只有应用层，那些开发给你们捧在掌心里的 Android/iOS 最火两大移动平台的应用，才能成为“网红”“年薪百万”的程序员吧...
或者说，开发前端框架才是正道吧...

做的东西不是拿来直接给终端用户实用的，就不会有一大群开心完整的活人，不热爱技术热爱生活的活人陪着你们插科打诨吧... 我还是想念曾经在酷安全水贴的时候的，大概
我不想老是做后端啊，我和他们不一样，我也是想和这些应用层开发者一样能成天写着自己要用的应用，要不然我也不会来这么热闹的 Telegram，可或许... 或许现在的热闹的确不是属于现在的我的...
可是没办法啊... 有些东西是和实践结合起来的，有些... 其实，我是真的没有时间做工程系的事情啊，或许，或许高中毕业了就可以吧。

即使是开发者大概也没有多少做到理解这种，这就是理科们肯定的孤独了，不像开发应用层的程序员。哪怕是那些程序员都无法理解他们...
写一堆被人看不见的代码，甚至不会被人直接使用，有什么意义呢... 还不如去做前端，写 HTML/CSS 然后用 JavaScript 之类的添加额外的逻辑，然后和别人争论 Chrome 好还是 Firefox 好...
Atom 和 VSCode 哪个好... 自己可能完全没有用过的 Emacs 和 Vim 哪个好... GNU/Linux 和 Windows NT 哪个好...

Servo/Gecko、SpiderMonkey 引擎和 Blink、Google v8 引擎的开发者们会为了你们的争论感到开心吗？
他们可能不觉得自己是一个世界的人... 永远的生活可能就几个人一个小组，因为，因为做这些的人太少了...

不如好好讨论 Android 应用开发什么的吧... 现在桌面、跨平台应用都有点沦陷了，一切都在指尖之中
Qt 算什么呢... 好吧，我现在就在用使用 Qt 的 KDE 和 Telegram Desktop Linux，但是，Qt 开始的确是很创新的窗体控件和跨平台应用框架啊，信号插槽、事件驱动编程...
曾经第一个提出笔记本电脑概念的人，大概能想到这一天吧。根本不需要等开机，一天都是开机的，像手表一样
如果以后再变化... 总是有各种各样未来的

”预测未来的最好方式就是去创造它！“ — Alan Kay

#Lua #build #sysadmin

刚才我编译 32 位的 Lua（为了测试正确性）

有 multilib 的话直接给 CFLAGS 和 LDFLAGS 加上 -m32 即可
可是说 ld 找不到 -lreadline...
我临时的解决方案是不使用 -lreadline，找到 relocable 后手动添加 file /usr/lib/libreadline.so.7.0

编译成功

那么呢，每周回家都有每周的任务，要不然会非常无聊 #life #tech #dev #daily #Learn

#Java
每次呢看的书好像比较多，又都是轮流转结果可能最后一周完了枚举不出来自己看了什么书比较尴尬，大概是操作系统和嵌入式的，JVM 的也有，但大概是记住了吧。

📚 最近会开始掺杂一些文化课的书学习，由于 CS 的书看的比较多我发现自己的智商和认知理解至于记忆能力都有很大的提升（也可能是年龄关系，目前大概是 17 岁吧，和某 GAN（生成式对抗神经网络，14 年的）算法的 19 岁美国大佬少年还差两年，逃，当然和某些 17 岁就上博士的奇幻人生就比不了了）
主要的原因是有时候看 #CS/IT 系的书比较累

并且愿意尝试补习一下数学，数学里解析几何暂时还有点难理解，其他的代数问题大概都好，因为我现在也稍微有点工程数据结构算法分析能力。
之前一直觉得很难看的数学公式式的表达方式突然觉得没有那么难看了，觉得很自然，也有兴趣理解他们所表示的含义。

这周今天大概就是专门讲讲 r2 x86 架构逆向工程和 #Android Dalvik/Native 逆向工程顺便混杂一点信息工程理论、编译原理什么的，因为我不得不使笔记记录几乎停止，要不然的确有队爆的可能（跑）
#Book 顺便将会发点书单什么的（跑），当然之前我有资料单，不过很早之前了，你们可以自己在文件里面找（皮）
总之就四个字：逆向工程
逆向工程
逆向工程
逆向工程（

（我们可以 r2 - （malloc 512 bytes）
w 逆向工程


pr 3*4

（跑，因为我还不怎么会 r2lang，不知道循环怎么弄，他们那个蛮 #Unix-style 的，就是一切皆大部分可打印字符串，包括 ESIL（Evaluatable Strings Intermidiate Language）都是蛮像 Brainf**k 的字符串语言）

（出人意料吗？很多后端不是没有做前端的能力，比如 r2 的主要开发者 @pancake 就既写 CLI 的 Visual Viewer 也写 HTML
（讲道理，我觉得 Qt 的桌面开发者可能技术反而比 Android Views SDK 的要高

当然密码学之类的是不涉及的，如何解决别人反逆向工程（这里是说，那种高等 native 后端程序员的代码保护方法（比如 false disassembly 也即『花指令』），不是 JVM 开发者或者 Lua 这种托管给别人虚拟机运行的那种，而且不是不会去考虑什么指针不指针内存不内存分页不分页线程不线程分配不分配阻塞不阻塞堆不堆栈不栈动态链接不动态链接的什么混淆压缩然后用某某公司团队或者个人的加固工具『加固』『加密』（然后运行时类加载、虚拟机加载的时候解密载入内存，最后被人扫 file magic 再内存 dump 出来）的那种，不是内建虚拟机什么的，当然内建虚拟机解释不是说就不能 hack 了，记住所有程序逻辑都在你的机器上执行）也是不涉及的，目标是入门和简单的使用，以及给你一个运行时的视角，使你基本可以进行软件分析什么的（

#talk #backend #OS #PL #Sysadmin #CS
（这里底层素质的优势就显现出来了，虽然底层知识并不特殊，但它能给你更广阔的视角，而不是局限在应用的 Resources、Dalvik EXecutable、JNI 库接口和 HTTP 协议那层）

（说到这里忍不住感叹一下，现在又有多少开发者看得到 IL、汇编层面的东西？都是一群只知混淆处理模糊名称算法的，而且自己还不一定会写，自己连自己平台编译完后生成的东西文件结构都不知道的多的去了...）
（当然，这里能写 Java Annotation Processor 程度能力的自然也是明白人了，至少他们有学习能力吧？至少透过 Java 代码文本看到 AST 了吧？）
（好吧，AST、PSI（就是 JB 的 AST）什么的其实也是基本技能，编译优化那才是大佬... 什么逃逸分析、指针别名、代数化简指令合并、公共子表达式消除、向量化、积极虚方法内联的复杂算法...）
（那你这么说 ANN 那群 AI 开发者不是更 dalao 了么？（也不一定（现在编译优化都在用人工智能系算法了么？（启发式至少有吧
（成天批判术语... 其实还是躲不开吧，我所批判的大概是知识层次浅但是不知道自己知识层次浅的那些开发者吧...
（你的意思是你是大佬？（对不起我没有这个意思，我，duangsuse，菜鸡，菜爆了，啥算法都不会写，最讨厌图算法和动态规划（跑
（当然诸如 @RikkaW 这种 C++ 大佬自然也是大佬了（吐槽：有什么必然联系么？）
（当然，给编译原理的大佬们澄明一下，我不是带坏小白，编译是个非常抽象的翻译过程，不一定非得序列化生成文件存盘的，我只是想说明一个常用模式）

（最后：radare2 这种灭天地的逆向工程分析框架才是真理啊！世界上最好的『二进制编辑器、扇区编辑器、系统 I/O 工具、二进制可视化分析工具（like bindiff、base conversion）、反汇编器/JIT 替换汇编器、Shellcode 工具、逆向代码分析器、动态静态调试器、解析器』而且非常『可扩展、可移植、可嵌入』

（总结：Cross-platform unix-like multi-architecture reverse engineering framework and commandline toolchain for security/forensics. wow. debug.exe(MSDOS) for the 21ₛₜ century

（最后：真正的无知不是知识匮乏，你看我以前那么匮乏现在不都好很多了么？都是靠积累学习思考实践的，没有本本我能做到这么快吗？
（吐槽：你又飘了，菜鸡 （回：你的意思是我给 Echo 加了那么多 admin，随便他们发广播，可是他们没一个人评价我的广播... （不过，羽毛 @kodamasakuno 你不评价吗...）

（就是说，至少和那些专科高中的比，我学得很快了吧？不行吗？至少我是在身边完全没有电脑的情况下看书自学的，而且学的还不是应用层的东西,,, 而且我有做框架的能力他们只有用框架的份... 而且我会设计不那么线性一点的算法... 不是挺好么？而且我也会 #CG 画画... 而且我可能会写地图生成器这种随机自动生成的算法... 而且我有实用的数学和逻辑学基础.... 比方说... 呃... 偏序理论？（不会）好吧... well done...

（最后再澄明一下 #disclaimer 我真的真的不针对任何人，因为大家都是这样的，不要对号入座）

（如果要把 Lua 开发者（不是 Androlua 这种）的综合技术素质和 JVM 开发者比的话，我一般觉得 Lua 开发者的素质更好，理由是知道 #Lua 的人一般都会写 #C/C++，不是把 C/C++ 当成 Java 写的那种））

JVM 平台的一些东西可能也讲一下，如果顺手的话，可能明天也要写个 Android 应用 Reflector，尝试提供一个 Dalvik 反射类信息获取 API 的前端，模块化面向接口设计方便扩展。（别喷什么低级技能之类的...

其实每次学到的东西比较多，甚至 Android 开发上的也有（主要是带手机去学校，看一些 Androlua 开发手册上的有点 Android/Java API 使用讲解），只是知识不系统。可是，现在又有几个 Android 开发者的知识真正是系统的呢？（笑）不过是经验之谈而已吧。只是单单靠着自己本来的能力学，学到的知识基本都是 Implicit 的，你控制不了它，你『有那么一点点感觉』但『又的确不能说出它是什么』，这样弄了两三年工程发现都是自己作为搜索引擎和模式识别机器写出的代码，比较线性比较模式化，而且除了可能的名利没有什么太大的理论上的收获，可能也会比较尴尬（笑），当然我之前是不知道有所谓的理论的，我眼里只有应用编程。只有看代码看文档写代码，当然所谓学习其实也不过如此嘛。只是能看破封装的开销有点大了，不如哪怕自己的代码不那么 parallelism 也好（愉悦即可，什么留给后端吧... 反正各种线程同步、什么内核模式用户模式、同步块原子操作什么的都...

JVM 『著名』的双检锁技术（Double-checked Locking，DCL，一种用来解决 singleton 单件实例对象模式线程竞争问题的方案，虽然比较慢）都不知道有没有 Android Developer 会，大概是只知异步不懂并发了吧... 包装啊包装... 万能的包装... 万能的社区库... JMM（Java 内存模型）那（一 JVM 书）讲的什么 store、assign 和 write 这几个语义几乎一样的词用起来总是弄不清楚... 缓存同步啊缓存同步... 不会啊... ...

java.util.concurrent 这个包存不存在都不知道有没有人知道呢，或许（笑）

#Lua MoonScript.org ? （不是

Typed Lua？ Maybe

我考虑的主要是它的语法扩展没有 MoonScript 那么明显
看起来貌似只扩展了 function (a: number, b: string) 这种类型定义

比如说，我现在开始能看得懂 C 语言 + 算法工程实践的 Lua 5.1 了 （《Lua 设计与实践》这本书，我居然开始能看懂了） #Lua #PL

比如说，Android 开发的设计模式再也不困扰我了（我花了三四节课的时间看了一下《Kotlin 极简教程》里的 Android Realm 日程软件示例，现在我居然能默写很多代码，RealmAdapter/ViewHolder/TodoItemOnClickListener/TodoEditFragment/TodoListFragment/Anko UI/Coordinator Layout/RealmRecycler Layout/View inflator/Android Menus/MainActivity/AppBar/Supportv7Toolbar/XML/Resources/Layouts/Colors/，甚至包括 Groovy Gradle 项目文件了）

比如说，我花了不到十分钟终于看懂了 ES6 的 Generator Functions 和 Thunk 函数、Async callbacks 之间有何关系，为啥要用 Coroutine + yield Promise 的方式而不是直接阻塞地调用 Sync 函数或者，Async 函数使用 function * 和简单使用 function 有啥区别，为啥就要专门的 co module 来执行 Generator 函数了，为啥 Generator 看起来只是为了状态机随时挂起恢复的却要用来做 Async，Async 和 Await （语法糖）的本质是什么（Fibers，也就是 Coroutine，协程）
而看懂其实是得益于现在能够基于程序执行时控制流模拟的 — 现在我能看到啥是『阻塞』，啥是『挂起等待』了，也知道为啥要做成『分段执行』的函数了

比如说，我现在能理解 Jawa 8 里的泛型型变了（P 是 T 的父类，协变 F<T> : F<P>、逆变 F<P> : F<T>、不变 F<P>, F<T> 没有子类型关系），我知道为啥要说 <? extends T>, 为啥要说 <? super T> (? 是 T 的超类，这是类型下界限定)，为啥要有 PECS(producer-extends,consumer-super) 规则，我记住了 Kotlin 泛型里的 <in T>, <out T> 分别是对应 Java 里的啥（PECS，<? super T>, <? extends T>），但最重要的是我知道为什么 Consumer 要 <super T>（Number n = ints.get(0); 这是一个缘由，而 capature<? extends T> 限定符实现了泛型类型的协变，也就是说 List<E>, boolean addAll(Collection<? extends E> c), List<Number> 这种 receiver 可以 addAll List<Integer> 的 producer，或者说 List<Intger> : Collection<? extends Number>, List<Integer> is covariant over Collection<? extends Number>），而且我看到了谁是谁的子类型这个关系，并且我看了一遍就记住了 OOP 里的几种多态 — Ad hoc polymorphism（特数多态） 的 参数类型重载多态、类型转换多态，参型多态（参数化类型, Parametric Polymorphism），子类型（继承）多态

比如说，曾经我专门记的东西现在更清楚了，为啥有人要用，为啥有些精简代码的技巧因为可读性和语言明确性的原因不能用，比如 newvector[i++]
比如 Lua 的 table 预填充技术 p = {0, 0, 0} 防止表存储被动扩充，比如 Lua 的 local time = os.time 可以让访问减少几次索引查找
比如位运算『优化』，比如索引从 10 数到 0 而不是从 0 数到 10 for (int i = 9; i >= 0; i--)
比如数组下标（subscript）为啥要叫下标

#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

总而言之，用 PDL(Program Design Language) 可以表示为：

fun main(argv)
  String? template = readFormatString();
  String? formated = String.format(template.getOr { exit(EXIT_FAILURE); }, argv);
  formated.let(stdout::println);

fun readFormatString()
  File.Path fileName = getenv("TEMPLATE") ?: "template";
  File templateFile = File(fileName);

  unless file.exists and file.isFile: raise "File ${fileName} not found"
  unless file.canRead: raise "File ${fileName}: cannot read"

  FileInputStream is = null;
  byte templateBytes;

  begin /* readAll is into templateBytes */
    templateBytes = new byte[is.available];
    is = FileInputStream(templateFile);
    is.read(templateBytes);
  handle IOException rethrow
  ensure is.close

  return String(templateBytes);

那么我就顺手再写个 C 的版本和 C++ 的版本和 PHP 的版本和 Ruby 的版本和 VisualBasic 的版本和 CSharp 的版本... 反正我还有很多事没做... 啊 😵

#C

#Cplusplus

#PHP

#Ruby

#Lua

#VisualBasic (VB.NET)

#CSharp

#Kotlin #Java #Lua #design #cs
Delegate 呢，和 java.lang.reflect.Proxy (方法调用拦截) 当然是有区别的啊，不过提到 reflect.Proxy 可能有助于对 Delegate 的形象理解。
class MyDict(private val m: MutableMap<K, V> = mutableMapOf()): Map<K, V> by m
这就是咱漂亮的 Kotlin 对 Delegate 的支持(T by m) 里 T 是任意接口，它会代理其中的成员(从 this)到 m 这个 receiver 上。

负责的老师会告诉面向对象的程序是一群对象相互「发消息(message passing)」的过程，确实是这样；而且 OOP 的 this(即receiver引用, 或者说"主语") 使得我们以更自然的方法编程和划分代码块，不过发消息的确切说法是「驱使」或「属性访问」 (就是引用某个「主语」上的动词或名词)。

Delegate 在你了解这个事实的时候很直白：它就是把某些方法(调用的"消息")从某个 receiver 上转移给另一个 receiver ，所以我们可以更灵活的利用面向对象的继承，甚至实现"多继承"…… 在上例里，MutableMap 是个无构造器的类，但我们利用 Delegate 使它上的方法(get,set,remove,...) 通通可以访问了 (当然这个"子类型"并不兼容 mutableMapOf() 的实际类型，它是另一个继承自 Any 的新类型，但如果有 m 实现了的 interface 则其方法皆可被代理，这才是"代理"存在的意义)

如果你利用 Delegate, 则可以完美解决上面用 Mixin 很麻烦的复用问题，定义一个需实现的接口(子集)即可 (而且 AnimalBoilerplate 也可以使用 this 外的变量, 同时不局限于访问某 interface 了)。

附赠另两个特色设计模式： Visitor 和 Reducer(非标准) #PLT #ce #OOP

经常写基于 Iterable<T> (map/fliter/sorted/zip/first/...) 的程序吗？那你应该听说过 java.util.stream.Collector :

import java.util.stream.*
Stream.of(1, 2).map { it + 1 }.collect(Collectors.asList())

我最讨厌 Java 的一点就是它废话太多了，聒噪。仔细看 Collector 里有什么？ supplier; accumulator:BiConsumer; combiner:BinOperator; finisher ，这就是所谓的 "architect" 到处弄 XXX er/or 的对象，不懂得沉默是金、混淆组合(combine)流与普通映射/过滤流、没有复用 Collection 而是用了所谓的 finisher，咱才懒得看它呢。

Reducer 和 Fold 是另一个版本的 forEach: 假设你是要拿到序列的最大值/最小值(min/max)，或者把它化为映射表(associate/groupBy)，或者仅仅只是复制一份 List ，但不想写重复代码，你会怎么做？

val xs = listOf(1, 2, 3)
xs.reduce { a, b -> kotlin.math.max(a, b) } // 3

等价这个"折叠"循环： var acc=xs[0]; xs.indices.drop(1).forEach { acc = kotlin.math.max(acc, it) }; acc
当然如果是求和的话，也可以不要求列表至少存1项： xs.fold(0) { a, b -> a+b }
fold 操作往往比 reduce 更实用(如 xs.fold(StringBuilder(), op) )，如果我们把他们结合起来变成对象呢？就成了 Fold/Reducer 。这名词是我自造的 😗

以上操作或依赖一个可变量, 或是 MutableList 什么的。 他们的交集是，都依赖一个(变)量，且在 <T> 流结束的时候，返回结果类型 <R> ，所以必须建模为对象，因为它要构造并持有一个状态并且在 accept(T) 时更新此状态。
我写了泛用的 ConvertReducer<T,R> 和 ModifyReducer<T,A> 两个基类，因为这不是标准设计模式我不赘述，有兴趣找我的代码看，Fold 是 () -> Reducer (R.的构造器类型)。
ParserKt 利用了这个设计模式，从而实现 Repeat(asList()/*asInt(radix=10), asMap,joinAsString...*/, digit) 这种方便的定义式单项构造。

流式编程是来自于函数式 #FP 的智慧，这可以视作它们广为人知的特色(自Lisp就有，地位类似OOP链式调用，不过有了 Kotlin 的 scope function (let/run/apply/also) 后我觉得 Builder 等设计模式要无地自容了😂，流式编程和 MapReduce 却越来越火，超过 LINQ 和 SQL ，嘿嘿)，看看你听没听说过这些处理方法： flatMap(trans)/zipWithNext()/first(n)/takeWhile(predicate)/foldRight 。大体上分为 映射(map)/过滤(filterNotNull,first,takeWhile)/排序(sorted,reversed,shuffle)/组合(zip,zipWithNext,interleave)/归纳(fold/associate/flatten/maxBy) 五大类。
注： interleave/shuffle/flatten 应该是不太常见的用法， that's correct ，简单来说就是 交替流/乱序洗牌/铺平嵌套流

顺便一提：猜猜这个是什么： def zipPairs(xs): return zip(xs[0::2], xs[1::2])。当然这么简单定义不了 zipWithNext, 它和 fold (的累积变量)系出同门... 😂
但是 zipWithNext = lambda xs: zip(xs, xs[1:]) 我们仍没有用到重赋值，这证明了函数式的组合表现力，的确应该更新观念了。

" and ".join([f"{a} < {b}" for (a,b) in zipWithNext("1 2 3".split(" "))]) #'1 < 2 and 2 < 3'

很有趣不是吗？ 定义式的代码，根本无需数学化的简写语法(点名批评 Py 的 slice)来保持他它们的易读性，这也是 Kotlin 的一大特色。

🤔 理解了 #Lua 的做法后，我对「精雕细琢」这个词也有了新的领悟。 一个看起来完全不相关的算法，竟然可以拿来优化，真是妙不可言……

说起来最近提到『节约内存』『降低回收开销』的频率越来越高了，莫非是因为被 #Lua 的胸襟震惊而开始强迫症了吗…… #Java #Kotlin

#Lua #oop #PL 🤔刚才体验写标准Android之前又把 LuaOOP 默写了一遍，构造器调用子类优先了，重写后果然感觉优化了不少（也提升了效率编程自信心）

#recommended #blog #security #game #web #php #lua #js #net #windows 这个人涉猎非常广，WinApi、网络、逆向、密码学 都有实践经历，而且非常有活力，之前忘记加紧关注了（当然我觉得代码质量还能更好点）

#China #tech 🌚 脸红不？ 2021 还不会写 ANSI C 编译器的同学们（
https://blog.csdn.net/myan/article/details/490 《Lua让我脸红》
Python是荷兰人写的，Ruby是日本人写的， #Lua 是巴西人写的，我这个中国人只能在这里脸红。

“ 我1996年就学会了C，1997年就跑去研究Win32 API，后来是C++，STL，Java... 直到2002年看到C Interfaces and Implementations，才知道仅仅用ANSI C就可以实现一个强大的优美的library，直到2004年看到Lua的源代码才知道仅仅用ANSI C就可以实现一个非常快的虚拟机、非常棒的解释器/编译器和非常漂亮的语言实现。

但是，看完这条的第一个链接你就毁会了 🌝（跑，但这篇文章的确精炼而且 practical

#js #DontKnow 原型链：（感谢 @JackWorks 提供相关信息）

访问语法都是动态解析的，比如 x.prop 或

x["prop"]

就是

x.[[Get]]("prop", x)

ES 里一共有五种不同的 [[Get]] 实现，分别是
- 普通对象 [规范]
- Argument 对象（你们今天应该不会用到了）
- 类数组对象（数组的特殊行为就在这里）
- 模块对象（import * as Mod 里的 Mod）
- Proxy 对象(reflect proxy 全 delegate)

此外， Object.getOwnPropertyDescriptor(o, k) 可以获取可配置 enumerable, writeable 等属性的配置对象

Object.[get/set]PrototypeOf(o)

和 o.__proto__ 是它的「超类虚表」

[[Get]] 过程的 Receiver （第二参数）很重要，如果没有这个 Receiver，基于原型链的 OOP 其实是做不起来的

原来是往 proto 上找属性！
这就解释了 Array.prototype.map 之类的东西

parent = { method() { return this; } }
child = {}; child.__proto__ = parent;
child.a = 1; child.method(); // 返回自身

最简单的解释是， Receiver 就是属性访问的时候最上层的那个对象，会被当成 this 用。
因为在这个算法里你可以看到，Receiver 是跟着递归一路传递下去的

原来是 o["RESOLVE"](o.prototype, "attr", receiver=o) ！（当然，肯定是先查本地，然后才查 prototype
本地如果有就不会查 prototype 了

明白了，和之前写的 LuaOOP 很像，都是层叠属性查找

“ 大佬能交换下原型链相关知识吗
之前看加 Mixin 好像是说把 prototype 除了哪两个属性的什么全部复制一下
#Python 和 #Ruby 的情况我都了解， Py 是 mro() 链查询， A.wtf 和 a.wtf 都是往 class A 找成员，后者实质是 type(a).wtf(a) 所以得到 bound method ，而直接 A.wtf 就是 bind 操作
@staticmethod 直接不收 self ，不需要 bound 所以可以在类和实例上用

https://paste.ubuntu.com/p/tJv7QpSjGt/ liuil-util 的 #TypeScript mixin.ts 重写

https://github.com/bamless/jstar#special-thanks #plt #Lua 一个很像 Lua 但也像 JS 的语言， C 实现