fn main() {
  let needle = 42;
  let haystack = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862]; 
    
  for reference in haystack.iter() {
    let item = *reference;
    if item == needle {
      println!("{}", item); // 42
    }
  }
}

字符串

Rust中，str和String是两种不同的数据类型，特别容易搞混，str是字符串切片类型，是一个不可变引用，而String是字符串类型，是一个可变的字符串。

fn main() {
  // 使用字符串字面量创建一个str类型的字符串切片
  let str_slice = "Hello, World!";
  println!("str_slice: {}", str_slice);
  // 尝试修改str_slice会发生报错

  // 使用String结构体创建一个可变的字符串
  let mut string = String::from("Hello");
  println!("string: {}", string);

  // 修改String类型的字符串
  string.push_str(", World!");
  println!("string: {}", string);
    
  // String -> &str
  let s1 = String::from("PKU");
    
  let s2 = &s1[..];
  let s3 = s1.as_str();
  
  // &str -> String
  let s4 = "THU";
  
  let s5 = s4.to_string();
  let s6 = String::from(s4);
  let s7 = s4.to_owned();
}

还有更多就没写了，还是得多练练。

2024春夏季开源操作系统训练营第一阶段总结报告-frezcirno

Posted on 2024-04-27 Edited on 2025-05-19 In 2024春夏季开源操作系统训练营

训练营第一阶段主要是通过上课以及Rustlings练习的方式学习Rust语言。Rust语言在学校的时候已经学过一遍了所以做起来还算轻松。

Rust语言学习心得

在学习Rust语言的过程中，我深深地感受到了这门语言的独特之处以及学习的挑战。通过完成第一阶段的Rustlings练习和复习Rust语法知识，我收获了许多宝贵的经验和见解。

Rustlings

Rustlings是学习Rust非常好的资料。

通过解决各种练习题，我不仅熟悉了Rust语言的基本语法，还学会了如何处理各种常见的编程问题。尤其是在处理字符串和迭代器等常见操作时，我学会了如何巧妙地利用Rust语言特性来简化代码，提高效率。

第一遍做的时候以为全过，过了n久才发现fail了三道，飞速赶工修好了。。。

另外，Copilot和ChatGPT真的非常好用。

未来期望

希望能够入门Rust-for-linux，真正在各种现实项目中用起来Rust。

2024Spring-Rcore-schedule1-GYHPCG

Posted on 2024-04-27 Edited on 2025-05-19 In report

第一阶段总结

回顾

这是第二次参加rcore训练营了，上一次的时候是2023秋季的时候,那时候还没有学过rust,也不知道risc-v。而是在学过操作系统课后，想要找一个操作系统实验来做，锻炼自己。因为自己平时很喜欢c++，而各种地方都在不断拿Rust和C++对比，因而开始去接触Rust,也因此，正巧碰上了2023秋季rcore训练营的开启。去年时间很短，个人基础也很差，所以学得很费劲，磕磕绊绊才把第二阶段过了。刚到第三阶段，碰上了期末周，导致没有继续持续下去，很是遗憾。所以又在等啊等啊，2024年春季的rcore终于开始了……。

rustling

由于上次做过，所以本次的前一百道题做得很顺利，花费的时间很少。直到今年多出来的10道算法题，其实思想也是很简单，就是用Rust来写很让我难受。尤其第一题的链表，让我实在……，用c++写得挺感觉很简洁或者轻松。但rust写起来……拖着最后还是不得不写完了。

Rust

Rust算是我学过的一种蛮特别的语言。开始C->C++->Java/python。我感觉基础语法什么的基本都差不多。但是Rust确实是给我的感觉不太一样，风格不一样。但学的时候，却是在不断对比C++来学习，学起来确是不断加深对两门语言的印象。总之Rust促使C++更多思考安全！,但对Rust也越来越喜欢了。总之，两个我都要。

第二阶段好好搞！！！

2024春夏季操作系统训练营一阶段总结-Renli

Posted on 2024-04-27 Edited on 2025-05-19 In 2024春夏季开源操作系统训练营

Rustlings 学习感悟

不得不说，Rust对于我这种只会C/C++的语言的人来说还是很有一定难度的，这种难度来自于对于函数式编程的不熟悉。但一旦熟悉后就感觉到了函数式编程的便捷，特别是迭代器的处理。同时这也增加了一些压力，相较于啥都自己手写的C/C++，Rust等函数编程语言的重点则是熟悉各种各样的函数方法，有时候自己冥思苦想几天的代码，一个简单的函数就能解决，这种经历还是很难受的。

Rust语言除去函数编程以及一些语法糖之外，令人啧啧称道的就是他的安全机制了。确实，初次接触Rust感觉十分惊艳，觉得取代C/C++只是时间问题。但做过Rustlings后，感觉到可能这还是存在一些距离。一方面对于程序员要求太高了，难度感觉比C/C++高出了很多，另一方面尽管尽力屏蔽了底层，但却不得不使用一些unsafe的代码块实现底层操作，导致有点emmm怪怪的。

难度方面，我感觉Rustlings中的algorithm系列题目可以展现出Rust的“刁钻之处”，特别是对泛型T的处理。由于泛型T既可能有Copy也有可能有Clone，这导致很多常规的赋值方法并不能使用，在老师的讲解中我了解到了

1 2	let mut k = T::default(); std::mem::swap(&mut k, &mut self.data[self.top]);

这种写法，但实际使用中还是存在很多限制。不过经过思考和练习，发现很多赋值是可以优化的，特别是在使用相对应的数据结构的方法。感觉这其实有点像编译器强制程序员思考优化代码（被鞭策的感觉。

底层操作方面，则主要还是指针的使用，不得不说，链表之类的使用指针写代码是真的快。不过网上关于这个争议还是蛮多的，我有一段实现safe的双向链表代码，可惜这里太小了粘不下（笑

Rustlings 感觉练习还是蛮不错的，对于我这种0基础的学生来说，三四天看完b站课程后刷完成就感还是蛮强的（虽然看了不少题解，特别是经过最后algorithm部分的练习，感觉自己算是初步入门了Rust

RCore 学习感悟

作为一个只会408操作系统的电子学生，很早之前就想从代码阶段了解操作系统的构成，很感谢训练营能够给我这次机会。

但不得不说，使用Rust语言实现的RCore对我这种只会C语言的难度有点大，各种各样的闭包、智能指针让我看得经常找不到北。坦白来说，就算经过RCore的学习，RCore的很多细节我仍然不是很熟悉，只能说大概框架是有的，这一方面是因为操作系统的本身难度，作为一个之前没有太多接触操作系统的学术，这样一个包含汇编、C语言、Rust的大型工程实在是令人压力山大，另一方面则是Rust本身的难度，这语言是有点抽象的（o(╥﹏╥)o），本以为经过Rustlings学习能够大展拳脚，结果发现自己只是入门的阶段，经常忘记用闭包，函数式编程的思想，常常都是C语言的编程逻辑（还是自己太菜了）。

不过，经过RCore的学习我还是收获颇丰，不仅精进了我的Rust技术，更是极大地扩充了我的操作系统知识，原先只能死记的知识点，现在又有了不一样的理解，比如说管道的实现、内核态和用户态的地址，另外也学习到的书本上很少涉及的知识，比如说用户态空间与内核态空间分离（RCore称之为双页表），SV39多级页表机制等等。

经过RCore学习也能感受到自己的不足，特别是汇编部分，不得不说RCore的汇编涉及太巧妙了，经常是读下来感觉耳目一新，醍醐灌顶。希望以后有机会还能参加编译器的训练营。

2024春夏季开源操作系统训练营第一、二阶段总结报告-kami

Posted on 2024-04-27 Edited on 2025-05-19

一阶段小结

这是我第二次参加了，秋冬季的时候二阶段适逢期中考试，完成的不是很好，三阶段也没有参加。这次期中考试和一阶段又撞一起了，挑了时间一口气赶进度是相当的折磨。

通过rustlings可以快速对Rust的特性进行了解，但是感觉学习的效果并不是非常的好，题目做过之后就忘的差不多了，归根到底还是一直用cpp而不习惯使用rust，在学习的时候很容易在想”这个东西就相当于cpp里的…”

最后几个算法题挺有意思的，做起来也很头疼- -

一阶段暂且告一段落，虽然笔记做了一大堆，但是实际上大部分是复制文档内容和代码样例，勉勉强强算给自己制造完成了很多工作量的错觉来给自己一点正反馈吧。

二阶段小结

写在开头，如果没有rust-analyzer，我可能对着这一大堆东西愣半天也写不了几段正确且符合逻辑的代码。

做PA的时候总是看到强调要多RTFSC，这确实是相当的重要。所以刚开始的时候对着指导书，并结合源码，把每一个模块的实现的源码阅读了一遍，虽然并不是自己敲的，而且有的地方也不是很理解为什么要这么写，但是总体上有了大概的了解，不至于那么的无从下手。

这个学期学校课程安排开设了操作系统课程，相比于秋冬季时没有系统的学习操作系统而直接开始阅读Tutorial来说，这一次重新阅读，结合课本的相关知识，这些概念和代码实现亲切了许多。

简单说说在各个章节中的收获：

多道程序

本章学习了任务相关的知识，包括任务切换，任务调度，任务控制块TCB数据结构的设计等，相比于课本上生硬地写出TCB需要保存的内容来说，使用代码实现TCB的设计可以有了更加深刻的理解。

实践作业实现了一个新的系统调用 sys_task_info 用以获取当前正在运行的任务的信息。

地址空间

印象最深的是SV39多级页表。类似于字典树(Trie)，大大节省了占用的内存空间。
还有虚拟内存的相关概念，虚拟内存和物理内存的转换。

实践作业实现了 mmap 和 munmap 匿名映射，简化了实现，仅用于申请内存。
主要是要RTFSC，在其他的系统调用中查看如何转换地址，如何查页表。

进程

进程和线程在学校课程学习中是很重要的一部分，本章介绍了进程的概念和相关系统调用，并进行进程管理和进程调度。

实践作业包括两个：

实现spawn
虽然好像 fork+execve!=spawn，但是我的实现就是把fork的代码复制下来，然后和execve的代码进行了一个缝合…
实现stride调度
发现了ci的一个bug，即实际上如果只实现了set_priority这个用于设置优先级的系统调用，并没有去实现调度的话也可以通过ci测试…

文件系统

印象非常的深刻的是Unix哲学的一切皆文件

本章的内容相当的多，因为文件系统比较复杂，读起来非常的费劲而且读完就容易忘…

只记得bitmap，inode啥的了2333，在PA中实现过read，open，seek等操作，印象也不是很深刻了，当时好像是可以将不同类型的文件用统一的接口来进行读写操作。

实践作业实现了linkat和unlinkat，关于fstat，在计算inode时遇到了一些困难…

并发

首先介绍了用户态和内核态的线程管理。
线程的并发问题是老生常谈了，用了锁，信号量，条件变量等进行线程同步互斥管理。

实践作业实现死锁检测，一开始就把这个认为是银行家算法，但是潜水看群里大佬们聊天说并不是，只是用了银行家算法的思想，再想了想课本上学习的，好像确实…

比较麻烦，一开始无从下手，因为不知道资源数量，需求资源啥的需要在哪里定义。

小结的小结

二阶段的编程小练习涵盖了操作系统设计的几个重要方面，我认为二刷甚至多刷也是有价值的-。-

三阶段小结

项目3 Rust for Linux & 跨内核驱动框架

练习一配环境

工欲善其事，必先利其器。

万事开头难，确实如此。在配环境上折腾了好久，一开始用WSL，但是对于图形界面的支持不够以致QEMU界面始终是黑屏- -…又改用虚拟机，但是性能很差，编译一次要花费好长时间，虽然可以显示画面了，但是到练习二的时候又出现了画面卡死动不了的问题- - …

有群友使用docker整了一个环境，也整下来试了一下，但是被mac的大小写问题给坑了一下，到最后也没配好

最后得到的最优解是在WSL启动QEMU时使用 vnc 进行连接。

算一下为了配好环境前前后后折腾了好几天，编译了不下十几次- -

练习二实现Miscdev驱动基本读写

本学期学校开设的操作系统课程实验也使用了树莓派进行内核编程，其上烧写的是OpenEuler。于是对于内核模块的编写多少有一点亲切感。

完善了open/read/write的内容，使得杂项字符设备可以实现基本读写操作。

练习三跨内核驱动框架下的树莓派4B GPIO点灯实现

一开始一头雾水，不知道要怎么下手，又遇上期末考试，于是就暂时搁置了。

考试周结束后又重新捡了起来，去课堂看了之前的回放才知道了如何把写的pure driver编译进内核。

在pure driver中要做的事情主要是完成树莓派的所有寄存器的抽象。(阅读树莓派的手册很重要)

然后在Adapter driver中把寄存器映射到内存地址，通过对于地址的操作，进而控制寄存器，达到GPIO口的电平和输出模式等等的目的。

1	let mapped_base = unsafe { bindings::ioremap(BCM2837_GPIO_BASE, GPIO_SIZE) };

在Arceos上的操作也类似，pure driver可以直接复用，但是要把osl相关的东西给换掉。在映射地址时多了个物理地址转为虚拟地址的操作。

1	let mut gpio_map=RpiGpioPort::new(phys_to_virt((gpio_base as usize).into()).as_mut_ptr());

文档给的点灯驱动参考非常的详细，照着做基本上就能够正常运行起来。（但是有的地方还是不理解为什么要这么操作）

总结

本次训练营的学习内容相当丰富，学到了很多新知识，以及探索了之前没有涉足过的领域。
但是由于课业等等压力，一直都算是在闲时才来跟一下训练营的进度，因此各方面感觉自己学的不够扎实，学习深度也有限，仍需要继续沉淀…
总结就是要多读源码，多看手册，不要因为嫌麻烦偷懒不看- - 问就是在这方面吃了很多的教训，有的问题想好久想不明白，这里为啥这么写？这个寄存器为啥这么操作？最后一看手册里写的清清楚楚的…

我们旅行时不要像个信使一样，而应当像个探险家一样。我们不仅要考虑起点和终点，还得考虑起点和终点之间的距离

~

繋がる空の下
さあ自分らしく進もう
始まりの歌贈るよ
歩き出す君へ
–献给此刻迈步前行的你

Author:
kami
Xiamen University

2024春季开源操作系统训练营一阶段总结

Posted on 2024-04-27 Edited on 2025-05-19 In report

Rust学习经验

作为经验分享，我不会写太多，一小篇足以

前言

Rust作为新时代的语言，其语法特性相对于以前的语言有着较大的差别，而且目前的Rust教程都是非常繁琐且没有梳理出一条很好的路线的，具体表现为既不是阶梯式也不是直接深入讲一个点，前后内容穿插令人无法理解。当然这也与Rust本身语言的特性相关，而并非完全是教程编写者的原因。

学习任何语言的思想都应该是读大量的项目源码，Rust也是如此，不过更应该先掌握Rust语法基础。

以下为Rust学习的部分参考资料：

官方学习文档

Rust圣经(可以看作官方文档的中文替代版)

THU-Rust学习建议

Rustlings

我的建议

先通过学习文档练习语法，然后刷Rustlings，学习过程中参考教程代码or别人的代码，通过crate doc文档查询相关crate源码

Rust特色分享

所有权与生命周期

众所周知，Rust同C++一样是没有GC的，虽然C++在C++11有过GC提案，但是并未有编译器实现（可以当作没有），在C++23移除。C++可以通过RAII控制资源，那么Rust也有智能指针可以实现RAII，但是本文不讨论这个。本篇的主角是所有权。

既然我要聊所有权，那么我为什么要标注生命周期这个东西呢，那当然是因为所有权和生命周期息息相关，C++的内存安全问题基本上都是对于所有权和生命周期的错误使用导致的。而由于Rust中的所有权是在编译期进行的，对运行期的性能没有任何影响。

Rust的所有权有三个原则

Rust 中每一个值都被一个变量所拥有，该变量被称为值的所有者

一个值同时只能被一个变量所拥有，或者说一个值只能拥有一个所有者

当所有者(变量)离开作用域范围时，这个值将被丢弃(drop)

下面将通过一段代码说明以上意思

fn main(){
    let a = String::from("Hello Rust"); 
    let b = a;//此时所有权转移到b
    println!("{:?}", a); //Wrong !!!
    let c = b.clone();//c通过克隆产生，不会拿走b所有权
    {
        let d = b;//d获得b的所有权，并在该代码段结束后drop
    }
    println!("{:?}", b); //Wrong !!!
}

当然这只是浅浅的一点例子，我无法在这说完，可以查看前言中的资料进行深入学习

生命周期

有一个关于很有意思的概念可以被应用于生命周期，我只会在此介绍这个概念。

三种映射：

协变(covariant) T: R(T<’a>, T<’b>) = R(‘a, ‘b)。

逆变(contravariant) T: R(T<’a>, T<’b>) = ~R(‘a, ‘b)，也就是若 ‘a<’b，则 T<’a> > T<’b>。

不变(invariant) T: R(T<’a>, T<’b>) = “<> 或 =”，也就是无法推导子类型关系

你会发现，看上面的概念是不是看不懂？

看不懂就对了，其实这个对于编程来说并没有什么卵用，只是一个很有意思的东西。

那么我们不从Rust的角度来看协变和逆变的概念。

A <: B 代表A是B的子类型
A -> B 以 A 为参数类型, 以 B 为返回值类型的函数类型
x : A 这里x是一个变量, 其类型为A

其实这里从继承关系来看就很好接受了，我们有三个类型如下：
A <: B <: C

这里A变成B、C是协变，B变成C是协变，C变成A、B是逆变，B变成A是逆变。

为什么呢？
定义如下：

协变(Covariance)是指子类向基类的转换.
逆变(Contravariance)是指基类向子类的转换.

是不是突然明白了

那这和生命周期有啥关系呢？

生命周期是有长短的，在哪开始在哪结束，那是不是就有变长变短，的概念了，协变和逆变的概念是不是就能套进去了？

fn main() {
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {}", r); //          |
}                         // ---------+

从上面可以看出显示看出r的生命周期和x的生命周期，那是不是生命周期变长的就是协变，生命周期变短的就是逆变了。

非常容易理解！

TODO!
PS:慢慢写

Posted on 2024-04-27 Edited on 2025-05-19

2024年春夏季开源操作系统训练营-基础阶段-rust编程

1. rust编程语言

在软件开发的广阔天地中，Rust以其独特的内存安全性和高性能特性，赢得了越来越多开发者的青睐。作为一位对Rust感兴趣的新手，我决定踏上这段基础学习的旅程，并在这里分享我的学习心得。

2. 学习之前对rust的了解

Rust是一种系统编程语言，它旨在提供内存安全性，而又不牺牲性能。它的主要特点包括所有权系统、生命周期和借用检查器，这些特性共同确保了程序在运行时不会出现内存泄漏或空指针引用等常见问题。在开始学习Rust之前，我先对其背景和发展历程进行了了解。Rust起源于Mozilla的研究项目，旨在为C++提供一种更安全、更高效的替代品。经过多年的发展，Rust已经成为了一个功能强大且稳定的编程语言，被广泛应用于各种领域，包括操作系统开发、网络编程、嵌入式系统等。

3. 基础语法与数据类型

Rust的语法简洁明了，与C++和Java等主流编程语言有许多相似之处。我开始从学习Rust的基本语法和数据类型入手，如变量声明、条件语句、循环结构等。Rust的数据类型包括整数、浮点数、布尔值、字符和字符串等，这些数据类型的使用与其他语言类似，但也有一些独特之处。例如，Rust中的变量默认是不可变的（immutable），如果需要修改变量的值，必须在声明时使用mut关键字将其标记为可变的（mutable）。这种设计有助于减少程序中的错误，提高代码的可读性和可维护性。

4. 所有权与借用

Rust的所有权系统和借用检查器是其内存安全性的核心所在。在学习过程中，我花了大量时间来理解这两个概念。所有权系统决定了谁负责一块内存区域的生命周期，而借用检查器则确保了在任何给定时间，一个值只能有一个可变引用或任意数量的不可变引用。通过编写一些简单的示例程序，我逐渐掌握了如何正确使用引用和所有权来避免常见的内存错误。这虽然是一个挑战，但当我看到程序能够安全地运行而不会出现内存问题时，我感到非常兴奋和满足。

5. 学习过程难点

rust-rustlings-2024-spring中前面题总体还比较容易进行，特别是后10道题，花费了不少时间，经过不断的分析解决，最终解决了这些试题。通过这些试题对链表等数据操作认识更加深刻。

6. 总结

通过这次Rust基础学习之旅，我对Rust有了更深入的了解和认识。虽然Rust的语法和概念相对复杂一些，但我认为这是值得的，因为它为我们提供了一种更加安全和高效的编程方式。

2024春夏季开源操作系统训练营第一阶段总结-黄文轩

Posted on 2024-04-27 Edited on 2025-05-19 In 2024春夏季开源操作系统训练营

2024开源操作系统训练营第一阶段总结-黄文轩

本文是对OS训练营第一阶段的总结，重点谈谈在第一阶段学习Rust的过程中，印象比较深刻的一些知识点。

所有权

所有权是Rust中一个非常重要的特性，查看如下代码：

fn main() {
    let s1 = String::from("Hello World");
    let s2 = s1;

    println!("{s2}");
}

执行let s2=s1语句后，s1就不能再使用了，也就是说s1将资源移动给了s2，原来的变量就不再用原先的值了。Rust明确了所有权的概念，如果一个变量拥有了一个资源的所有权，就要负责那个资源的回收和释放，主要目的是为了安全。

在使用函数时，也同样要注意：

fn foo(s: String) {
    println!("{s}")
}

fn main() {
    let s1 = String::from("Hello World");
    foo(s1); // 所有权发生移动
    foo(s1); // 出错
}

在第一次使用foo时，s1字符串的所有权就移动到了参数s上，在该函数回收栈空间时，这个字符串就被回收掉了，因此无法再打印这个字符串。

如下代码就不存在问题，因为foo将所有权转移出来：

fn foo(s: String) -> String {
    println!("{s}");
    s
}

fn main() {
    let s1 = String::from("Hello World");
    let  s1= foo(s1); 
    foo(s1); 
}

但是上述代码将所有权转移出来，有时还是麻烦了点，频繁转移所有权会显得很冗余，可以使用引用这个特性。

下述代码使用了引用：

fn foo(s: &String) {
    println!("{s}");
}

fn main() {
    let s1 = String::from("Hello World");
    foo(&s1);
    foo(&s1);
}

Box智能指针

如果一个变量，存的是另一个变量在内存的地址值，那么就被称为指针。普通指针是对值的借用，而智能指针通常拥有对数据的所有权，可以做一些额外操作，比如管理引用计数和资源自动回收。

标准库中常见的智能指针：

Box<T>：在堆内存上分配值
Rc<T>：启用多重所有权的引用计数类型
Ref<T>&RefMut<T>，通过RefCell<T>访问：在运行时而不是编译时强制借用规则的类型

本文着重介绍Box，即指向堆内存的智能指针，允许在堆上存储数据而非栈，没有其他性能开销。

常用场景：在编译时，某类型的大小无法确定。但使用该类型时，上下文却要知道它的确切大小。

fn main() {
    let b = Box::new(5); // 存储在堆上
    println!("b = {}",b);
}

在变量 b 在离开作用域时，同样会被释放。

同样可以作用于结构体：

struct Point {
    x: u32,
    y: u32
}

fn foo() -> Box<Point> {
    let p = Point {x:10, y:20};
    Box::new(p)
}

fn main() {
    // ....
}

在创建Point结构体时，其尺寸是固定的，所以它的实例会被创建在栈上。而在创建 Box<Point> 实例的时候会发生所有权转移：资源从栈上移动到了堆，原来栈的那片资源被置为无效。

可以对Box进行解引用，由于u8具有copy语义，所以解引用后，原来的boxed还能使用

fn main() {
    let boxed:  Box<u8> = Box::new(5);
    let val: u8 = *boxed;

    println!("{:?}",val);
    println!("{:?}",boxed);
}

但是对于move语义的类型来说，就不适用了
Box同样可以作为函数参数:

#[derive(Debug)]
struct Point {
    x: u32,
    y: u32
}

fn foo(p: Box<Point>) {
    println!("{:?}",p);
}

fn main() {
    let b: Box<Point> = Box::new(Point{x:10, y:20});

    foo(b)
}

2024春季开源操作系统训练营第一阶段总结-邓子焕

Posted on 2024-04-27 Edited on 2025-05-19

前言

对于Rust和OS，其实之前也只了解过Rust但是并未深入学习和研究，恰好开源操作系统训练营的开班，然后就积极报名参加，进入了交流群。同时，rust语言博大精深且与之前学习的语言也存在差异，作为从业者而言，每天并没有太多的时间去专注于该训练营开展的活动，但是每天都会尽可能的抽出相应的时间进行学习Rust和OS，为了去挖掘更多其未知的知识，丰富自我，达到更高一个层次。

学习总结感悟

总体来说在第一阶段这个学习过程还是挺顺利的，因为在报名之后，我已经着手学习Rust的相关知识，且网络平台上存在许多大量的资源供学习参考。整个大约一个月学习过程中，曾经碰到过许多的问题，在网上阅读过很多的文章寻找相关答案，也和有在加入的微信群交流探讨，总体感觉Rust还是一个正在发展中的语言，从开始接触到深入探究，就能发现Rust是一门年轻的且充满潜力的编程语言并且Rust语言同时也兼顾了安全性和高性能，因而它是一门非常出色的系统编程语言，能够编写操作系统、数据库、区块链应用等对安全、性能都要求极为严苛的系统级软件。
Rust语言同时是一门优秀的生产力语言，出色的文档、完善且高效的工具链（cargo,rustup），能够快速进行各个层次（小的嵌入式、大到操作系统，从底层系统开发到网络应用开发，均能胜任）的应用的开发。而且Rust社区也在快速发展，不断地创新，不断地摸索，学习者可以在社区中交流探讨中摩擦出了灿烂的火花。

Rust学习

学习历程

学习最开始查找的资料就是Rust语言社区，一般来说一门语言、框架或者库出现后，人们应用它们，不只是因为自身的强大，更是因为其背后的生态圈。这里有相应的且完整的代码、丰富的配套资源以及官方的指导文档，大家互相促进，在一个良好的氛围中交流学习Rust是种非常nice的感觉。

语法：相对而言，Rust的语法是挺特别的。因为有生存周期和借用检查这类独有的概念，所以语法上看上去是比较复杂。但是作为一种现代编程语言，大量使用了泛型，但是也带来代码可读性较差的问题。这个问题也很让人感到苦恼的，需要有耐心且保持积极心态去学习、去摸索。
特性：内存安全性、并发性强、高性能、易用性、跨平台性和社区活跃
exercise：边学边练才能达到更好的效果，前大半的练习题都差不多是基础，很容易做，我大概花了一天的时间做完了前100道题，还剩下最后十道的算法题，这还是有点难度在的，其实最终还是得靠牢牢掌握Rust的语法、数据结构以及代码逻辑分析等，还是能很快的解决掉最后的十道题。在这个过程中，Rust难上手很关键的一点就是其严格的编译器，编译器会做尽可能多的检查，而且也十分详细地发现问题，这样可以提早消除安全隐患。所以编译器像一个好老师，及早扼杀你的bug，强制性要求你写出可以正常运行的正确代码
note：学习过程中没有笔记是不完美的，所以整理了学习笔记, 记录日常学习的过程以及学习的内容，对于理解不清晰的模块和问题会仔细梳理代码逻辑，这是锻炼思维能力的一种方法，同时这对我来说可以将几节甚至是几章的内容进行串联起来，可以建立起更牢固的知识框架。
学习氛围
微信群里积极交流，提出问题，解决问题
老师督促，学生活跃
技术性的学术氛围浓厚
目标一致
学习成果
在第一阶段的学习中，掌握了rust基础，学习到操作系统相关的概念以及原理
展望
Rust 是一门全新的语言，它会带给我们前所未有的体验，同时也能提升通用编程水平，甚至于赋予我们全新的编程思想。希望能够在第二阶段上继续保持，再接再厉
致谢
在老师的悉心指导下和交流群互帮互助下，从最开始的 Hello World 起步，到深入系统地学习了操作系统的基本概念、原理。这使我对Rust和OS 有了更加全面和深入的理解。最后，衷心感谢清华大学的老师们为我们提供了这次难得的学习机会，还有两位教学的讲师，对我们授课讲学。
这次学习经历对我们来说，无疑是非常宝贵的财富，在以后走的更长远。
分享连接~
《Rust语言圣经》：https://course.rs/about-book.html
《Rust程序设计语言》：https://rustwiki.org/zh-CN/book/
《Rust指南》：https://tourofrust.com/
《深入浅出rust》：https://zhuanlan.zhihu.com/rust-lang
https://link.zhihu.com/?target=https%3A//www.gitbook.com/book/rustcc/rustprimer/details
Rust 语言中文社区：https://rustcc.cn/

2024春季开源操作系统训练营第一阶段总结报告-谭智超

Posted on 2024-04-27 Edited on 2025-05-19 In 2024春夏季开源操作系统训练营

训练营第一阶段总结

1. 参加训练背景

其实去年秋就已经知道了这件事情，不过当时是大二，觉得太难了些，当时就是图一个乐子，报了一个名，甚至连 github的仓库都没有打开过，去年可以说是完全没有用心的。没有那个时间和心力去坚持下去。

今年能够重新来过，要走出舒适区，我觉得对于我来说是一个挑战，我本身并没有学过 C++，对于C++的一些浅显的了解仅限于用它打过算法，看过一点点 C++ 的书，甚至 Python 都没有学过，基本上看 Rust 一开始是让我感觉不适应的，这100道题目前80道算是自己摸索模索，大家讨论勉强能够写出，后面的线程，不安全的块unsafe，智能指针，闭包等，其实都是云里雾里，只能说是似是而非，感觉十分不扎实。

不过令人庆幸的是，能够找到志同道合的队友，虽然我在我们的小队中一般是进度最慢的，另外两个队员给了我很多帮助，我有很多的疑问不解他们都会与我讨论，每天都有讨论的乐趣与激情，每晚10点30分就是到了今日学习总结分享的小队时间，这个时候大家的思想融汇贯通，是最能让人收获乐趣的。

进度还是慢了很多，差不多一周半慢慢悠悠的混过去了第一阶段，遗憾是思维导图没有时间去做了，预计要拿出时间进行复盘。

特此鸣谢两位志同道合的队友(theOnlyUnique 和 ccaikano)，有人共行是一大乐事

2. 参考书籍

在学习 Rust 语言基础中，Rust 程序设计语言 - Rust 程序设计语言中文版 (rustwiki.org)对我影响巨大，这本书力图教会我们从程序设计的思想上进行思考，考虑这段代码可能会出现的问题，以及他人看这段代码可能会出现的情况，在认真阅读过这本书之后，实在是令人受益匪浅。

3. 编译器报错

编译器报错是成功之母！！我写 C++ 都没有这么多报错！！ Rust 编译器的报错真是让人想要吐槽，动不动就报错，不过令人欣慰的是，编译器的错误提示很精准，这令人感官十分良好，唯一麻烦的就是要逼着我去阅读编译器报错信息，这是程序员的基本功，但是还是很讨厌！

在面对Rust 中的频繁报错时，尽量学会和编译器做朋友，他能够帮助你很多很多。

4. 资源分享

Tips: 嘿嘿嘿，就厚颜无耻的 借用一下 我队员的资源分享吧，你们偷偷看，把这个当成我的资源分享也是可以的！！

1Rust 程序设计语言 - Rust 程序设计语言中文版 (rustwiki.org)

2std - Rust (rustwiki.org)

3Rust 中文文档 | Rust 文档网 (rustwiki.org)

4关于本书 - Rust语言圣经(Rust Course)

5Rust入门第一课 - Rust入门秘籍 (junmajinlong.com)

6介绍 - Rust精选 (rustmagazine.github.io)

7简介 - 通过例子学 Rust 中文版 (rustwiki.org)

来源 : 2024春季开源操作系统训练营刘启东一阶段总结

第一阶段总结

RUST

RISC-V

rustlings 难点记录

引用

字符串

Rust语言学习心得

Rustlings

未来期望

第一阶段总结

回顾

rustling

Rust

Rustlings 学习感悟

RCore 学习感悟

一阶段 小结

二阶段 小结

多道程序

地址空间

进程

文件系统

并发

小结的小结

三阶段 小结

项目3 Rust for Linux & 跨内核驱动框架

练习一 配环境

练习二 实现Miscdev驱动基本读写

练习三 跨内核驱动框架下的树莓派4B GPIO点灯实现

总结

~

Rust学习经验

前言

我的建议

Rust特色分享

所有权与生命周期

2024年春夏季开源操作系统训练营-基础阶段-rust编程

1. rust编程语言

2. 学习之前对rust的了解

3. 基础语法与数据类型

4. 所有权与借用

5. 学习过程难点

6. 总结

2024开源操作系统训练营第一阶段总结-黄文轩

所有权

Box智能指针

前言

学习总结感悟

Rust学习

学习历程

学习氛围

学习成果

展望

致谢

分享连接~

训练营第一阶段总结

1. 参加训练背景

2. 参考书籍

3. 编译器报错

4. 资源分享

一阶段小结

二阶段小结

三阶段小结

练习一配环境

练习二实现Miscdev驱动基本读写

练习三跨内核驱动框架下的树莓派4B GPIO点灯实现