[Rust Self-Study] 1.0. Intro

1.0.1 Preface

This project (both code and notes) was documented during my self-learning journey with Rust. It might contain inaccuracies or unclear expressions, so I ask for your understanding. If you benefit from it, all the better.

1.0.2 Why Use Rust

• Rust is reliable and efficient.

• Rust can replace C and C++ with similar performance but higher safety, and it does not require frequent recompilation to check for errors like C and C++. Key advantages include:

  • Memory safety (prevents null pointer dereferencing, dangling pointers, and data races).
  • Thread safety (ensures multithreaded code is safe before execution).
  • Avoids undefined behavior (e.g., array out-of-bounds, uninitialized variables, or accessing freed memory).

• Rust provides modern language features (e.g., generics, traits, pattern matching).

• Rust offers a modern toolchain. Rust's Cargo shares similar principles with Python’s pip. Unlike the cumbersome dependency configuration of C/C++, Cargo provides a user-friendly dependency management experience akin to Python, while maintaining C/C++-level performance.

1.0.3 Applicable Scenarios

• When performance is required: Rust can control memory as precisely as C (using unsafe) while also providing modern conveniences (e.g., ownership system and pattern matching). Python, on the other hand, prioritizes developer efficiency but sacrifices performance.

• When memory safety is critical: Rust’s static checks at compile time ensure strong memory safety, making it highly suitable for scenarios requiring error prevention, such as operating systems, embedded systems, and network servers.

• When efficient use of multi-core processors is needed: Rust natively supports efficient concurrency and multi-core programming without sacrificing safety, making it particularly advantageous in scenarios requiring high throughput and concurrent tasks (e.g., web servers, distributed systems, real-time computing).

Rust excels in the following domains:

• Web services
• WebAssembly (Rust and C/C++ outperform C# and Java significantly in terms of performance)
• Command-line tools
• Network programming
• Embedded devices
• System programming

1.0.4 Comparison with Other Languages

Category	Language	Features
Machine Code	Binary	Closest to hardware, executed directly by CPU.
Assembly	Assembly	Uses mnemonics to replace machine code, e.g., MOV AX, BX.
Low-level	C, C++	Close to hardware, provides limited abstraction.
Mid-level	Rust, Go	Performance similar to low-level languages with higher abstraction.
High-level	Python, Java	Higher-level abstraction, easier to read and use.

High-level and low-level languages are not strictly opposed but exist on a continuous spectrum:

• Lower-level languages offer greater control over hardware but require more complex coding and lower development efficiency.

• Higher-level languages offer greater abstraction and automation but may introduce runtime overhead and lose fine-grained hardware control.

Rust’s advantages:

• High performance
• Strong safety guarantees
• Excellent support for concurrency

Rust’s position as a mid-level language offers the following benefits:

• C/C++: Excellent performance but lacking in safety; Rust ensures safety with comparable performance.

• Java/C#: Ensures memory safety (using garbage collection) and offers numerous features, but performance is weaker; Rust achieves similar safety levels with superior performance.

1.0.5 History of Rust

Rust originated as a research project by Mozilla, with the Firefox browser being a notable application example.

Mozilla developed the Servo experimental browser engine using Rust (initiated in 2012, first preview released in 2016). Servo’s architecture is entirely parallelized. Unfortunately, in August 2020, Mozilla laid off most of the Servo development team. From November 17, 2020, Servo was transferred to the Linux Foundation. Parts of Servo’s functionality have already been integrated into Firefox.

The Quantum version of Firefox incorporates Servo’s CSS rendering engine. Rust has brought significant performance improvements to Firefox.

1.0.6 Rust Users and Case Studies

• Google: The Fuschia operating system, where Rust constitutes 30% of the codebase.

• Amazon: A Linux-based operating system designed for running containers directly on bare metal or virtual machines.

• System76: Developed the next-generation secure operating system Redox entirely in Rust.

• Stanford and University of Michigan: An embedded real-time operating system used in Google’s cryptographic products.

• Microsoft: Rewrote certain low-level components in Windows using Rust.

• Microsoft: The WinRT/Rust project.