初识Rust：编程王国的小铁匠

内存怪物：编程世界里的隐形恶龙

想象一下，你刚刚用积木搭好了一座漂亮的城堡，正准备给小伙伴们展示，却发现城堡的某一块积木松动了，整个城堡在碰到桌面的那一刻轰然倒塌——散落的积木滚得到处都是，有些还掉到了桌子底下，再也找不回来。

In the world of programming, this kind of "collapse" happens all the time. Programmers call these collapses memory bugs（内存错误）. They are like invisible dragons that sneak into your code while you're not looking. The most famous of these dragons has a terrifying name: Segfault（段错误，segmentation fault 的缩写）. When a program commits a segfault, it's like the operating system is shouting: "Hey! You just tried to read a memory address that doesn't belong to you! I'm going to shut you down right now!"

A segfault occurs when a program tries to access memory it has no permission to access, or when it tries to access memory in a way that doesn't make sense (like reading a "house number" that doesn't exist on a street). In the computer's memory, every byte has an address, just like every house has a street number. If you try to read address `0xDEADBEEF` (a famous hex number programmers use as a placeholder) and that memory doesn't exist or isn't yours, the operating system will kill your program instantly to protect other programs.

There's another dragon called Memory Leak（内存泄漏）. Imagine you borrow ten books from the library, read them, but forget to return them. The library can't lend those books to anyone else. Over time, the library runs out of books, even though everyone has technically "finished reading". In computer terms, a memory leak happens when a program allocates memory but forgets to release it when it's done. The program keeps claiming more and more memory, and eventually the computer runs out of RAM and grinds to a halt.

These dragons have caused real disasters in history. One of the most famous is the Heartbleed Bug（心脏滴血漏洞）, discovered in 2014. It was a vulnerability in a piece of software called OpenSSL, which is used to encrypt internet traffic. Because of a missing bounds check—a tiny mistake where the program forgot to verify how much data was being read—a hacker could steal passwords, credit card numbers, and private keys from servers all over the world. The bug had been hiding in plain sight for two years before anyone noticed. It's estimated that Heartbleed affected 17% of the secure web servers on the internet at the time of its discovery.

Another famous disaster happened in 1996 with the Ariane 5 rocket. Just 40 seconds after launch, the rocket exploded. Why? A piece of code tried to convert a 64-bit floating-point number into a 16-bit signed integer, but the number was too big. This caused an overflow error, which led to incorrect navigation data, which led to the rocket veering off course and self-destructing. The code had worked perfectly on Ariane 4, but Ariane 5 was faster, and the numbers were bigger. The code had cost $370 million and decades of work.

These dragons are not just theoretical problems. They bite real programs, real companies, and real people every single day. Studies have shown that roughly 70% of all security vulnerabilities in large software systems (like operating systems and browsers) are caused by memory safety issues. Microsoft, Google, Apple, and other tech giants have reported similar numbers.

So how do we fight these dragons? For decades, programmers had two main weapons:

1. Be very, very careful when writing C or C++ code (these languages give you direct control over memory, but also direct access to all the dragons). 2. Use a Garbage Collector（垃圾回收器）, like in Python, Java, or JavaScript. A garbage collector is like a helpful robot that walks around your program collecting unused memory and putting it back in the pool. It makes programming safer, but it slows things down and can be unpredictable.

What if there were a third way? A way that gives you the speed and control of C++, but with built-in armor against the dragons? That's exactly what Rust promises. And that's why we're going to learn it.

---

寻访锻造大师：Rust 的诞生故事

Every great tool has a great maker. Rust's story begins in 2006, with a young programmer named Graydon Hoare. Hoare was a Canadian software developer who, like many programmers, was frustrated by memory bugs. He was particularly annoyed by a memory bug that crashed the elevator in his apartment building. The elevator software had crashed and needed to be restarted, and Hoare thought: "There has to be a better way to write this kind of software."

Hoare was working at Mozilla Research at the time (he would later become a Mozilla employee). Mozilla is the company behind the Firefox web browser, and they were very interested in building a faster, safer browser. They had lots of code written in C++, but C++ was causing too many memory bugs. So Mozilla encouraged Hoare to design a new language from scratch.

Hoare named the language Rust, after a group of plant-parasitic fungi. These fungi are tough, resilient, and have multi-threaded, distributed structures. Hoare thought it was a fitting name for a language that was designed to be both robust and capable of handling concurrency.

``` Timeline of Rust's Birth ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2006 Graydon Hoare begins designing Rust (personal project) 2009 Mozilla begins sponsoring Rust development 2010 Rust's compiler is officially announced to the public 2012 First pre-alpha release (0.1) 2015 Rust 1.0 released (May 15, 2015) - the stable version 2021 Rust Foundation established (with AWS, Google, Huawei, Microsoft) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ```

Rust took nearly ten years to reach its 1.0 release, which is unusually long for a programming language. But this wasn't because the developers were slow. It was because they wanted to get the design exactly right. Rust's development was guided by three sacred goals, often called its Three Design Goals（三大设计目标）:

Goal 1: Memory Safety without Garbage Collection（无垃圾回收的内存安全）

Rust promises that if your code compiles, it won't have memory bugs. Not "probably won't"—definitely won't. This is a bold promise. Most languages can't make this promise at all. Rust makes it through a clever system called the Ownership Model（所有权模型）, which we'll explore deeply in Chapter 3. For now, just know that Rust's compiler is like a strict but fair teacher who checks every single memory access before your program is allowed to run.

Goal 2: Zero-Cost Abstractions（零成本抽象）

An "abstraction" in programming is when you hide complicated details behind a simpler interface. Like how a car's steering wheel abstracts away all the complex mechanics of turning the wheels. In many languages, these abstractions cost performance—you get nicer code, but your program runs slower. Rust promises that its abstractions cost zero. You can write high-level, elegant code, and it will run just as fast as low-level hand-optimized code. The compiler is smart enough to optimize everything away.

Goal 3: Fearless Concurrency（无畏并发）

Modern computers have multiple CPU cores. To use them well, your program needs to do multiple things at once—this is called concurrency（并发）. In most languages, concurrency is terrifying because multiple threads can mess with each other's memory in unpredictable ways, causing bugs that only happen once in a blue moon. Rust makes concurrency safe by extending its ownership model to threads. If your concurrent code compiles, it's probably correct.

These three goals are not just marketing slogans. They are baked into every line of Rust code, and the compiler enforces them with strict checks. Hoare and his team spent years refining the design until they were confident the goals were met. The release of Rust 1.0 in 2015 was a major milestone, signaling that the language was ready for production use.

In 2021, the Rust Foundation（Rust 基金会）was established as an independent non-profit organization to support the language. Its founding members included **AWS, Google, Huawei, Microsoft,