Skip to content

Rust trong phát triển phần mềm AI

Spread the love

Rust là ngôn ngữ lập trình hệ thống hiện đại, nổi bật với hiệu năng cao, an toàn bộ nhớ và khả năng xử lý đồng thời vượt trội.

Giới thiệu về Rust

Rust là một ngôn ngữ lập trình hệ thống hiện đại, tập trung vào ba mục tiêu chính: hiệu năng, an toàn bộ nhớ, và xử lý đồng thời. Nó mang lại tốc độ thô và khả năng kiểm soát cấp thấp như C/C++, nhưng được trang bị một “người bảo vệ” mạnh mẽ—bộ kiểm tra mượn (borrow checker)—giúp phát hiện lỗi bộ nhớ và điều kiện tranh chấp ngay tại thời điểm biên dịch.

🔑 Các đặc điểm nổi bật

  • Hiệu năng: Rust biên dịch thành mã máy hiệu quả, cho phép kiểm soát tài nguyên hệ thống chi tiết—lý tưởng cho các tác vụ yêu cầu hiệu năng cao.
  • An toàn bộ nhớ (Không cần bộ gom rác): Khác với Python hay Java, Rust quản lý bộ nhớ tại thời điểm biên dịch, giúp tránh các lỗi phổ biến như tràn bộ đệm hoặc con trỏ null.
  • Xử lý đồng thời: Quy tắc an toàn của Rust giúp viết chương trình đa luồng dễ dàng và an toàn hơn.
  • Công cụ hiện đại: Cargo—trình quản lý gói và công cụ xây dựng—giúp quản lý phụ thuộc và dự án cực kỳ đơn giản.

🧠 Rust trong phát triển phần mềm AI

Rust không thay thế Python trong nghiên cứu AI, nhưng đang trở thành lựa chọn hàng đầu cho các phần hiệu năng cao trong quy trình sản xuất AI:

  • Thư viện nền hiệu năng cao: Rust đang dần thay thế C++ trong các thư viện mà Python gọi đến, nhờ độ an toàn và ít lỗi hơn.
  • Kỹ thuật dữ liệu: Các công cụ xử lý dữ liệu lớn viết bằng Rust nhanh hơn đáng kể so với Python.
  • Suy luận và AI biên (Edge AI): Với kích thước nhị phân nhỏ, tiêu thụ bộ nhớ thấp và không cần bộ gom rác, Rust lý tưởng cho thiết bị hạn chế như điện thoại, ô tô, hoặc hệ thống nhúng.
  • Công cụ AI: Nhiều công cụ hỗ trợ hệ sinh thái AI như trình soạn thảo mã, kiểm tra cú pháp, và trình quản lý gói đang được xây dựng bằng Rust.

👉 Tóm lại: Python là “bộ não” để thử nghiệm và nguyên mẫu, còn Rust là “động cơ” mạnh mẽ và an toàn để thực thi các tác vụ nặng.

🛠️ Cách cài đặt Rust

Cách chính thức là dùng rustup, trình cài đặt và quản lý phiên bản Rust:

  • macOS, Linux, WSL:
    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
    Có thể cần quyền sudo để cài đặt. Sau khi cài xong, chạy: source $HOME/.cargo/env
  • Windows: Truy cập rust-lang.org/tools/install và tải rustup-init.exe.
  • Kiểm tra cài đặt: rustc --version cargo --version

👋 Dự án “Hello, World!”

  1. Tạo dự án mới: cargo new hello_world cd hello_world
  2. Mã nguồn mặc định (src/main.rs): 
fn main() {
    println!("Hello, world!");
}
  1. Chạy chương trình: cargo run

📘 Ví dụ mã cơ bản

// Đây là hàm chính, điểm bắt đầu của chương trình.
fn main() {
    // 1. BIẾN
    // Mặc định, biến là bất biến (không thể thay đổi).
    let an_immutable_number = 5;
    println!("Số bất biến là: {}", an_immutable_number);

    // Để biến có thể thay đổi, PHẢI dùng từ khóa `mut`.
    let mut a_mutable_number = 10;
    println!("Số có thể thay đổi ban đầu là: {}", a_mutable_number);

    a_mutable_number = 20;
    println!("Số có thể thay đổi bây giờ là: {}", a_mutable_number);

    // 2. GỌI HÀM
    // Chúng ta có thể gọi hàm tự định nghĩa `add_numbers`.
    let sum = add_numbers(an_immutable_number, a_mutable_number);
    println!("{} + {} = {}", an_immutable_number, a_mutable_number, sum);
}

// Đây là một hàm tự định nghĩa.
// Nó nhận hai số nguyên có dấu 32-bit (i32) làm tham số.
// Phần `-> i32` cho biết hàm này trả về một số nguyên 32-bit.
fn add_numbers(x: i32, y: i32) -> i32 {
    // Trong Rust, nếu dòng cuối cùng của hàm là một biểu thức
    // (không có dấu chấm phẩy), thì giá trị đó sẽ được trả về tự động.
    x + y
}

Kết quả khi chạy:

Số bất biến là: 5
Số có thể thay đổi ban đầu là: 10
Số có thể thay đổi bây giờ là: 20
5 + 20 = 25

Dùng RUST trong Visual Studio Code

Visual Studio Code là trình soạn thảo mã (code editor) phổ biến nhất và được khuyên dùng để phát triển Rust.

Trải nghiệm rất tuyệt vời, nhưng nó yêu cầu một tiện ích mở rộng (extension) then chốt để hoạt động.

Cách Cài Đặt (2 Bước)

Sau khi cài đặt RUST theo hướng dẫn bên trên, (hoặc bạn cũng có thể cài đặt sau khi cài các tiện ích mở rộng này):

  1. Cài đặt Tiện ích mở rộng rust-analyzer: Đây là máy chủ ngôn ngữ (language server) chính thức cho Rust. Nó chính là thứ cung cấp cho bạn tất cả các tính năng thông minh.
    • Đi tới tab Extensions (Tiện ích mở rộng) trong VS Code (biểu tượng bốn ô vuông).
    • Tìm kiếm rust-analyzer.
    • Cài đặt tiện ích được phát hành bởi Rust-lang team.
  2. Cài đặt Tiện ích mở rộng Trình gỡ lỗi (Debugger): Để có trải nghiệm gỡ lỗi (debugging) đầy đủ (đặt điểm dừng – breakpoints, đi qua từng bước mã), bạn cũng cần một trình gỡ lỗi.
    • Nếu bạn dùng Mac/Linux, tiện ích tốt nhất là CodeLLDB.
    • Nếu bạn dùng Windows, bạn nên sử dụng tiện ích mở rộng C/C++ chính thức của Microsoft: Đi tới tab Extensions >> Tìm kiếm: C/C++ >> Cài đặt tiện ích được phát hành bởi: Microsoft. Gói tiện ích mở rộng C/C++ này bao gồm trình gỡ lỗi của Microsoft, mà rust-analyzer sẽ tự động sử dụng để cho phép bạn đặt điểm dừng và duyệt qua từng bước mã Rust của mình.

Cài đặt này mang lại cho bạn những gì

Một khi bạn đã cài đặt rust-analyzer, bạn sẽ nhận được tất cả các tính năng hiện đại mà bạn mong đợi từ một IDE, ngay bên trong VS Code:

  • Hoàn thành mã thông minh (Intelligent Code Completion): Tự động hoàn thành mã của bạn, bao gồm các phương thức và kiểu.
  • Kiểm tra lỗi theo thời gian thực (Real-time Error Checking): Hiển thị lỗi trình biên dịch ngay khi bạn gõ, vì vậy bạn thậm chí không cần chạy cargo build để thấy lỗi.
  • “Đi tới Định nghĩa” (Go to Definition): Bạn có thể nhảy thẳng đến mã nguồn của bất kỳ hàm hoặc kiểu nào.
  • Các nút Chạy & Gỡ lỗi (Run & Debug Buttons): Các nút văn bản nhỏ “Run | Debug” sẽ xuất hiện ngay phía trên các hàm fn main() và hàm test của bạn, cho phép bạn chạy hoặc gỡ lỗi mã của mình chỉ bằng một cú nhấp chuột.

Bây giờ bạn đã có một môi trường phát triển Rust hoàn chỉnh, chuyên nghiệp được thiết lập.

Tạo và chạy dự án Rust đầu tiên của bạn trong VS Code

Chúng ta sẽ sử dụng cargo (công cụ bạn vừa cài đặt) để tạo dự án, và sau đó sử dụng VS Code để viết và chạy mã.

Bước 1: Tạo Dự án Mới với cargo

Đầu tiên, mở Terminal của bạn. Di chuyển (cd) đến thư mục mà bạn muốn lưu các dự án của mình (ví dụ: ~/Documents hoặc ~/Developer).

Sau đó, chạy lệnh này để tạo một dự án mới tên là hello_rust:

Bash

cargo new hello_rust

Bạn sẽ thấy kết quả này:

     Created binary (application) `hello_rust` package

Lệnh này vừa tạo một thư mục mới tên là hello_rust với tất cả các tệp cần thiết bên trong, bao gồm một chương trình “Hello, world!” đơn giản.

Bước 2: Mở Dự án trong VS Code

Bây giờ, hãy mở thư mục đó trong VS Code.

Trong Terminal của bạn, di chuyển vào thư mục mới:

Bash

cd hello_rust

Gõ lệnh sau để mở toàn bộ thư mục trong VS Code:

Bash

code .

(Dấu . có nghĩa là “mở thư mục hiện tại”.)

Bước 3: Khám phá các Tệp Dự án

Trong trình khám phá tệp (file explorer) của VS Code ở bên trái, bạn sẽ thấy hai tệp chính:

  • Cargo.toml: Đây là tệp kê khai (manifest file) cho dự án của bạn. Nó theo dõi tên, phiên bản, và bất kỳ phụ thuộc (dependencies) (các thư viện khác) nào bạn có thể thêm vào sau này.
  • src/main.rs: Đây là nơi chứa tất cả mã ứng dụng của bạn. (.rs là phần mở rộng tệp cho Rust).

Bước 4: Chạy Chương trình “Hello, world!” của bạn

Nhấp vào tệp src/main.rs để mở nó.

Bạn sẽ thấy mã “Hello, world!” mà Cargo đã tạo cho bạn:

Rust

fn main() {
    println!("Hello, world!");
}

Bây giờ, hãy nhìn ngay phía trên dòng fn main(). Vì bạn đã cài đặt rust-analyzer, bạn sẽ thấy hai nút văn bản nhỏ, có thể nhấp được:

Run | Debug

Nhấp vào nút “Run“.

Bước 5: Xem Kết quả (Output)

Một bảng điều khiển Terminal sẽ mở ra ở dưới cùng của cửa sổ VS Code. Cargo sẽ biên dịch (compile) chương trình của bạn và sau đó chạy nó. Bạn sẽ thấy kết quả:

Bash

    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/hello_rust`
Hello, world!

Thế là xong! Bạn đã tạo, biên dịch và chạy thành công một chương trình Rust hoàn toàn từ bên trong VS Code.

Từ đây, bạn có thể chỉ cần thay đổi văn bản bên trong macro println!, nhấp “Run” lần nữa, và xem các thay đổi của mình.

Bây giờ, bạn có thể tiếp tục dán code này từ ví dụ đã được nói đến trước vào để chạy

// Đây là hàm chính, điểm bắt đầu của chương trình.
fn main() {
    // 1. BIẾN
    // Mặc định, biến là bất biến (không thể thay đổi).
    let an_immutable_number = 5;
    println!("Số bất biến là: {}", an_immutable_number);

    // Để biến có thể thay đổi, PHẢI dùng từ khóa `mut`.
    let mut a_mutable_number = 10;
    println!("Số có thể thay đổi ban đầu là: {}", a_mutable_number);

    a_mutable_number = 20;
    println!("Số có thể thay đổi bây giờ là: {}", a_mutable_number);

    // 2. GỌI HÀM
    // Chúng ta có thể gọi hàm tự định nghĩa `add_numbers`.
    let sum = add_numbers(an_immutable_number, a_mutable_number);
    println!("{} + {} = {}", an_immutable_number, a_mutable_number, sum);
}

// Đây là một hàm tự định nghĩa.
// Nó nhận hai số nguyên có dấu 32-bit (i32) làm tham số.
// Phần `-> i32` cho biết hàm này trả về một số nguyên 32-bit.
fn add_numbers(x: i32, y: i32) -> i32 {
    // Trong Rust, nếu dòng cuối cùng của hàm là một biểu thức
    // (không có dấu chấm phẩy), thì giá trị đó sẽ được trả về tự động.
    x + y
}

📚 Tài liệu học tốt nhất: The Rust Book và Rust by Example

Theo https://ksml4.com/rust-for-ai-software-development/
https://ksml4.com/using-rust-with-visual-studio-code/

Discover more from Cùng Học Cùng Mơ

Subscribe to get the latest posts sent to your email.

Leave a Reply

Your email address will not be published. Required fields are marked *

error: Content is protected !!