很复杂... 我语文水平不好的，这个例子本身没有那么 trivial

我也是一个很热爱生活的人，现在我要立刻继续我的付出了，睡觉。

#life #tech 修整了两三天。暑假，duangsuse 可能回老家过... 🤔

修好了一台旧笔记本电脑，顺便被换了个硬盘，换掉了坏的风扇... 之前因为养尊处优就一直没有想修，没有拿电表查也没有示波器这种高端仪器，怀疑只是电源按钮坏了...

暑假也没啥安排，有通网，就是做一点之前计划了没完成的事情吧。

眼见着自己对编译原理和杂七杂八应用设计的理解也开始向深发展了，大概之前费了点力气 GeekApk 可以重新启动了吧，大不了我再抄两三次书。

老系统用的是 OpenSUSE，大概先换上 Arch + XFCE 吧。

其实这是一个计划的三天适应性休息，不过因为一些事情没有完成延长了一天。期间我看了 N 集的三大民工漫之一 — 《火影忍者 疾风传》

（不过，看起来坏习惯还是依然存在嘛。还是不擅于管理时间，唉。
而且虽然没有上线，前两天也是有熬夜到 12 点左右的，这么说，只是比写代码讲 XXXX 的时候好一点点。 🤪

[In reply to ...]
啊，对不起，现在基本了解了；Python 的确提供了很多方便的列表操作语法

list[0] 这是最简单的 list.at(0) 解索引
list[0:10] 这是依据 slice 取 subsequence

list[0:-1:2] 就是 list.take(Range(from=0, to=list.length-1, step=2))

Python 因为比较『灵活』所以索引有两种：
+ 0..lastIndex, 数学里的 (0, size]
+ -1..-size, 代表 (size-1, -size]

比如，

xs=[1,2,3]; ys=[2,4,6]

Python 里可以用 List comprehension 定义 ys
ys = [x *2 for x in xs]

索引:

xs[-1] #=> 3
xs[-3] #=> 1

子序列:

xs[0:1] #=> [1,2]

加上 Range with step 后可以按『步』跳着复制

xs[0:-1:2] #=> [1,3]

list[:] 实际上是 list.subsequence(range(0, list.size-1))
list[::-1] 实际上是 list.subsequence(range(list.size-1, 0, -1))

以 -1 为步长复制的话，就是这个颠倒序的结果

啊，可惜我现在还是 2G 的说（马上

2019 年了，温习一下：4GB 在电脑上绝对称不上大内存，8GB 都称不上大内存。最近想要购买笔记本电脑的朋友们，尤其是高中毕业准备走进大学的朋友们，如果对自己专业软件所需的硬件配置不清楚，请咨询自己专业的学长学姐们。

#TT #PLT ... Typescript 渐进类型果然爽炸，Type notation 就可以讨论 value level 的事情，随便创建类型集合，甚至可以是 ("+" | "-")[] 这种...

累死我了 #TypeScript

#Java #Syntax

https://t.me/drakeets/1650 #bin #Telegram

啊，Telegram 最近支持的 Channel Preview 功能使得我不需要什么『内奸』帐号就可以 preview 某 Channel 的内容了
突然想解释一下这个，因为也比较简单嘛。

二进制计数法是一种位置计数法，它用于在机器中存储一定范围的数字（数位计数法）
因为其和数字电路的优异对应性，被广泛采用于现代电子计算机内。

保存整数值，其核心就是记录状态，把状态『编号』对应上数值。
10 进制里，一个数位有 10 种状态；10 位累积起来组合就有 10^{10} — 100 种，换到二进制里也是一样。

二进制无法和日常生活使用的十进制直接对应，但是可以和 16 进制以 4 bit <=> 0x0~0xF （4 位二进制对应 1 位十六进制）为单元直接对应

具体的二进制机器数运算比较复杂，这里不讨论（一部分是通过高层不可见的移位器、乘法器做到的，但算法抽象也是存在的）

0xF，15，如果不能保存 sign （符号）的话是 4 个 『二进制位』（bit）组合的极限了。
0xFF (255) 则是 8 bits 储存状态的极限了

0xFFFF_FFFF 数一下有几个 F: 8 个，就是说，对应 8*4=32 位的二进制数值

那么为什么不能？我们知道 Kotlin 是安全的，安全有时候也意味着应该尽可能避免溢出(overflow)整数值。
计算机是基础数学的实践，当然应该首先为性能考虑 — 不要想直接让处理器 ALU(Arithematic Logic Unit) 实现无限长度精度的数值，太慢了。

那 4 bits 最大能储存到 0xF 个状态（以二元状态混合叠加成 N 元状态就是我们计数的方式，0x1_0 = 2×2×2×2 = 16）可是到了这个地步，满了，记不下数了怎么办？
回滚(rollback)到最小值或者溢出(overflow)，这是很多机器给出的方式，当然也有程序员自己考虑溢出情况的方式 （比如 GCC 的 __builtin_sadd_overflow）

— 所以为什么，不能 (0xFFFF_FFFF as Int)

看到这个数的时候，可能觉得它反射了底层二进制存储的状况吧（其实也未必尽然，只是抽象层次不同而已，比如还存在有 byte order 的情况）。
其实还差一点：这只是语言对于 literate integer 字面量（当然是常量）的表示语法糖而已，它缺了一点：数值的表示方式，是有符号(signed)还是无符号(unsigned)

Kotlin multiplatfrom 里是有 kotlin.UInt 无符号 32-bit integer 的，这种类型是包含 0xFFFF_FFFF 这个值的

可问题在于，kotlin.Int 是要有一位来记录数值符号的，这导致 32-bit 的状态叠加得留一位，来给余下的 31 位指定其符号是正 (+) 是负 (-)

对应到 LLVM 里，i1 类型就只有符号部分 (+) (-)，它只有两个状态，所以被当作同样二态的 boolean 用，i1 的真值只能是 +0 或者 -0

结果，0xFFFF_FFFF 实际上就溢出了，因为表示它至少需要 32 个二进制位，而 kotlin.Int 只能表示 31 位的正/负数而已。
32-bit 最大值 2^{32} 是 4294967296 — 16 进制 0x100000000

试试把这个值的 succ (后继数)转换到 kotlin.Int: (0x100000000+1) as Int, 你会得到

java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer

而真正的 Integer.MAX_VALUE 是 2^{32}-1 （去掉一个 "0" 状态） 0x7F_FF_FF_FF (2147483647)

数值类型宽度自动提升(widen)，或者如果你写成常量的形式进行常量折叠(constant folding)，Kotlin 编译器，已经自动选择了 Long 64-bit 的数值类型来表示溢出的数值了。

— 所以为什么 Java 里就可以？魔法 Java

因为 Java 支持数值类型可以随便溢出啊，应该说是被自动推导得比较有风格吧。至少在语义上是对的，No implicit conversations、representable using 32-bits。你 explicit 地声明它是 int 的，你为溢出负责。

class Wrong32Bit {
public static void main(String... args) {
int x = (int) 0xFF_FF_FF_FF;
System.out.println(x);
}
}

你会得到一个 (-1)
Kotlin 里就是 type error

得了吧，白活了，睡觉

明天就回老家喽~

#Android 第一次听到辅助服务（无障碍服务, Accessiblity service）会导致手机变卡... 不过想想也是有道理的，那么多数据要跨 ring 级别传输呢

—
Ring 级别：计算机系统底层分级权限控制
类似的就是操作系统内核支持的进程访问权限控制呢。

其实这里的误会大概是我开始根本没有考虑 type checker 感受导致的，过几天我会做个总结。

我是搜索 flatMap keyword 看到这里的。搜索是原因是我在某个地方看到了 RxJava 的 flatMap operator

#Kotlin 咳咳，其实如果 @UseExperimental 支持的话，大家可以用 @file:UseExperimental 哦。
这也是 Kotlin 的一个改进（不是语法糖^1），Java 里 Annotation 是不能加在 File 上的，File 本身不是可见的语法元素。
—
^1 语法糖：对某种语法表述的惯用性简写，e.g. C++ 的 std::string abcs("abcdefg..."); 就是 std::string abcs = std::string("abcdefg..."); 的惯用法