## How Git Commands work

To begin with, it's essential to identify where our code is stored. The common assumption is that there are only two locations - one on a remote server like Github and the other on our local machine. However, this isn't entirely accurate. Git maintains three local storages on our machine, which means that our code can be found in four places:





![image.png](/static/img/9dc574e95d3152d66e3b4b1d407b427e.image.webp)

* 工作目录：我们编辑文件的地方
* 暂存区：一个临时位置，用于保存下一次提交的文件
* 本地仓库：包含已提交代码的地方
* 远程仓库：存储代码的远程服务器

大多数Git命令主要在这四个位置之间移动文件。


## How does Git Work?

![image.png](/static/img/4bfecfd3b4d0eda2679da46fa4901b48.image.webp)

Git是一个分布式版本控制系统。

每个开发人员都维护主仓库的本地副本，并在本地副本上进行编辑和提交。

提交操作非常快，因为该操作不与远程仓库进行交互。

如果远程仓库崩溃，可以从本地仓库恢复文件。


## Git merge vs. Git rebase

What are the differences?


![image.png](/static/img/0dc127b9730f39fe9e0d1b70832db907.image.webp)

当我们从一个Git分支合并更改到另一个分支时，我们可以使用“git merge”或“git rebase”。下面的图表显示了这两个命令的工作原理。

>Git合并

这会在主分支中创建一个新的提交G'。G'将主分支和功能分支的历史联系起来。

Git合并是非破坏性的。主分支和功能分支都不会改变。

> Git变基

Git变基将功能分支历史移动到主分支的头部。它为功能分支中的每个提交创建新的提交E'、F'和G'。

变基的好处是它有一个线性的提交历史。

如果不遵循“git rebase的黄金法则”，变基可能会很危险。

>Git Rebase的黄金法则

永远不要在对公共分支使用它！

09 Git

## DevOps vs. SRE vs. Platform Engineering. What is the difference?

DevOps、SRE和平台工程的概念在不同时期出现，并由不同的个人和组织发展而来。




![image.png](/static/img/49b8ad81967ba5cc8a32d6e8e23b7837.image.webp)

DevOps作为一个概念是由Patrick Debois和Andrew Shafer在2009年的敏捷会议上提出的。他们试图通过促进协作文化和对整个软件开发生命周期的共同责任来弥合软件开发与运营之间的鸿沟。

SRE，即站点可靠性工程，是由谷歌在21世纪初为解决管理大规模复杂系统的运营挑战而开创的。谷歌开发了SRE实践和工具，如Borg集群管理系统和Monarch监控系统，以提高其服务的可靠性和效率。

平台工程是一个较新的概念，建立在SRE工程的基础上。平台工程的精确起源不太清楚，但它通常被认为是对DevOps和SRE实践的扩展，专注于为产品开发提供一个全面的平台，支持整个业务视角。

值得注意的是，虽然这些概念在不同的时间出现，但它们都与改进软件开发与运营中的协作、自动化和效率的更广泛趋势有关。


## What is k8s (Kubernetes)?

K8s is a container orchestration system. It is used for container deployment and management. Its design is greatly impacted by Google’s internal system Borg.

![image.png](/static/img/7958105618b5335ae6370937b243a0da.image.webp)

一个k8s集群由一组工作机器组成，称为节点，它们运行容器化应用程序。每个集群至少有一个工作节点。

工作节点承载Pod，这是应用程序工作负载的组成部分。控制平面管理集群中的工作节点和Pod。在生产环境中，控制平面通常在多台计算机上运行，并且一个集群通常运行多个节点，提供容错和高可用性。

>控制平面组件
1. API服务器: API服务器与k8s集群中的所有组件通信。对Pod的所有操作都是通过与API服务器通信执行的。

2. 调度器: 调度器监视Pod工作负载并分配新创建的Pod上的负载。

3. 控制器管理器 :控制器管理器运行控制器，包括节点控制器、作业控制器、EndpointSlice控制器和ServiceAccount控制器。

4. Etcd: etcd是一个键值存储，用作Kubernetes所有集群数据的后端存储。

> 节点
 
1. Pods: Pod是一组容器，是k8s管理的最小单位。Pod具有一个IP地址，应用于Pod内的每个容器。

2. Kubelet: 一个在集群的每个节点上运行的代理。它确保容器在Pod中运行。

3. Kube Proxy: Kube-proxy是运行在集群每个节点上的网络代理。它将来自服务的流量路由到节点。它将工作请求转发到正确的容器。

## Docker vs. Kubernetes. Which one should we use?

![image.png](/static/img/5377c2bc5b7e9b4fcf3938f5d20c6bd4.image.webp)

Docker是一个开源平台，允许您将应用程序打包、分发并在隔离的容器中运行。它专注于容器化，提供轻量级环境，封装应用程序及其依赖关系。

Kubernetes，通常被称为K8s，是一个开源容器编排平台。它提供了一个框架，用于自动化跨节点集群的容器化应用程序的部署、扩展和管理。

两者之间的区别在于：

* Docker：Docker在单个操作系统主机上的单个容器级别运行。您必须手动管理每个主机，并为多个相关容器设置网络、安全策略和存储可能会很复杂。
* Kubernetes：Kubernetes在集群级别运行。它管理跨多个主机的多个容器化应用程序，为负载平衡、扩展和确保应用程序所需状态等任务提供自动化。

简而言之，Docker专注于容器化和在单个主机上运行容器，而Kubernetes专门负责跨主机集群管理和编排容器。


## How does Docker work?
The diagram below shows the architecture of Docker and how it works when we run “docker build”, “docker pull” and “docker run”.


![image.png](/static/img/5faa8c6bbf1d762fe2a1dc430786ce66.image.webp)
Docker架构中有3个组件：

1. Docker客户端：Docker客户端与Docker守护进程通信。
2. Docker主机： Docker守护进程监听Docker API请求并管理Docker对象，如镜像、容器、网络和卷。
3. Docker注册表： Docker注册表存储Docker镜像。Docker Hub是一个任何人都可以使用的公共注册表。

让我们以“docker run”命令为例。

1. Docker从注册表中拉取镜像。
2. Docker创建一个新容器。
3. Docker为容器分配一个读写文件系统。
4. Docker创建一个网络接口，将容器连接到默认网络。
5. Docker启动容器。

08 DevOps

## How to learn payment systems?



![image.png](/static/img/82cac64b721c623bb9fac0667d773a04.image.webp)

## Why is the credit card called “the most profitable product in banks”? How does VISA/Mastercard make money?

The diagram below shows the economics of the credit card payment flow.


![image.png](/static/img/dfdd7c98c1162c1d77a55358f7a00e6b.image.webp)

翻译：

1. 持卡人向商家支付100美元购买产品。

2. 商家通过使用信用卡获得更高的销售额，并需要补偿发卡机构和卡网络提供的支付服务。收单银行与商家设定一个费用，称为“商户折扣费”。

3-4. 收单银行保留0.25美元作为收单利润，而1.75美元支付给发卡银行作为交换费。商户折扣费应覆盖交换费。

交换费由卡网络设定，因为每个发卡银行与每个商家协商费用效率较低。

5. 卡网络与每家银行设定网络评估和费用，银行每月为其服务向卡网络支付费用。例如，VISA每次刷卡收取0.11%的评估费，加上0.0195美元的使用费。

6. 持卡人为发卡银行的服务付费。

> 为什么发卡银行应该得到补偿？

即使持卡人未能支付发卡机构，发卡机构仍会支付商家。
发卡机构在持卡人支付之前先支付给商家。
发卡机构有其他运营成本，包括管理客户账户、提供账单、欺诈检测、风险管理、清算和结算等。

## How does VISA work when we swipe a credit card at a merchatn's shop?


![image.png](/static/img/2e5573c572d13ae610084014d583cae5.image.webp)

VISA、Mastercard和American Express作为卡网络参与资金的清算和结算。收单银行和发卡银行可以是不同的银行，通常也是如此。如果银行不通过中介逐一结算交易，那么每家银行都需要与其他所有银行结算交易。这非常低效。

下图显示了VISA在信用卡支付过程中的作用。涉及两个流程。授权流程发生在客户刷卡时。捕获和结算流程发生在商家在一天结束时想要收款时。

授权流程
* 步骤0：发卡银行向其客户发放信用卡。
* 步骤1：持卡人想要购买产品，并在商家的销售点（POS）终端刷卡。
* 步骤2：POS终端将交易发送给提供POS终端的收单银行。
* 步骤3和4：收单银行将交易发送给卡网络，也称为卡计划。卡网络将交易发送给发卡银行以获取批准。
* 步骤4.1、4.2和4.3：如果交易获得批准，发卡银行冻结资金。批准或拒绝信息被发送回收单银行以及POS终端。

捕获和结算流程
* 步骤1和2：商家在一天结束时想要收款，因此在POS终端上点击“捕获”。交易批量发送给收单银行。收单银行将包含交易的批文件发送给卡网络。
* 步骤3：卡网络对从不同收单银行收集的交易进行清算，并将清算文件发送给不同的发卡银行。
* 步骤4：发卡银行确认清算文件的正确性，并将资金转账给相关的收单银行。
* 步骤5：收单银行然后将资金转账给商家的银行。
* 步骤4：卡网络清理来自不同收单银行的交易。清算是相互抵消的交易进行净额结算的过程，从而减少总交易数量。

在这个过程中，卡网络承担了与每家银行沟通的负担，并收取服务费作为回报。

## Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India

翻译：

什么是UPI？UPI是由印度国家支付公司开发的即时实时支付系统。

目前，它占印度数字零售交易的60%。

UPI = 支付标记语言 + 可互操作支付标准


![image.png](/static/img/6f256138dc0577d3ec7cb324b5fc0fe4.image.webp)

07 Payment systems

## 语法
右边是一个泛型接口，其中类型参数T可以是任务类型


![image.png](/static/img/151eadf4d3c916e9742280e5cc100410.image.webp)




结构体也可以使用泛型
```go
type LinedListV1[T any] struct {
    head *nodeV1[T]
}

func (l *LinkedListV1[T]) Add (idx int, val T) {
    //TODO implement me 
    panic("implement me")
}

func (l *LinkedListV1[T]) Append(val T){
    //TODO implement me 
    panic("implement me")
}

func (l *LinkedListV1[T]) Delete(idx T){
    //TODO implement me 
    panic("implement me ")
}

type NodeV1[T any] struct {
    data T
}

func UseList(){
    l := &LinkedListV1[int]{}
    l.Add(index: 1, val:123)
    l.Add(index: 1, val:"123") //这里会报错
}
```

方法也可以用泛型

```go
package generics

func Sum[T Number](vals []T) T{
    var res T
    for _,v :=range vals{
        res = res + v // 若sum用的是Any，就不能相加，因为数据类型可能是非数字，所以该用Number来检查
    }
    return res
}

type Integer int
type Number interface {
    int | unint
    // 或者int的衍生类型 ~int | unint
}

func UseSum(){
// 必须使用衍生类型的int
    res:=Sum[int]([]int{123, 123})
    println(res)
    resV1 := Sum[Integer]([]Integer{123,123})
    println(res)
}


func Closable[T io.Closer](){
    var t T
    t.Close()
}
```


## 代码演示
[标准实现参考](https://github.com/ecodeclub/ekit/tree/dev/slice)
### 求和
### 求最大值、最小值
```go
func Max[T Number](vals []T) T{
    t:=vals[0]
    for i :=1; i< len(vals);i++ {
        if t <vals[i]{
            t=vals[i]
            }
        }
    return t
}

func Min[T Number](vals []T) T{
    t:=vals[0]
    for i :=1; i< len(vals);i++ {
        if t >vals[i]{
            t=vals[i]
            }
        }
    return t
}

```
### 过滤和查找
```go
func Find[T any](vals []T, filter func(t T)bool) T{
    for _,v :=range vals{
        if filter(v) {
            return v
        }
    }
    var t T
    return t

}

```
### 在切片特定索引位置插入元素
```go
func Insert[T any](ids int, vals []int) {
    if idx <0 || idx >= len(vals) {
        panic("idx 不合法")
    }
    //先扩容
    vas = append(vals, val)
    for i:=len(vals)-1; i>idx; i-- {
        if i-1>=0{
            vals[i]=vals[i-1]
        }
    }
    vals[idx] = val
    return vals
}

//调用使用

package main

import "fmt"

func main(){
    fmt.Printf("%v \n", Insert[int](0, 12, []int{1,2}))
    fmt.Printf("%v \n", Insert[int](2, 12, []int{1,2}))
    fmt.Printf("%v \n", Insert[int](1, 12, []int{1,2}))
}
```

07 Go泛型

## 接口定义
基本语法： type 名字 interface{}
* 里面只能有方法，方法也不需要func关键字


> 什么是接口？：接口是一组行为的抽象
* 尽量用接口，以实现面向接口编程

原则上任务：即便是任务开发，也应该面向接口编程

![image.png](/static/img/7048f9215c1c20fe1942c6d21c4db6e6.image.png)

当你怀疑要不要定义接口的时候，加上去。


## 结构体定义
* 基本语法：
```go
type  Name struct{
    fieldName FieldType
    //....
}
```

![image.png](/static/img/e33b3ff60b6ab42825732472326b697d.image.png)
结构体和结构体的字段都遵循大小写控制访问性的原则。

通过. 这个符号来访问字段或者方法。


## 结构体初始化
* Go没有构造函数
* 初始化语法：struct{}
* 获取指针
    * &struct {}
    * new(Struct)

new可理解为Go会为你的变量分配内存，并且把内存都置为0.


![image.png](/static/img/7939caafefa2b8aef6eb64d7b8c89f0f.image.png)

有两种形态：
* 按照字段名赋值
* 按照字段顺序赋值：不推荐使用，非常不利于后期维护


![image.png](/static/img/35cc67aa5f82ddb166051973f3c83b67.image.png)

## 结构体与指针
go的指针和别的语言的概念一样，本质上都是一个内存地址。
* 和c、c++一样，*表示指针，&取地址
* 如果声明了一个指针，但是没有赋值，那么他是nil。


![image.png](/static/img/5a1ec4d55dd184a98d22a0e94e75e4a9.image.png)
 
 ## 方法接收器
 
 一个方法可以定义在这个结构体上，也可以定义在这个结构体的指针上。
 
 前者叫做结构体接收器，后者叫做指针接收器。
 
 
![image.png](/static/img/66a40e9ccc6512cbe94f392c049de168.image.png)


结构体接收器内部修改字段，不会生效。因为方法调用本身是值传递的。

目前没有统一的说法什么时候用什么接收器，你在初学的时候：遇事不决用指针。

也就是：
* 如果是基本类型，结构体，那么就相当于复制一份了
* 如果是指针，那么就复制了一份指针（也就是地址），但是指向的结构体还是同一个
* 内置类型复制了一份，但是他们的内部数据结构，还是同一个。（初学你就可以这么理解）


![image.png](/static/img/341119a6c3c29a84c261e1ddda25950a.image.png)

## 结构体自引用

如果在结构体内部还要引用自身，那么只能使用指针。

准确来说，在整个引用链上，如果构成循环，那就只能用指针。

如果引用链路很长，你比较难发现这种错误。


![image.png](/static/img/a407f9f8b0d4ca6932b0d95aa8e09dc3.image.png)

## 衍生类型
* 基本语法： type typeA type B

我一般在想使用第三方库，又没有办法修改远吗，又想扩展整个库的结构体的方法的情况下，就用这个。

记住衍生核心：衍生类型是一个全新的类型。

衍生类型可以互相转换，使用（）进行转换

注意：typeB实现了某个接口，不等于TypeA也实现了某个接口


![image.png](/static/img/e8606c4c892f263099a8930f2d25a524.image.png)

## 类型别名
* 基本语法： type TypeA=Type B
    * 别名，除了换了一个名字，没有任何区别
    * 他和衍生类型的区别就是用了=


类型别名一般用在导出类型、兼容性修改里面，也不常见。


![image.png](/static/img/3e892edfef0edc44e313bbf26c04c68e.image.png)


## 结构体实现接口

当看到某个东西走起来像鸭子、有勇气来像鸭子、饺子来也像鸭子，那么这个东西就被称为鸭子。

当一个结构体具备的接口的所有方法的时候，他就实现了这个接口。

![image.png](/static/img/c230ad6733d11d1fd5ad470c7fea831d.image.png)

## 组合
组合是go里面独有的语法概念，基本语法形态是：
```go
type A struct{
    B
}
```
组合可以是以下几种情况：
* 接口组合接口
* 结构体组合结构体
* 结构体组合结构体指针
* 结构体组合接口

可以组合多个。

![image.png](/static/img/6a7ec372bcc572d84d5b2cde897f4c99.image.png)

## 组合的特性
* 当A组合了B之后
    * 可以直接在A上调用B的方法
    * B实现的所有接口，都认为A已经实现了

* A组合B之后，在初始化A的时候将B看做普通字段来初始化
* 组合不是继承，没有多态

右边的例子输出什么？
* hello，inner
* hello，outer

![image.png](/static/img/2d7699ec2bcdaf48741109fdc607fe84.image.png)