noblog 0.0.2 → 0.0.3

package/output/99a7b0c5-f9de-403c-95ec-eba3d700a195

@@ -1,49 +0,0 @@
-
-一直想讨论这个问题，包括在今年（23年）秋招时，也有很多面试官问了对人工智能的看法，我是个不喜欢说假话的人，在面试的时候也是会直截地说出人工智能现在泡沫太多的看法，或许也因为这个被一些公司打了tag（笑）。
-
-
-首先，在基于深度学习的人工智能在2016年前后兴起后，大批大批的资金遍涌入了这个赛道。是啊，一个几乎什么方向都能应用，paper发得飞起的领域，怎么会没有前途呢，或许大多数人都是这么想的吧。但是事实上，但凡把人工智能作为主要战略方向的公司（除了龙头的服务提供商，如OPENAI），都在慢慢走向衰落，这一点对于国内公司来说尤其灵验。反过来说，微软在2000年初发展云平台而非人工智能是一个例子；谷歌晚了一点，好在体量大，还是做出了google cloud；这几年的百度式微也多少证明了这一点，近期的阿里宣布要以人工智能为主要发展方向，对此我只能尊重祝福。
-
-
-首先，目前的深度学习严重依赖于计算硬件，这是中国的超级短板。而且在我看来，深度学习本质上是一种基于向量的搜索引擎，一切的一切都是以数据为灵魂的，算法是一个重要的点，但是妄图通过算法来对抗数据是几乎不可能的，近期流行的大模型rank也间接说明了，在模型参数量丰富到足以表示所有的语料前，参数越多，效果越好是毋庸置疑的。深度学习模型作为一种向量搜索引擎，也就自然的引出了最重要的一个功能——知识检索。请允许我戛然而止一下，先讨论下一个约束人工智能的方向，并在其中描述知识检索的联系。
-
-
-市场，这往往是资本首先考虑的因素，是否具有足够的经济效益，是否能够吹牛逼，创造信心神话。而我对于此进行了简单的归纳：只有生产者需要知识检索，消费者不需要知识检索。这貌似是一句废话，因为消费者越多，盘子越大，生产者也会越多，对应的，知识检索的需求也会膨胀。但是反过来呢？如果市场不再有增量呢，你是否需要花费如此之高的成本去养着一批期望值极低的所谓算法工程师。有些人可能会说，万一我不赶上这个风口，市场都被友商吃掉了呢？那你需要的是trade-off，你需要想一想你手头上的现金流，以及投入的这些人力和算力是不是真的能够覆盖这个风险。对于大多数上市公司来说，几乎所有的决策都是为了缓解资本焦虑。甚至你抬头看一看你身边的人，除了媒体编辑和工程师（电类工程师），深度学习真的对大多数人有帮助吗？绝大多数人对于人工智能的态度就是“确实很厉害，但是我好像不怎么用”。甚至支付宝删掉一半的无聊功能，打开软件时间减少半秒对社会的帮助都会更大吧。对于大多数软件来说，嵌入模型和助手之类的功能除了向上级邀功，没有任何效益可言，因为用户真的不care。
-
-
-放眼深度学习这个领域，但凡你看看最近的会议和期刊，空怕都会得出一个结论，“学术就是一个草台班子”，99%的深度学习相关论文，事实意义上都是小圈子的自娱自乐，从发布起到人类文明结束为止都不会对生产力发展产生任何正面的作用（可能会对财富的再分配起到作用）。包括很多人工智能方向的入局者，可以去社交媒体和论坛上看一下，很难想象作为计算机的从业者，会搞不清楚Pycharm，解释器和anaconda的关系，当然这也只是冰山一角，所谓的面试也是没有多少选拔价值，因为有时甚至这些面试官也是走运入职的。试想一下，transformer是18年提出的，LLM初露头角是在21年，而且在相关的工程领域至今没有一个很好的通用工程方案，而如今（甚至早在对应的18年，22年）相关的算法专家/领域大牛已经遍地跑了，这是在是有些滑稽。因为这实在是矛盾的，如果技术方向重要，那么那些专家就不可能是专家，因为他们先前就没在研究或研究不出这些技巧；如果技术方向不重要，那么面试为何偏向学术吹水，只追热门，忽略模式识别和数学的基本功？对于大多数的所谓“专家”，一个优秀的工程师恐怕要不了一个月就能拆穿他们微调的把戏了。
-
-
-插个题外话，如果我是算法方面的面试官，我会筛选几篇近期的会议论文，让候选者进行反向传播的求导，并要求在不与其他人进行沟通的情况下，查阅任意资料，在短时间内截取模型中的一个module进行输入模拟和输出打印。这是最重要的，何恺明也会有发不出论文的一天，但是每天都会有人引用他的方法和模型。现在绝大多数的算法已然成为了靠ppt和画大饼抢饭的岗位。但是，我并不是说尖端的人才也是这样的，只是说大多数算法工程师的招聘标准完全是按照顶学术热门方向来的，对于企业来说，这只会招聘到一群高不成低不就的吸血鬼。严格来说，大多数算法工程师不是工程师。（从此也可以看出Brendan Eich 说的是对的，从0到1的程序员和被高级语言呵护长大的程序员是不一样的，前些年混入了一大批只会python的算法工程师）
-
-
-这些观点也不仅仅是我个人的暴论，Yoshua Bengio、朱松纯和 Filip Piekniewski 等人也对现如今基于深度学习的人工智能有着类似的观点。中国目前处于一个阶段，那便是投资找不到方向，投资人心急如焚，看着资产被破败的预期和通胀不断稀释；企业也找不到投资方向——互联网规模见顶，生产力进步停滞，投资不知道该如何反哺生产，只能抢夺存量，像无头苍蝇一样到处撒网，渴望创造奇迹。做蛋糕的时代已经过去了，甚至已经分完了，字节跳动的成功也是一次成功的存量市场抢夺。所以投资人看到了希望，开始投资 kwai、lazada、shein 之类的产品，国家和地方也开始入场，投资各种实验室。这些公司能不能成功，我不知道，但是大多数的从业人员应该已经意识到，他们日常做的其实只有follow和东拼西凑。绝大部分的算法是一个草台班子，遮遮掩掩不是他们有多厉害，而是怕被人看到不过如此。
-
-
-总结一下，我不看好的主要原因，实际上就是以下几点：市场有限，多数人的使用频率极低；技术本身起催化剂作用，可以降本增效，如果不能促进生产力的进步，宏观上只会减少工作岗位（公务员群体尤甚，甚至会抗拒这样的产品入场）；数据驱动，从业人员鱼龙混杂，ppt 主要赚吆喝，复杂性成为指标；投资具有泡沫性，同质化严重，缺少持续变现能力，资本会在一定的经济周期后踩踏离场。深度学习是一项很重要的技术，在娱乐应用方面尤其适配，但是绝对不需要这么多的关注，这项技术可以在很多场景减少开销，但本质上是工程大于算法的，而这其中的算法又只需要万里挑一的天才。中国的互联网神话是网民数量和网民素质的神话，在世界经济濒临债务危机的前夕，面临已经停滞的生产力发展、生产力解放和生产关系变化，寄希望于深度学习来进行科技革命的人一定会付出惨痛的代价。如果有AGI，那一定不是深度学习。
-
-
-希望我说的都是屁话。
-
-
-2023.10.19
-
-
-# 马后炮
-
-<details>
-<summary>[Gen AI: too much spend, too little benefit?](https://www.goldmansachs.com/intelligence/pages/gen-ai-too-much-spend-too-little-benefit.html) (高盛) 2024.06.27</summary>
-
-</details>
-
-<details>
-<summary>大型科技公司需要 6000 亿美元的年利润才能证明人工智能硬件支出的合理性 （红杉资本）2024.07.06</summary>
-
-[https://www.techspot.com/news/103699-big-tech-needs-generate-600-billion-annual-revenue.html](https://www.techspot.com/news/103699-big-tech-needs-generate-600-billion-annual-revenue.html)
-
-
-</details>
-
-
-
-

package/output/c844b66d-0bf3-4f89-bbe1-5974f2de454b

@@ -1,193 +0,0 @@
-
-# Introduction
-
-
-拜占庭将军问题是指，当一群**将军**（计算机）打算**攻打拜占庭王国的城堡**（达成一致）时，约定**进攻策略**（一致内容）的问题。这个问题的前提是，**攻下城堡或撤退**（达成一致）所需要的**将军**（节点）数量是小于等于将军中**忠诚将军**（忠诚节点）的数量的。
-
-
-拜占庭将军问题实际上是一个分布式系统的一致性问题。解决的核心问题是对叛徒节点的tolerance。
-
-
-# Magical $\frac{1}{3}$
-
-
-这里介绍一些便于理解的思路
-
-- 假定节点总数是$n$，作恶节点数为$m$，那么剩下的正确节点数为 $n - m$，意味着只要收到 $n - m$ 个消息且 $n - m > m$ 就能做出决定，但是这 $n - m$ 个消息有可能有 $m$ 个是由作恶节点冒充的（或因网络延迟导致f个恶意节点的消息先被收到），那么正确的消息就是 $n - m - m$ 个，为了多数一致，正确消息必须占多数，也就是 $n - m - m > m$ ，所以N最少是 $3m + 1$ 个。
-- [拜占庭容错算法BFT的33%](https://zhuanlan.zhihu.com/p/44198965)
-
-# Complexity
-
-
-为何oral massage algorithm的复杂度是$O(N^{m+1})$？
-
-
-## 算法
-
-
-从论文出发来分析一下：
-
-
-A commanding general must send an order to his $n - 1$ lieutenant generals such that:
-
-- **IC1:** All loyal lieutenants obey the same order.
-- **IC2:** If the commanding general is loyal, then every loyal lieutenant obeys the order he sends.
-
-这是两个重要的 interactive consistency conditions，满足这些，就认为保持了一致性。
-
-
-先扔出论文中的几个assumption：
-
-- A1. Every message that is sent is delivered correctly.
-
-不考虑丢包
-
-- A2. The receiver of a message knows who sent it.
-
-信息来源已知
-
-- A3. The absence of a message can be detected.
-
-可以感知哪个将军没有进行决策
-
-
-A1 和 A2 可以防止叛徒干扰另外两名将军之间的通信，因为根据 A1，不能干扰将军发送的消息，而根据 A2，不能通过引入虚假消息来混淆将军的通信。 A3 防止叛徒试图通过不发送消息来阻止决策。这些假设的实现在论文中的section 6得到阐述。
-
-
-提出算法的定义：
-
-- $OM(m)$: oral massage algorithm when the number of malicious node is $m$.
-- $v_i$: lieutenants $i$ "obtaining a value" as its command.
-- $majority(v_1, ..., v_{n-1})$: for each lieutenant, its value $v_i$ should equal to the majority of the $(v_1, ..., v_{n-1})$ received from other lieutenants.
-
-在正式开始推导之前，再提出两个限制：
-
-1. choose the majority value among the $v_i$ if it exists, otherwise the default value $RETREAT$;
-2. The median of the $v_i$, assuming that they come from an ordered set.
-
-符合majority多于一半的原则
-
-
-**对于 Algorithm** $ OM(0)$：
-
-1. The commander sends his value to every lieutenant.
-2. Each lieutenant uses the value he receives from the commander, or uses the value RETREAT if he receives no value.
-
-**对于 Algorithm** $OM(m) , m > 0$：
-
-1. The commander sends his value to every lieutenant.
-2. For each $i$, let $v_i$ be the value Lieutenant $i$ receives from the commander, or else be $RETREAT$ if he receives no value. Lieutenant $i$ acts as the commander in Algorithm $OM(m - 1)$ to send the value $v_i$ to each of the $n - 2$ other lieutenants.
-3. For each $i$, and each $j \ne i$, let $v_j$ be the value Lieutenant $i$ received from Lieutenant $j$ in **step (2)** (using Algorithm $OM(m - 1)$), or else $RETREAT$ if he received no such value. Lieutenant $i$ uses the value $majority (v_1,...,v_{n-1} )$.
-
-论文认为这个算法可以解决拜占庭问题
-
-
-## 证明
-
-
-实际上就是证明算法满足互相一致性条件。
-
-<details>
-<summary>**LEMMA 1.** For any $m$ and $k$, Algorithm $OM(m)$ satisfies **IC2** if there are more than $2k + m$ generals and at most $k$ traitors.</summary>
-
-如果有多于 $2k+m$ 个将军而且将军中叛徒的数量不多于 $k$ 个，那么算法满足**IC2**。
-
-
-当 $m=0$ 时，此时 commander 一定是忠诚的，显然成立。
-
-
-在引理中，我们有 $n > 2k + m$，所以有 $n - 1 > 2k + (m - 1)$ 。假设 m-1 时成立，当为 m 时，通过归纳法应当也成立。
-
-
-由于叛徒最多有 $k$ 个，且 $n - 1 > 2k + (m - 1) \geq 2k$，因此 $n - 1$ 名副官中的大多数是忠诚的。 因此，对于 $n-1$ 个中的大多数lieutenant $i$，每个忠诚的 lieutenant 都有$v_i = v$，因此他在step 3中获得$majority (v_1,...,v_{n-1})=v$ ，证明**IC2**。
-
-
-</details>
-
-
-**重头戏来了**
-
-
-**THEOREM 1.** For any $m$, Algorithm $OM(m)$ satisfies conditions **IC1** and **IC2** if there are more than $3m$ generals and at most $m$ traitors.
-
-
-依然使用归纳法证明：
-
-- 如果没有叛徒，容易得到 $OM(0)$ 满足 **IC1** and **IC2**。假设定理对于 $OM ( m - 1)$ 成立，归纳证明 $O M ( m ), m > 0$ 的情况 。
-- 先考虑 commander 忠诚时的情况，使用 **lemma1** 并使 $k=m$，当 commander 是忠诚的时，**IC1**实际上就自然被满足了。
-- 考虑 commander 是叛徒的情况，此时，在 $n-1$ 个 lieutenant 中至多有 $m-1$ 个 lieutenant 是叛徒，且 $n-1>3m-1$ ，说明 lieutenant 的数量多于 $3m-1$ 。同时， $3m-1>3(m-1)$，正好符合定理在 $m-1$ 时的情况（假设正确）。也就是说，对于 $n-1$ 的情况，当新的 commander 是叛徒时，可以保证忠诚的 lieutenant 做出了一致的决策；当新的 commander 是忠诚时，可以保证忠诚的 lieutenant 听从忠诚的 commander（做出了一致的决策）。发现了吗，所有忠诚者的决策向量应当是一致的，所以可以推断得到，所有忠诚者的最终决策 $v$ 都是一样的。回到 m 的情况，此时竟然自然地满足了 **IC1**。
-
-至此，定理得证。
-
-
-# Full step for $OM(2),~n=7$
-
-
-$OM(2)$ step 1
-
-
-
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/acc0db25-6a8b-48a0-9f29-4ccbd8f8259f/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=3880633858ecef2396af0d6910cf4d9a7b3015a12e1d45a7a1faa31857ad4ad5&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-$OM(1)$ step 1，这里进入第一层迭代，以第一个忠诚节点为例
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/7062a889-ed50-4cf0-9b5e-961afa8a4194/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=ba78bb8dbe6ec82b06b19aac9968dccb2702f07f8260fa85fd7535d49ee247f1&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-$OM(1)$ step 2
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/5228b720-4acc-40c8-8cdc-c53a7215daae/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=d88fb1b87a08f91dc2ad1ac39d557dfa2baf9b3b73a9f6c215bf873a963c61cf&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-$OM(1)$ step 3
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/61fba768-14e2-4b99-8562-e18f6b2ca8c5/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=3df4f0e3f0923e886130c3e1ae9551b5312a8e3ed73571a61d70e00efee6c16b&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-以此类推还有五次 $OM(1)$ 需要完成，对于忠诚节点为 commander 的情况来说，都是一样的，这里再过一遍叛徒是 commander 的情况
-
-
-$OM(1)$ step 1，这里进入第一层迭代，以叛徒为例，这里 $a,b,c,d,e$ 只是一个代数，它们可以等于任何一个决策。
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/b241f8d4-bee5-400d-a11e-cb74f93658d9/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=dac98d631696a9a4972c4d0b3f644b58301fb1364e87169b561803d2b6cb61ff&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-$OM(1)$ step 2
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/fc9f4ed5-b02c-4ada-bc4b-40f8f9fb94c5/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=a03cdc7c982ef7b7920cb87afa850b7264631ed79c38fbfc9c2a3c7868c389c1&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-$OM(1)$ step 3，就算有着叛徒，我们发现此时，所有节点的决策向量也是一样的。此时可能没有一个决策占了多数，所以我们姑且让没有达成一致时的默认决策为 $D$ 。
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/37b91780-4da9-42dd-b2b9-c648df767b72/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=a805124cb1c12de57225d596a10efe65c7214b318ac9d3680e730623fc9c0b1c&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-OK，回到主线，$OM(2)$ step2
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/0cabd3a8-0dd5-4a81-ac07-c99df7ff0676/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=4ebecc5888dfcd5e35ab3ad49570125b406b9b5808a6bab3f09702b6aba4757f&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-整理向量，得到最后的 $OM(2)$ step 3
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/ea116a62-b669-4944-aaf0-6a2f766cd9e6/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=74ff2540f9746a0a45eef41bd0082d5e1e501010be9f7096eb87b2ee762302ac&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-可以朴素地认为，算法的核心就是为了使忠诚节点的最终结果一致。
-
-
-# Full step for $OM(2),~n=6$ 
-
-
-[https://pages.cs.wisc.edu/~zuyu/files/om_algo.pdf](https://pages.cs.wisc.edu/~zuyu/files/om_algo.pdf)
-

package/output/cd6299f7-54bb-4160-8735-16e629422a57

@@ -1,193 +0,0 @@
-
-# Abbrivation && Concept
-
-- **ABI:** <u>Application Binary Interface</u> ([what is ABI?](https://stackoverflow.com/questions/2171177/what-is-an-application-binary-interface-abi))
-- **AVX:** <u>Advanced Vector Extensions</u> (instruction set)
-- **ISA:** <u>Instruction Set Architecture</u>
-- **PLT:** <u>Procedure Linkage Table</u>
-- **CPE:** <u>Clock cycles Per Element</u>
-- **ATT:** An Assembly Syntax
-- **misc:** [Miscellaneous files](https://learn.microsoft.com/en-us/visualstudio/ide/reference/miscellaneous-files?view=vs-2022#:~:text=In%20this%20article&text=Files%20you%20want%20to%20work,a%20solution%20under%20source%20control.)
-
-# CSAPP
-
-
-[link_preview](https://github.com/humbornjo/csapp)
-
-
-# GDB
-
-
-[Cheatsheet](https://cs.brown.edu/courses/cs033/docs/guides/gdb.pdf)
-
-
-# Reverie
-
-
-## OS
-
-<details>
-<summary>[What is the difference between MOV and LEA?](https://stackoverflow.com/questions/1699748/what-is-the-difference-between-mov-and-lea)</summary>
-
-</details>
-
-<details>
-<summary>[Is performance of less/greater better than less/greater or equal](https://stackoverflow.com/questions/27016781/is-performance-of-less-greater-than-than-better-than-less-greater-than-or-equ)</summary>
-
-</details>
-
-<details>
-<summary>[What is a memory fence?](https://stackoverflow.com/questions/286629/what-is-a-memory-fence)</summary>
-
-</details>
-
-<details>
-<summary>[Disassembly and Binary Analysis Fundamentals](https://hexterisk.github.io/blog/posts/2020/04/02/disassembly-and-binary-analysis-fundamentals/)</summary>
-
-</details>
-
-<details>
-<summary>[How does multithreading utilizes multiple cores?](https://stackoverflow.com/questions/63589801/how-does-multithreading-utilizes-multiple-cores)</summary>
-
-</details>
-
-<details>
-<summary>[Why mmap() is faster than sequential IO?](https://stackoverflow.com/questions/9817233/why-mmap-is-faster-than-sequential-io)</summary>
-
-</details>
-
-<details>
-<summary>[What does reaping children imply?](https://stackoverflow.com/questions/58885831/what-does-reaping-children-imply)</summary>
-
-</details>
-
-<details>
-<summary>Overhead over switch between process and thread</summary>
-
-[**Thread context switch Vs. process context switch**](https://stackoverflow.com/questions/5440128/thread-context-switch-vs-process-context-switch)
-
-
-[**Why is it less overhead to switch between threads belonging to the same process than to switch between threads belonging to different processes?**](https://www.quora.com/Why-is-it-less-overhead-to-switch-between-threads-belonging-to-the-same-process-than-to-switch-between-threads-belonging-to-different-processes)
-
-
-</details>
-
-<details>
-<summary>[Definition of "synchronization primitive"](https://stackoverflow.com/questions/8017507/definition-of-synchronization-primitive)</summary>
-
-</details>
-
-<details>
-<summary>[What is the first process a typical Linux kernel starts?](https://stackoverflow.com/questions/21612801/what-is-the-first-process-a-typical-linux-kernel-starts)</summary>
-
-</details>
-
-<details>
-<summary>All about MMU</summary>
-
-[**Why does the OS need a page table if the MMU already has one?**](https://stackoverflow.com/questions/58995151/why-does-the-os-need-a-page-table-if-the-mmu-already-has-one)
-
-
-[**Why doesn't the MMU require a gargantuan amount of memory?**](https://www.reddit.com/r/osdev/comments/qu4zea/why_doesnt_the_mmu_require_a_gargantuan_amount_of/)
-
-
-[**What is the difference between TLB and MMU in OS?**](https://www.quora.com/What-is-the-difference-between-TLB-and-MMU-in-OS)
-
-
-</details>
-
-<details>
-<summary>What does swap do to Page Table Entries</summary>
-
-[https://stackoverflow.com/questions/16581490/how-does-kernel-know-which-pages-in-the-virtual-address-space-correspond-to-a-s](https://stackoverflow.com/questions/16581490/how-does-kernel-know-which-pages-in-the-virtual-address-space-correspond-to-a-s)
-
-
-</details>
-
-<details>
-<summary>[Conservative garbage collector](https://stackoverflow.com/questions/7629446/conservative-garbage-collector)</summary>
-
-</details>
-
-<details>
-<summary>[Unix system file tables](https://stackoverflow.com/questions/14189944/unix-system-file-tables)</summary>
-
-</details>
-
-<details>
-<summary>Which one to use: static variable or heap allocated variable?</summary>
-
-[Memory allocation areas in C++ (Stack vs heap vs Static)](https://stackoverflow.com/questions/14172505/memory-allocation-areas-in-c-stack-vs-heap-vs-static)
-
-
-</details>
-
-<details>
-<summary>Thread local memory is not thread stack</summary>
-
-[What is thread local storage? Why we need it?](https://stackoverflow.com/questions/35692188/what-is-thread-local-storage-why-we-need-it)
-
-
-</details>
-
-<details>
-<summary>How to implement semaphore?</summary>
-
-[Implementation of a semaphore in C](https://stackoverflow.com/questions/54898512/implementation-of-a-semaphore-in-c)
-
-
-[C & low-level semaphore implementation](https://stackoverflow.com/questions/36094115/c-low-level-semaphore-implementation)
-
-
-[https://gist.github.com/mepcotterell/6f0a779befe388ab822764255e3776ae](https://gist.github.com/mepcotterell/6f0a779befe388ab822764255e3776ae)
-
-
-</details>
-
-<details>
-<summary>[Why is malloc() considered a library call and not a system call?](https://stackoverflow.com/questions/71413587/why-is-malloc-considered-a-library-call-and-not-a-system-call)</summary>
-
-</details>
-
-<details>
-<summary>`gprof` under the hood</summary>
-
-[https://docs-archive.freebsd.org/44doc/psd/18.gprof/paper.pdf](https://docs-archive.freebsd.org/44doc/psd/18.gprof/paper.pdf)
-
-
-[http://gnu.cs.utah.edu/Manuals/gprof-2.9.1/html_mono/gprof.html#SEC25](http://gnu.cs.utah.edu/Manuals/gprof-2.9.1/html_mono/gprof.html#SEC25)
-
-
-[How exactly does gprof work?](https://stackoverflow.com/questions/4981121/how-exactly-does-gprof-work)
-
-
-[Is it possible to read another thread's program counter?](https://stackoverflow.com/questions/30088710/is-it-possible-to-read-another-threads-program-counter)
-
-
-[Can we read and fault-inject another thread's program counter?](https://stackoverflow.com/questions/38018713/can-we-read-and-fault-inject-another-threads-program-counter)
-
-
-</details>
-
-<details>
-<summary>[threads and LWP in Linux](https://stackoverflow.com/questions/28476456/threads-and-lwp-in-linux)</summary>
-
-</details>
-
-
-## Net
-
-1. [Output of "ip route show"](https://serverfault.com/questions/838853/what-does-the-command-ip-route-show)
-
-## Misc
-
-- [https://en.wikipedia.org/wiki/Hexspeak](https://en.wikipedia.org/wiki/Hexspeak)
-- [How to write a "dummy" (do nothing) line in C](https://stackoverflow.com/questions/22264284/how-to-write-a-dummy-do-nothing-line-in-c)
-- [Bash : Taking a wildcard as argument of a shell script](https://stackoverflow.com/questions/60357123/bash-taking-a-wildcard-as-argument-of-a-shell-script-and-being-able-to-expand)
-- [Notes on structured concurrency, or: Go statement considered harmful](https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/#id1)
-- [Golang runtime/internal/syscall.Syscall6 consuming large amount of CPU](https://stackoverflow.com/questions/78614811/golang-runtime-internal-syscall-syscall6-consuming-large-amount-of-cpu)
-- [Stupid clangd](https://clangd.llvm.org/config#files)
-- [Exceptions: Yes or No?](https://www.reddit.com/r/cpp/comments/vr771l/exceptions_yes_or_no/)
-
-
-

package/output/d462cfca-0a39-4b65-8430-4eae35edbb76

@@ -1,27 +0,0 @@
-
-# 🎧 Zart
-
-
-zart is a music player written in tauri which help you download, organize, and stay sync with your music. It dont need any platform account, all you need to stay sync is to provide a cloud database access.
-
-
-[Zart: AI powered music app](ff7ea97c-55ac-471c-902f-b7a7bd101ee6.md)
-
-
-# 🐱 Lulu
-
-
-lulu is my personal exploration on clash project. ☉A☉
-
-
-# 🐝 Abee
-
-
-abee is a telegram robot which help you achieve as much “simple earn” as possible, it now support binance.
-
-
-[link_preview](https://github.com/humbornjo/abee)
-
-
-
-

package/output/daafaad2-2570-43da-8e9e-f95a1b29ca17

@@ -1,12 +0,0 @@
-
-> It is really interesting that essentially we are compatible with the world 
-
-
-# fd and channel
-
-
-# Rust and go
-
-
-# libaco
-

package/output/e45ef6bf-6c30-4fb2-9efc-a1984e5dc530

@@ -1,84 +0,0 @@
-
-
-
-
-# Why Rust
-
-
-pls read ch1 of “Programming Rust”
-
-
-# Programming Rust
-
-
-## ch2
-
-
-try read ch2 of “Programming Rust”, you can skip if it’s too hard for you now.
-
-
-## ch[3:]
-
-
-follow _REPL_, I love jupyter lab [https://github.com/humbornjo/rusting](https://github.com/humbornjo/rusting)
-
-
-# Rust Wandering
-
-
-Before the beginning, please google “auto trait”. And understand “str and &str”.
-
-
-## My Note
-
-
-[str &str and more](e7931a8e-45ca-444a-8d6f-e6fed9415c26.md)
-
-
-[Rust iterator, deref, ref from top to bottom](4d6663a2-e93a-402e-89f8-a47cccc0c8cf.md)
-
-
-[slice and &slice](5771c956-25bf-4714-bc2e-65959c9156d9.md)
-
-
-[Tiny blog for Arc](05009ca9-cb39-4356-8f24-c0db39cb4661.md)
-
-
-[Do u really understand Option?](81e4a2b0-05e2-4013-bd41-14b144979d91.md)
-
-
-[Understand Send & Sync in practice](a45b383c-d894-4480-8322-9c5d028722e3.md)
-
-
-## Newbie
-
-
-**Follow this guy** [**youtube@jonhoo**](https://www.youtube.com/@jonhoo)
-
-
-**Debug with backtrace:** [**Rust Backtrace on windows?**](https://stackoverflow.com/questions/59131262/rust-backtrace-on-windows) **+** [**How to pass RUST_BACKTRACE=1**](https://stackoverflow.com/questions/54055139/how-to-pass-rust-backtrace-1-when-running-a-rust-binary-installed-in-debian)
-
-
-[**Understanding  Send and Sync**](https://stackoverflow.com/questions/59428096/understanding-the-send-trait)
-
-
-[**Is there any way to explicitly write the type of a closure?**](https://stackoverflow.com/questions/29191170/is-there-any-way-to-explicitly-write-the-type-of-a-closure)
-
-
-[**How Clone differ from Copy?**](https://stackoverflow.com/questions/31012923/what-is-the-difference-between-copy-and-clone) **⭐**
-
-
-[**How Copy and Clone traits are implemented under the hood in rust**](https://www.reddit.com/r/rust/comments/uc8npp/how_copy_and_clone_traits_are_implemented_under/) 
-
-
-[**Rust Module System**](https://www.sheshbabu.com/posts/rust-module-system/)
-
-
-[**Pin and Unpin**](https://www.sobyte.net/post/2022-07/rust-pin-unpin/)
-
-
-## Best Practice
-
-
-[Replace every to_owned(), into(), to_string() with Cow<str>, and more.](https://doc.rust-lang.org/std/borrow/enum.Cow.html)
-

package/output/sub/05009ca9-cb39-4356-8f24-c0db39cb4661

@@ -1,64 +0,0 @@
-
-We all know that Arc is a thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically Reference Counted’.
-
-
-But have you ever think about what will happen if Arc is only applied in one thread. Can it be mutable? Does the Mutex still needed?
-
-
-Suppose got a scene like:
-
-
-```rust
-// try manipulate the val in Arc without the aid of Mutex
-use std::sync::{Arc, Mutex};
-
-fn main() {
-    use std::thread;
-    
-    let mut five = Arc::new("okk".to_string());
-    five.push_str("!");
-    
-    for _ in 0..10 {
-        let tfive = five.clone();
-    
-        thread::spawn(move || {
-            println!("{tfive:?}");
-        });
-    }
-}
-# Error
---> src/main.rs:6:9
-  |
-6 |     let mut five = Arc::new("okk".to_string());
-  |         ----^^^^
-  |         |
-  |         help: remove this `mut`
-  |
-  = note: `#[warn(unused_mut)]` on by default
-
-error[E0596]: cannot borrow data in an `Arc` as mutable
- --> src/main.rs:7:5
-  |
-7 |     five.push_str("!");
-  |     ^^^^^^^^^^^^^^^^^^ cannot borrow as mutable
-  |
-  = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Arc<String>`
-
-For more information about this error, try `rustc --explain E0596`.
-```
-
-
-According to the hint from compiler, the key is trait `DerefMut` 
-
-
-![Screenshot_2023-09-06_at_10.55.17.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/0fdecccd-4415-4ee2-8ab9-32baf08b345d/Screenshot_2023-09-06_at_10.55.17.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100314Z&X-Amz-Expires=3600&X-Amz-Signature=d701a0b3c058f39d87bca3243d321dbca7d5ee019d0b0a51476f40c165ae914c&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-Yyyyyyyyyyes, Arc only implements `Deref` rather than `DerefMut`[.](http://derefmut.so/) So only the method that called by `&self` can be adjusted. That’s why Mutex has to be wrapped outside the target value to complete the chain-style dereference: **`Arc`** `-Deref→` **`Mutex`** `-DerefMut→` **`value`**
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/6d3b11fc-4fbb-4157-b6e0-8de32cb9113e/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100314Z&X-Amz-Expires=3600&X-Amz-Signature=b32cddfd0235c9b0c93b65606d150e0a6ae6694e7b4489e59bc09db2cddf2b4f&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-
-