望尘可及的秘密基地

课程作业：

论文

夏令营

实习

课程作业：

夏令营

实习准备

课程作业：

夏令营

实习准备

课程作业：

夏令营

实习准备

Polkadot

peaq网络基于polkadot，Polkadot是一个可扩展的异构多链区块链。由一个协作的去中心化区块链网络组成，这个网络叫做中继链，它与并行运行的分片链即平行链交互，所有平行链共享中继链的安全性。

Substrate

一个基于rust的模块化的区块链框架

安装

在WSL中安装，不要在windows下安装！！！由于windows环境和rust的版本会遇到很多坑！

先安装rust，然后clone模板，注意版本，git clone完substrate-node-template和substrate-front-end-template后分别cargo build --release和yarn install

运行

在substrate-node-template中执行./target/release/node-template --dev --tmp，开启一个临时节点

在substrate-front-end-template中执行yarn start，打开可视化界面。

遇到的问题

报错：build error: Rust WASM toolchain not installed, please install it!

解决办法：build前执行rustup target add wasm32-unknown-unknown --toolchain nightly

WASM

WebAssembly（缩写为Wasm）是一种基于栈式虚拟机的二进制指令集，可以作为编程语言的编译目标，使得程序可以在Web上进行客户端和服务器应用的部署

参考资料

知乎专栏-Substrate区块链开发

知乎专栏-Substrate开发快速入门

Substrate开发者中心-substrate安装

csdn-Substrate学习记录

官方-Windows安装Substrate

Docker入门

镜像和容器

使用步骤：

1. 拉取镜像
2. 用镜像创建容器
3. 进入容器

拉取镜像

docker pull imageName:version

可设置镜像加速器

启动容器

新建容器并启动：docker run imageName:version，-i保持io流对容器开放，-t分配终端，--name设置容器名

启动已有容器：docker start containerName

查看容器信息：docker ps -a

停止容器

停止正在运行的容器：docker stop containerName，-t指定等待时间

Docker容器以sh为主进程，执行完启动命令，主进程将停止，容器也将自动终止。

容器启动后不立即停止：

1. 启动命令设置为死循环
2. 启动命令设置为某个一直运行的子进程

进入容器

docker run中-d可以使容器在后台运行

进入一个docker容器的几种方法：

1. 使用ssh登陆进容器；
2. 使用nsenter、nsinit等第三方工具；
3. 使用docker本身提供的工具：exec和attach

先docker run创建容器并让它在后台执行，在用docker attach进入容器内部，其实就是进入容器启动命令的终端

docker exec则可以在容器内部执行一条命令

删除容器

删除终止状态的容器：docker rm containerName

删除运行状态的容器：

1. 先docker stop，再docker rm
2. 强制删除docker rm -f

查看所有容器ID：docker ps –a –q

Docker镜像管理

Commit制作镜像

docker run -p 80:80将主机的80端口映射到容器的80端口

docker commit containerName imageName将容器保存成镜像

保存和加载镜像

保存镜像：docker save imageName1:version imageName2:version > tarName.tar

加载镜像：docker load < tarName.tar

导入导出容器

把容器的文件系统保存为tar包：docker export containerName -o tarName.tar

从tar包导入镜像：docker import tarName.tar imageName:version

删除镜像

docker rmi image，-f表示强制删除

构建私有仓库

创建私人仓库：docker run -d -p 5000:5000 --restart=always --name registry registry:2，-v可以指定仓库位置

镜像加标签：docker tag imageName:version tagName

推送镜像到仓库：docker push tagName，如果tagName正好是主机名:端口号则推送到私人仓库

从私人仓库拉取镜像：docker pull tagName

删除私人仓库：docker rm repoName，-f表示强制，-v表示删除仓库的同时删除其中镜像

Dockerfile

用于构建镜像

FROM和RUN

FROM imgaeName:version指定构建镜像的基础镜像

RUN 命令创建容器并执行命令，命令结束后提交容器为新镜像

build，COPY和ADD

构建镜像：docker build -t foo .，-t指定名字，-f指定Dockerfile

COPY 源路径 目标路径将源路径复制到目标路径，源路径必须为绝对路径

ADD 源路径 目标路径COPY的加强版，可自动解压tar包，自动下载文件等等操作

CMD和ENTRYPOINT

CMD [命令，参数1，参数2]设置容器启动时的默认命令，可被覆盖，可作为ENTRYPOINT的参数

ENTRYPOINT [命令，参数1，参数2]设置容器启动时的默认命令，不可被覆盖

ENV，EXPOSE，WORKDIR和ARG

WORKDIR 路径设置工作目录

ENV key value设置环境变量

ARG argName设置参数，可被之后指令及docker build使用

EXPOSE port1暴露端口，只是一个声明，仍需要在docker run中用-p指定端口

ONBUILD和VOLUME

ONBUILD 其他指令其他指令为RUN，COPY等等指令，当前镜像中不会使用，仅用于下一级镜像构建，不会被继承

VOLUME 路径定义数据卷

缓存

none

Docker数据卷

创建数据卷

docker volume create --name volName创建数据卷

docker run -v /data创建一个随机名字的数据卷，并挂载到容器的/data

docker run -v volName:/data创建volName数据卷，并挂载到容器的/data

挂载和共享数据卷

docker run --name containerName -v /host/dir:/container/dir将主机的/host/dir挂载到/container/dir

docker run --name volName2 --volumes-from volName1创建volName2并与volName1共享数据卷

查看数据卷信息

docker inspect可查看镜像，容器，数据卷等的具体信息

删除数据卷

docker volume rm volName若数据卷仍被使用则无法删除

docekr rm -v containerName删除容器时同时删除数据卷，若数据卷仍被使用则无法删除

删除正在使用的数据卷：

1. docker rm -v containerName解除数据卷和容器的关系
2. docker volume rm volName删除数据卷

备份和恢复数据卷

$(pwd)表示当前目录

docker run --volumes-from CONTAINER_NAME -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /path/to/data将CONTAINER_NAME的/path/to/data备份到主机的当前目录

docker run --volumes-from dbcontainer2 -v $(pwd):/backup busybox tar -xvf /backup/backup.tar -C /dbdata

新容器，旧容器和主机一起实现的数据卷备份和恢复，新容器和旧容器共享，主机数据卷挂载到新主机。

课程作业：

什么是peaq

区块链网络，类似物联网中的以太坊

Rust

环境安装

cargo是rust的包管理器

1. 下载rustup
2. 安装MSVC或MingGW
3. 运行rustup，安装rustc和cargo

I/O

宏规则

println!()和print!()：前面的换行

1

print!("x = {0}", x)

数据类型

整型：i32有符号32位，u64无符号64位

浮点数：默认64位精度

布尔型

字符：一个char有4个字节，用utf-8表示

元组：()

数组：[]

函数

传入参数时需指定类型

1
2
3

fn foo(x:i32, y:u64){
    print!(x, y)
}

函数体表达式：块中最后为一个没有;的表达式，用来返回值

1
2
3
4

fn foo(x:i32) -> i32 {
    x+1
    return x+1;
}

条件语句

条件表达式必须为布尔型，不适用c++中的“非0即真”

可用if-else结构和函数体表达式实现a?b:c的效果

循环语句

无for(int i=0; i<10; i++){}的用法，用while i<10 {i=i+1}代替

可以for x in array.iter(){}或for x in 0..5 {}

无限循环：loop{break ret;}，ret为返回值

重影

重影：指变量的名称可以被重新使用的机制

不可变变量：let a = 123;

可变变量：let mut a = 123;

常量：const a = 123;

重影与可变变量：重影可改变变量的类型，可变属性和值，而可变变量仅可改变值

所有者

为了让 Rust 在编译阶段更有效地分析内存资源的有用性以实现内存管理而诞生的概念

所有权有以下三条规则：

• Rust 中的每个值都有一个变量，称为其所有者。
• 一次只能有一个所有者。
• 当所有者不在程序运行范围时，该值将被删除。

变量范围：从声明变量开始有效直到变量所在域结束

移动

1
2

let a = xxx;
let b = a;

对以上情况有：

1. 栈中：基本数据，直接复制成两份数据，比如整型，浮点数等等
2. 堆中：不定长数据，将释放前一变量，比如string等等

克隆

对于上面堆中数据确实需要复制成两份的情况，可以这样做：

1
2

let a = String::from("helloRust");
let b = a.clone();

传参

同移动，基本数据传完后依旧可以使用，不定长数据传完即被移动

引用

1
2

let s1 = String::from("hello");
let s2 = &s1;

这里s1并不会被释放，s2指向s1，s1再指向堆中的数据。

引用仅租借所有权，如果所有权移动了则需要重新租借。

可变引用可以修改原变量的值let b = &mut a;

可变引用不允许多重引用，但不可变引用可以。

垂直引用

指针指向NULL或者被释放的变量。

Rust中不允许垂直指针存在。

切片

let part = &str[0..5];

切片结果必须是引用类型。

..y，x..，..都是符合语法的。

被切片的变量禁止修改值。

String和str：不一样的类型，切片结果都是&str类型

可以通过&string[..]将String转换成str

结构体

1
2
3
4
5
6
7
8
9
10

struct Foo{
    name: String,
    Age: u32
}
// 定义Foo
let a = Foo{
    name: String::from("henry"),
    Age: 18
};
//实例化Foo

1
2
3
4
5
6
7

//结构体更新
let b = Foo2{
	name: String::from("five"),
	..a
};
//b的Age和a不同，其他字段相同
//能不能完全复制，直接..a

1
2
3
4
5

//元组结构体
struct Color(u8, u8, u8);
let black = Color(0,0,0)
//通过下标访问
println!("{}", black.1);

1
2
3
4
5
6
7
8
9
10

//输出结构体
#[derive(Debug)]

struct Rectangle {
    width: u32,
    height: u32,
}

println!("{:?}", Rectangle);
println!("{:#?}", Rectangle);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//结构体方法
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}
//结构体关联函数，不依赖实例
impl Rectangle1 {
    fn create(width: u32, height: u32) -> Rectangle {
        Rectangle{width, height}
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    println!("rect1's area is {}", rect1.area());
}

生命周期

重要，但没细看qaq

1
2
3
4

//生命周期注释
&i32        // 常规引用
&'a i32     // 含有生命周期注释的引用
&'a mut i32 // 可变型含有生命周期注释的引用

静态生态周期：’static，生命周期为程序运行期间

1
2
3
4
5
6
7
8
9
10
11
12
13

//泛型+特性+生命周期
use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
    where T: Display
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

泛型与特性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//函数中泛型
fn max<T>(array: &[T]) -> T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i] > array[max_index] {
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}
//<T>
//可以用<T1, T2>表示不同数据类型

//结构体，枚举类和方法中泛型
//struct Foo<T>{}
//impl<T> Foo<T>{}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

//特性
trait Descriptive {
	fn decribe(&self) -> String {
        //默认特性
    	String:: from("[Object]")
    }
}

struct Foo {
    name: String,
    age: u8
}

impl Descriptive for Foo {
    fn describe(&self) -> String{
        //重新定义特性
        format!("{} {}", self.name, self.age)
    }
}
//特性作为函数参数，这样在函数内可调用该特性规范的方法
fn output<T: Descriptive>(object: T) {
    println!("{}", object.describe());
}
fn output_two<T: Descriptive>(arg1: T, arg2: T) {
    println!("{}", arg1.describe());
    println!("{}", arg2.describe());
}
//多个特性
fn notify(item: impl Summary + Display)
fn notify<T: Summary + Display>(item: T)
//可以简化
fn some_function<T, U>(t: T, u: U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
//特性做返回值，
//特性做返回值只接受实现了该特性的对象做返回值
//且在同一个函数中所有可能的返回值类型必须完全一样
fn person() -> impl Descriptive {
    Person {
        name: String::from("Cali"),
        age: 24
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//泛型+特性例子
trait Comparable {
    fn compare(&self, object: &Self) -> i8;
}

fn max<T: Comparable>(array: &[T]) -> &T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i].compare(&array[max_index]) > 0 {
            max_index = i;
        }
        i += 1;
    }
    &array[max_index]
}

impl Comparable for f64 {
    fn compare(&self, object: &f64) -> i8 {
        if &self > &object { 1 }
        else if &self == &object { 0 }
        else { -1 }
    }
}

fn main() {
    let arr = [1.0, 3.0, 5.0, 4.0, 2.0];
    println!("maximum of arr is {}", max(&arr));
}

课程作业：

培养方案

准备按着培养方案整理一下

数学课程

数学分析

高等代数

离散数学

概率论

信息安全数学基础（数论+抽象代数）

信号与系统

信息论

现代密码学

图论

专业课程

C/C++

计算机组成原理

数据结构与算法

操作系统原理

计算机网络

人工智能原理

移动互联网

数据库系统

计算机体系结构

分布式系统

模式识别与计算机视觉

人工神经网络

云计算技术

专业综合实践

网络安全技术

电子商务安全

网络协议逆向分析

屁用没有

PS. 个人感觉

讲座

数字电路

大学物理

工程训练