Câu trả lời: Docker Compose. Bài viết này hướng dẫn bạn từng bước cài đặt môi trường phát triển Mojo hoàn chỉnh trên Windows — không cần WSL phức tạp, không cần dual-boot Linux.

Nếu bạn chưa biết Mojo là gì, hãy đọc bài Ngôn ngữ lập trình Mojo: Python++ nhanh hơn Python đến 68.000 lần trước nhé!

Tại sao dùng Docker cho Mojo trên Windows?

Mojo SDK yêu cầu hệ điều hành Linux (Ubuntu 22.04+). Trên Windows, bạn có 3 lựa chọn:

1. WSL2 — Cài Windows Subsystem for Linux, rồi cài Mojo trong đó
2. Virtual Machine — Chạy Linux trong VMware/VirtualBox
3. Docker ← Lựa chọn tốt nhất

Docker vượt trội ở các điểm:

• Nhẹ hơn VM nhiều lần — khởi động chỉ vài giây
• Dễ chia sẻ, tái tạo môi trường — đồng nghiệp chỉ cần docker compose up
• Quản lý bằng file docker-compose.yml — version control được
• Không “ô nhiễm” máy host
• Hỗ trợ tích hợp VS Code qua Dev Containers

Yêu cầu hệ thống

• Windows 10/11 (64-bit, bản Pro/Enterprise/Education hoặc Home có WSL2 backend)
• Docker Desktop for Windows (phiên bản mới nhất)
• RAM: tối thiểu 8GB (khuyến nghị 16GB)
• Ổ cứng: tối thiểu 10GB trống
• CPU: hỗ trợ virtualization (VT-x/AMD-V)

Bước 1: Cài đặt Docker Desktop

Truy cập docker.com/products/docker-desktop và tải Docker Desktop for Windows. Khi cài, chọn Use WSL 2 instead of Hyper-V (khuyến nghị). Sau khi cài xong, khởi động lại máy.

Kiểm tra Docker trong PowerShell:

docker --version
docker compose version

Kết quả mong đợi:

Docker version 27.x.x, build xxxxxxx
Docker Compose version v2.x.x

Bước 2: Tạo cấu trúc dự án

Tạo thư mục dự án trên Windows:

mkdir C:\Projects\mojo-dev
cd C:\Projects\mojo-dev

Dockerfile

Tạo file Dockerfile:

# Mojo Development Environment
FROM ubuntu:22.04

# Tránh interactive prompts khi cài packages
ENV DEBIAN_FRONTEND=noninteractive

# Cài đặt dependencies cơ bản
RUN apt-get update && apt-get install -y \
    curl git python3 python3-pip python3-venv wget nano \
    && rm -rf /var/lib/apt/lists/*

# Cài pixi (package manager cho Mojo)
RUN curl -fsSL https://pixi.sh/install.sh | bash
ENV PATH="/root/.pixi/bin:${PATH}"

# Tạo thư mục workspace
WORKDIR /workspace

# Tạo Mojo project với pixi
RUN pixi init mojo-project \
    -c https://conda.modular.com/max-nightly/ \
    -c conda-forge \
    && cd mojo-project \
    && pixi add mojo

# Set working directory vào project
WORKDIR /workspace/mojo-project

# Giữ container chạy
CMD ["bash"]

docker-compose.yml

services:
  mojo:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: mojo-dev
    volumes:
      # Mount thư mục code từ Windows vào container
      - ./code:/workspace/mojo-project/code
    stdin_open: true   # Giữ stdin mở (tương đương -i)
    tty: true          # Cấp pseudo-TTY (tương đương -t)
    working_dir: /workspace/mojo-project
    deploy:
      resources:
        limits:
          memory: 4G

Tạo thư mục chứa code:

mkdir code

Cấu trúc dự án cuối cùng:

C:\Projects\mojo-dev\
├── Dockerfile
├── docker-compose.yml
└── code\           ← Thư mục chứa code Mojo của bạn

Bước 3: Build và khởi động container

# Build image (lần đầu mất khoảng 5-10 phút)
docker compose build

# Khởi động container ở background
docker compose up -d

# Kiểm tra container đang chạy
docker compose ps

Bước 4: Kiểm tra Mojo đã hoạt động

Vào container:

docker compose exec mojo bash

Kiểm tra phiên bản:

pixi run mojo --version
# Output: mojo 2026.1.x (xxxxxxxx)

Thử Mojo REPL:

pixi run mojo

# Trong REPL:
1> print("Hello from Mojo on Windows! 🔥")
Hello from Mojo on Windows! 🔥

Bước 5: Viết chương trình Mojo đầu tiên

5.1 Hello World

Tạo file code/hello.mojo trên Windows (dùng VS Code hoặc bất kỳ editor nào):

# hello.mojo - Chương trình Mojo đầu tiên trên Windows!

def main():
    print("🔥 Xin chào từ Mojo trên Docker!")
    print("Mojo chạy thành công trên Windows!")
    
    # Kiểm tra kiểu dữ liệu cơ bản
    var name: String = "Mojo Developer"
    var version: Int = 2026
    print("Xin chào, " + name + "! Chào mừng đến với Mojo " + str(version))

Chạy trong container:

pixi run mojo run code/hello.mojo

Kết quả:

🔥 Xin chào từ Mojo trên Docker!
Mojo chạy thành công trên Windows!
Xin chào, Mojo Developer! Chào mừng đến với Mojo 2026

5.2 Benchmark — So sánh tốc độ Mojo

Tạo file code/benchmark.mojo để kiểm tra hiệu năng:

# benchmark.mojo - So sánh tốc độ tính toán
from time import now

def fibonacci_mojo(n: Int) -> Int:
    if n <= 1:
        return n
    var a: Int = 0
    var b: Int = 1
    for _ in range(2, n + 1):
        var temp = a + b
        a = b
        b = temp
    return b

def main():
    print("=" * 50)
    print("🔥 MOJO BENCHMARK trên Docker/Windows")
    print("=" * 50)
    
    var iterations = 1_000_000
    
    var start = now()
    var total: Int = 0
    for i in range(iterations):
        total += fibonacci_mojo(100)
    var elapsed_ms = (now() - start) / 1_000_000
    
    print("\n📊 Kết quả:")
    print("  Fibonacci(100) x " + str(iterations) + " lần")
    print("  Thời gian: " + str(elapsed_ms) + " ms")
    
    print("\n✅ Mojo hoạt động hoàn hảo trên Docker/Windows!")

pixi run mojo run code/benchmark.mojo

5.3 Kiểm tra tích hợp Python

Một trong những điểm mạnh nhất của Mojo là gọi được thư viện Python trực tiếp. Tạo file code/python_interop.mojo:

# python_interop.mojo - Gọi Python từ Mojo
from python import Python

def main():
    print("🐍 Kiểm tra tích hợp Python từ Mojo\n")
    
    # Import thư viện Python chuẩn
    var sys = Python.import_module("sys")
    print("Python version: " + str(sys.version))
    
    # Dùng math module
    var math = Python.import_module("math")
    print("Pi = " + str(math.pi))
    print("sqrt(144) = " + str(math.sqrt(144)))
    
    # Dùng datetime
    var datetime = Python.import_module("datetime")
    var now_time = datetime.datetime.now()
    print("Thời gian hiện tại: " + str(now_time))
    
    # Tạo và xử lý JSON
    var json_mod = Python.import_module("json")
    var data = Python.dict()
    data["language"] = "Mojo"
    data["platform"] = "Docker on Windows"
    data["status"] = "Working!"
    print("\nJSON output: " + str(json_mod.dumps(data, indent=2)))
    
    print("\n✅ Python interop hoạt động tốt!")

Nếu thấy output Python version, Pi, thời gian, và JSON — môi trường Mojo của bạn đã hoàn chỉnh!

Các lệnh Docker Compose thường dùng

Kết nối VS Code với container

Để có trải nghiệm lập trình tốt nhất, kết nối VS Code trực tiếp vào container:

1. Cài extension Dev Containers (ms-vscode-remote.remote-containers) và Mojo (modular-mojotools.vscode-mojo)
2. Nhấn F1 → gõ Dev Containers: Attach to Running Container
3. Chọn container mojo-dev
4. VS Code sẽ mở cửa sổ mới kết nối vào container
5. Mở thư mục /workspace/mojo-project/code

Giờ bạn có thể viết code Mojo trên Windows với syntax highlighting, autocompletion, và chạy trực tiếp trong container!

Xử lý lỗi thường gặp

Docker build bị timeout

$env:DOCKER_CLIENT_TIMEOUT=300
$env:COMPOSE_HTTP_TIMEOUT=300
docker compose build

Container bị "Exited"

# Kiểm tra logs
docker compose logs mojo

# Khởi động lại
docker compose restart

Lỗi "permission denied" với file mount

Mở Docker Desktop → Settings → Resources → File Sharing, thêm đường dẫn C:\Projects\mojo-dev.

Thiếu RAM khi build

Mở Docker Desktop → Settings → Resources → tăng Memory lên 4-6GB.

Fullstack Station Tips

1. Mount thư mục code, không mount cả project: Chỉ mount thư mục code/ vào container. Pixi project files nên ở trong container để tránh xung đột path Linux/Windows.
2. Dùng .dockerignore: Tạo file .dockerignore để loại bỏ node_modules, .git, etc. khỏi build context.
3. Pin version Mojo: Trong Dockerfile, thay pixi add mojo bằng pixi add 'mojo>=2026.1,<2027' để tránh breaking changes.
4. Tự động khởi động REPL: Thêm command: pixi run mojo vào docker-compose.yml — container sẽ vào REPL ngay khi khởi động.
5. Multi-stage build cho production: Dùng 2 stage — stage 1 build binary, stage 2 chỉ chứa runtime. Image nhẹ hơn nhiều lần.

Bài viết liên quan về Mojo

• Ngôn ngữ lập trình Mojo: Python++ nhanh hơn Python đến 68.000 lần
• Mojo 2024: Cập nhật tính năng và hiệu suất mới nhất
• Mojo 2025: Roadmap và tương lai ngôn ngữ AI

Bài viết được tổng hợp bởi Fullstack Station. Nguồn tham khảo: Modular Docs, Modular Blog.

The post Hướng dẫn cài đặt Mojo🔥 bằng Docker Compose trên Windows (2026) appeared first on Fullstack Station.

Mojo trong năm 2024: Tóm tắt

• Tháng 3: Mở mã nguồn thư viện chuẩn trên GitHub
• Tháng 5: Ra mắt nền tảng MAX (triển khai AI)
• Tháng 9: Mojo 24.4 với nhiều cải tiến
• Tháng 12: Cộng đồng phát triển đáng kể

Tình trạng hiện tại (Đầu năm 2025)

Những gì hoạt động tốt

from algorithm import vectorize
from sys.info import simdwidthof

# Phép toán SIMD - cực kỳ nhanh
alias kieu_du_lieu = DType.float32
alias do_rong_simd = simdwidthof[kieu_du_lieu]()

fn cong_mang(a: DTypePointer[kieu_du_lieu], b: DTypePointer[kieu_du_lieu], 
             ket_qua: DTypePointer[kieu_du_lieu], kich_thuoc: Int):
    @parameter
    fn cong_simd[do_rong: Int](i: Int):
        ket_qua.store[width=do_rong](i, 
            a.load[width=do_rong](i) + b.load[width=do_rong](i))
    
    vectorize[cong_simd, do_rong_simd](kich_thuoc)

Tương tác với Python

from python import Python

def main():
    np = Python.import_module("numpy")
    pd = Python.import_module("pandas")
    plt = Python.import_module("matplotlib.pyplot")
    
    # Sử dụng thư viện Python liền mạch
    du_lieu = np.random.randn(100)
    df = pd.DataFrame({"gia_tri": du_lieu})
    plt.plot(du_lieu)
    plt.show()

Lộ trình năm 2025

Quý 1/2025: Tập trung ổn định

• Sửa lỗi và cải thiện độ ổn định
• Thông báo lỗi rõ ràng hơn
• Cải thiện tài liệu
• Tích hợp phản hồi từ cộng đồng

Quý 2/2025: Trình quản lý gói

# Dự kiến: lệnh mojo pkg
mojo pkg init           # Khởi tạo dự án
mojo pkg add ten-goi    # Thêm gói
mojo pkg publish        # Xuất bản gói

Quý 3/2025: Hỗ trợ Windows

• Hỗ trợ Windows đầy đủ
• Tích hợp Visual Studio
• Tối ưu riêng cho Windows

Quý 4/2025: WebAssembly

# Dự kiến: biên dịch sang WASM
mojo build --target wasm ung_dung.mojo

Sự phát triển của nền tảng MAX

MAX (Modular Accelerated Xecution) là nền tảng triển khai cho AI:

from max.engine import InferenceSession
from max.tensor import Tensor

def main():
    # Tải bất kỳ model nào: PyTorch, TensorFlow, ONNX
    phien = InferenceSession()
    model = phien.load("model.onnx")
    
    # Tự động tối ưu cho phần cứng
    tensor_dau_vao = Tensor[DType.float32]([1, 3, 224, 224])
    ket_qua = model.execute(tensor_dau_vao)
    
    # Hoạt động trên CPU, GPU, bộ tăng tốc tùy chỉnh
    print(ket_qua[0])

MAX Serving (Môi trường sản phẩm)

# Triển khai model như API
max serve model.onnx --port 8000

# Máy khách
curl -X POST http://localhost:8000/predict \
    -H "Content-Type: application/json" \
    -d '{"input": [1.0, 2.0, 3.0]}'

Sự phát triển của cộng đồng

Các trường hợp sử dụng hiện tại

1. Tối ưu suy luận học máy

# Các toán tử tùy chỉnh với Mojo
struct FastAttention:
    fn forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
        # Triển khai được tối ưu
        # Nhanh hơn 10-100 lần so với Python
        ...

2. Đường ống xử lý dữ liệu

fn xu_ly_lo[T: DType](du_lieu: Tensor[T]) -> Tensor[T]:
    # Xử lý song song với SIMD
    var ket_qua = Tensor[T](du_lieu.shape)
    
    @parameter
    fn xu_ly[do_rong: Int](i: Int):
        ket_qua.store[width=do_rong](i, 
            du_lieu.load[width=do_rong](i) * 2.0)
    
    vectorize[xu_ly, simdwidthof[T]()](du_lieu.size())
    return ket_qua

3. Tính toán số học

from math import sqrt, pow

fn mandelbrot(c_re: Float64, c_im: Float64, so_lan_lap_toi_da: Int) -> Int:
    var z_re: Float64 = 0
    var z_im: Float64 = 0
    
    for i in range(so_lan_lap_toi_da):
        if z_re * z_re + z_im * z_im > 4.0:
            return i
        let tam = z_re * z_re - z_im * z_im + c_re
        z_im = 2.0 * z_re * z_im + c_im
        z_re = tam
    
    return so_lan_lap_toi_da

So sánh với các lựa chọn khác

Tiêu chí	Mojo	Python	Rust	C++
Tốc độ
Học	Dễ (giống Python)	Dễ nhất	Khó	Khó
Hệ sinh thái AI/ML	Đang phát triển	Tốt nhất	Hạn chế	Tốt
An toàn bộ nhớ	Có	Thu gom rác	Có	Thủ công

Bắt đầu

# Cài đặt Mojo
curl -s https://get.modular.com | sh -
modular auth
modular install mojo

# Kiểm tra
mojo --version

# Tạo tệp đầu tiên
echo 'fn main(): print("Xin chào, Mojo!")' > xinchao.mojo
mojo run xinchao.mojo

# Chế độ tương tác
mojo

Lời khuyên từ Fullstack Station

Mojo đang trưởng thành nhanh chóng. Gợi ý cho năm 2025:

• Học ngay: Cú pháp giống Python, dễ nắm bắt
• Bắt đầu với MAX: Trường hợp sử dụng thực tế cho triển khai AI
• Theo dõi cộng đồng: Phát triển nhanh, nhiều tài liệu sắp có
• Chưa sẵn sàng cho sản phẩm: Chờ trình quản lý gói và Windows
• Hoàn hảo cho: Tối ưu AI/ML, tính toán số học

Năm 2025 sẽ là năm Mojo chuyển từ “thú vị” sang “hữu ích”. Nếu bạn làm AI/ML, đây là ngôn ngữ đáng đầu tư.

Tham khảo

• Mojo Official
• Tài liệu Mojo
• Mojo GitHub

The post Mojo 2025: Roadmap và tương lai ngôn ngữ AI appeared first on Fullstack Station.

Mojo trong 2024: Những cập nhật quan trọng

Open Source trên GitHub

Tháng 3/2024, Modular đã open source Mojo standard library trên GitHub, đánh dấu bước ngoặt quan trọng cho cộng đồng.

MAX Platform

MAX (Modular Accelerated Xecution) là platform AI mới từ Modular, sử dụng Mojo như ngôn ngữ chính:

• Chạy models PyTorch/TensorFlow/ONNX
• Tối ưu tự động cho hardware
• API đơn giản hơn nhiều so với CUDA

Tính năng mới trong Mojo 24.x

Improved Python Interop

from python import Python

def main():
    np = Python.import_module("numpy")
    pd = Python.import_module("pandas")
    
    # Sử dụng numpy trực tiếp
    arr = np.array([1, 2, 3, 4, 5])
    print(arr.mean())  # 3.0
    
    # Pandas dataframe
    df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
    print(df)

SIMD Improvements

from algorithm import vectorize
from sys.info import simdwidthof

alias dtype = DType.float32
alias simd_width = simdwidthof[dtype]()

fn add_vectors(a: DTypePointer[dtype], b: DTypePointer[dtype], 
               result: DTypePointer[dtype], size: Int):
    @parameter
    fn add_simd[width: Int](i: Int):
        result.store[width=width](i, 
            a.load[width=width](i) + b.load[width=width](i))
    
    vectorize[add_simd, simd_width](size)

Traits và Generic Programming

trait Printable:
    fn to_string(self) -> String: ...

struct Point(Printable):
    var x: Float64
    var y: Float64
    
    fn to_string(self) -> String:
        return "(" + str(self.x) + ", " + str(self.y) + ")"

fn print_all[T: Printable](items: List[T]):
    for item in items:
        print(item.to_string())

Memory Safety Features

# Ownership và borrowing như Rust
fn process(owned data: String):
    # data được move vào function
    print(data)
    # data tự động được deallocate khi kết thúc

fn read_only(borrowed data: String):
    # Chỉ có thể đọc, không thể modify
    print(data)

Benchmark Updates

Task	Python	Mojo	Speedup
Matrix multiply	1x	68,000x
Mandelbrot	1x	35,000x
N-body simulation	1x	50,000x
Simple loops	1x	1,000x

IDE Support

• VS Code Extension – Syntax highlighting, LSP support
• Jupyter Notebooks – Mojo kernel cho interactive development
• Debugging – LLDB integration

Cài đặt Mojo (2024)

# macOS/Linux
curl -s https://get.modular.com | sh -

# Activate
modular auth
modular install mojo

# Verify
mojo --version
# mojo 24.x

Example: AI Inference với MAX

from max.engine import InferenceSession
from max.tensor import Tensor

def main():
    # Load model
    session = InferenceSession()
    model = session.load("model.onnx")
    
    # Prepare input
    input_tensor = Tensor[DType.float32]([1, 3, 224, 224])
    
    # Run inference
    outputs = model.execute(input_tensor)
    
    # Get results
    print(outputs[0])

Roadmap

Theo Modular, những tính năng sắp tới:

• Full Windows support
• Package manager
• More standard library modules
• WebAssembly target

Fullstack Station Tips

Mojo đang trưởng thành nhanh chóng. Những điểm đáng chú ý:

• Học ngay nếu bạn làm ML/AI – Mojo sẽ là future
• Python interop cho phép migrate dần dần
• MAX platform đơn giản hóa AI deployment

Mojo không thay thế Python cho mọi thứ, nhưng cho performance-critical AI workloads, nó là game-changer. Syntax giống Python nên dễ học nếu bạn đã biết Python.

Tham khảo

• Mojo Official
• Mojo GitHub
• Mojo Documentation

The post Mojo 2024: Cập nhật tính năng và hiệu suất mới nhất appeared first on Fullstack Station.

Bài viết này sẽ tập trung vào việc đo hiệu suất của ngôn ngữ lập trình Mojo, để xem thực tế chính xác đến đâu nhé. Bạn cũng đừng bỏ qua bài viết Tại sao nên học Python nhé.

Sơ lược về ngôn ngữ lập trình Mojo

Ngôn ngữ lập trình Mojo là gì

Ngôn ngữ lập trình Mojo được phát triển bởi công ty Modular, có cú pháp tương tự như Python và đạt hiệu cao hơn Python nhiều lần như C. Ban đầu họ hướng đến ngôn ngữ lập trình dành cho lập trình AI, nhưng ở thời điểm hiện tại thì đã trở thành ngôn ngữ lập trình cho những mục tiêu chung.

Ngôn ngữ lập trình Mojo khá dễ học do tương đồng với ngôn ngữ lập trình Python và được xem là Python++ nên sẽ giúp rút ngắn khoảng cách của những người nghiên cứu AI (thường sử dụng Python) đến phát triển sản phẩm (Python khá chậm và đòi hỏi nhiều tối ưu để sản phẩm đạt hiệu suất tốt)

Những đặc tính của ngôn ngữ lập trình Mojo

• Sử dụng được các thư viện Python (numpy, pandas, …): sử dụng thông Cython nên có thể dùng được hầu hết các thư viện này. Tuy nhiên, theo kết quả đo hiệu suất bên dưới, thì việc sử dụng các thư viện này không mang lại kết quả tốt về hiệu suất mong muốn.
• Sử dụng được cú pháp Python: Bạn hoàn toàn có thể sử dụng code Python trong Mojo, tuy nhiên việc sử dụng Python trong Mojo không nên ưu tiên nếu quan tâm đến hiệu suất.
• Cú pháp tương tự Python: phong cách viết tương tự Python, tuy nhiên thuần Mojo thì sẽ khắt khe trong type-checker
• Chạy đa luồng: Mojo sử dụng hạ tầng biên dịch (MLIR) để hỗ trợ nhiều loại phần cứng, bao gồm GPU chạy CUDA và phần cứng tương tự, mà không làm tăng thêm sự phức tạp trong lập trình.

Những điểm còn thiếu sót của ngôn ngữ lập trình Mojo

• Chưa hỗ trợ Mac Intel, Window và các hệ Linux khác ngoài Ubuntu
• Còn xa để đạt được mức tập cha (superset) của Python
• Rất ít các thư viện hỗ trợ
• Chưa có dependencies management: làm gì có thư viện khác mà đòi quản lý :))

Bạn có thể xem những vấn đề đang tồn tại: https://docs.modular.com/mojo/roadmap#mojo-sdk-known-issues

Cha đẻ của Mojo: Chris Latter

Thật thiếu sót nếu không nói về cha đẻ của ngôn ngữ lập trình Mojo: Chris Latter – người cũng là tác giả của trình biên dịch LLVM. Đồng thời ông cũng là người tạo ra MLIR – compiler stack thế hệ tiếp theo, và Mojo được thiết kế để biên dịch trên MLIR, đó cũng có thể là lý do vì sao Mojo nhanh hơn Rust (Rust và Swift được xây dựng trên nền tảng LLVM). Người sáng lập ngôn ngữ lập trình cũng là người tham gia vào quá trình thiết kế compiler, vì vậy ông rất am hiểu về cách vận hành của các chip cũng như trình biên dịch tương ứng. Đó cũng là ưu thế rất lớn để phát triển ngôn ngữ lập trình Mojo trở thành ngôn ngữ của thập niên tiếp theo – đặc biệt là trong mảng lập trình AI.

So sánh hiệu suất với Python

Môi trường

Công cụ được sử dụng đo hiệu suất: Hyperfine (https://github.com/sharkdp/hyperfine)
Hàm sử dụng: Fibonacci (thuật toán không tối ưu)
Cấu hình máy chính: 2.4 GHz 8-Core Intel Core i9
Cấu hình docker: RAM 8GB, max 200% CPU

Cài đặt Mojo

Cài đặt ngôn ngữ lập trình Mojo chỉ mới dành cho MacOS Apple, và Ubuntu. Với các máy khác có thể sử dụng docker. Chi tiết cho từng phiên bản thì bạn tham khảo ở đây:

https://docs.modular.com/mojo/manual/get-started/

Việc cài đặt cũng không mất nhiều thời gian và khó khăn gì cả nên mình không bổ sung gì thêm.

Code

# fibonacci.mojo
# Fibonacci thuần mojo
import sys
fn fibonacci(n: Int) -> Int:
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)


fn main():
    try:
        print(fibonacci(atol(sys.argv()[1])))
    except:
        pass

# fibonacci_python_style_no_type_annotation.mojo
# Fibonacci không có type-annotation với code kiểu Python
import sys
def fibonacci(n):
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)

fn main():
    try:
        print(fibonacci(atol(sys.argv()[1])))
    except:
        pass

# fibonacci_python_style_with_type_annotation.mojo
# Fibonacci có type-annotation với code kiểu Python
import sys
def fibonacci(n: Int) -> Int:
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)

fn main():
    try:
        print(fibonacci(atol(sys.argv()[1])))
    except:
        pass

# fibonacci.py
# Fibonacci không có type-annotation (Python)
import sys

def fibonacci(n):
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)

def main():
    print(fibonacci(int(sys.argv[1])))

main()

vscode ➜ /workspaces/ubuntu $ hyperfine "mojo fibonacci.mojo 40"
Benchmark 1: mojo fibonacci.mojo 40
  Time (mean ± σ):     700.7 ms ±  16.8 ms    [User: 431.9 ms, System: 19.5 ms]
  Range (min … max):   677.3 ms … 735.1 ms    10 runs
 
vscode ➜ /workspaces/ubuntu $ hyperfine "mojo fibonacci_python_style_with_type_annotation.mojo 40"
Benchmark 1: mojo fibonacci_python_style_with_type_annotation.mojo 40
  Time (mean ± σ):      1.202 s ±  0.012 s    [User: 0.927 s, System: 0.021 s]
  Range (min … max):    1.184 s …  1.217 s    10 runs
 
vscode ➜ /workspaces/ubuntu $ hyperfine "mojo fibonacci_python_style_no_type_annotation.mojo 40"
Benchmark 1: mojo fibonacci_python_style_no_type_annotation.mojo 40
  Time (mean ± σ):     15.129 s ±  3.435 s    [User: 14.793 s, System: 0.059 s]
  Range (min … max):   10.228 s … 19.135 s    10 runs
 
vscode ➜ /workspaces/ubuntu $ hyperfine "python3 fibonacci.py 40"
Benchmark 1: python3 fibonacci.py 40
  Time (mean ± σ):     44.586 s ±  3.859 s    [User: 44.502 s, System: 0.033 s]
  Range (min … max):   37.771 s … 51.637 s    10 runs
 

vscode ➜ /workspaces/ubuntu $ hyperfine "./fibonacci 40"
Benchmark 1: ./fibonacci 40
  Time (mean ± σ):     350.3 ms ±   5.5 ms    [User: 346.5 ms, System: 2.4 ms]
  Range (min … max):   340.9 ms … 358.6 ms    10 runs
 
vscode ➜ /workspaces/ubuntu $ hyperfine "./fibonacci_python_style_no_type_annotation 40"
Benchmark 1: ./fibonacci_python_style_no_type_annotation 40
  Time (mean ± σ):     10.667 s ±  0.872 s    [User: 10.650 s, System: 0.007 s]
  Range (min … max):    9.323 s … 11.830 s    10 runs
 
vscode ➜ /workspaces/ubuntu $ hyperfine "./fibonacci_python_style_with_type_annotation 40"
Benchmark 1: ./fibonacci_python_style_with_type_annotation 40
  Time (mean ± σ):     831.7 ms ±  11.5 ms    [User: 827.4 ms, System: 2.5 ms]
  Range (min … max):   814.2 ms … 852.2 ms    10 runs

Kết quả so sánh

Bonus

Với phiên bản Python thuần, nếu bạn tối ưu bằng decorator cache thì tốc độ cũng cải thiện rất nhiều, tuy nhiên Mojo chưa hỗ trợ decorator này nên chưa so sánh được.

import sys
from functools import cache

@cache
def fibonacci(n):
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)

def main():
    print(fibonacci(int(sys.argv[1])))

main()

vscode ➜ /workspaces/ubuntu $ hyperfine "python3 fibonacci_with_cache.py 40"
Benchmark 1: python3 fibonacci_with_cache.py 40
  Time (mean ± σ):      14.0 ms ±   1.1 ms    [User: 11.6 ms, System: 2.2 ms]
  Range (min … max):    12.7 ms …  19.3 ms    159 runs
 

Kết luận

Nhanh hơn Python 68.000 lần?

Without a parallel Python implementation, It would be more fair to claim that Mojo is 874 times faster than a naive CPython implementation, 175 times faster than a (rather naive) Numpy code, and 40 times faster than a PyPy implementation (on this specific Mandelbrot set computation).

StackOverflow

Mặc dù con số 68.000 lần là thực tế từ kết quả, tuy nhiên đây chỉ là con số mang tính chất biểu tượng/marketing là chính chứ không có tác dụng trong thực tế nhiều lắm.

• Mojo là ngôn ngữ multi-threaded chứ không có chạy tuần tự, nên một số tác vụ tính toán có thể hưởng lợi
• Sử dụng tính toán vector, lại là về tính toán con số; numpy có thực hiện tính toán vector nên vẫn ổn
• Sử dụng chiến thuật thực thi song hành (parallel) trên con CPU khủng 88-Core Intel Xeon

Bạn có thể đọc thêm cách đo hiệu suất trong 3 bài viết từ blog của Modular có gắn kèm bên dưới.

Bài toán thực tế

Với kết quả từ thực nghiệm ở trên với hàm Fibonacci (một hàm thường được dùng cho việc tính hiệu suất vì có dùng đệ quy), có thể kết luận việc sử dụng ngôn ngữ lập trình Mojo có thể nhanh hơn Python khoảng 100 lần. Đây là con số khá hấp dẫn trong việc chọn lựa với những hệ thống yêu cầu tốc độ. Với những người yêu thích tốc độ như mình thì khó có thể cưỡng lại được

Tốc độ đến từ ngôn ngữ biên dịch và type-checked cũng là điều dễ hiểu, ngoài ra kết hợp tính toán vector, multi-thread thì ngôn ngữ lập trình Mojo có thể còn phát huy được nhiều ứng dụng khác. Về điểm này thì chúng ta nên so sánh với Golang mới đúng, hi vọng sẽ có thời gian để viết bài so sánh với Golang.

Fullstack Station Tips:

• Không khuyến khích dành cho người mới học lập trình, khuyến khích dành cho người đã biết Python
• Mặc dù có thể sử dụng cú pháp Python, nhưng với kết quả kiểm tra hiệu suất thì rõ ràng không nên sử dụng cú pháp Python nếu muốn có hiệu suất cao, chí ít cũng phải có type-annotation (xem thêm MyPy là gì). Tốt nhất cũng là sử dụng ngôn ngữ lập trình Mojo thuần để cho tốt độ cao nhất.
• Tuy tuổi đời còn ít, nhưng với những thành tựu đã đạt được thì ngôn ngữ lập trình Mojo sẽ còn phát triển nhanh và xa. Đặc biệt là rút ngắn khoảng cách từ nghiên cứu đến phát triển sản phẩm AI.
• Vì chưa trưởng thành, nên nhiều cú pháp sẽ bị thay đổi, không nên sử dụng ngôn ngữ lập trình cho sản phẩm thực tế.
• Với những lợi ích mà ngôn ngữ lập trình Mojo mang lại, mình nghĩ sẽ rất có lợi cho bạn ở tương lai gần khi học Mojo. Giống như lập trình viên Golang, là một ngôn ngữ lập trình cho bạn mức thu nhập rất tốt.

Tham khảo:

• https://www.modular.com/blog/how-mojo-gets-a-35-000x-speedup-over-python-part-1
• https://www.modular.com/blog/how-mojo-gets-a-35-000x-speedup-over-python-part-2
• https://www.modular.com/blog/mojo-a-journey-to-68-000x-speedup-over-python-part-3
• https://dev.classmethod.jp/articles/try-mojo-programming-langurage/
• https://stackoverflow.com/questions/77070883/performance-comparison-mojo-vs-python
• https://augierpi.gricad-pages.univ-grenoble-alpes.fr/mojo-the-point-of-view-of-a-researcher-using-python.html

The post Ngôn ngữ lập trình Mojo🔥: Python++ nhanh hơn Python tùy theo tác vụ đến 68.000 lần appeared first on Fullstack Station.