Foundations Part 1 Beginner+

Đặt nền móng vững chắc — Hiểu Rust từ cách nó quản lý Memory

Dành cho ai?

Module này dành cho kỹ sư đã có kinh nghiệm với C++, Java, hoặc Python. Bạn đã biết "vòng lặp là gì" — ở đây chúng ta tập trung vào cách Rust làm khác và tại sao.

📋 PREREQUISITES

• Biết cơ bản về lập trình (variables, functions, loops)
• Hiểu sơ lược về Stack vs Heap (sẽ được ôn lại)
• Đã cài đặt Rust toolchain (rustc, cargo)

Tổng quan Module

┌─────────────────────────────────────────────────────────────────────┐
│                      FOUNDATIONS PART 1                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐   │
│  │   VARIABLES &   │   │    PRIMITIVE    │   │   FUNCTIONS &   │   │
│  │   MUTABILITY    │   │      TYPES      │   │  CONTROL FLOW   │   │
│  ├─────────────────┤   ├─────────────────┤   ├─────────────────┤   │
│  │ • let vs mut    │   │ • Integers      │   │ • Stack Frames  │   │
│  │ • Shadowing     │   │ • Floats (754)  │   │ • Expressions   │   │
│  │ • const/static  │   │ • Booleans      │   │ • match Safety  │   │
│  │ • Stack Slots   │   │ • Characters    │   │ • Pattern Match │   │
│  └─────────────────┘   │ • Tuples/Arrays │   └─────────────────┘   │
│          ↓             │ • isize/usize   │            ↓            │
│    Stack Memory        └─────────────────┘      Stack Frames       │
│                              ↓                                     │
│                        Memory Layout                               │
└─────────────────────────────────────────────────────────────────────┘

Nội dung chi tiết

1. Variables & Mutability

Rust mặc định immutable — đây không phải hạn chế, mà là design decision cho safety. Chúng ta sẽ khám phá:

• let vs let mut: Cơ chế hoạt động ở mức Stack
• Shadowing: Tại sao nó khác với mutation và ảnh hưởng memory thế nào
• const vs static: Impact lên binary size và memory segments (.rodata, .data, .bss)

2. Primitive Data Types

Mọi ngôn ngữ đều có primitives, nhưng Rust yêu cầu bạn hiểu rõ size và layout:

• Integers: i8 → i128, u8 → u128 — khi nào dùng gì?
• Floats: IEEE 754 representation và precision traps
• Characters: Tại sao char là 4 bytes (Unicode Scalar Value)?
• Tuples & Arrays: Stack-allocated, fixed size — khác biệt với Vec/slice
• isize/usize: Phụ thuộc CPU architecture — implications cho code portable

3. Functions & Control Flow

Rust function không chỉ là "block of code" — mỗi call tạo Stack Frame:

• Stack Frames: Cách arguments và return values di chuyển
• Statements vs Expressions: Concept "trả về giá trị không cần return"
• match: Tại sao compiler bắt buộc exhaustive patterns (an toàn hơn switch-case)

---

So sánh với ngôn ngữ khác

Khái niệm	C/C++	Java	Python	Rust
Mặc định mutable	✅	✅	✅	❌ Immutable
Shadowing	❌ Error	❌ Error	✅ (Same name in scope)	✅ Re-binding với type mới
Integer overflow	Undefined Behavior	Wraps	Auto BigInt	Panic (debug) / Wrap (release)
Null value	NULL	null	None	Không có! (Option<T>)
Switch exhaustive	❌	❌	❌	✅ Compiler enforced

Bắt đầu học

💡 CÁCH HỌC HIỆU QUẢ

1. Đọc theory trong từng bài
2. Chạy code examples trong Rust Playground hoặc local
3. Vẽ lại Stack diagrams bằng tay để nhớ lâu
4. Thử break code — xem compiler nói gì

Bước tiếp theo

1. 📖 Variables & Mutability — Bắt đầu từ đây
2. 📊 Primitive Types — Sau khi nắm vững variables
3. ⚙️ Functions & Control Flow — Hoàn thành Part 1

---

"In Rust, safety isn't a library feature — it's baked into the language design from the ground up."