状态机的确是一个很通用的模型（程序计数器也可以理解为基于 counter 的特殊状态机），而且非常有用，尤其是针对 GUI 程序的设计（比如某种状态下，接受到某个信号应该做什么、再切换到什么状态），推荐了解一下。

...其实不管怎么样，从仅仅是不强调思路清晰而已到复制粘贴代码是一件很可怕的事情，D(o not)R(epeat)Y(ourself) 原则啊，机器人才复制呢。推荐你写一个 Gradle task 从某种 input file 生成代码填进到 outputs.file 里... 之前大佬应该也听说过苏上个暑假写 GeekApk （虽然最后没有完成...）的时候，一大堆接口 mapping 都不是靠复制粘贴得来的... Kotlin 代码生成程序还算是简单的，我根本不会写 LLVM 编译器

我在写这个，目前已经完成了

写的时候很是感叹空纸上谈兵和实践果然还是不一样啊 #Lua #dev

我之前在学校里看了《Lua 设计与实现》里类似这些的代码，自以为很了解并且能写出更好看的代码，
可还没有两秒钟就被自己的愚蠢打脸了... 我有一个优化没看见

其实这些数据依赖、数据操作的模拟分析和回溯，又有多么简单呢。它们的复杂性需要大量的实践经验去填补。

想到要写只是一会的事情，刚准备写的时候冷汗直冒... 原来我其实一直都没有彻底理解 而已
我靠的大部分是记忆，不是抽丝剥茧。

不过还好，我还是最终通过自己勉强有一点的直觉想到了该怎么写... 并且在三十分钟内完成了总体的程序，之后一直在调试。

第一次我把 {__newindex=mkmember } 写错为 {__newindex, mkmember} 导致莫名其妙 bug 的出现，花了我好长时间...
第二次我不知道 __newindex 对应的 rawset, 上网查了第一次
第三次我写 local helper=function()... 但不知为何错误，改成了 local function helper()...
我也修改了不少次递归查找的函数。

最后我还是证明了开始写的程序，总体逻辑是正确的。
代码一共 80 多行，不多，但是我已经开始从理论走向编程。

我准备将它整理，添加一个非 Prototype 的方式（call super 链）
并且附上 LinkIterable, InvocationChain 的实现，
顺便加一个 Lua C 函数编写的简易示范发上 essay.

想要试用的同学：

require 'oop'
animal = inherit.class()
animal.ctor = function(o, id) o.name= id end
function animal:describe() print("我叫" .. self.name) end
cat = inherit.class(animal)
cat.ctor = function(o, id) o.name= "猫" .. id end
meo = cat.new('喵喵')
meo:describe()

说起来，因为有这个小号的原因
我知道 drakeet 曾经研究的反破解也的确是取得了一些进步，至少他都知道我能找到『黑箱』里的符号了
当然，作为 C 开发者我也是知道怎么办的，CC -fvisibility=hidden, __attribute__((visibility("hidden"))), static, LD --exclude-symbols, strip -K Java_io_Main_digest 都可以

可惜 drakeet 虽然的确是从我曾经的逆向工程经验里学到了很多应对经验了... 我觉得这很不错
这和『无懈可击』还是蛮不一样的。

我在编译原理上也有进步，实际上，他改进之后的『反破解』，也未必是真的无懈可击... 他依然是并没有给出破解动态调试的方法，进步了，在添加无用代码混淆视听了，但是这对基于关键方法断点的动态调试手段没有本质上的改善。用『空白字符』『不可打印的字符』也是没有用处的，他们都不是本质。本质仅仅是引用，写过 Haskell、LLVM IR 用过惰性求值你就知道。

弄了半天我才知道之前 -assumenosideeffects kotlin.Intrinsics 的原因居然是为了反破解（可惜现在大部分猴子好像还没有自动代码重构的能力...）
不过有一件事情不一定知道：side effect 死代码消除是 ProGuard 优化代码的手段（之前是不是只把这个玩意当成混淆器呢？），你以为它是说删除 Intrinsics 调用，可实际上它是说删除『返回值没有被使用的』Intrinsics 调用，结果正常只是因为 Intrinsics 对象的方法只是使用副作用(side effects) 而已，这也是我琢磨一会后猜的。

这是(猴子/老鼠)和猫不一样的地方。
猴子总比你知道多一点、深一层，猴子编程的同时训练自己的记忆不靠 StackOverflow。
因为猴子不怕失败，不会浅尝辄止，猴子向往的是背后的东西，只把使用层面当配菜慢慢品尝。

猴子还是老鼠... 可是如果站到了更高的层次，如果已经是程序设计者，还是不一样的吧。

简而言之，我看了一部分后觉得他维护的果然还是变勤快了。
而且内容质量看起来也是高了不少，虽然还算是意料之中，分享的大部分还是停留在使用层面...

两个看到了想说什么的：

1. native 中不依赖 PackageManager 和 signature API 进行签名验证的方法
猜测：
a. 手动算 file 再算 dex hash 和长度什么的，总之就是利用文件系统
b. 找几个应用类算代码 hash 校验，不过实际上这也不叫签名验证
c. JNI 是否 Android 有提供验证的方法
d. 检查重新打包时一切可能发生改变的东西，比如安装包大小？APK 的路径完全可以用 native 的系统 API 得到，不依赖 Java API。

drakeet 早就说过他可以，不过具体怎么办恕我无才，我就猜不出了，而且我不打算再去当甚么猴子，当成迷吧。
但是，如果还有下一次，恐怕我会当成迷的东西真的会少很多。

2. Kotlin 里使用 Number.dp 扩展属性而不是 Number.dp()

开始我套了一下：JavaScript 里 String.prototype.bold 是不是也得变成『accessor』呢
后来自认为是 DSL 方便点而已。 10.dp 不是比 10.dp() 好看么，虽然在符合直觉上有争论（显然第二个语义上有 10.makeAs(dp) 的意思，第一个则从表述上取胜）。

至于 Android 和 Java 开发/日常部分我不熟悉也就不看了，关于逆向和代码保护的标题我看了，也就是防猴不防人。

没做 OCR 的原因是机器太卡了...

... 我打算浅尝辄止了，因为事情的确比较多... 我不想在 #Lua 和 #OOP 上花太多精力
简单讲一下，LinkIterable 和 InvocationChain 也非常简单，LinkIterable
take 一个 object、一个 chainf、一个 hasnextf，具体怎么做就是通过 hasnextf 确认是否有下一项、 chainf 箭头完成状态切换。
InvocationChain 就是 ListIterator 控制，使用完全相同参数调用的函数 chain 而已，利用副作用在受管函数间传递，实现了 OOP 的 call-super chain 模式（不过不能做到在没有 call 的时候自动调用，需要额外添加处理余项的逻辑）

Lua 的 C 用户接口使用 lua_ 开头，Lua 支持 C Closure。
非 prototype 的意思就是：

Prototype 使用 prototype 创建（初始化）对象
prototype 也可能有自己的 prototype，prototype 创建先 call 自己的 prototype 初始化目标对象，再 call 自己的 initializer(constructor)

非 prototype 就是类似 Java 的实现方法，自动生成 call-super 调用，保证初始化都做过了。

class Animal(id: Int, name: String, friendly: Boolean = true)
class Cat(nick: String, fur_color: Cat.Property.FurColor): Animal(0, "cat", true)
class MagicAnimal constructor(id: Int, name: String, friendly: Boolean): Animal(id,name,friendly)

Kotlin 里这种行为比 Java 8 里明显（MagicAnimal 明明没有专门定义子类型的架构器，可还是用了 Animal()）。

class MagicAnimal extends Animal {}

Lua OOP 的这个事情不发就可以了。（逃跑

对 Lua OO 的理解不够深入，vtable 的 meta 方法向上查找没有注意到。

本来应该是实例 __index 到本 class 的 vtable 找，每一 class 的 vtable 找不到就到上层找，我的是实例级别包办一切。
而且我不知道可以给 __index 指定一个 table 作为代理...

Telegram 连接总是不太平... 唉，doge 酱的 Telegram Web 勉强可以用

待会我打算先写篇文章（因为 npm install -g web-ext 垃圾成功不了，NPM 是基于 GIt VCS 的包管理... 某 maintainer 手贱写错部署配置了）

标题是《状态机模型、分词器、解析器、解释器》
画点 dia...

#hw http://esp8266.net/ 突然又在 @YuutaW 的分享里看到了奇怪的东西... 这不是电子嵌入式和无线系的么

我修改了一下，平复了思路上的区别... 的确是我辣鸡不少，本来递归查找就应该是虚表级别的事情，我却让实例级别来做。

顺便 #fix 一下：
之前消息 https://t.me/dsuse_tmp/11 里的『某个作用域』应为『某个生存周期(lifetime)』

数据流和某些数据本身的回溯真的是不好做的，lifetime 也很难分析
就像这次我奇怪的递归查找一样，其实这不是最好看最高效能的方法（虽然它也很好）。
设计思路永远应该是第一，可是实现的方法就有那么多种，怎么才能对自己的架构拥有良好的直觉呢？
架构是个更大的问题，可是对于连数据生存周期和依赖都看不透的我来说有点高大上 了。
虚表做并且缓存的事情，我让实例去做，但是编程中我也发现

对于高阶函数 UpValue 数据生存周期的选择和分析，真是不好做啊，
感觉自己可能莫名其妙就引用错了 UpValue，或许本来应该做成参数的，或许应该搞清楚数据依赖是来自哪个作用域该来自哪里，或许...

做到容易，做好难... #Lua 附上使用例子：

animal = inherit.class()
animal.ctor = function(o, id) o.name= id end
function animal:describe()
  print("我是" .. self.name) end

cat = inherit.class(animal)
cat.ctor = function(o, id) o.name= "猫" .. id end

meo = cat.new('喵喵')
meo:describe() -- 我是猫喵喵

dog = inherit.class(animal)
dog.ctor = mk_nameprefix_ctor("狗")

woof = dog.new("招财")
woof:describe() -- 我是狗招财

coolanimal = inherit.class(animal)
function coolanimal:describe()
  print(self.name .. " 是很酷的！") end

caffe = coolanimal.new("Caffe")
caffe:describe() -- Caffe 是很酷的！

pig = mk_animal("猪")
goog = mk_animal("神秘鸽", coolanimal)

pig.new("哼哼"):describe() -- 我是猪哼哼
goog.new("咕咕"):describe()

-- 神秘鸽咕咕 是很酷的！

#Lua #code Lua-OOP r2

Lua 基于虚表查找缓存的面向对象继承(prototype-based)实现

[LuaOOP] 使用范例

如果想要覆盖『父类』（实质是自己的 prototype）的架构器，很不幸，不可能

因为你的父类架构器总在你之前调用。

如果想要使用某个类的父类架构器，可以

1. 指名道姓地引用， animal.ctor(o)
2. 修改 oop 模块的源码，让 __newindex 元方法在冲突的时候定义 dog.super_ctor, 或者直接使用 dog.super.ctor

如果面向对象实例行为的覆盖想要使用父类的操作：

1. 用名字去引用父类的方法
2. 修改 oop 模块的 member_creation __newindex, 在发现覆盖的时候定义一个 super_XXX 就可以

以上 (2) 项目都是玩玩而已，实际上完全没有必要（跑

如果想要拥有静态方法和静态字段，则需要建立 companion object
使用静态（需要和实例级别的成员完全隔离）的时候也得完全隔离（虽然实际作用域上是行为和状态都不分开，实例作用域可以随便引用静态成员，和 Lua OOP 里的相称，不过 LuaOOP 里 cat.name 是不能当成『类』的『静态成员』看待的，只有实例成员才会向上查找继承树）

object = inherit.class()

animal.helper = object.new()
animal.helper.feed_animal = function ...

面向对象的混入(mix-in) 必须通过修改 vtable 虚表查找和 oop 模型来建立，因为要混入额外的成员查找路径

LinkIterable 可以用来实现基于 super 指针的超类成员查找
InvocationChain 则可以实现对架构器链条的调用（非 prototype 模式的，子类架构器可以选择是否调用超类架构器来初始化）

不过还是先写... 《基于状态机的流处理程序和文本解释器》 休息一下~

#sysadmin pacman -S kotlin scala
我选择了 jdk11-openjdk