Introduction to Rust & Environment Setup

🎯 Learning Objectives

By the end of this module, you will:

• Understand what Rust can do and its intersection with JavaScript.
• Master the language migration learning method from JavaScript to Rust.
• Learn how to install and configure the Rust development environment.
• Create and run your first Rust project.

---

🤔 Why Learn Rust?

As a JavaScript developer, you might ask:

• I already know JavaScript, why should I learn Rust?
• What problems can Rust help me solve?
• How can learning Rust benefit my career?

What can Rust offer you?

1. Performance Boost - Rust programs run at speeds close to C/C++, 10-100 times faster than JavaScript.
2. Memory Safety - Compile-time checks prevent memory leaks and null pointer errors.
3. Concurrency Safety - Compile-time guarantees for multi-threaded safety, avoiding race conditions.
4. Systems Programming - Ability to write operating systems, drivers, and embedded programs.
5. WebAssembly - Run high-performance code in the browser.
6. Career Growth - Master a systems-level programming language and broaden your tech stack.

The Complementary Relationship between JavaScript and Rust

---

🧠 Learning Strategy: From JS to Rust

Adjusting Your Mindset

When learning Rust, you need to adjust some of your thinking habits:

JavaScript Mindset:

• Focus on "what to do" - directly write business logic.
• Runtime checks - errors are discovered at runtime.
• Automatic memory management - no need to worry about memory allocation.

Rust Mindset:

• Focus on "how to do it" - need to explicitly specify types and memory management.
• Compile-time checks - errors are discovered at compile time.
• Explicit memory management - manage memory through the ownership system.

Learning Strategy

1. Comparative Learning - Every Rust concept corresponds to a JavaScript concept.
2. Progressive - From simple syntax to complex concepts.
3. Practice-Driven - Every concept must be verified by hand.
4. Project-Oriented - Consolidate knowledge through actual projects.

---

🛠️ Installing the Rust Development Environment

1. Install Rust

Rust uses rustup as its version management tool, similar to Node.js's nvm:

# Install Rust (similar to nvm install node)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Or use Homebrew (macOS)
brew install rust

# Verify installation
rustc --version
cargo --version

2. Configure Your IDE

VS Code is recommended. Install the following extensions:

• rust-analyzer - The officially recommended code analysis tool for Rust.
• Even Better TOML - Syntax highlighting for configuration files.
• crates - Dependency management.
• Error Lens - Enhanced error highlighting.
• CodeLLDB - Debugging support.

3. Configure Cargo

Cargo is Rust's package manager and build tool, similar to npm:

# Check Cargo version
cargo --version

# Configure a mirror source (for users in China)
# Add the following to ~/.cargo/config.toml:
[source.crates-io]
replace-with = 'ustc'

[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index"

---

🚀 Hello, Rust: Your First Project

Create a New Project

# Create a new project (similar to npm init)
cargo new hello-rust
cd hello-rust

# Project Structure
hello-rust/
├── Cargo.toml    # Project configuration (like package.json)
└── src/
    └── main.rs   # Entry file (like index.js)

Project Configuration File Comparison

Your First Rust Program

Running the Project

# Run the project (similar to npm start)
cargo run

# Build the project (similar to npm run build)
cargo build

# Build a release version (optimized binary)
cargo build --release

# Run tests (similar to npm test)
cargo test

# Check the code (similar to npm run lint)
cargo clippy

# Format the code (similar to npm run format)
cargo fmt

---

🔍 Understanding the Rust Project Structure

Standard Project Structure

my-rust-project/
├── Cargo.toml          # Project configuration and dependencies
├── Cargo.lock          # Dependency lock file (like package-lock.json)
├── src/
│   ├── main.rs         # Binary program entry point
│   ├── lib.rs          # Library entry point (optional)
│   ├── bin/            # Multiple binary entry points (optional)
│   │   └── another_main.rs
│   └── tests/          # Integration tests (optional)
│       └── some_test.rs
└── examples/           # Example programs (optional)
    └── some_example.rs

📚 Summary

In this module, we learned:

• The advantages of Rust and its relationship with JavaScript.
• How to set up a Rust development environment.
• How to create, run, and manage a Rust project using Cargo.
• The basic structure of a Rust project.

In the next module, we will dive into a detailed comparison of Rust and JavaScript syntax.