book

xq_study/golang.md

@@ -0,0 +1,141 @@
+
+
+---
+
+2022/01/21
+
+### go语言学习
+
+2007年9月开始设计，2009年11月推出
+
+每年半年发布一个二级版本
+
+- Go 1.0 — 2012 年 3 月
+  Go 的第一个版本，带着一份兼容性说明文档来**保证与未来发布版本的兼容性**，进而不会破坏已有的程序
+
+- Go 1.1 — 2013 年 5 月
+  这个 Go 版本专注于**优化**语言（编译器，gc，map，go 调度器）和提升它的性能
+
+- Go 1.2 — 2013 年 12 月
+  本版本中 test 命令支持测试代码覆盖范围并提供了一个新命令 go tool cover ，此命令能测试代码覆盖率
+
+- Go 1.3 — 2014 年 6 月：
+  这个版本对栈管理做了重要的改进。栈可以申请连续的内存片段，提高了分配的效率，使下一个版本的栈空间降到 2KB
+
+- Go 1.4 — 2014 年 12 月：
+  此版本带来了官方对 Android 的支持，golang.org/x/mobile ) 让我们可以只用 Go 代码就能写出简单的 Android 程序
+  Go 也提供了 go generate 命令通过扫描用 //go:generate 指示的代码来简化代码生成过程
+
+- Go 1.5 — 2015 年 8 月：
+  **实现了自举**
+  这个新版本，发布时间推迟了两个月，目的是在以后每年八月和二月发布新版本
+  这个版本对 gc 进行了重新设计
+  这个版本也发布了运行时追踪，用命令 go tool trace 可以查看
+
+- Go 1.6 — 2016 年 2 月:
+  这个版本最重大的变化是使用 HTTPS 时默认支持 HTTP/2
+  在这个版本中 gc 等待时间也降低了
+
+- Go 1.7 — 2016 年 8 月:
+  这个版本发布了 context 包，为用户提供了处理超时和任务取消的方法
+  对编译工具链也作了优化，编译速度更快，生成的二进制文件更小，有时甚至可以减小 20% 到 30%
+
+- Go 1.8 — 2017 年 2 月:
+  把 gc 的停顿时间减少到了 1 毫秒以下：其他的停顿时间已知，并会在下一个版本中降到 100 微秒以内
+  这个版本也改进了 defer 函数
+
+- Go 1.9 — 2017 年 8 月:
+  这个版本支持下面的别名声明：type byte = uint8
+  **sync 包新增了一个 Map 类型，是并发写安全的**
+
+- Go 1.10 — 2018 年 2 月:
+  test 包引进了一个新的智能 cache，运行会测试后会缓存测试结果。如果运行完一次后没有做任何修改，那么开发者就不需要重复运行测试，节省时间。
+  为了加快构建速度，go build 命令现在也维持了一份最近构建包的缓存。
+
+- Go 1.11 — 2018 年 8 月:
+  带来了一个重要的新功能**包管理：Go modules**
+  第二个特性是实验性的 WebAssembly，为开发者提供了把 Go 程序编译成一个可兼容四大主流 Web 浏览器的二进制格式的能力
+
+- Go 1.12 — 2019 年 2 月:
+  基于 analysis 包重写了 go vet 命令，为开发者写自己的检查器提供了更大的灵活性
+
+- Go 1.13 — 2019 年 9 月:
+  改进了 sync 包中的 Pool，在 gc 运行时不会清除 pool。它引进了一个缓存来清理两次 gc 运行时都没有被引用的 pool 中的实例。
+  重写了逃逸分析，减少了 Go 程序中堆上的内存申请的空间。
+
+- Go1.14 - 2020 年 2 月：
+  现在 Go Module 已经可以用于生产环境，鼓励所有用户迁移到 Module。
+  该版本支持嵌入具有重叠方法集的接口。
+  性能方面做了较大的改进，包括：进一步提升 defer 性能、页分配器更高效，同时 timer 也更高效。
+  Goroutine 支持异步抢占。
+
+- Go1.15 - 2020 年 8 月：
+  Go 链接器现在具有更低的资源使用量，更快的速度以及更高的代码质量。通常，对于大型Go应用程序，链接过程比之前快 20％ 左右，而内存使用消耗减少 30％ 左右.
+  Go 1.15 二进制文件比Go 1.14 小约5％.
+  Go 对 ARM / ARM64 有了更好的 OpenBSD 支持
+  现在使用更高内核数的系统，分配的小对象要比之前版本快很多.
+
+- Go 1.16 — 2021 年 2 月:
+  embed 包和 //go:embed 指令
+  增加对 macOS ARM64 的支持
+  默认启用 Module
+  io/fs 包，不建议使用 io/ioutil 了，因为其中的内容移到 os 和 io 包了
+
+- Go 1.17 — 2021 年 8 月:
+  **基于寄存器的调用惯例**替代基于堆栈的调用惯例
+  增加对 Windows ARM64 的支持
+  新的 //go:build 新版构建约束格式化支持
+  go.mod 优化
+  标准库的一些改进
+
+- Go1.18 - 2022 年初：
+  如果您正在更新您的软件包以使用**泛型**，请考虑将新的泛型API隔离到自己的文件中，并为其使用Go 1.18的构建标签（//go:build go1.18），以便Go 1.17用户可以继续构建和使用非泛型部分。
+
+
+
+- 线上编译环境<https://go.dev/play/>
+
+- 本地编译环境
+
+  - goup（功能方便；对于国内网络比较友好）
+
+  - <https://github.com/owenthereal/goup>
+
+  - 如果用线上脚本安装不成功，就用手动安装
+
+  - ```shell
+    ~ % goup --help
+    The Go installer
+    
+    Usage:
+      goup [flags]
+      goup [command]
+    
+    Available Commands:
+      default     Set the default Go version
+      help        Help about any command
+      install     Install Go with a version
+      ls-ver      List Go versions to install
+      remove      Remove Go with a version
+      show        Show installed Go
+      upgrade     Upgrade goup
+      version     Show goup version
+    
+    Flags:
+      -h, --help      help for goup
+      -v, --verbose   Verbose
+    
+    ~ % goup install 1.17.6
+    
+    ~ % goup show
+    |  VERSION  | ACTIVE |
+    |-----------|--------|
+    |  1.17.6   |        |
+    | 1.18beta1 |   *    |
+    
+    ~ % go version
+    go version go1.18beta1 darwin/arm64
+    
+
+- 
+

xq_study/readbook.md

@@ -1,20 +1,24 @@
 
-2021/12
+
+
+
+---
+
+2022/01
 
 ### 函数式编程笔记
 
-- 函数式编程主要解决的问题（通过历史预测未来）
+- 函数式编程主要解决的问题
 
   - 代码复杂度
-  - 线程管理
-  - 迭代
+  - 线程管理、迭代
   - 分布式计算颗粒度
-
+  
 - 编程语言是工具（简化程序复杂度）模块化问题
 
   - 软件开发的工具，团队协作软件开发的工具
   - 使用工具到顶了，功能复杂度hold人脑不住了，就要换新工具（人脑几十年的时间不会有什么进化）
-  - 应用软件开发：结构化编程(模块化) -> 面向对象 -> 函数式编程；可以看到这个路线就是对“**状态**”的限制使用之路
+  - 应用软件开发：通过历史看未来，结构化编程(模块化) -> 面向对象 -> 函数式编程；可以看到这个路线就是**对“状态”的限制**使用之路
   
   
   
@@ -148,7 +152,7 @@
 
     - 当我们知道有些代数结构具有一些很好的性质，满足某些定律。那如果我们写的程序具有这些代数结构，则这些程序也自然就具有同样的性质，满足同样的定律，可以应用同样的规则。例如**幺半群**![[公式]](https://www.zhihu.com/equation?tex=%28M%2C+id%2C+%5Coplus%29)满足结合律，即![[公式]](https://www.zhihu.com/equation?tex=a+%5Coplus+%28b+%5Coplus+c%29+%3D+%28a+%5Coplus+b%29+%5Coplus+c)，也就是和结合的次序无关。我们知道列表类型 [a] 是一个幺半群，当我们将列表[a1, a2, a3, a4]内的所有元素相加时，我们可以先计算b = a1 + a2, c = a3 + a4，然后再计算sum = b + c。这样在多核CPU的情况下，我们可以让CPU1计算b = a1 + a2，让CPU2计算c = a3 + a4，再让CPU1计算最后的结果sum = b + c。这样我们就实现了4个元素的并行求和运算，有n个元素的求和运算也可按这种方式并行化。若我们的另一个数据类型也同样具有幺半群的代数结构，则这个数据类型的![[公式]](https://www.zhihu.com/equation?tex=%5Coplus)运算同样具有并行计算的能力。范畴论在这方面则起到了重要的理论指导作用，我们可以将范畴论中得到的范畴的代数性质和定律应用到函数式编程中，通过类型系统以新的方式来构造我们的程序。
 
-    - 柯里化和反柯里化是一对**同构变换**，其变换得到的函数是唯一的。也可以将柯里化和反柯里化看成是普通函数和高阶函数之间的变换，柯里化具有升阶的作用，而反柯里化则具有降阶的作用。
+    - 柯里化和反柯里化是一对**同构变换**，其变换得到的函数是唯一的。也可以将柯里化和反柯里化看成是普通函数和高阶函数之间的变换，柯里化具有升阶的作用，而反柯里化则具有降阶的作用。这样单参数函数和多参数函数在参数形式上**就没有区别了**，具有统一的形式，从而可以放在同一个列表中，也可以串在一起。
   
     - 范畴论是从拓扑学这一数学分支发展出来的一门抽象的数学理论，后来成为一个独立的分支，并成为了其他数学分支的基础。再后来，和**类型理论**结合，成为了**编程语言理论的数学基础**，因此我们才会在这里来介绍范畴论。但是，学习范畴论却是不需要学习拓扑学也是可以的，学习编程也是可以不学习范畴论。
   
@@ -197,31 +201,32 @@
 
   - **函子(Functor)**
 
-    - 函子是范畴之间的map关系。可以理解为范畴之间的态射。
-    - 图中，函数`f`完成值的转换（`a`到`b`），将它传入函子，就可以实现范畴的转换（`Fa`到`Fb`）。
+    - 函子是范畴之间的关系。可以理解为范畴之间的态射。
+    - 图中，函数`f`完成object的转换（`a`到`b`），将它传入函子，就可以实现范畴的转换（`Fa`到`Fb`）。
     - ![bg2017022211](./img_readbook/bg2017022211.jpg)
-    - 具有`map`方法的数据结构，都可以当作函子的实现。代码中，`Functor`是一个函子，它的`map`方法接受函数`F`作为参数，然后返回一个新的函子，里面包含的值是被`F`处理过的（`F(this.val)`）。
     - 范畴之间的态射，得到函子，由函子之间的态射，得到自然变换
     - 函子 F 将简单类型a 构造为复杂类型 F a，将简单类型的函数 f 变换为复杂类型的函数 F f；**类型构造子只有同时变换类型和函数，且满足函子定律时，才是一个函子。函子的用处**是将简单类型的函数通过类型构造子提升为复杂类型的函数，且不需要写额外的代码，使得一些基本函数可以应用到多种复杂数据类型的成员中，提高了这些基本函数的**重用性**。
-
-    - Maybe 函子
+- Maybe 函子
     - Either 函子(运算`if...else`)
     - ap函子，函子里面包含的值，完全可能是函数。我们可以想象这样一种情况，一个函子的值是数值，另一个函子的值是函数。
     - 协变函子 F:C→D
-
-      - 对于每一个 C 中的对象x，对应一个 D 中的F(x)。
+    
+  - 对于每一个 C 中的对象x，对应一个 D 中的F(x)。
       - 对于每一个C中的态射f:x→y，对应D的态射F(f):F(x)→F(y)。
     - 逆变函子
-
-      - 和协变函子类似，只不过态射的方向是从D到C。
+    
+  - 和协变函子类似，只不过态射的方向是从D到C。
     - 自然转换(Natural transformation)
       - 自然转换是两个函子之间的关系。函子描述“自然构造(natural constructions)”，自然转换描述两个这样构造的"自然同态(natural homomorphisms)"。
+    - 
 
     
 
+  - 编程实践
+
     - Map-Reduce-Filter 模式
 
-    - Continuation 顺延
+    - Continuation 延续
 
     - ```java
       System.out.println("Please enter your name: ");
@@ -651,9 +656,7 @@
     
 
 
-
-  - 例子
-
+- 例子
 
     - ```java
         abstract class MessageHandler {
@@ -681,6 +684,9 @@
             }
         }
         ```
+        
+    
+    
     
     - ```java
         class MessageHandler {
@@ -833,6 +839,7 @@
         
         ```
     
+    
     - ```java
         @Configuration
         public class RouterConfig {
@@ -848,123 +855,23 @@
         
         ```
     
-    - 再来一个例子
-    
-    - ```java
-        @Component
-        public class UserHandler {
-        
-            @Autowired
-            private ReactiveRedisConnection connection;
-        
-            public Mono<ServerResponse> getTime(ServerRequest request) {
-                return ServerResponse.ok().contentType(MediaType.TEXT_PLAIN)
-                        .body(Mono.just("Now is " + new SimpleDateFormat("HH:mm:ss").format(new Date())), String.class);
-            }
-            public Mono<ServerResponse> getDate(ServerRequest request) {
-                return ServerResponse.ok().contentType(MediaType.TEXT_PLAIN)
-                        .body(Mono.just("Today is " + new SimpleDateFormat("yyyy-MM-dd").format(new Date())), String.class);
-            }
-        
-            public Mono<ServerResponse> sendTimePerSec(ServerRequest request) {
-                return ServerResponse.ok().contentType(MediaType.TEXT_EVENT_STREAM)
-                        .body(Flux.interval(Duration.ofSeconds(1)).map(l -> new SimpleDateFormat("HH:mm:ss").format(new Date())), String.class);
-            }
+    - 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
-​        
-            public Mono<ServerResponse> register(ServerRequest request) {
-                Mono<Map> body = request.bodyToMono(Map.class);
-                return body.flatMap(map -> {
-                    String username = (String) map.get("username");
-                    String password = (String) map.get("password");
-                    String hashedPassword = BCrypt.hashpw(password, BCrypt.gensalt());
-                    return connection.stringCommands()
-                            .set(ByteBuffer.wrap(username.getBytes()), ByteBuffer.wrap(hashedPassword.getBytes()));
-                }).flatMap(aBoolean -> {
-                    Map<String, String> result = new HashMap<>();
-                    ServerResponse serverResponse = null;
-                    if (aBoolean){
-                        result.put("message", "successful");
-                        return ServerResponse.ok()
-                                .contentType(MediaType.APPLICATION_JSON_UTF8)
-                                .body(BodyInserters.fromObject(result));
-                    }else {
-                        result.put("message", "failed");
-                        return ServerResponse.status(HttpStatus.BAD_REQUEST)
-                                .contentType(MediaType.APPLICATION_JSON_UTF8)
-                                .body(BodyInserters.fromObject(request));
-                    }
-                });
-        
-            }
-        
-            public Mono<ServerResponse> login(ServerRequest request) {
-                Mono<Map> body = request.bodyToMono(Map.class);
-                return body.flatMap(map -> {
-                    String username = (String) map.get("username");
-                    String password = (String) map.get("password");
-                    return connection.stringCommands().get(ByteBuffer.wrap(username.getBytes())).flatMap(byteBuffer -> {
-                        byte[] bytes = new byte[byteBuffer.remaining()];
-                        byteBuffer.get(bytes, 0, bytes.length);
-                        String hashedPassword = null;
-                        try {
-                            hashedPassword = new String(bytes, "UTF-8");
-                        } catch (UnsupportedEncodingException e) {
-                            e.printStackTrace();
-                        }
-                        Map<String, String> result = new HashMap<>();
-                        if (hashedPassword == null || !BCrypt.checkpw(password, hashedPassword)) {
-                            result.put("message", "账号或密码错误");
-                            return ServerResponse.status(HttpStatus.UNAUTHORIZED)
-                                    .contentType(MediaType.APPLICATION_JSON_UTF8)
-                                    .body(BodyInserters.fromObject(result));
-                        } else {
-                            result.put("token", "无效token");
-                            return ServerResponse.ok()
-                                    .contentType(MediaType.APPLICATION_JSON_UTF8)
-                                    .body(BodyInserters.fromObject(result));
-                        }
-                    });
-                });
-            }
-        }
-        
-        ```
-    
-    - ```java
-        
-        @Configuration
-        public class RouterConfig {
-        
-            @Autowired
-            private HelloWorldHandler helloWorldHandler;
-        
-            @Bean
-            public RouterFunction<?> helloRouter() {
-                return RouterFunctions.route(RequestPredicates.GET("/hello"), helloWorldHandler::helloWorld);
-            }
-        
-            @Autowired
-            private UserHandler userHandler;
-        
-            @Bean
-            public RouterFunction<ServerResponse> timerRouter() {
-                return RouterFunctions.route(RequestPredicates.GET("/time"), userHandler::getTime)
-                        .andRoute(RequestPredicates.GET("/date"), userHandler::getDate);
-            }
-        
-            @Bean
-            public RouterFunction<?> routerFunction() {
-                return RouterFunctions.route(RequestPredicates.GET("/hello"), helloWorldHandler::helloWorld)
-                        .andRoute(RequestPredicates.POST("/register"), userHandler::register)
-                        .andRoute(RequestPredicates.POST("/login"), userHandler::login)
-                        .andRoute(RequestPredicates.GET("/times"), userHandler::sendTimePerSec);
-            }
-        }
-        ```
-    
-    - 
 
 
 
@@ -1032,7 +939,7 @@
       - 功能独立的模块（GUI和计算逻辑）（隔离）
       - 多资源（多I/O设备）
 
-  
+ 
 
   - 复杂软件系统设计的要素
     - 表示法（编程语言，影响复杂度）（表现力，阿拉伯数字表示法）
@@ -1085,8 +992,6 @@
     - 函数重载带来的还有两个常见的特性，**多态性和强制类型转换**；在面向对象语言中，会有继承的**子类型的多态性以及强制转换**，比如一个接受接口类型参数的方法，可以通过传递一个子类类型来调用。还有一种多态称之为**类型化参数的多态性**（通常我们称之为“泛型”）
 
 
-
-
 - 控制流
 
   - 顺序执行，选择，迭代，过程抽象，递归，并发，无顺序