7. WiFi (/ˈwaɪfaɪ/, 念『歪wai1』『负爱fu4ai4』🤣) 是啥

WiFi 无线抱̶枕̶保真技术啊，但是这些东西，知识复杂性梯度太大了，没啥好讲的啊！

说点概念吧：
— 它是一个无线电双工信息传输技术
— 98 年的技术，开始有专利，并且在 WLAN 技术里，一直无可替代，20 年了
可惜啊可惜无可替代（跑路）
— 它的标准 AP 射频设备，IEEE 802.11

Wifi 目前有三个版本，
WiFi4 — 802.11n — 72–600 Mbit/s
Wi‑Fi5 — 802.11ac — 433–6933 Mbit/s
Wi‑Fi6 — 802.11ax — 600–9608 Mbit/s

啊，真多，不过我懒得讲了，因为我看书上没有写太多，而我是个本本主义者（逃跑）

列点术语和解释吧：
局域网（LAN）
就是在一片小地理区域的计算机网络（皮）
无线局域网（WLAN）
同上，不过是不用物理线路连接的（再皮）
Wi-Fi
无线保真技术，当然也有一说称本身没有任何含义，无线保真为与『高保真音质 HiFi』的混淆，但现在联盟官方也已经开始使用这种解释
Wifi 是一种无线电无线局域网技术，基于 IEEE 802.11 标准
2.4GHz
所谓 WiFi，常见 802.11n
20和40MHz信道宽度下最快72和150Mbit/s
2.5GHz
所谓 5G WiFi，常见 802.11ax

Wi-Fi 设备：如个人计算机，游戏机，智能手机或数字音频播放器可以从范围内的无线网络连接到网络
热点：一个或多个（互联）接入点，可以组成一个面积由几间房间到数平方英里范围的上网空间，覆盖的面积大小可能取决于接入点的重叠范围

路由器：结合了调制解调器和Wi-Fi接入点
因为家用无线路由器的功率较小，所以其信号覆盖范围、信号强度也较小。随着MiFi和WiBro（携带式Wi-Fi路由器）的出现，可以很容易地创建自己的Wi-Fi热点，透过电信网络连接到网络。现在，许多移动电话（智能手机）也可充当小型无线路由器，供周围的设备连接互联网。

Ad-hoc（即地模式）：不经路由器而是客户端直接连接到另一个客户端的Wi-Fi设备。

Wi-Fi无线覆盖范围，也包含了浴室、厨房和花园等地，使网络无所不在。
Wi-Fi无线网络还可以提供免费使用的公开热点和各种商业服务。


—
当然，老谈计算机科学很累的，历史的东西，很多都不好玩（违心话）
对于 WiFi 这种有意思的东西，我们得 Hack 啊，AP、这么多概念，为什么不好好利用一下，钻钻可能的空子，享受一下控制别人的乐趣呢？（恶趣味）

不像程序员（虽然很多骇客也是程序员），骇客们经常喜欢搞破坏，但其实更准确的说法是他们总是做坏事（调皮的语气）

在信息技术的计算机网络上下文上，这一般是说：

+ 欺骗信息传输参与者、截取信息（嗅探/欺骗）
+ 篡改信息，破坏信息系统

这些不怀好意的操作，统称为攻击（attack）

针对 WiFi 的攻击，被称为无线攻击
虽然不一定有 RFID 攻击值钱，也可能没有后门有效，也没有 Web 攻击（e.g. XSS、SQLi、各种有可能是弱智级别的漏洞利用）有意思、没有 DDoS 暴力、没有社工和数字取证兴奋 🐸、没有软件逆向工程靠谱，没有硬件逆向工程坑爹

但它是很多有意思的攻击的敲门砖，记得我家的无线安全就靠 WiFi 安全（和 SSL）来保护，也就是说也可能很值钱，尤其是曾经没有 SSL 的时候（跑）
但是也是相当有趣的。

如果实在干不过 WPA2（别说 WEP 了，那玩意，分分钟给你破解掉，很多不防 PIN 攻击的 router 也早挂了）（肯定的，有种你去和 512-bit key RSA 杠，以目前计算机的算力，太阳还在的时间内还杠不完）
那就上 mdk3 吧，我以前用那玩意开过 Fake AP Flood

当然，如果你坚信你的攻击对象是个纸张，你可以试用 Fluxion，它能利用任何不明事理的小白用户『欸，我家 WiFi 怎么断了？』，社会工程他们，让他们乖乖地把自己的 WiFi 密码交给攻击者『哦，原来我家的 WiFi 遭到攻击了，需要验证密码，那我就填上去』『哇，又恢复网络访问了！我可以刷 TikTok 了』（他们还以为自己是安全的呢！可笑）（过一会『啊？我没有发过这个抖音视频啊？这是怎么回事？』）

当然，19 年的 315 晚会上，你们能看到使用语音识别和合成、chatbot 技术的垃圾骚扰电话『开发商』，他们就用到了『探针』Fake AP 来搜集身边的 WiFi 设备，拿到他们的机器地址（MAC）和数据库比对以探查附近的用户信息。

这就是这种『不怀好意』的方式的魅力。 — 当然今年这群人呢，已经不能继续这么做下去了，这是侵犯用户隐私的。

8. 是先有鸡还是先有蛋？

等等，别急，看完下面这行代码你就知道了！

"

🐔🥚

".match(/(.)/ug).sort() //=> Array [ "

🐔

", "

🥚

" ]

是先有鸡！

...等等，真的是先有鸡？

'🐔'.codePointAt() //=> 128020(U+1F414)
'🥚'.codePointAt() //=>129370(U+1F95A)

我们知道，Unicode 码表在扩展的时候，是不会考虑到什么先后顺序的！

比如它会颠倒因果顺序，这就很灵性了。

["👫", "👪"].sort() //=> Array [ "👪", "👫" ]

显然是先有 👱🏼‍♂️🍹👩🏼‍🦳 才有 👪 （装作很确定一样，嗯嗯）

—
好吧，那么进入正题：

先有蛋。

如果你说的蛋没有限定是鸡蛋的话 — 看起来就是这样的啊

最早的恐龙蛋，可以追溯到一亿多年前的白垩纪，而鸡的驯化历史就晚太多了，4000 年前。

#Learn 这次的杂项科普（虽然是杂项居然花了我很长时间，打字太慢了

https://github.com/telegramdesktop/tdesktop/blob/4ebf6ebb6f188b00a838a3b6337887e76c308c3d/Telegram/SourceFiles/boxes/create_poll_box.cpp

靠，Telegram Qt 居然支持新的 Poll Box？

好气！我的 Telegram 1.6.2 和 Telegram 1.6.3 只差一个修订号！

目前回家自学半年时间，使用PHP+MySQL初步搭建了一个简易新闻网站

我当时就喷了，自学半年才这个三脚猫水
平，也不知道这位同学工程到了个什么程度呢，是测试套件写了几万行呢还是自己设计了什么不得了的框架和去繁复的方案呢、还是写出了个不得了的 Web 应用呢，还是使用了最新的框架、最新的技术、最新的点子呢，比如，OAuth、RESTFul、灰盒测试、特性测试？还是说有部分是用 C++ 写的呢？还是说你在算法上达到了多么高的造诣？形式化验证程序逻辑？自己写了所有平台的客户端？我现在真的很佩服轮子哥的忍耐能力。要是我一上去就喷... 我这种没素质的人。

这种应用层的东西，我觉得即使是入门，PHP，即使对于高中生来讲，三个月时间足矣。而这位大学生，勉强搭建这种简易新闻（没错，它的身份验证可以瞎做、访问控制可以少做、而信息保密性几乎不需要考虑，其他信息安全侧面交给框架和运维吧，打包部署不是我的事情，是框架的事情，监控管理有运维工具呢）网站都花了半年左右的时间，我不知道这位是学到了什么程度。

我自学有两年了（实际上很长一段时间以来，都是『业余时间』，总的来说四舍五入也就一年而已），今年三月，这是第三年，我觉得好的学习者只应该学习，他们不应该去强调某种『学习方法』『学习技巧』『捷径』让自己分心，他们不应该这么功利地去学习，这是短视的。

本苏当年在酷安的时候，利用 AIDE 的交互式教程，虽然我连子类型是啥都不知道，也实现了一些简单的 Android 应用（虽然很多连个列表视图都没有，第一个我只花了三四天的时间过了一遍教程，然后就写出了一个使用 android.util.Base64 的前端应用），一个大学生，写 Web 时代的『后端/全栈』应用，就难到需要半年时间完成？


真正能达到对计算机科学，交叉了那么多知识系统、那么多学科，把那么多领域都融会贯通程度的人，都很难想象他们平时会去追求什么『技巧』什么『捷径』

除了死干，还是死干，除了死磕死背还是死背，坚持那么多个月、那么多年，把十几本、几十本书翻来覆去看不知多少遍，把各种优质工程不断拿来剖析重写，不断写博文、看博文、看论文、写论文，技术都是一天一天积累来的，不费力气想靠着一点肤浅的理解吃饭，吃一阵子可以，能这么滴水不入地在这个领域干一辈子？那是中国计算机工程的悲哀。

技术就是积累来的，每个人的智商总是差异不大，那就看谁更能积累深刻了，一天天的努力，最后能积累起来，一天比一天多会一个知识点、一周比一周多了解一个问题、一个月多涉足一个领域，最后可以达到融会贯通。

拥有奶酪，就拥有幸福；
如果你不改变，就会被淘汰；
越早放弃旧的奶酪，你就会发现新的奶酪；
随着奶酪的变化而变化，并享受变化！

有捷径为什么你能走别人不能走，你比别人多条腿、多张嘴？

—

『教官，能不能给我们传授一下，您一招必胜的绝技呀。』

凭什么有这种绝技就只能你会别人不会。成绩都是练出来的，就看谁能在逼近极限的同时犯更少的错误，你过的每一个弯，都没有机会再来一次，你犯的每一个错，都会断送整场比赛，甚至你的一生。

竞技体育，成绩是练出来的，冠军是撞出来的。作为一个拉力车手，冲出赛道没有任何缓冲区域，旁边可能是墙是树，是水库，是悬崖。就看谁能在逼近极限的同时，犯更少的错误。你过得每一个弯都没有机会再来一次！你犯的每一个错，都会断送整场比赛。你所爱的事业和别的运动不一样，需要你的专业和冷静。

巴音布鲁克，1462道弯，109公里。
耍小聪明，赢得了100米，赢不了100公里。
你问我绝招，绝招只有两个字，奉献！
就是把你的全部，奉献给你所热爱的一切。
我每天在脑海里开20遍，5年，3万6千遍，
我能记住每一个弯道。

所要的就是这种精神 — 奉献

奉献到不知道自己在奉献，当奉献成为常态的时候，你才能成为一个真正的优秀的软件工程者，而不是仅仅一个『称职』的软件工程者。

== UPDATE: 上面的言过了，这位同学的追求和我的不一样，所以上面的，全当我胡说算了。

这位同学也就是想好好生活，对于这方面，老师、同学、家人想必说的也不少了，我也没什么经验，不能帮到任何一点。
所以呢，只要能看清自己在技术上处在哪种层次，我根本不会『看不起』这些人，因为他们只是在做自己喜欢做的事而已（我也一样），我完全可以无视他们的『职位』而只把他们当成自然人看待。emmmm 🌝
上面的文字只能代表我自己对以后几十年经验的老程的期待，因为热爱生活的人肯定学的更慢一些，这是非常正常的。

虽然我确实比较笨，但无端被人议论起智商问题还是有点恼火，我就回家自己搞搞技术，打算以此谋生而已，招谁惹谁了 ……

极端

https://www.zhihu.com/question/317346252

#backend #GeekApk #SQL select * from yourTable limit 14 offset (4-1)*14;

🤔 我之前设计的 GeekApk 还没写 Database service 层，可是我居然因为没写到最后就不知道这个东西... 虽然我知道 SQL LIMIT，但我所想的却是 先 LIMIT 查询了之后，结果上 JVM 再去 subsequence...

我甚至还真把这个当回事了，还以为得专门抽提一个函数完成分页功能（geekapk API 的分页是很灵活的，使用的参数基本等价于 LIMIT 和 OFFSET）

还有，我刚才居然以为 LIMIT OFFSET 的 LIMIT 是基于整个关系行表头位置来说的偏移量，也就是说得 SELECT * FROM _ LIMIT (4-2)*14 OFFSET (4-1)*14... 简直毫无脑子

A, B, C, ... 都是关系元组

Table = [A | B | C | D | E | F]
SELECT * FROM Table LIMIT 1;
[A]
SELECT * FROM Table LIMIT 1 OFFSET 2;
[B]

(define pageSize 3)
(define collect-page' (pageSize page)
  SELECT * FROM Table
  LIMIT ${pageSize} OFFSET ((${page}-1)*${pageSize}))
(define collect-page (n) (collect-page' pageSize n))

(collect-page 1) = SELECT * FROM Table LIMIT 3 OFFSET (1-1)*3
[A | B | C]

(collect-page 2) = SELECT * FROM Table LIMIT 3 OFFSET (2-1)*3
= [A | B | C <OFFSET:3> D | E | F] Read 3
= [D | E | F]

== UPDATE: 我刚才用 SQLite 3 测试了一下，SQLite 其实是从 0 开始索引的，所以上面的是错的，我应该再减去 1...
至于为什么他们自己的就没有问题，是因为第一个 (1-1) 碰巧是 0，forall n in {R}. 0*n = 0，但是如果不为零，就得考虑零基数组的问题了...

create table test(text name);
foreach(x in listOf('a', 'b', 'c', 'd')) insert into test values(x);
select * from test limit 3;
select * from test limit 1;
select * from test limit 1 offset 1;
select * from test limit 1 offset 0; -- no returning records

（没用到啥关系代数知识，一方面也是关系代数那点操作符不够，虽然可以自己造新含义...）
唉，看来我还是了解的不够仔细。

其实我也相当努力了... 可是，其实有些东西就是要花时间... 而且我现在还没有机会沾染计算机图形学和人工智能

所以 GeekApk v1b trivial 的不得了的权限验证和所谓高难度的分页，都是智障级别的.... 除了被不良工程的 GeekSpec、Spectrum，我不知道它还有什么可取之处... 只要我现在完成这个临时的版本，真该啥时候重写的。

我感觉我的智商受到了侮辱

#DuangsuseSB 煞笔警告一次

好吧，好吧，duangsuse 来恢复一下心情，顺便写今天最后一个代码：默写重写 @YuutaW 的 RandomPicture

完全默写，包括 Gradle 构建文件（除了 Vertx 的依赖关系 Coordinate 在外）
并且，不得使用 IDEA 等具有自动补齐功能的 IDE

== 首先，我们来玩个简单的文件排序游戏，因为 duangsuse 不是学算法的（我以后会学）所以不考虑算法层的东西，就快速排序吧（因为它不需要我花时间去记，皮一下哦）（反正怎么说我，交换、插入、选择排序里，我也只会快排、冒泡、简单选择，虽然 OI 基础里还有简单插入、希尔排序、堆排序）。

肯定要用 Kotlin 最好，Haskell？那玩意 IO 模块的 API 我还不是老熟，现在弄了又要花掉十几分钟时间。

首先，我们要这么定义我们的『顺序』（基于 Int 优先级）：
优先级，0 为最高优先级，往后依次递减，排序时使用 greaterThan （[a|b]，若 a greaterThan b，则交换顺序） 来比较

针对每个字符，使用求和函数归并出优先级：
[A-Z] 范围内，递减优先级（0..23）
[a-z] 范围内，递减优先级，比 [A-Z] 小（23..49）
[0-9] 范围内，比 [a-z] 小（49..59）
任意其他字符，不影响优先级（0）

首先我们定义快速排序函数：

fun <E> quickSort(compare: Comparator<E>)
  = fun (items: List<E>, lhsStart: Int = 0, rhsEnd: Int = items.lastIndex) {
  // recursion base: like [1] / [2]
  if (items.size < 2) return items;

  // select swap pivot
  val pivot = items.size / 2
  // recursion
  val lhsSorted = quickSort(compare)(items[lhsStart..pivot], pivot, );
  val rhsSorted = quickSort(compare)(items[pivot..rhsEnd], pivot, );

  // exchange mybe?
  if (compare(lhsSorted.last(), rhsSorted.first()) > 0) {
    // lhs is greaterThan rhs, swap then
    return rhsSorted + lhsSorted
  } else { return lhsSorted + rhsSorted }
}

以上这个函数写了我差不多半个小时，但是没有成功，我始终忘记了应该怎么模拟调用栈来设计算法... 🤔
所以我索性直接抄了某本算法书上的算法，我说过我是本本主义者。

fun <E> List<E>.quickSort(cmp: Comparator<E>): List<E> {
  if (this.size < 2) return listOf() 
  val pivot = this[this.size / 2]
  val less = this.filter { cmp.compare(pivot, it) > 0 }
  val more = this.filter { cmp.compare(pivot, it) < 0 }
  return more.quickSort(cmp) + pivot + less.quickSort(cmp)
}

import java.text.Collator
val col = Collator.getInstance()
const val TEXT = "hello HELLO 810 114514 1919810 z ab cd dc"
TEXT.split(' ').quickSort(col)

[z, HELLO, dc, cd, ab, 1919810]


我开始居然忘记递归调用 quickSort 了... 最近思路有点崩溃，看不到数据的流动了。
然后居然又忘记了，基线条件，列表的大小必须得大于等于 2 才有顺序一说啊！
亏我还想画图分析来着... 回头发现自己连顺序是啥都忘记了
没有思路了... 大概是老了吧

我得恶补一下算法了... 我居然不知道，左边的必须全是比 pivot 小的元素、右边的全得是比 pivot 大的元素，才能交换啊！唉
可怜的、不是天才的 duangsuse，长得又不好看，emmmmm....

然后是 [A-Z] [a-z] [0-9] 的排序

class StringComparator: Comparator<String> {
  override fun compare(r: String, l: String): Int = toLevel(r).compareTo(toLevel(l))
  override fun equals(o: Any?) = o is StringComparator // Stateless comparator

  companion object Helper {
    fun toLevel(str: String) = str.fold(0, ::appendLevel)
    private fun appendLevel(acc: Int, ch: Char) = acc + getCharLevel(ch)
    fun getCharLevel(ch: Char): Int = when (ch) {
        in 'A'..'Z' -> ch - 'A'
        in 'a'..'z' -> ch - 'a' + 26
        in '0'..'9' -> ch - '0' + ('a'-'0'+2)
        else -> 0
      }
    }
  }
}

且慢，那么，假若我们希望开头的字符优先级更高呢？
这就是我们用 fold 而不是 sum 的原因啊！

修改一下：

fun toLevel(str: String) = str.fold((0, str.size), ::appendLevel)
private fun appendLevel(acc: Int, chnk: (Char, Int)) = (acc + chnk.second * getCharLevel(chnk.first), chnk.second - 1)

:: 从第一个字符开始以字符串长度数，每个字符都递减，然后把当前字符的长度，乘当前字符的优先级

那么是测试时间了呢。
好了，我玩够了。


和画出 mindmap，给大家讲出『Vibrator 到 System Service』所有的知识点。

快快写完睡觉吧。

#Kotlin #ALgotithm #OOP

虽说是简单，因为熬夜的缘故，居然花了 3 个小时，真是没效率。