# Syllabus system design (1)

# PHASE 0 - Foundation (Ngày 1–25)

## Module 1. Computer Architecture (Ngày 1–6)

**Ngày 1: CPU & Cache Hierarchy**

*   Mục tiêu: Hiểu vì sao CPU hiện đại nhanh không chỉ nhờ xung nhịp mà nhờ pipeline, cache.
    
*   Lý thuyết: L1/L2/L3 cache, cache line, cache miss, false sharing, branch prediction, out-of-order execution.
    
*   Thực hành: Viết benchmark nhỏ (C/Go) đo chênh lệch latency khi truy cập mảng tuần tự vs ngẫu nhiên (cache locality).
    

**Ngày 2: RAM & Memory Hierarchy**

*   Mục tiêu: Hiểu tại sao RAM nhanh hơn SSD hàng trăm lần và ảnh hưởng đến thiết kế hệ thống (in-memory DB, cache).
    
*   Lý thuyết: DRAM vs SRAM, memory bandwidth, latency, NUMA (Non-Uniform Memory Access).
    
*   Thực hành: Đọc kết quả `numactl --hardware` trên một máy Linux thật, giải thích ảnh hưởng NUMA đến DB như PostgreSQL/Redis đa luồng.
    

**Ngày 3: NUMA & ảnh hưởng tới Distributed Systems**

*   Mục tiêu: Hiểu tại sao pinning CPU/memory quan trọng với hệ thống hiệu năng cao (Kafka broker, Redis).
    
*   Lý thuyết: NUMA node, memory allocation policy, cross-node latency penalty.
    
*   Thực hành: Thiết kế bảng so sánh: hệ thống nào nhạy cảm với NUMA (in-memory DB, HFT) vs không (stateless web service).
    

**Ngày 4: SSD vs HDD**

*   Mục tiêu: Hiểu I/O characteristics ảnh hưởng thiết kế storage engine (LSM-Tree ra đời vì sao).
    
*   Lý thuyết: Seek time, IOPS, sequential vs random write, write amplification, TRIM, wear leveling.
    
*   Thực hành: So sánh benchmark `fio` sequential-write vs random-write trên SSD, liên hệ tới thiết kế Kafka (append-only log).
    

**Ngày 5: DMA & Interrupt**

*   Mục tiêu: Hiểu vì sao network card hiện đại (DPDK, RDMA) bypass CPU để đạt throughput cao.
    
*   Lý thuyết: DMA transfer, interrupt coalescing, interrupt storm, polling vs interrupt-driven I/O.
    
*   Thực hành: Đọc tài liệu DPDK/RDMA, giải thích vì sao các sàn giao dịch chứng khoán dùng kernel-bypass networking.
    

**Ngày 6: PCIe & Review Module 1**

*   Mục tiêu: Hiểu băng thông giữa CPU–GPU–NIC–SSD ảnh hưởng thế nào tới AI system design (Phase 15).
    
*   Lý thuyết: PCIe lanes, bandwidth bottleneck khi nhiều GPU trên một host.
    
*   Thực hành: Vẽ sơ đồ data path của một request đi từ NIC → CPU → RAM → SSD, đánh dấu từng điểm nghẽn tiềm năng.
    

## Module 2. Operating System (Ngày 7–11)

**Ngày 7: Process & Thread**

*   Mục tiêu: Hiểu chi phí context switch ảnh hưởng đến thiết kế concurrency model (thread pool vs event loop).
    
*   Lý thuyết: Process vs thread, kernel thread vs user thread (green thread), context switch cost.
    
*   Thực hành: Benchmark context switch cost bằng công cụ `perf` hoặc viết script đo với `pthread`.
    

**Ngày 8: Virtual Memory & mmap**

*   Mục tiêu: Hiểu vì sao DB dùng mmap (SQLite, LMDB) và trade-off của nó.
    
*   Lý thuyết: Page table, TLB, page fault, mmap vs read/write syscall, copy-on-write.
    
*   Thực hành: Đọc source LMDB, giải thích cách nó dùng mmap để đạt zero-copy read.
    

**Ngày 9: Scheduler**

*   Mục tiêu: Hiểu CFS (Completely Fair Scheduler) và ảnh hưởng tới latency-sensitive workload.
    
*   Lý thuyết: Preemptive scheduling, priority, nice value, real-time scheduling class.
    
*   Thực hành: Cấu hình CPU affinity/priority cho một service demo, đo tail latency trước/sau.
    

**Ngày 10: File System**

*   Mục tiêu: Hiểu ext4/XFS ảnh hưởng đến thiết kế storage engine của DB.
    
*   Lý thuyết: Inode, journaling, fsync, page cache, O\_DIRECT.
    
*   Thực hành: So sánh hành vi `fsync` trên ext4 vs XFS, liên hệ tới WAL của PostgreSQL.
    

**Ngày 11: Signals & Review Module 2**

*   Mục tiêu: Hiểu graceful shutdown - nền tảng cho zero-downtime deployment (Phase 8, 13).
    
*   Lý thuyết: SIGTERM/SIGKILL, signal handler, graceful drain connection.
    
*   Thực hành: Viết một service Go/Java xử lý SIGTERM đúng cách (drain request đang chạy trước khi thoát).
    

## Module 3. Networking (Ngày 12–17)

**Ngày 12: Ethernet & Data Link Layer**

*   Mục tiêu: Hiểu nền tảng thấp nhất trước khi học TCP/IP.
    
*   Lý thuyết: MAC address, switch, VLAN, MTU.
    
*   Thực hành: Dùng `tcpdump`/Wireshark bắt gói tin, quan sát Ethernet frame header.
    

**Ngày 13: TCP**

*   Mục tiêu: Hiểu vì sao TCP là nền tảng của hầu hết hệ thống backend (HTTP, gRPC, Kafka).
    
*   Lý thuyết: 3-way handshake, congestion control (slow start, AIMD), sliding window, TCP retransmission, Nagle's algorithm.
    
*   Thực hành: Dùng `ss -i` quan sát congestion window thực tế của một kết nối đang chạy.
    

**Ngày 14: UDP & QUIC**

*   Mục tiêu: Hiểu vì sao HTTP/3 chuyển sang QUIC (UDP-based).
    
*   Lý thuyết: UDP connectionless, head-of-line blocking của TCP, QUIC giải quyết bằng multiplexed streams + 0-RTT.
    
*   Thực hành: So sánh thời gian thiết lập kết nối HTTP/2 (TCP+TLS) vs HTTP/3 (QUIC) bằng công cụ đo thực tế.
    

**Ngày 15: TLS**

*   Mục tiêu: Hiểu handshake TLS ảnh hưởng latency, nền tảng cho mTLS (Phase 11).
    
*   Lý thuyết: TLS 1.2 vs 1.3 handshake, certificate chain, session resumption.
    
*   Thực hành: Dùng `openssl s_client` phân tích handshake của một domain thật.
    

**Ngày 16: HTTP/1.1, HTTP/2, HTTP/3**

*   Mục tiêu: Hiểu evolution của HTTP và lý do multiplexing ra đời.
    
*   Lý thuyết: Keep-alive, head-of-line blocking, HTTP/2 stream multiplexing, HTTP/3 trên QUIC.
    
*   Thực hành: So sánh waterfall chart tải một trang web qua HTTP/1.1 vs HTTP/2 (DevTools).
    

**Ngày 17: DNS & BGP + Review Module 3**

*   Mục tiêu: Hiểu DNS resolution và BGP - nền tảng cho CDN, multi-region routing (Phase 6, 7).
    
*   Lý thuyết: DNS recursive resolver, TTL, GeoDNS, BGP route propagation, anycast.
    
*   Thực hành: `dig`/`traceroute` một domain lớn (vd cloudflare.com), giải thích vì sao IP trả về khác nhau theo vị trí địa lý.
    

## Module 4. Linux (Ngày 18–21)

**Ngày 18: epoll & I/O Multiplexing**

*   Mục tiêu: Hiểu nền tảng của mọi event-loop server (Nginx, Node.js, Redis).
    
*   Lý thuyết: select/poll vs epoll, edge-triggered vs level-triggered.
    
*   Thực hành: Viết một echo server đơn giản dùng epoll (C) hoặc đọc source event loop của Redis.
    

**Ngày 19: io\_uring**

*   Mục tiêu: Hiểu công nghệ I/O thế hệ mới đang thay thế epoll cho workload throughput cao.
    
*   Lý thuyết: Submission queue/completion queue, zero-copy, giảm syscall overhead.
    
*   Thực hành: Đọc benchmark io\_uring vs epoll (vd trong dự án nginx/ScyllaDB), tóm tắt lý do cải thiện throughput.
    

**Ngày 20: Namespace & cgroup**

*   Mục tiêu: Hiểu nền tảng của container - chuẩn bị cho Phase 8 (Kubernetes).
    
*   Lý thuyết: PID/net/mount namespace, cgroup v1 vs v2 (CPU/memory limit).
    
*   Thực hành: Tự tạo một "container" tối giản bằng `unshare` + `chroot` + `cgroup` (không dùng Docker) để hiểu cơ chế.
    

**Ngày 21: Socket Programming + Review Module 4**

*   Mục tiêu: Củng cố toàn bộ kiến thức mạng bằng thực hành.
    
*   Lý thuyết: Socket API, blocking vs non-blocking socket.
    
*   Thực hành: Viết TCP echo server/client bằng ngôn ngữ tùy chọn, đo throughput với nhiều client đồng thời.
    

## Module 5. Programming để đọc source (Ngày 22–25)

**Ngày 22: Đọc Go source (đủ để hiểu etcd/Kubernetes/Prometheus)**

*   Mục tiêu: Nắm cú pháp và idiom Go đủ để đọc source code hệ thống lớn.
    
*   Lý thuyết: Goroutine, channel, interface, error handling idiom.
    
*   Thực hành: Đọc một package nhỏ trong etcd source, tóm tắt luồng xử lý.
    

**Ngày 23: Đọc Java source (đủ để hiểu Kafka/Elasticsearch)**

*   Mục tiêu: Đọc hiểu code Java enterprise-grade.
    
*   Lý thuyết: JVM memory model cơ bản, generics, concurrency package (java.util.concurrent).
    
*   Thực hành: Đọc class `Log.scala`/`Log.java` trong Kafka broker, vẽ lại luồng ghi log.
    

**Ngày 24: Đọc Rust & C++ source (đủ để hiểu TiKV/ScyllaDB/RocksDB)**

*   Mục tiêu: Đọc hiểu code hệ thống hiệu năng cao viết bằng Rust/C++.
    
*   Lý thuyết: Ownership/borrowing (Rust), RAII (C++), zero-cost abstraction.
    
*   Thực hành: Đọc một module storage engine trong RocksDB (C++), giải thích cơ chế memtable → SSTable flush.
    

**Ngày 25: Đọc Python source + Review Phase 0**

*   Mục tiêu: Tổng kết Phase 0, chuẩn bị chuyển sang Phase 1 (Data).
    
*   Lý thuyết: Python GIL và ảnh hưởng đến concurrency (liên hệ tới thiết kế hệ thống dùng Python, vd Airflow).
    
*   Thực hành: Viết báo cáo tổng kết 1 trang: "10 khái niệm OS/Network quan trọng nhất ảnh hưởng đến System Design", dùng làm tài liệu tham khảo xuyên suốt các Phase sau.
    

# PHASE 1 - Data (Ngày 26–65)

## Module 1. Relational Database Internals (Ngày 26–41)

**Ngày 26: Kiến trúc tổng quan của một RDBMS**

*   Mục tiêu: Có bức tranh toàn cảnh trước khi đi sâu từng thành phần.
    
*   Lý thuyết: Các lớp trong RDBMS - connection/session layer, parser, query optimizer, execution engine, storage engine, buffer pool, WAL/log manager.
    
*   Thực hành: Vẽ sơ đồ kiến trúc PostgreSQL (dựa trên tài liệu chính thức), đánh dấu đường đi của một câu `SELECT` từ client đến khi trả kết quả.
    

**Ngày 27: BTree - cấu trúc chỉ mục nền tảng**

*   Mục tiêu: Hiểu vì sao BTree là cấu trúc index mặc định của hầu hết RDBMS.
    
*   Lý thuyết: Node, order, chiều cao cây O(log n), tại sao BTree tối ưu cho disk-based storage (giảm số lần seek).
    
*   Thực hành: Tự vẽ tay quá trình insert 10 giá trị vào một BTree bậc 3, quan sát split node.
    

**Ngày 28: B+Tree & Clustered vs Non-clustered Index**

*   Mục tiêu: Phân biệt B+Tree (dùng thực tế trong DB) với BTree lý thuyết, hiểu clustered index ảnh hưởng physical layout.
    
*   Lý thuyết: B+Tree có leaf node liên kết dạng linked-list để range scan hiệu quả; clustered index quyết định thứ tự lưu trữ vật lý (InnoDB); non-clustered index trỏ đến row qua con trỏ/primary key.
    
*   Thực hành: So sánh execution plan (`EXPLAIN`) của một query range scan khi có/không có index phù hợp trên PostgreSQL hoặc MySQL.
    

**Ngày 29: MVCC (Multi-Version Concurrency Control)**

*   Mục tiêu: Hiểu cơ chế cho phép đọc không block ghi - nền tảng concurrency của Postgres/MySQL/Oracle.
    
*   Lý thuyết: Snapshot isolation, mỗi transaction thấy một "version" dữ liệu riêng, xử lý row versioning (xmin/xmax trong Postgres, undo log trong MySQL/Oracle).
    
*   Thực hành: Mở 2 session Postgres, một session update chưa commit, session kia SELECT - quan sát hành vi snapshot; đọc `pg_stat_activity` để thấy transaction ID.
    

**Ngày 30: Transaction & ACID**

*   Mục tiêu: Hiểu bản chất từng thuộc tính ACID và cách hệ thống thực sự đảm bảo chúng (không chỉ định nghĩa sách giáo khoa).
    
*   Lý thuyết: Atomicity qua log + rollback; Consistency qua constraint; Isolation qua lock/MVCC; Durability qua WAL + fsync.
    
*   Thực hành: Thiết kế test case chứng minh từng thuộc tính ACID bị vi phạm nếu tắt một cơ chế tương ứng (vd tắt fsync → mất Durability khi crash).
    

**Ngày 31: Isolation Levels**

*   Mục tiêu: Hiểu rõ 4 mức isolation và các anomaly tương ứng - kiến thức hay bị hỏi sai nhất trong phỏng vấn Staff-level.
    
*   Lý thuyết: Read Uncommitted/Read Committed/Repeatable Read/Serializable; Dirty Read, Non-repeatable Read, Phantom Read, Write Skew.
    
*   Thực hành: Tái hiện Write Skew (anomaly mà Repeatable Read không chặn được nhưng Serializable chặn được) bằng 2 session Postgres.
    

**Ngày 32: WAL (Write-Ahead Log)**

*   Mục tiêu: Hiểu cơ chế đảm bảo Durability và là nền tảng cho Replication/CDC (Phase 2, 3).
    
*   Lý thuyết: Ghi log trước khi ghi data page (WAL), checkpoint, crash recovery (REDO/UNDO).
    
*   Thực hành: Đọc cấu trúc file WAL segment của PostgreSQL (`pg_waldump`), quan sát log record của một transaction đơn giản.
    

**Ngày 33: Replication (Physical & Logical)**

*   Mục tiêu: Hiểu cách RDBMS nhân bản dữ liệu và trade-off sync/async.
    
*   Lý thuyết: Streaming replication (physical, dựa trên WAL) vs logical replication (dựa trên thay đổi logic/row); synchronous vs asynchronous commit; replication lag.
    
*   Thực hành: Thiết lập một cặp Postgres primary-replica (streaming replication) trên Docker, đo replication lag khi ghi liên tục.
    

**Ngày 34: Query Optimizer - Cost-based Optimization**

*   Mục tiêu: Hiểu vì sao cùng một query có thể chạy nhanh/chậm khác nhau tùy statistics.
    
*   Lý thuyết: Cost model (I/O cost, CPU cost), statistics (histogram, cardinality estimation), rule-based vs cost-based optimizer.
    
*   Thực hành: Chạy `ANALYZE` trên một bảng lớn, so sánh execution plan trước/sau khi statistics được cập nhật.
    

**Ngày 35: Query Execution - Join Algorithms**

*   Mục tiêu: Hiểu cách optimizer chọn thuật toán join phù hợp.
    
*   Lý thuyết: Nested Loop Join, Hash Join, Merge Join - điều kiện tối ưu cho từng loại (kích thước bảng, có index hay không, dữ liệu đã sort chưa).
    
*   Thực hành: Ép buộc (`SET enable_hashjoin = off`) từng loại join trên cùng một query, so sánh thời gian thực thi.
    

**Ngày 36: PostgreSQL Internals - Buffer Pool & VACUUM**

*   Mục tiêu: Hiểu vì sao Postgres cần VACUUM - hệ quả trực tiếp của MVCC.
    
*   Lý thuyết: Dead tuple do MVCC để lại, autovacuum, bloat, buffer pool (shared\_buffers) và page eviction (clock-sweep algorithm).
    
*   Thực hành: Tạo bảng, update lặp nhiều lần, quan sát bloat qua `pg_stat_user_tables`, chạy VACUUM và so sánh.
    

**Ngày 37: PostgreSQL - Table Partitioning & Extensions**

*   Mục tiêu: Hiểu cách Postgres scale theo chiều dữ liệu lớn.
    
*   Lý thuyết: Declarative partitioning (range/list/hash), partition pruning, extension ecosystem (pg\_partman, TimescaleDB, pgvector).
    
*   Thực hành: Tạo bảng range-partition theo thời gian, chứng minh partition pruning qua `EXPLAIN`.
    

**Ngày 38: MySQL Internals - InnoDB**

*   Mục tiêu: Hiểu storage engine mặc định của MySQL và điểm khác biệt với Postgres.
    
*   Lý thuyết: InnoDB buffer pool, clustered index theo primary key (khác Postgres - heap table), undo log, redo log, gap lock.
    
*   Thực hành: So sánh hành vi lock giữa InnoDB (gap lock để chống phantom read) và Postgres (dùng predicate lock trong Serializable) qua ví dụ cụ thể.
    

**Ngày 39: MySQL Replication & Clustering**

*   Mục tiêu: Hiểu các mô hình HA phổ biến của MySQL trong enterprise.
    
*   Lý thuyết: Async/semi-sync replication, Group Replication, Galera Cluster (multi-master, certification-based replication).
    
*   Thực hành: So sánh trade-off giữa Group Replication (Raft-like) và Galera (certification-based) cho một use case cụ thể (vd hệ thống cần multi-master ghi ở nhiều region).
    

**Ngày 40: Oracle Internals (tổng quan cho Enterprise/Banking)**

*   Mục tiêu: Hiểu đủ để làm việc trong môi trường ngân hàng/enterprise vẫn dùng Oracle nhiều.
    
*   Lý thuyết: Redo log & Undo tablespace, RAC (Real Application Clusters) - shared storage multi-instance, Data Guard cho DR.
    
*   Thực hành: Vẽ so sánh kiến trúc HA: Oracle RAC (shared-disk) vs PostgreSQL streaming replication (shared-nothing) - nêu rõ trade-off.
    

**Ngày 41: Review Module 1 - So sánh 3 RDBMS**

*   Mục tiêu: Tổng hợp năng lực chọn RDBMS phù hợp cho từng bài toán.
    
*   Lý thuyết: Ôn lại MVCC/WAL/Replication/Optimizer của cả 3 hệ.
    
*   Thực hành: Lập bảng so sánh PostgreSQL vs MySQL vs Oracle theo 8 tiêu chí (concurrency model, replication, partitioning, licensing cost, ecosystem, HA, use case điển hình, giới hạn scale).
    

## Module 2. NoSQL (Ngày 42–49)

**Ngày 42: Document Database - MongoDB Internals**

*   Mục tiêu: Hiểu mô hình document và khi nào nó thắng thế mô hình quan hệ.
    
*   Lý thuyết: BSON, WiredTiger storage engine, replica set (Raft-like election), sharding (chunk, config server, mongos router).
    
*   Thực hành: Thiết kế schema document cho một bài toán "product catalog" có nhiều thuộc tính biến đổi, so sánh với thiết kế relational tương đương.
    

**Ngày 43: Key-Value Store - DynamoDB/Riak Internals**

*   Mục tiêu: Hiểu mô hình Dynamo gốc - nền tảng của rất nhiều NoSQL hiện đại.
    
*   Lý thuyết: Consistent hashing, quorum (N/R/W), vector clock, hinted handoff, read repair.
    
*   Thực hành: Tính toán ví dụ quorum N=3, R=2, W=2 - chứng minh vì sao R+W>N đảm bảo strong-ish consistency.
    

**Ngày 44: Wide-column Store - Cassandra/Bigtable Internals**

*   Mục tiêu: Hiểu mô hình wide-column và write path tối ưu cho ghi lớn.
    
*   Lý thuyết: Partition key/clustering key, SSTable + Memtable (Cassandra dùng LSM-Tree - liên hệ Module 3), tunable consistency (ONE/QUORUM/ALL), gossip protocol cho membership.
    
*   Thực hành: Thiết kế data model Cassandra cho bài toán "lưu event log theo user, truy vấn theo thời gian" - áp dụng nguyên tắc "query-first design" (khác hẳn tư duy chuẩn hóa của RDBMS).
    

**Ngày 45: Graph Database - Neo4j Internals**

*   Mục tiêu: Hiểu khi nào graph DB thắng thế relational cho bài toán quan hệ phức tạp.
    
*   Lý thuyết: Index-free adjacency (con trỏ trực tiếp giữa node thay vì join), Cypher query language, traversal performance O(1) theo số cạnh thay vì join cost tăng theo độ sâu.
    
*   Thực hành: So sánh chi phí truy vấn "bạn của bạn của bạn" (3-hop) trên mô hình relational (nhiều JOIN) vs graph (traversal), giải thích tại sao graph thắng khi độ sâu tăng.
    

**Ngày 46: Time-series Database - InfluxDB/TimescaleDB**

*   Mục tiêu: Hiểu tối ưu hóa đặc thù cho dữ liệu theo thời gian (metrics, IoT).
    
*   Lý thuyết: Columnar storage cho time-series, downsampling, retention policy, high write throughput qua batching theo thời gian.
    
*   Thực hành: Thiết kế schema time-series cho hệ thống metrics (device\_id, timestamp, value, tags), thiết kế downsampling policy (raw 7 ngày → 1 phút aggregate 90 ngày → 1 giờ aggregate 2 năm).
    

**Ngày 47: Vector Database - Pinecone/Milvus/pgvector**

*   Mục tiêu: Hiểu nền tảng cho AI System Design (Phase 15) - tìm kiếm tương đồng ngữ nghĩa.
    
*   Lý thuyết: Embedding vector, ANN (Approximate Nearest Neighbor) search, HNSW index, IVF index, trade-off recall vs latency.
    
*   Thực hành: Đọc tài liệu HNSW, giải thích tại sao nó nhanh hơn brute-force k-NN, vẽ sơ đồ cấu trúc multi-layer graph của HNSW.
    

**Ngày 48: NoSQL Data Modeling Patterns**

*   Mục tiêu: Học tư duy modeling khác biệt căn bản so với chuẩn hóa RDBMS.
    
*   Lý thuyết: Denormalization có chủ đích, single-table design (DynamoDB), embedding vs referencing (MongoDB), query-driven modeling.
    
*   Thực hành: Thiết kế single-table DynamoDB cho một hệ thống e-commerce (Order, Customer, Product) hỗ trợ 4 access pattern khác nhau bằng GSI (Global Secondary Index).
    

**Ngày 49: Review Module 2 - CAP Trade-off Comparison**

*   Mục tiêu: Tổng hợp năng lực chọn NoSQL phù hợp theo CAP/PACELC.
    
*   Lý thuyết: Ôn lại CAP (Phase 2 sẽ học, ở đây áp dụng thực tế): MongoDB/Cassandra/DynamoDB nằm ở đâu trên phổ CP-AP.
    
*   Thực hành: Lập bảng so sánh 6 loại NoSQL đã học theo: Consistency model, Partition tolerance behavior, use case điển hình, ví dụ công ty dùng thực tế.
    

## Module 3. Storage Engine (Ngày 50–59)

**Ngày 50: LSM-Tree - Nguyên lý cơ bản**

*   Mục tiêu: Hiểu vì sao LSM-Tree tối ưu cho write-heavy workload - nền tảng của Cassandra/RocksDB/Kafka.
    
*   Lý thuyết: Ghi sequential thay vì random write (liên hệ Ngày 4 - SSD random write chậm), amortize cost qua compaction.
    
*   Thực hành: Vẽ sơ đồ write path LSM-Tree: write → WAL → memtable → flush → SSTable.
    

**Ngày 51: Memtable & SSTable**

*   Mục tiêu: Hiểu chi tiết 2 thành phần cốt lõi của LSM-Tree.
    
*   Lý thuyết: Memtable (in-memory sorted structure, thường là skip-list), SSTable (immutable, sorted, trên disk), flush trigger (size-based).
    
*   Thực hành: Đọc cấu trúc file SSTable của RocksDB (data block, index block, footer), giải thích vì sao immutable giúp đơn giản hóa concurrency.
    

**Ngày 52: Compaction Strategies**

*   Mục tiêu: Hiểu cách LSM-Tree dọn dẹp dữ liệu cũ/trùng lặp mà không chặn ghi.
    
*   Lý thuyết: Size-tiered compaction vs Leveled compaction - trade-off write amplification vs read amplification vs space amplification.
    
*   Thực hành: So sánh cấu hình compaction của Cassandra (size-tiered mặc định) vs RocksDB (leveled mặc định), giải thích vì sao mỗi hệ chọn default khác nhau dựa trên workload mục tiêu.
    

**Ngày 53: Bloom Filter**

*   Mục tiêu: Hiểu cấu trúc xác suất giúp tránh đọc disk không cần thiết.
    
*   Lý thuyết: Bit array + nhiều hash function, false positive có thể xảy ra nhưng false negative thì không, trade-off kích thước bloom filter vs tỷ lệ false positive.
    
*   Thực hành: Tự cài đặt một Bloom Filter đơn giản (bất kỳ ngôn ngữ), đo tỷ lệ false positive thực tế với số lượng bit khác nhau.
    

**Ngày 54: RUM Conjecture (Read/Update/Memory Amplification)**

*   Mục tiêu: Hiểu khung tư duy tổng quát để đánh giá mọi storage engine.
    
*   Lý thuyết: Không thể tối ưu đồng thời cả 3: Read amplification, Update(write) amplification, Memory(space) amplification - mọi thiết kế storage engine đều là một điểm trade-off trên tam giác này.
    
*   Thực hành: Định vị BTree, LSM-Tree (size-tiered), LSM-Tree (leveled) trên tam giác RUM, giải thích lý do.
    

**Ngày 55: BTree vs LSM-Tree - So sánh toàn diện**

*   Mục tiêu: Có khả năng ra quyết định chọn storage engine cho một bài toán cụ thể - câu hỏi kinh điển ở phỏng vấn Staff-level.
    
*   Lý thuyết: BTree tối ưu cho read-heavy/update-in-place; LSM-Tree tối ưu cho write-heavy/append-only; ảnh hưởng đến lựa chọn DB (Postgres dùng BTree, Cassandra/RocksDB dùng LSM).
    
*   Thực hành: Với 3 bài toán cụ thể (OLTP banking ledger, time-series metrics ingestion, session cache), chọn BTree hay LSM-Tree và giải thích.
    

**Ngày 56: RocksDB**

*   Mục tiêu: Hiểu một implementation LSM-Tree thực tế được dùng rộng rãi (bên trong CockroachDB, TiKV, Kafka Streams).
    
*   Lý thuyết: Column family, write buffer, level-based compaction, block cache.
    
*   Thực hành: Đọc benchmark RocksDB chính thức, giải thích ảnh hưởng của `write_buffer_size` và `max_background_compactions` đến throughput.
    

**Ngày 57: ScyllaDB/Cassandra Storage Engine trong thực tế**

*   Mục tiêu: Kết nối lý thuyết LSM với một hệ wide-column thực chiến.
    
*   Lý thuyết: SSTable format của Cassandra, tombstone (đánh dấu xóa trong hệ append-only), garbage collection grace period.
    
*   Thực hành: Giải thích vấn đề "tombstone storm" trong Cassandra khi xóa nhiều dữ liệu - và cách tránh qua TTL thay vì DELETE.
    

**Ngày 58: WiredTiger - Storage Engine của MongoDB**

*   Mục tiêu: Hiểu MongoDB dùng cấu trúc hybrid (không thuần LSM).
    
*   Lý thuyết: WiredTiger dùng BTree mặc định (có thể cấu hình LSM), document-level concurrency control, compression built-in.
    
*   Thực hành: So sánh WiredTiger (BTree-based) với InnoDB (Ngày 38) - vì sao cả hai đều chọn BTree dù là hệ khác nhau (Document vs Relational).
    

**Ngày 59: Review Module 3**

*   Mục tiêu: Tổng hợp năng lực đánh giá storage engine.
    
*   Lý thuyết: Ôn lại toàn bộ Module 3.
    
*   Thực hành: Viết một "Storage Engine Selection Guide" 1 trang - checklist câu hỏi cần đặt ra trước khi chọn storage engine cho một hệ thống mới (write:read ratio, data size, latency requirement, consistency requirement).
    

## Module 4. Search Engine (Ngày 60–65)

**Ngày 60: Inverted Index - Nền tảng của Search Engine**

*   Mục tiêu: Hiểu cấu trúc dữ liệu lõi cho phép tìm kiếm full-text nhanh.
    
*   Lý thuyết: Term → danh sách document chứa term (posting list), so sánh với forward index; tokenization, stemming, stop-words.
    
*   Thực hành: Tự xây một inverted index tối giản bằng Python cho 5 văn bản mẫu, thực hiện query AND/OR thủ công.
    

**Ngày 61: BM25 - Thuật toán xếp hạng**

*   Mục tiêu: Hiểu cách search engine xếp hạng độ liên quan, không chỉ tìm có/không.
    
*   Lý thuyết: TF-IDF là nền tảng, BM25 cải tiến bằng term frequency saturation và document length normalization.
    
*   Thực hành: Tính tay điểm BM25 cho 2 document với cùng 1 query, giải thích vì sao document ngắn hơn có thể được ưu tiên hơn dù cùng số lần xuất hiện từ khóa.
    

**Ngày 62: Lucene Architecture**

*   Mục tiêu: Hiểu engine nền tảng bên dưới Elasticsearch/Solr/OpenSearch.
    
*   Lý thuyết: Segment (immutable, giống SSTable), merge policy, near-real-time search (refresh), Lucene index format cơ bản.
    
*   Thực hành: Vẽ liên hệ giữa Lucene segment/merge và LSM-Tree SSTable/compaction (Ngày 50–52) - chỉ ra điểm tương đồng kiến trúc.
    

**Ngày 63: Elasticsearch Architecture**

*   Mục tiêu: Hiểu cách Elasticsearch scale search ra nhiều node.
    
*   Lý thuyết: Index → shard (primary/replica) → Lucene instance; cluster state, master node election; routing document đến shard qua hash.
    
*   Thực hành: Thiết kế số lượng shard/replica hợp lý cho một index có 500GB dữ liệu, 3 node, giải thích lý do tránh over-sharding.
    

**Ngày 64: OpenSearch & Search ở Scale lớn**

*   Mục tiêu: Hiểu các vấn đề vận hành search engine ở production scale.
    
*   Lý thuyết: Hot-warm-cold architecture (ILM - Index Lifecycle Management), query performance tuning, split-brain risk trong cluster.
    
*   Thực hành: Thiết kế ILM policy cho một hệ thống log (hot 7 ngày trên SSD, warm 30 ngày, cold/archive sau đó xuống object storage).
    

**Ngày 65: Review Phase 1 - Capstone mini**

*   Mục tiêu: Tổng kết toàn bộ Phase 1 (Data), chuẩn bị chuyển sang Phase 2 (Distributed Systems).
    
*   Lý thuyết: Ôn lại toàn bộ 4 module: Relational, NoSQL, Storage Engine, Search Engine.
    
*   Thực hành: Capstone mini - thiết kế data layer cho một hệ thống "E-commerce Order Platform": chọn RDBMS cho order/payment (giải thích vì sao cần ACID), NoSQL nào cho product catalog, có cần search engine không (và dùng cho phần nào), storage engine ngầm bên dưới ảnh hưởng gì đến quyết định capacity planning. Viết thành một trang thiết kế ngắn.