duangsuse::Echo

#daily #tech #cs #pl 又是一周的 duangsuse 随机瞎想集合今天的格言是想给你一个拥抱，让全世界知道。 ——微微一笑很倾城 via 一言 API （闲的了） + #Rust 奇怪的 ty 标记类型名称对 Rust 宏稍微有一点了解的人（比如我）（但我只限于·一点·了解）（我还会学）知道宏可以按标记类型匹配（其实是我搞错了... Rust 这个宏处理过程有点奇葩弄得我糊涂了）宏模式中还可以包含捕获。这允许输入匹配在某种通用语法基础上进行，并使得结果被捕获进某个变量中。此变量可在输出中被替换使用。…

+ #oop 垃圾 duangsuse 才知道为什么 #Java 子类转型基类是类型安全的

简单点来说（我不讲什么面向对象的 is_a（class）什么 can_do（interface）无关的）：

我们知道，有一种类型理论叫做「Duck Typing（动态类型）」「一个动物走起来像鸭子、叫起来像鸭子，那它就是鸭子」

abstract class Animal {
  boolean is_sleeping = false;
  public Animal() {}
  public void sleep() { is_sleeping = true; }
  public void wakeUp() { is_sleeping = false; }
  public boolean isSleeping() { return is_sleeping; }
  public void makeNoise() {
    if (!is_sleeping)
      System.out.println("Animal making noise");
    else
      System.out.println("Sleeping animal making noise");
  }
}

这是我们对「动物」的定义：可以睡觉、可以发声，同时这个封装保存了 boolean is_sleeping 状态，允许 Animal 的子类实现根据情况（动物是否醒着）

makeNoise

class Duck extends Animal {
  final String name;

  public Duck(String name) { this.name = name; }
  public String getName() { return name; }

  @Override public void makeNoise() {
    System.out.print("[Duck ");
    System.out.print(name);
    System.out.print("] ");
    if (!is_sleeping) System.out.println("Quack!");
    else System.out.println();
  }
}

这是我们对鸭子（Duck）的定义：它定义为依赖 Animal 类（从此类派生（Derived）），并且有一个扩展字段：name 以允许我们给鸭子命名
鸭子的叫声是 Quack，并且它叫唤的时候，我们假设能够获得它的名字 — 并且知道它是只鸭（肯定的）

现在我们有个函数，它接受一只动物（Animal）并且会先确保它醒着（如果已经睡着就把它弄醒），让它叫。然后会再让它睡着，再让它叫（打呼噜 233）

public static void playWithAnimal(final Animal animal) {
  if (animal.isSleeping()) animal.wakeUp();
  animal.makeNoise();
  animal.sleep();
  animal.makeNoise();
}

我们来测试一下（假设下面的代码是 Groovy 写的）

animal = new Duck("Doddle")
animal.makeNoise()
// [Duck Doddle] Quack!
animal.sleep()
animal.makeNoise()
// [Duck Doddle]

playWithAnimal(animal)
// [Duck Doddle] Quack!
// [Duck Doddle]

... 好吧，我承认我的例子举得比较失败，但有上面的例子我想你已经知道为啥这种类型转换（type casting）是安全的了

playWithAnimal 接受一个 Animal 作为它的参数，而 Duck 是 Animal 的子类却也可以被传递进去，为什么呢？我智商比较低一直不明白

因为 Duck 「继承」了 Animal 的所有公开方法和公共属性，将 Duck 转换为 Animal 会让对象不能 getName()（Animal 类没有这个方法），而不管怎么样，都不会让 Animal 类原有的 sleep() wakeUp() 方法被 *删除* 而无法调用

Duck *是*（is_a） 一个 Animal，只不过它有自己额外的特性（name）而已！所以将它隐式转型为 Animal 是完全可以的

Duck is JUST an Animal AND MORE！

我们再回到「Duck Typing」动态类型的理论上来，因为 Animal 类「派生」到的对象，他们都拥有的 Animal 所拥有行为（睡觉、发出叫声），所以他们都 *是* Animal
因为我们只知道可以在 Animal 对象上做这些操作：sleep、wakeUp、isSleeping、makeNoise，而这个类的实例对象实现了所有这些 *行为*，就说它 *是* Animal

而反观 Duck 呢？它从 Animal 那里继承到了所有这些操作，所以它当然是一只 Animal

我们反过来看，Duck 比 Animal 多了一项操作：getName，而 Animal *没有* 实现此操作，所以 Animal 不是一个 Duck

我们都知道了，Animal 并不是一个 Duck，所以在运行时将它（一个相对的基类）转型为 Duck（相对的子类）自然是不可能实现的。同时这也不是类型安全的行为

+ #emmm 菜鸡要啃草才能... 变成肉鸡

duangsuse 比较菜呢... 好好学习吧，菜鸡虽然菜... 多吃点总会变成... 肉鸡（删除）战斗鸡的吧当然也要注意身体啊（现在我明显没有...）

+ #cs #pl 读 Lice 动态作用域实现后我才知道 Lime 主动实现的是动态作用域...

动态作用域... 就是那种只是在特殊操作的时候维护作用域「Environment」栈的方法吧，比如在进行函数调用的时候，至于作用域嵌不嵌套是另一回事

冰冰这篇博文说的是 let var = valExpr 这种作用域优化。就是说在求值的时候可以只在全局放一个 Hashtable 因为一旦放多（每层 scope 一个 hashtable，*访问(read/write)* 还是带锁的（这是他原话我也不知道是写带锁还是全都带锁））了他会很心疼（Hashtable 这种空间换时间的数据结构... allocate 一大堆 bins 会爆炸的）

于是就这么做：我在进入新嵌套作用域时已经知道了那个作用域有哪些符号，然后我检查冲突并且把冲突的符号（包含符号的名字和值）给备份一下（集合类型引用备份到栈上），然后再进入作用域，这样就可以简单的 put() 和 get() 了（不过你依然得记录新产生的键值对，等到离开这层作用域时删除他们，不能让符号「泄漏」到作用域外面）

就是说它看重时序，而不是「定义域」

我看完博客后自己又草稿了几种不同的作用域实现，我感觉帅炸了：

\+ PrefillScope
\+ PrefixScope (NamespaceMap)
\+ IndexedScope
\+ ArrayOrHashScope (AutoArrayOrHashMap)
\+ CollisionScope (CollisionMap, ByPlaceCollisionMap)

+ #android #tech #dev Android 的保护（反 crack）技术

六个我还记得（真的有六个？）

1. 手动验证 OkHttp SSL 证书以 filter 掉系统 CA 证书信任「bypass 绕过检验」问题
2. Mess 混淆 XML
3. Proguard 混淆 repackage
4. 核心代码用 native 语言写
5. JNI_OnLoad 验证环境
6. 忘记了一个... 哦是用第三方库加密 assets 运行时解密，这个也很常见

+ #pl #cs 常见的程序语言实现优化技术，扫盲

1. 常量传播
2. 常量折叠
3. 函数内联
4. 指令顺序调整
5. 公共子表达式消除
6. 逃逸分析
7. 循环常量外提
8. 循环展开
9. 死代码消除
10. 表达式重组

啊啊啊懒得写了

81 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, edited 16:45