noblog 0.0.1

package/output/sub/5771c956-25bf-4714-bc2e-65959c9156d9

@@ -0,0 +1,52 @@
+
+# Intro
+
+
+This blog is written in eng cus ref and concept related to it could be super confusing when translation happens. 
+
+
+# All that matters
+
+- `[T; n]` is an array of length `n`, represented as `n` adjacent `T` instances.
+- `&[T; n]` is purely a reference to that array, represented as a thin pointer to the data.
+- `[T]` is a slice, an unsized type; it can only be used through some form of indirection.
+- `&[T]`, called a slice, is a sized type. It's a _fat pointer_, represented as a pointer to the first item and the length of the slice.
+
+# Array and Slice
+
+
+ok, first lets learn how to create a array.
+
+
+Lets picture a scenario, you are a python boy. You want to learn rust to show off to your miserable friends. you create a array based on the spirit of python. And the compiler complained that you should use `let i32slice: [i32; 2] = [0, 10];` instead of `let i32slice: [i32] = [0, 10];`.
+
+
+## TL; DR.
+
+
+This part is for those python boy. If you are familiar with c++, you should spit on my blog and go get some comic to read till I finish this stupid lesson.
+
+
+```c++
+// in C++
+std::array<int, 2> myArray = {1, 10};
+```
+
+
+`[T]` is a contiguous sequence of `T`s, while `&[T]` is a dynamically-sized view into this contiguous sequence.  The former has no statically known size while the latter does. while the lvalue always has an statically known size. If you dont know what lvalue is, go ask Dr.Google, on this I cant help.
+
+
+## Diff between `&[T; n]` and `&[T]`
+
+
+[https://stackoverflow.com/questions/30794235/what-is-the-difference-between-a-slice-and-an-array](https://stackoverflow.com/questions/30794235/what-is-the-difference-between-a-slice-and-an-array)
+
+
+## About `[T]`
+
+
+`[T]` is just a concept, you can never create a dynamically sized variable in rust, all you can do is let `&[T; n]` coerce to `&[T]` and thus exploit the returned fat pointer.
+
+
+
+

package/output/sub/6ff91a18-494e-4ffc-a33b-b9fd2c36f43f

@@ -0,0 +1,42 @@
+
+# 什么是反射
+
+
+> 在计算机科学中，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。
+
+
+难道不用反射就不能在运行时访问、检测和修改它本身的状态和行为吗？
+
+
+问题的回答，其实要首先理解什么叫访问、检测和修改它本身状态或行为，它的本质是什么？
+
+
+实际上，它的本质是程序在运行期探知对象的类型信息和内存结构。不用反射能行吗？可以的！使用汇编语言，直接和内层打交道，可以获取任何信息？但是，当编程迁移到高级语言上来之后，就不行了！只能通过`反射`来达到此项技能。
+
+
+不同语言的反射模型不尽相同，有些语言还不支持反射。《Go 语言圣经》中是这样定义反射的：
+
+
+> Go 语言提供了一种机制在运行时更新变量和检查它们的值、调用它们的方法，但是在编译时并不知道这些变量的具体类型，这称为反射机制。
+
+
+再挂一段摘自stackoverflow的解释
+
+
+> The first good example I can think of off the top of my head is for when you need to execute a set of methods on a given object without knowing at compile-time what methods will exist in it.  
+>   
+> Take unit testing frameworks for example. The test runner class that is responsible for running all your unit tests doesn't know ahead of time what you are going to name your methods. All it knows is that they will be prefixed with "test" (or in Java 5's case, annotated with `@Test`). So when given a test class, it reflects on that class in order to get a list of all the methods in it. Then, it iterates through those method names as strings and calls those methods on the object if they start with "test". That wouldn't be possible without reflection. And that's just one example.
+
+
+# 什么时候需要反射
+
+1. 不能明确接口调用哪个函数，需要根据传入的参数在运行时决定。
+2. 不能明确传入函数的参数类型，需要在运行时处理任意对象。
+3. 彻底解耦调用者和执行者，执行者只负责执行，方法可以在运行时动态获取
+
+# 为什么不推荐反射
+
+1. 与反射相关的代码，经常是难以阅读的。在软件工程中，代码可读性也是一个非常重要的指标。
+2. Go 语言作为一门静态语言，编码过程中，编译器能提前发现一些类型错误，但是对于反射代码是无能为力的。所以包含反射相关的代码，很可能会运行很久，才会出错，这时候经常是直接 panic，可能会造成严重的后果。
+3. 反射对性能影响还是比较大的，比正常代码运行速度慢一到两个数量级。所以，对于一个项目中处于运行效率关键位置的代码，尽量避免使用反射特性。
+4. 反射会让封装的变量、方法不再安全。

package/output/sub/99ef1497-0b94-490f-b9a0-f54b0e64194d

@@ -0,0 +1,6 @@
+
+this is a test phrase
+
+
+
+

package/output/sub/9a33b8cc-101a-4f6a-9852-115595cd166b

@@ -0,0 +1,172 @@
+
+## 1. Why Raft?
+
+- **Consensus algorithms** allow a collection of machines to work as a coherent group that can survive the failures of some of its members.
+- **Paxos** (one of the Consensus Algorithm)has dominated the discussion of consensus algorithms over the last decade. But it is hard to understand.
+- **Raft** define a consensus algorithm for practical systems and describe it in a way that is significantly easier to learn than Paxos.
+
+## 2. Main features in Raft
+
+- **Strong leader:** Raft uses a stronger form of leadership than other consensus algorithms. For example, log entries only flow from the leader to other servers. This simplifies the management of the replicated log and makes Raft easier to understand.
+- **Leader election:** Raft uses randomized timers to elect leaders. This adds only a small amount of mechanism to the heartbeats already required for any consensus algorithm, while resolving conflicts simply and rapidly.
+- **Membership changes:** Raft’s mechanism for changing the set of servers in the cluster uses a new joint consensus approach where the majorities of two different configurations overlap during transitions. This allows the cluster to continue operating normally during configuration changes.
+
+## 3. Replicated state machines
+
+
+> Replicated state machines are used to solve a variety of fault tolerance problems in distributed systems.
+
+
+> 💡 Replicated state machines are typically implemented using a replicated log  
+> ![Rep_state_machine.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/2744dbee-2a7a-4215-ac3c-a02d0041c497/Rep_state_machine.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=20240727T092523Z&X-Amz-Expires=3600&X-Amz-Signature=566e9efaf6d26542ffbac99f93ee062942d787d843ba2d5e0ab93ed2ba3ab01e&X-Amz-SignedHeaders=host&x-id=GetObject)  
+>   
+> - Each server stores a log containing a series of commands, which its state machine executes in order  
+>   
+> - Each log contains the same commands in the same order, so each state machine processes the same sequence of commands  
+>   
+> - State machines are deterministic, each computes the same state and the same sequence of outputs
+
+
+![Rep_state_machine.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/2744dbee-2a7a-4215-ac3c-a02d0041c497/Rep_state_machine.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=20240727T092522Z&X-Amz-Expires=3600&X-Amz-Signature=88c1bdb3c4cd3cb850d455c995727d653b493e90639dbaba0f2b84aa57e63452&X-Amz-SignedHeaders=host&x-id=GetObject)
+
+- Each server stores a log containing a series of commands, which its state machine executes in order
+- Each log contains the same commands in the same order, so each state machine processes the same sequence of commands
+- State machines are deterministic, each computes the same state and the same sequence of outputs
+
+**Keeping the replicated log consistent is the job of the consensus algorithm.**
+
+- The consensus module on a server receives commands from clients and adds them to its log.
+- It communicates with the consensus modules on other servers to ensure that every log eventually contains the same requests in the same order, even if some servers fail.
+- Once commands are properly replicated, each server’s state machine processes them in log order, and the outputs are returned to clients.
+
+**Consensus algorithms for practical systems typically have the following properties:**
+
+- They ensure safety (never returning an incorrect result) under all non-Byzantine conditions, including network delays, partitions, and packet loss, duplication, and reordering.
+- They are fully functional (available) as long as any majority of the servers are operational and can communicate with each other and with clients. Thus, a typical cluster of five servers can tolerate the failure of any two servers. Servers are assumed to fail by stopping; they may later recover from state on stable storage and rejoin the cluster.
+- They do not depend on timing to ensure the consistency of the logs: faulty clocks and extreme message delays can, at worst, cause availability problems.
+- In the common case, a command can complete as soon as a majority of the cluster has responded to a single round of remote procedure calls; a minority of slow servers need not impact overall system performance.
+
+## 4. Weakness of Paxos
+
+
+> Over the last ten years, Leslie Lamport’s Paxos protocol has become almost synonymous with consensus: it is the protocol most commonly taught in courses, and most implementations of consensus use it as a starting point.
+
+
+> 💡 Paxos first defines a protocol capable of reaching agreement on a single decision, such as a single replicated log entry. We refer to this subset as single-decree Paxos. Paxos then combines multiple instances of this protocol to facilitate a series of decisions such as a log (multi-Paxos)
+
+- Too difficult to understand.
+- does not provide a good foundation for building practical implementations.
+
+Each implementation begins with Paxos, discovers the difficulties in implementing it, and then develops a significantly different architecture. This is timeconsuming and error-prone, and the difficulties of understanding Paxos exacerbate the problem.
+
+
+## 5. Idea within Raft
+
+- Problem decomposition: wherever possible, we divided problems into separate pieces that could be solved, explained, and understood relatively independently.
+- Simplify the state space by reducing the number of states to consider, making the system more coherent and eliminating nondeterminism where possible
+- There are some situations where nondeterminism actually improves understandability. In particular, randomized approaches introduce nondeterminism, but they tend to reduce the state space by handling all possible choices in a similar fashion (“choose any; it doesn’t matter”). We used randomization to simplify the Raft leader election algorithm.
+
+## 6. The Raft consensus algorithm
+
+
+**First electing a distinguished leader**
+
+- leader has complete responsibility for managing the replicated log.
+- leader accepts log entries from clients, replicates them on other servers, and tells servers when it is safe to apply log entries to
+their state machines.
+- leader can fail or become disconnected from the other servers, in which case a new leader is elected
+
+**Given the leader approch, Raft decomposes the consensus problem into three relatively independent subproblems, which are discussed in the subsections that follow:**
+
+- Leader election: a new leader must be chosen when an existing leader failss
+- Log replication: the leader must accept log entries from clients and replicate them across the cluster.
+- Safety: the key safety property for Raft is the State Machine Safety Property. if any server has applied a particular log entry to its state machine, then no other server may apply a different command
+for the same log index.
+
+**term**
+
+
+Each server stores a current term number, which increases monotonically over time.
+
+- Current terms are exchanged whenever servers communicate.
+- If one server’s current term is smaller than the other’s, then it updates its current term to the larger value.
+- If a candidate or leader discovers that its term is out of date, it immediately reverts to follower state.
+- If a server receives a request with a stale term number, it rejects the request.
+
+**RPCs**
+
+- RequestVote RPCs are initiated by candidates during elections.
+- AppendEntries RPCs are initiated by leaders to replicate log entries and to provide a form of heartbeat.
+- A third RPC for transferring snapshots between servers
+- Servers retry RPCs if they do not receive a response in a timely manner, and they issue RPCs in parallel for best performance.
+
+## 7. Leader election
+
+
+> Raft uses a heartbeat mechanism to trigger leader election. When servers start up, they begin as followers. A server remains in follower state as long as it receives valid RPCs from a leader or candidate. Leaders send periodic heartbeats (AppendEntries RPCs that carry no log entries) to all followers in order to maintain their authority. If a  
+> follower receives no communication over a period of time called the _election timeout_, then it assumes there is no viable leader and begins an election to choose a new leader.
+
+
+**Begin an election**
+
+
+follower increments its current term and transitions to candidate state. It then votes for itself and issues RequestVote RPCs in parallel to each of the other servers in the cluster.
+
+
+**A candidate continues in this state until one of three things happens:**
+
+<details>
+<summary>**a.** it wins the election</summary>
+
+A candidate wins an election if it receives votes from a majority.
+
+
+</details>
+
+<details>
+<summary>**b.** another server establishes itself as leader</summary>
+
+Each server will vote for at most one candidate in a given term, on a first-come-first-served basis
+
+
+a candidate may receive AppendEntries RPC from another server claiming to be leader. If the leader’s term is at least as large as the candidate’s current term, then the candidate recognizes the leader as legitimate and returns to follower state. If the term in the RPC is smaller than the candidate’s current term, then the candidate rejects the RPC and continues in candidate state.
+
+
+</details>
+
+<details>
+<summary>**c.** a period of time goes by with no winner</summary>
+
+candidate neither wins nor loses the election: if many followers become candidates at the same time, votes could be split so that no candidate obtains a majority. When this happens, each candidate will time out and start a new election by incrementing its term and initiating another round of RequestVote RPCs. However, without extra measures split votes could repeat indefinitely.
+
+
+</details>
+
+
+Raft uses randomized election timeouts to ensure that split votes are rare and that they are resolved quickly
+
+
+**Why not use ranking?**
+
+
+a lower-ranked server might need to time out and become a candidate
+again if a higher-ranked server fails, but if it does so too soon, it can reset progress towards electing a leader.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+