Ngôn ngữ lập trình Rust

📚 Tóm tắt nội dung

Một hướng dẫn giới thiệu toàn diện về Rust, bao gồm các khái niệm lập trình hệ thống, an toàn về bộ nhớ, đồng thời thực hiện và công cụ Rust (Cargo, rustup). Nội dung chuyển từ cú pháp cơ bản đến việc xây dựng các dự án hoàn chỉnh như một máy chủ web đa luồng.

Thành thạo nghệ thuật lập trình hệ thống an toàn, nhanh chóng và đồng thời với hướng dẫn toàn diện về Rust.

Tác giả: Steve Klabnik và Carol Nichols, với sự đóng góp từ cộng đồng Rust

Lời cảm ơn: Những đóng góp từ cộng đồng Rust; được xuất bản dưới dạng sách in và ebook từ No Starch Press.

🎯 Mục tiêu học tập

1. Cài đặt và quản lý các công cụ Rust trên nhiều hệ điều hành bằng rustup.
2. Viết, biên dịch và chạy một chương trình Rust cơ bản, xác định các thành phần cốt lõi trong mã nguồn.
3. Sử dụng Cargo để tạo cấu trúc dự án chuẩn, quản lý quá trình biên dịch và sản xuất các tệp nhị phân tối ưu cho bản phát hành.
4. Thu thập và lưu trữ đầu vào người dùng trong khi quản lý tính thay đổi của biến và các lỗi I/O tiềm ẩn.
5. Tích hợp các phụ thuộc bên ngoài bằng Cargo và quản lý các bản dựng tái tạo được thông qua Cargo.lock.
6. Triển khai logic trò chơi bằng cách sử dụng suy diễn kiểu, phân tích chuỗi, vòng lặp và toán tử kiểm soát luồng match.
7. Phân biệt giữa hằng số và ghi đè biến để quản lý tính bất biến dữ liệu và phạm vi.
8. Triển khai chính xác các kiểu dữ liệu nguyên thủy (số nguyên, số thực, boolean, ký tự) và kiểu dữ liệu kết hợp (tuple, mảng).
9. Phân biệt giữa câu lệnh và biểu thức để định nghĩa hàm với giá trị trả về cụ thể.
10. Phân biệt giữa bộ nhớ ngăn xếp và bộ nhớ đệm, và giải thích cách Rust quản lý dữ liệu trên đệm.

🔹 Bài học 1: Bắt đầu với Rust

Tổng quan: Bài học này cung cấp một lời giới thiệu toàn diện về sinh thái Rust, tập trung vào việc thiết lập môi trường và quy trình cơ bản của nhà phát triển Rust. Người học sẽ tiến từ việc cài đặt ngôn ngữ qua rustup đến viết một chương trình "Xin chào Thế giới!" thủ công, và cuối cùng là làm chủ Cargo – hệ thống xây dựng và quản lý gói chính thức của Rust – để quản lý dự án chuyên nghiệp và tối ưu hóa bản phát hành.

Kết quả học tập:

• Cài đặt và quản lý các công cụ Rust trên nhiều hệ điều hành bằng rustup.
• Viết, biên dịch và chạy một chương trình Rust cơ bản, xác định các thành phần cốt lõi trong mã nguồn.
• Sử dụng Cargo để tạo cấu trúc dự án chuẩn, quản lý quá trình xây dựng và sản xuất tệp nhị phân tối ưu cho bản phát hành.

🔹 Bài học 2: Thực hành: Lập trình trò chơi đoán số

Tổng quan: Bài học này hướng dẫn nhà phát triển xây dựng một trò chơi đoán số hoạt động dựa trên dòng lệnh (CLI) bằng Rust. Nó bao gồm các khái niệm lập trình hệ thống cơ bản như xử lý đầu vào người dùng, tích hợp các thư viện bên ngoài cho việc sinh số ngẫu nhiên, và cách tiếp cận độc đáo của Rust về an toàn bộ nhớ và xử lý lỗi thông qua kiểu Result và khớp mẫu. Đến cuối bài học, người học sẽ có một ứng dụng mạnh mẽ xử lý đầu vào không hợp lệ và đảm bảo các bản dựng tái tạo được.

Kết quả học tập:

• Thu thập và lưu trữ đầu vào người dùng trong khi quản lý tính thay đổi của biến và các lỗi I/O tiềm ẩn.
• Tích hợp các phụ thuộc bên ngoài bằng Cargo và quản lý các bản dựng tái tạo được thông qua Cargo.lock.
• Triển khai logic trò chơi bằng cách sử dụng suy diễn kiểu, phân tích chuỗi, vòng lặp và toán tử kiểm soát luồng match.

🔹 Bài học 3: Các khái niệm lập trình phổ biến

Tổng quan: Bài học này đề cập đến những khối xây dựng nền tảng của lập trình Rust, tập trung vào việc lưu trữ và thao tác dữ liệu. Nó khám phá chi tiết về ghi đè biến và hằng số, phân loại dữ liệu thành kiểu nguyên thủy và kiểu kết hợp, quy tắc cấu trúc hàm, và logic điều khiển luồng và thực thi lặp lại.

Kết quả học tập:

• Phân biệt giữa hằng số và ghi đè biến để quản lý tính bất biến dữ liệu và phạm vi.
• Triển khai chính xác các kiểu dữ liệu nguyên thủy (số nguyên, số thực, boolean, ký tự) và kiểu dữ liệu kết hợp (tuple, mảng).
• Phân biệt giữa câu lệnh và biểu thức để định nghĩa hàm với giá trị trả về cụ thể.

🔹 Bài học 4: Hiểu về sở hữu và bộ nhớ

Tổng quan: Bài học này khám phá cách tiếp cận độc đáo của Rust đối với quản lý bộ nhớ thông qua hệ thống Sở hữu. Thay vì dựa vào bộ thu gom rác hay quản lý bộ nhớ thủ công, Rust sử dụng một tập các quy tắc được kiểm tra tại thời điểm biên dịch để đảm bảo an toàn bộ nhớ. Phần này bao gồm cơ chế của ngăn xếp và đệm, chu kỳ sống của dữ liệu, và cách tham chiếu và mảng (slice) cung cấp truy cập an toàn, hiệu quả vào bộ nhớ mà không cần chuyển giao quyền sở hữu.

Kết quả học tập:

• Phân biệt giữa bộ nhớ ngăn xếp và đệm, và giải thích cách Rust quản lý dữ liệu trên đệm.
• Áp dụng ba quy tắc của Sở hữu để dự đoán tính hợp lệ và phạm vi của biến.
• Thể hiện sự khác biệt giữa các thao tác Di chuyển (Move), Sao chép (Clone) và Chuyển sao (Copy).

🔹 Bài học 5: Structs: Quản lý dữ liệu liên quan

Tổng quan: Bài học này khám phá cách nhóm dữ liệu liên quan vào các kiểu tùy chỉnh bằng struct để tạo ra mã nguồn rõ ràng và tổ chức hơn. Nó bao gồm việc định nghĩa và khởi tạo các dạng struct khác nhau (cổ điển, tuple, và dạng đơn vị), quản lý quyền sở hữu dữ liệu trong các cấu trúc này, và nâng cao khả năng của struct thông qua các đặc tính được kế thừa như Debug và các phương thức tùy chỉnh định nghĩa bằng khối impl.

Kết quả học tập:

• Định nghĩa và khởi tạo struct bằng các trường tên, cú pháp ngắn gọn và cú pháp cập nhật.
• Phân biệt giữa struct cổ điển, struct tuple và struct đơn vị, và nhận diện các trường hợp sử dụng phù hợp.
• Triển khai đặc tính Debug và sử dụng macro dbg! để kiểm tra dữ liệu struct.

🔹 Bài học 6: Enums và khớp mẫu

Tổng quan: Bài học này khám phá cách Rust sử dụng các kiểu liệt kê (enums) để định nghĩa kiểu dữ liệu bằng cách liệt kê các biến thể có thể có, cung cấp một cách linh hoạt hơn để nhóm các hằng số và dữ liệu liên quan so với struct riêng lẻ. Nó đề cập đến vai trò then chốt của enum Option trong việc loại bỏ lỗi con trỏ null và minh họa cách các cấu trúc match và if let cung cấp luồng điều khiển mạnh mẽ, đầy đủ để xử lý các mẫu dữ liệu phức tạp một cách an toàn.

Kết quả học tập:

• Định nghĩa enums với nhiều loại dữ liệu khác nhau và triển khai các phương thức cho chúng bằng khối impl.
• Giải thích lợi ích an toàn của enum Option<T> so với các giá trị null truyền thống.
• Xây dựng các biểu thức match đầy đủ, gắn kết với các giá trị bên trong biến thể và sử dụng các chỗ trống tổng quát.

🔹 Bài học 7: Modules, Packages và Crates

Tổng quan: Bài học này khám phá cách Rust tổ chức mã nguồn để tăng tính dễ đọc và tái sử dụng thông qua hệ thống module. Nó bao gồm việc tạo cây module, áp dụng các quy tắc riêng tư để kiểm soát tầm nhìn của các mục, và sử dụng đường dẫn cũng như các từ khóa như use và pub để quản lý phạm vi và tạo ra API sạch sẽ.

Kết quả học tập:

• Tổ chức mã nguồn thành cấu trúc phân cấp bằng module và cây module.
• Tham chiếu các mục mã nguồn bằng cả đường dẫn tuyệt đối và tương đối.
• Kiểm soát tầm nhìn của hàm, module và trường bằng từ khóa pub và các quy tắc riêng tư.

🔹 Bài học 8: Các bộ sưu tập phổ biến

Tổng quan: Bài học này khám phá các bộ sưu tập trong thư viện chuẩn của Rust, cụ thể là Vectors, Strings và Hash Maps. Các cấu trúc dữ liệu này được lưu trữ trên đệm, cho phép chúng mở rộng hoặc thu nhỏ tại thời điểm chạy, và bài học chi tiết cách các quy tắc sở hữu và mượn của Rust đảm bảo an toàn bộ nhớ và hiệu suất khi quản lý các danh sách giá trị, văn bản UTF-8 và các cặp khóa-giá trị.

Kết quả học tập:

• Triển khai danh sách động bằng Vec<T> và quản lý vòng đời của chúng thông qua bộ kiểm tra mượn (borrow checker).
• Xử lý văn bản được mã hóa UTF-8 bằng kiểu String trong khi vượt qua các phức tạp về đại diện nội bộ và nối chuỗi.
• Áp dụng HashMap<K, V> để lưu trữ và cập nhật dữ liệu liên quan một cách hiệu quả bằng API Entry và xem xét băm tùy chỉnh.

🔹 Bài học 9: Chiến lược xử lý lỗi

Tổng quan: Bài học này khám phá triết lý xử lý lỗi mạnh mẽ của Rust, phân biệt giữa lỗi có thể phục hồi và lỗi không thể phục hồi. Người học sẽ học cách sử dụng macro panic! cho các lỗi nghiêm trọng, kiểu Result cho các lỗi có thể xử lý, và toán tử ? để đơn giản hóa việc lan truyền lỗi. Ngoài ra, bài học còn đề cập đến cách sử dụng hệ thống kiểu của Rust để buộc kiểm tra dữ liệu và duy trì tính toàn vẹn chương trình.

Kết quả học tập:

• Nhận diện khi nào nên dùng panic! không thể phục hồi thay vì Result có thể phục hồi dựa trên tiêu chí "trạng thái xấu".
• Sử dụng backtrace để gỡ lỗi nguồn gốc của lỗi không thể phục hồi.
• Triển khai lan truyền lỗi bằng toán tử ? và sửa đổi hàm main để hỗ trợ trả về lỗi.

🔹 Bài học 10: Generic, Traits và Lifetimes

Tổng quan: Bài học này khám phá các công cụ giúp trừu tượng hiệu quả trong Rust: Generic để giảm trùng lặp mã nguồn giữa các kiểu, Traits để định nghĩa hành vi chung (giao diện), và Lifetimes để đảm bảo an toàn bộ nhớ mà không cần quản lý thủ công. Cùng nhau, các tính năng này cho phép nhà phát triển viết mã nguồn hiệu suất cao, tái sử dụng được, được kiểm tra bởi trình biên dịch để ngăn chặn các tham chiếu treo và sai lệch kiểu.

Kết quả học tập:

• Định nghĩa và sử dụng tham số kiểu generic trong hàm, struct và enum để xử lý nhiều kiểu dữ liệu.
• Triển khai hành vi chung bằng Traits và Giới hạn Trait để giới hạn các kiểu generic.
• Áp dụng chú thích Lifetime và quy tắc Elision để quản lý tính hợp lệ của tham chiếu và thỏa mãn bộ kiểm tra mượn.

🔹 Bài học 11: Viết kiểm thử tự động

Tổng quan: Bài học này khám phá việc triển khai và tổ chức kiểm thử tự động trong Rust. Nó bao gồm các yêu cầu cấu trúc của một hàm kiểm thử, việc sử dụng các macro kiểm tra để xác minh logic, và các khác biệt kỹ thuật giữa kiểm thử đơn vị và kiểm thử tích hợp. Người học cũng sẽ hiểu cách kiểm soát hành vi của trình kiểm thử Rust để quản lý luồng thực thi và độ hiển thị.

Kết quả học tập:

• Xác định cấu trúc và dữ liệu bổ sung cần thiết cho một hàm kiểm thử Rust hợp lệ.
• Triển khai các kiểm tra đẳng thức và xác minh trạng thái gây lỗi để đảm bảo độ tin cậy của mã nguồn.
• Cấu hình trình kiểm thử để thực thi song song hoặc tuần tự và kiểm soát độ hiển thị đầu ra chương trình.

🔹 Bài học 12: Dự án I/O: Công cụ dòng lệnh

Tổng quan: Bài học này hướng dẫn nhà phát triển xây dựng một công cụ dòng lệnh hoạt động (một phiên bản đơn giản của grep) bằng Rust. Nó tập trung vào việc chuyển từ một tập lệnh một file sang một tệp nhị phân có cấu trúc, sản phẩm chuyên nghiệp bằng cách nhấn mạnh việc phân tích tham số an toàn về bộ nhớ, I/O tệp và tách biệt trách nhiệm giữa logic thư viện và giao diện dòng lệnh. Người học sẽ triển khai xử lý lỗi mạnh mẽ và phát triển các tính năng bằng phương pháp Phát triển kiểm thử theo hướng (TDD) trong khi quản lý trạng thái ứng dụng thông qua biến môi trường.

Kết quả học tập:

• Thu thập và chuyển đổi các tham số dòng lệnh thành các đối tượng cấu hình có cấu trúc.
• Refactor mã nguồn để tuân thủ nguyên tắc "Tách biệt trách nhiệm" cho các dự án nhị phân.
• Triển khai logic cốt lõi bằng chu trình Phát triển kiểm thử theo hướng (TDD) với chú thích lifetime.

🔹 Bài học 13: Tính năng hàm: Iterators và Closures

Tổng quan: Bài học này khám phá các tính năng lập trình hàm của Rust, cụ thể là closures và iterators. Closures là các hàm ẩn danh có thể bắt giữ môi trường của chúng, được kiểm soát bởi các trait Fn, trong khi iterators cung cấp cách xử lý dãy các mục một cách chậm (lazy) và hiệu quả. Cùng nhau, các tính năng này cho phép viết mã nguồn biểu đạt, tuân thủ nguyên tắc "abstraction không chi phí" của Rust, thường đạt hoặc vượt quá hiệu suất của các vòng lặp truyền thống.

Kết quả học tập:

• Định nghĩa các hàm ẩn danh (closures) và giải thích cách chúng bắt giữ biến từ môi trường thông qua mượn hoặc di chuyển.
• Phân biệt giữa ba trait Fn (Fn, FnMut, và FnOnce) và hiểu cách trình biên dịch suy luận kiểu closure.
• Triển khai trait Iterator bằng phương thức next và phân biệt giữa các bộ lọc tiêu thụ (consuming adaptors) và bộ lọc iterator.

🔹 Bài học 14: Cargo nâng cao và Crates.io

Tổng quan: Bài học này khám phá các tính năng nâng cao của trình quản lý gói Rust, Cargo, và hệ sinh thái của nó là Crates.io. Nó tập trung vào việc tối ưu hóa bản dựng thông qua các hồ sơ phát hành, tạo tài liệu chuyên nghiệp kèm kiểm thử tích hợp, và nắm vững kiến trúc API công cộng. Ngoài ra, nó còn đề cập đến chu kỳ sống của một crate – từ việc đăng tải và phiên bản hóa đến quản lý các dự án đa gói qua workspaces và mở rộng chức năng sẵn có của Cargo.

Kết quả học tập:

• Cấu hình Hồ sơ Phát hành để cân bằng tốc độ biên dịch và hiệu suất thời gian chạy.
• Tạo và xác minh Bình luận Tài liệu (Documentation Comments) để vừa là hướng dẫn người dùng vừa là kiểm thử tự động.
• Thiết kế một API công cộng thuận tiện bằng cách sử dụng re-export (pub use) để tách biệt cấu trúc nội bộ khỏi cách sử dụng bên ngoài.

🔹 Bài học 15: Con trỏ thông minh

Tổng quan: Bài học này khám phá các Con trỏ thông minh của Rust – các cấu trúc dữ liệu hoạt động như con trỏ nhưng mang thêm thông tin và khả năng. Chúng tôi tập trung vào việc quản lý cấp phát bộ nhớ đệm bằng Box<T>, cho phép chia sẻ quyền sở hữu bằng Rc<T>, và vượt qua các quy tắc mượn nghiêm ngặt nhờ mô hình Nội tại Thay đổi (Interior Mutability) với RefCell<T>. Ngoài ra, chúng tôi cũng đề cập đến các trait Deref và Drop – nền tảng cho hành vi con trỏ thông minh và dọn dẹp tài nguyên.

Kết quả học tập:

• Triển khai các cấu trúc dữ liệu đệ quy bằng Box<T> để cung cấp sự gián tiếp và kích thước bộ nhớ xác định.
• Tùy chỉnh hành vi con trỏ và quản lý tài nguyên bằng các trait Deref và Drop.
• Quản lý nhiều người sở hữu và tính thay đổi được kiểm tra tại thời điểm chạy bằng cách kết hợp Rc<T> và RefCell<T>.

🔹 Bài học 16: Tính đồng thời đáng tin cậy

Tổng quan: Bài học này khám phá triết lý "Tính đồng thời không sợ hãi" của Rust, chứng minh cách ngôn ngữ tận dụng hệ thống sở hữu và kiểu để biến lập trình đồng thời từ một khu vực nguy hiểm tại thời điểm chạy thành một chắc chắn tại thời điểm biên dịch. Chúng tôi đề cập đến việc tạo luồng, giao tiếp an toàn thông qua truyền tin, quản lý trạng thái chung bằng mutex, và các đặc tính cơ bản định nghĩa tính an toàn khi thực thi đồng thời.

Kết quả học tập:

• Tạo và quản lý luồng bằng spawn và join trong khi giải quyết xung đột sở hữu bằng từ khóa move.
• Triển khai tính đồng thời truyền tin bằng kênh mpsc để truyền dữ liệu an toàn giữa các luồng.
• Quản lý trạng thái chung giữa nhiều luồng bằng Mutex<T> để loại trừ lẫn nhau và Arc<T> để đếm tham chiếu an toàn khi thực thi đồng thời.

🔹 Bài học 17: Lập trình hướng đối tượng trong Rust

Tổng quan: Bài học này khám phá cách Rust triển khai các nguyên lý lập trình hướng đối tượng (OOP) cốt lõi, cụ thể là đóng gói và đa hình. Nó chi tiết các cơ chế của đối tượng trait để xử lý các tập hợp đa dạng, và các thỏa hiệp giữa truyền dẫn tĩnh và truyền dẫn động. Cuối cùng, nó so sánh cách triển khai Mẫu State kinh điển với một cách tiếp cận phù hợp hơn với phong cách Rust là mã hóa các trạng thái và hành vi trực tiếp vào hệ thống kiểu.

Kết quả học tập:

• Triển khai đóng gói trong Rust bằng module và các biện pháp kiểm soát tầm nhìn để che giấu trạng thái nội bộ.
• Sử dụng đối tượng trait để đạt được đa hình và hiểu hệ quả hiệu suất của truyền dẫn tĩnh so với truyền dẫn động.
• Áp dụng Mẫu State để quản lý hành vi đối tượng phức tạp và chuyển đổi giữa các trạng thái.

🔹 Bài học 18: Mô hình và khớp mẫu nâng cao

Tổng quan: Bài học này khám phá chiều sâu của hệ thống khớp mẫu trong Rust, đi xa hơn các cánh cửa match đơn giản để xử lý việc trích xuất dữ liệu phức tạp và điều khiển luồng. Người học sẽ thành thạo sự khác biệt giữa các mẫu không thể phản bác (irrefutable) và có thể phản bác (refutable), học cách phân tách các cấu trúc lồng ghép phức tạp, và sử dụng cú pháp nâng cao như điều kiện khớp (match guards) và gán (bindings) để viết mã nguồn biểu đạt và an toàn hơn.

Kết quả học tập:

• Phân biệt giữa các mẫu không thể phản bác và có thể phản bác, và áp dụng đúng vào các cấu trúc Rust phù hợp (ví dụ: let so với if let).
• Phân tách struct, enum và tuple để trích xuất dữ liệu cụ thể vào các biến cục bộ.
• Sử dụng cú pháp mẫu nâng cao, bao gồm khoảng cách, nhiều mẫu, bỏ qua giá trị, và gán @ cho khớp điều kiện phức tạp.

🔹 Bài học 19: Tính năng nâng cao và Rust không an toàn

Tổng quan: Bài học này khám phá "siêu năng lực" của Rust cho phép nhà phát triển vượt qua một số giới hạn trình biên dịch và tạo ra các trừu tượng cực kỳ linh hoạt. Chúng tôi đề cập đến việc sử dụng Rust không an toàn để thao tác bộ nhớ cấp thấp, các kỹ thuật nâng cao của trait cho mối quan hệ kiểu phức tạp, và khả năng lập trình siêu mạnh của Macro Khai báo và Macro Thủ tục.

Kết quả học tập:

• Phân biệt giữa Rust an toàn và các "siêu năng lực" không an toàn cần thiết để thao tác con trỏ thô và gọi hàm không an toàn.
• Triển khai các mẫu trait nâng cao bao gồm Kiểu liên quan, Ghi đè toán tử, Supertraits, và Mẫu Newtype.
• Làm rõ các cuộc gọi phương thức bằng cú pháp đầy đủ và quản lý các kiểu phức tạp như Kiểu Có kích thước động (DST) và Cách gán kiểu.

🔹 Bài học 20: Dự án cuối cùng: Máy chủ web đa luồng

Tổng quan: Bài học này hướng dẫn phát triển một máy chủ web hiệu suất cao sử dụng các nguyên tố mạng và đồng thời của Rust. Nó bao gồm việc chuyển từ một bộ lắng nghe TCP cơ bản sang một hệ thống đa luồng tiên tiến sử dụng một hàng đợi luồng do chính bạn xây dựng. Người học sẽ học cách quản lý các luồng cấp thấp, triển khai truyền tin dựa trên nhân viên để phân phối nhiệm vụ, và đảm bảo ổn định hệ thống thông qua cơ chế dừng hoạt động nhẹ nhàng.

Kết quả học tập:

• Thiết lập và quản lý Kết nối TCP: Gắn máy chủ vào một cổng cục bộ và xử lý luồng byte đầu vào.
• Phân tích và phản hồi HTTP: Đọc dữ liệu yêu cầu thô và tạo phản hồi HTTP hợp lệ với dòng trạng thái và nội dung HTML.
• Thiết kế Hàng đợi Luồng Tùy chỉnh: Sử dụng kênh mpsc và các công cụ đồng bộ (Arc, Mutex) để phân phối nhiệm vụ qua một số lượng luồng hữu hạn.

🔹 Bài học 21: Phụ lục Rust: Công cụ và tham khảo

Tổng quan: Bài học này cung cấp một tài liệu tham khảo kỹ thuật toàn diện cho ngôn ngữ lập trình Rust, tập trung vào cú pháp dày đặc, các công cụ phát triển tự động, và quy trình phát hành tiến hóa. Người học sẽ học cách đi xuyên qua cú pháp nặng ký của Rust, triển khai các hành vi chuẩn qua các trait có thể suy diễn, và tận dụng công cụ của hệ sinh thái để duy trì chất lượng mã nguồn cao và tuân thủ triết lý "ổn định mà không đình trệ" của ngôn ngữ.

Kết quả học tập:

• Nhận diện và Hiểu cú pháp: Giải mã các toán tử, ký hiệu liên quan đến đường dẫn và ràng buộc kiểu của Rust bằng bảng tham chiếu chuẩn.
• Triển khai Hành vi Chuẩn: Tự động hóa việc triển khai các đặc tính Debug, Clone, Eq, Ord, và Hash bằng thuộc tính derive.
• Tối ưu hóa Quy trình phát triển: Sử dụng rustfmt, rustfix và Clippy để định dạng, sửa lỗi và kiểm tra mã theo các chuẩn cộng đồng.