noblog 0.0.1

package/output/2b1c0d09-40f7-4151-a053-11391f775ece

@@ -0,0 +1,33 @@
+
+# What is hash
+
+
+## Prop of hash
+
+
+
+
+
+# Implement hash table
+
+
+
+
+
+# Dive into sha256
+
+
+
+
+
+## Implement Blockchain
+
+
+## **Merkle Tree**
+
+
+
+
+
+# Reference
+

package/output/336b6a5a-f383-4d6c-8fe5-54c9a918c4c0

@@ -0,0 +1,264 @@
+
+
+
+
+# Intro
+
+
+本篇主要 follow 书籍 **Fluent Python** ，对python的现代优雅实现进行汇总学习，由于语法检查器和python本身的发展，有些书籍中的不足之处或是不到位的地方都会在笔者的Elegant python中进行补充。
+
+
+# None 的静态类型警告
+
+
+你可能会写出类似以下的代码
+
+
+```python
+def step(context: Context = None):
+		context = context or Context.new()
+    """
+				code snippet
+		"""
+```
+
+
+程序顺利运行了
+
+
+但是LSP会毫不留情地给你一个错：”Expression of type "None" cannot be assigned to parameter of type [Context]”
+
+
+你愤懑不平，抱怨LSP是如何迂腐而不智能，连这样简单的代码逻辑都无法理清
+
+
+但是我们可以
+
+
+```python
+from typing import Union
+def step(context: Union[Context, None] = None):
+		context = context or Context.new()
+    """
+				code snippet
+		"""
+```
+
+
+或者
+
+
+```python
+from typing import Optional
+def step(context: Optional[Context] = None):
+		context = context or Context.new()
+    """
+				code snippet
+		"""
+```
+
+
+是的，it’s boring but this is the way
+
+
+# Fluent Python
+
+
+## abstract
+
+
+I don’t like meta class in Python，these shit makes your code unexplicit，which I despise a lot.  除了一些 asyncio 的场景下会对异步元编程进行简单总结，其余的相关内容将跳过。
+
+
+## ch2 序列组成的数组
+
+
+## 摘要
+
+
+作者会将主要精力放在第五、七、八、九章中，运算符的重载等内容对于本人来说实在不算一种优秀的编程习惯。有些人可能很喜欢元编程，但是本人更加青睐函数化，这样更加直观，通过不同的函数命名也会使得代码更加易于维护，而不是通过 `tree sitter` 去给自己没事找事。观后感不会明确区分章节，只会在思路和概念上进行区分。
+
+
+## 列表
+
+
+### Numpy的技巧
+
+
+在NumPy 中，`...` 用作多维数组切片的快捷方式。如果 `x` 是四维数组，那么 `x[i, ...]` 就是 `x[i, :, :, :]` 的缩写。
+
+
+### 用 `*` 来处理多余的元素
+
+- `*`运算符可以把一个可迭代对象拆开作为函数的参数
+
+```python
+>>> divmod(20, 8)
+(2, 4)
+>>> t = (20, 8)
+>>> divmod(*t)
+(2, 4)
+>>> quotient, remainder = divmod(*t)
+>>> quotient, remainder
+(2, 4)
+
+```
+
+
+### 用 `*` 来处理剩下的元素
+
+
+在 `Python` 中，函数用 `*args` 来获取不确定数量的参数是一种经典写法。
+于是 Python 3 里，这个概念被扩展到了平行赋值中：
+
+
+```python
+>>> a, b, *rest = range(5)
+>>> a, b, rest
+(0, 1, [2, 3, 4])
+>>> a, b, *rest = range(3)
+>>> a, b, rest
+(0, 1, [2])
+>>> a, b, *rest = range(2)
+>>> a, b, rest
+(0, 1, [])
+
+```
+
+
+在平行赋值中，`*` 前缀只能用在一个变量名前面，但是这个变量可以出现在赋值表达式的任意位置：
+
+
+```python
+>>> a, *body, c, d = range(5)
+>>> a, body, c, d
+(0, [1, 2], 3, 4)
+>>> *head, b, c, d = range(5)
+>>> head, b, c, d
+([0, 1], 2, 3, 4)
+
+```
+
+
+### 嵌套结构的元组拆包
+
+
+```python
+metro_areas = [
+	('Tokyo','JP',36.933,(35.689722,139.691667)),
+	('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
+	('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
+	('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
+	('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
+]
+print('{:15} | {:^9} | {:^9}'.format('', 'lat.', 'long.'))
+fmt = '{:15} | {:9.4f} | {:9.4f}'
+for name, cc, pop, (latitude, longitude) in metro_areas:
+	if longitude <= 0:
+		print(fmt.format(name, latitude, longitude))
+
+```
+
+
+## namedtuple
+
+
+```python
+>>> from collections import namedtuple
+>>> City = namedtuple('City', 'name country population coordinates')
+>>> tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
+>>> tokyo
+City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722,
+139.691667))
+>>> tokyo.population
+36.933
+>>> tokyo.coordinates
+(35.689722, 139.691667)
+>>> tokyo[1]
+'JP'
+```
+
+
+创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
+
+
+存放在对应字段里的数据要以一串参数的形式传入到构造函数中（注意，元组的构造函数却只接受单一的可迭代对象）
+
+
+可以通过字段名或者位置来获取一个字段的信息。除了从普通元组那里继承来的属性之外，具名元组还有一些自己专有的属性。下面的示例中就展示了几个最有用的：`_fields` 类属性、类方法
+`_make(iterable)` 和实例方法 `_asdict()`。
+
+
+```python
+>>> City._fields
+('name', 'country', 'population', 'coordinates')
+>>> LatLong = namedtuple('LatLong', 'lat long')
+>>> delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
+>>> delhi = City._make(delhi_data)
+>>> delhi._asdict()
+OrderedDict([('name', 'Delhi NCR'), ('country', 'IN'), ('population',
+21.935), ('coordinates', LatLong(lat=28.613889, long=77.208889))])
+>>> for key, value in delhi._asdict().items():
+print(key + ':', value)
+name: Delhi NCR
+country: IN
+population: 21.935
+coordinates: LatLong(lat=28.613889, long=77.208889)
+```
+
+
+## bisect
+
+
+`bisect(haystack, needle)` 在 `haystack`（干草垛）里搜索 `needle`（针）的位置，该位置满足的条件是，把 `needle` 插入这个位置之后，`haystack` 还能保持升序。也就是在说这个函数返回的位置前面
+
+
+的值，都小于或等于 `needle` 的值。其中 `haystack` 必须是一个有序的序列。你可以先用 `bisect(haystack, needle)` 查找位置 `index`，再用 `haystack.insert(index, needle)` 来插入新值。但你也可用 `insort` 来一步到位，并且后者的速度更快一些。
+
+
+### 数组保存与读取的优雅实现
+
+
+如果我们需要一个只包含数字的列表，那么 `array.array` 比 `list` 更高效。数组支持所有跟可变序列有关的操作，包括 `.pop`、`.insert` 和 `.extend`。另外，数组还提供从文件读取和存入文件的更快的方法，如 `.frombytes` 和 `.tofile`。
+
+
+`Python` 数组跟 `C` 语言数组一样精简。创建数组需要一个类型码，这个类型码用来表示在底层的 C 语言应该存放怎样的数据类型。比如 b 类型码代表的是有符号的字符（signed char），因此 `array('b')` 创建出的数组就只能存放一个字节大小的整数，范围从 -128 到 127，这样在序列很大的时候，我们能节省很多空间。而且 `Python` 不会允许你在数组里存放除指定类型之外的数据。
+
+
+```python
+>>> from array import array
+>>> from random import random
+>>> floats = array('d', (random() for i in range(10**7)))
+>>> floats[-1]
+0.07802343889111107
+>>> fp = open('floats.bin', 'wb')
+>>> floats.tofile(fp)
+>>> fp.close()
+>>> floats2 = array('d')
+>>> fp = open('floats.bin', 'rb')
+>>> floats2.fromfile(fp, 10**7)
+>>> fp.close()
+>>> floats2[-1]
+0.07802343889111107
+>>> floats2 == floats
+True
+```
+
+
+## 高阶函数相关
+
+
+`map`、`filter`和`reduce`，`all` 和 `any`
+
+
+## Decorator
+
+
+Just fully read chapter 7. 
+
+
+## Coroutine & asyncio
+
+
+Fully read chapter 14, 16, 17 and 18
+

package/output/37b77a0a-e233-405a-93f5-a60a808eee35

@@ -0,0 +1,72 @@
+
+
+
+
+# HTML/CSS
+
+
+[https://www.reddit.com/r/Frontend/comments/g05kc1/when_should_you_use_grid_css_instead_of_flexbox/](https://www.reddit.com/r/Frontend/comments/g05kc1/when_should_you_use_grid_css_instead_of_flexbox/)
+
+
+**some advice: you should only use tailwind css, I spit on it on first sight, now I Fucking loving it.**
+
+
+# Type/Javascript
+
+
+## Tutorial
+
+
+[javascript tutorial](https://javascript.info/mixins)
+
+
+[ts tooling](https://www.typescriptlang.org/docs/handbook/typescript-tooling-in-5-minutes.html)
+
+
+[project config](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)
+
+
+## Tools
+
+<details>
+<summary>bundle tool</summary>
+
+**vite** webpack
+
+
+</details>
+
+<details>
+<summary>framework</summary>
+
+hono, **react**, **remix**, nextjs, **astro**
+
+
+</details>
+
+<details>
+<summary>package manager</summary>
+
+npm **pnpm** bun yarn
+
+
+[https://stackoverflow.com/questions/75413361/can-i-use-npx-with-pnpm](https://stackoverflow.com/questions/75413361/can-i-use-npx-with-pnpm)
+
+
+</details>
+
+
+## All bout prototype 
+
+
+[https://stackoverflow.com/questions/18198178/null-prototype-object-prototype-and-object-create](https://stackoverflow.com/questions/18198178/null-prototype-object-prototype-and-object-create)
+
+
+[https://juejin.cn/post/7039580424170897421](https://juejin.cn/post/7039580424170897421)
+
+
+# React
+
+
+[debouncing with useEffect](99ef1497-0b94-490f-b9a0-f54b0e64194d.md)
+

package/output/3ac660cb-9503-4e88-8939-5aee30c98351

@@ -0,0 +1,24 @@
+
+“for people who want to learn things, you just fuck around, and you find out” - youtube@TsodingDaily
+
+
+# Selfie
+
+
+我是汉堡粥 / I’m humbornjo。
+
+
+I am a apprentice, a coder, former child, couch potato, the lord of meme, killer of salmon, shield of whiterun, and a Chinese.
+
+
+By the way, I like the word “Illusion”, and I dont know why.
+
+
+# Masterpiece
+
+
+People who ain’t smart enough can not see the masterpiece I publish below.
+
+
+Actually I am planning to make a website where I can show the web design I made and the meme I collected. Maybe later.
+

package/output/5bc1b19a-8350-48b3-aa19-8073561ad45b

@@ -0,0 +1,109 @@
+
+> 💡 “you are no god” - Process  
+> ”yeah, god have mercy, I don’t” - OS  
+> This lyrics just come out of no where to my mind when I finally made a bite on the ECF. Alone with virtual memory, the crown of computer is granted.
+
+
+
+
+
+This article is for those who want to correctly have a shallow understanding on signal. I will try to make it as simple, clean and straight-forward as possible.
+
+
+# Exception control flow
+
+
+## process
+
+
+
+
+
+## process control
+
+
+
+
+
+## signal 
+
+
+> A _signal_ is a small message that notifies a process that an event of some type has occurred in the system. —— CSAPP
+
+
+To understand signal, we need to know its, 
+
+- data structure
+- where it is stored
+- how to send it
+- how to receive it
+
+### **data structure**
+
+
+![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/262f41a6-16b5-45d4-9c27-3ac1a41da67c/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=20240727T092415Z&X-Amz-Expires=3600&X-Amz-Signature=7476280a06453e916fae7eed9b905bdde05ce4dc09ddda8d82f0b05a3bc53828&X-Amz-SignedHeaders=host&x-id=GetObject)
+
+
+Ok, if we don’t dive too deep, that’s it. An array of **bits**. If the bit is set, the according signal is received, otherwise not received. You can google the mapping between number and signal if you are interested.
+
+
+### where it is stored
+
+
+> [Process control block](Process%20control%20block)
+
+- Interprocess communication information – flags, **signals** and messages associated with the communication among independent processes;
+
+Wow, it is stored in PCB, **not in the memory model (like stack or heap)**. And it also indicates kernel would manage it for us.
+
+
+The place it is preserved may not explain everything, but it would let the following talk makes sense, so bite it.
+
+
+### how to send it
+
+
+### how to receive it
+
+
+### in case you aren’t satisfied
+
+
+[How do unix signals work?](https://stackoverflow.com/questions/4208004/how-do-unix-signals-work)
+
+
+### anons on Reddit argues
+
+
+[Should you be scared of Unix signals?](https://www.reddit.com/r/programming/comments/4o027w/should_you_be_scared_of_unix_signals/)
+
+
+# Why bother reaping
+
+
+
+
+
+## wait & waitpid
+
+
+
+
+
+## SIGCHLD
+
+
+
+
+
+## signal & sigaction
+
+
+
+
+
+# CSAPP shell lab
+
+
+
+

package/output/765976b5-7790-497b-8634-4be1d4770e16

@@ -0,0 +1,111 @@
+
+ok，来到了看起来很厉害，实际上也很厉害的零知识证明，这里根据论文 [Why and How zk-SNARK Works](http://arxiv.org/abs/1906.07221) 梳理一遍，对于自己死去的代数记忆也进行一个妙手回春。
+
+
+# 定义
+
+
+**什么是 zk-SNARK?**
+
+
+> Zero-knowledge succinct non-interactive arguments of knowledge (zk-SNARK) is the truly ingenious method of proving that something is true without revealing any other information
+
+
+# 多项式的魅力时刻
+
+
+首先，三次多项式的等式可以被定义为：
+
+
+$$
+c_3x^3+c_2x^2+c_1x+c_0=0
+$$
+
+
+也就是说，这个多项式的阶 $d$（degree: The degree of a polynomial is determined by its greatest exponent of x）为3。更直观的，这个等式最多有三个解。
+
+
+此时假设我们有一个场景，
+
+
+
+
+
+> prover claims to know some polynomial (no matter how large its degree is) that the verifier also knows
+
+- Verifier chooses a random value for x and evaluates his polynomial locally
+- Verifier gives x to the prover and asks to evaluate the polynomial in question
+- Prover evaluates his polynomial at x and gives the result to the verifier
+- Verifier checks if the local result is equal to the prover’s result, and if so then the statement is proven with a high confidence
+
+我们假设 verifier 选择的值是 $x=\alpha$ ，两方都知晓的多项式为 $p(x)$ ，多项式在一个限定的范围内的总共结果数为 $10^{77}$ 个，在这其中，结果不等于 $p(\alpha)$ 的数量为 $10^{77}-k,~where~k\in[1,~d],~k\in Z^+$ ，也就是说，如果 prover 如果不知道这个多项式 $p(x)$ ，那么猜中的几率只有 $\frac{k}{10^{77}}$ 。
+
+
+> That is why polynomials are at the very core of zk-SNARK, although it is likely that other proof mediums exist as well.
+
+
+# Non-Interactive Zero-Knowledge of a Polynomial
+
+
+> The discussion so far has focused on a weak notion of a proof, where parties have to trust each other because there are no measures yet to enforce the rules of the protocol. For example, the prover is not required to know a polynomial, and he can use any other means available to him to come up with a correct result. Moreover, if the amplitude of the verifier’s polynomial evaluations is not large, let us say 10, the verifier can guess a number, and there is a non-negligible probability that it will be accepted.
+
+
+所以啊，为了解决上一段中（也就是下方）protocol 的问题，我可以回顾一下多项式的定义，
+
+
+
+
+
+> prover claims to know some polynomial (no matter how large its degree is) that the verifier also knows
+
+- Verifier chooses a random value for x and evaluates his polynomial locally
+- Verifier gives x to the prover and asks to evaluate the polynomial in question
+- Prover evaluates his polynomial at x and gives the result to the verifier
+- Verifier checks if the local result is equal to the prover’s result, and if so then the statement is proven with a high confidence
+
+对于 $d = n$ 的多项式：
+
+
+$$
+c_nx^n+c_{n-1}x^{n-1}+...+c_1x+c_0
+$$
+
+
+假设，如果有人说他了解一个 $d=1$ 的多项式（$c_1x+c_0$），这实际上说明的是他知道 $c_1$ 和 $c_0$ 的值。
+
+
+现在把问题推广一下，有人说他了解一个 $d=3$ 的多项式 $p(x)$，而且他知道 $p(1) = p(2) = 0$。我们假设 $p(x) = x^3-3x^2+2x$。那么根据代数的因式分解，我们可以得到 $p(x) = (x-0)(x-1)(x-2)$。也就是剩下的一个解是 $x=0$。在这个人的视角中，$(x-1)$ 和 $(x-2)$ 是 $p(x)$ 的辅因子（cofactor）。所以，如果他想在不泄露 $p(x)$ 的情况下让别人相信他真的知道 $p(x)$，其中的一个方法就是证明 $t(x) = (x-1)(x-2)$ 可以整除 $p(x)$ ，我们把 $t(x)$ 称为 _target polynomial_ ，因此，会存在一个多项式 $h(x)$，使得：
+
+
+$$
+p(x) = t(x)h(x)
+$$
+
+
+ok，那现在我们想要验证的话，由于 $p(x)$ 是已知的，可以进行多项式除法，只要多项式除法没有余数（remainder），就说明 $p(x)$ 确实包含了 $t(x)$。下面是改进的方法：
+
+
+> Using our polynomial identity check protocol we can compare polynomials p(x) and t(x)·h(x):
+
+- Verifier samples a random value r, calculates t = t(r) (i.e., evaluates) and gives r to the prover
+- Prover calculates h(x) = p(x)/t(x) and evaluates p(r) and h(r); the resulting values p,h are provided to the verifier
+- Verifier then checks that p = t · h, if so those polynomials are equal, meaning that p(x) has t(x) as a cofactor.
+
+基本逻辑是：
+
+1. prover 把自己用于证明的 t(x) 发给 verifier
+2. verifier 搞一个随机数 r，计算 t(r)，并把 r 发给 prover
+3. prover 目前“应该”知道 p(x) 和 t(x) ，所以 prover 也可以根据多项式除法得到对应的 h(x)，由此得到 p(r) 和 h(r)，并发送给 verifier。
+4. verifier 验证 p(r) = t(r) · h(r)。如果成立，则 t(x) 确实为 p(r) 的 cofactor。
+
+## QA
+
+
+不是完全理解 verifier  和 prover 一开始都知道些什么
+
+
+# 
+
+
+
+