Bỏ qua tới nội dung chính

Trước khi có nguyên lý hệ thống

Nguyên lý hệ thống máy tính: những ý tưởng giữ cho hệ thống lớn đứng vững

Những ý tưởng lặp lại trong mọi hệ thống lớn: chế ngự độ phức tạp, đặt tên, lập luận đầu cuối, bản sao và số chín, lưu tạm — và nên học từ đâu.

Ban biên tập OpenER

Cập nhật 18/11/2026 · 19 phút đọc · CC BY 4.0

Tấm ảnh bạn tải lên Google Photos từ nhiều năm trước, hôm nay vẫn mở được. Trong ngần ấy năm, chiếc ổ cứng đầu tiên giữ nó rất có thể đã hỏng và bị thay: ở một trung tâm dữ liệu có hàng trăm nghìn ổ cứng, ngày nào cũng có vài ổ hỏng. Không ai báo cho bạn, vì bạn không cần biết — tấm ảnh còn những bản sao khác, ở chỗ khác. Đường link bạn gửi bạn bè từ năm ngoái vẫn mở đúng trang, dù máy chủ phía sau có thể đã chuyển chỗ. Một file tải qua Wi-Fi chập chờn ở quán cà phê vẫn giống bản gốc tới từng byte.

Không điều nào ở trên là tính năng riêng của một hệ thống. Đó là những ý tưởng lặp lại trong hệ điều hành, mạng, cơ sở dữ liệu, dịch vụ đám mây, mà người làm hệ thống mất mấy chục năm mới gọi được thành tên. Môn Nguyên lý hệ thống máy tính (Principles of Computer Systems) gom chúng lại. Ở MIT, đó là môn 6.033 Computer System Engineering, dạy theo cuốn Principles of Computer System Design của Jerome Saltzer và Frans Kaashoek.

Trước khi có nguyên lý hệ thống

Thập niên 1960, phần mềm lần đầu lớn tới mức không ai nắm được hết — chuyện OS/360 của IBM trễ hẹn, vượt ngân sách đã kể trong bài Nhập môn công nghệ phần mềm. Mỗi đội tự rút bài học, và bài học ra đi cùng người rời dự án. Chưa có từ vựng chung để nói một hệ thống "thiết kế tốt" là thế nào.

Các nguyên lý được gọi tên từng bước:

  1. Multics và giấc mơ "máy tính như điện nước" — giữa thập niên 1960. MIT, General Electric và Bell Labs cùng xây Multics, hệ chia sẻ thời gian nối tiếp CTSS (bài Hệ điều hành), với tham vọng biến tính toán thành một tiện ích công cộng (computer utility): cắm vào là dùng, như điện, như nước. Multics ra đời chậm và rất phức tạp; năm 1969 Bell Labs rút lui, hai người của họ đi viết Unix. Nhưng nhiều ý tưởng của nó sống tới hôm nay: cây thư mục và đường dẫn, vòng bảo vệ (protection ring) trong phần cứng, hệ điều hành viết bằng ngôn ngữ bậc cao. Fernando Corbató, người dẫn dắt dự án, nhận giải Turing năm 1990; Saltzer cũng ở trong nhóm.
  2. Từ kinh nghiệm thành lời khuyên — năm 1983, Butler Lampson, một trong những người làm ra máy tính cá nhân Alto ở Xerox PARC, viết Hints for Computer System Design: vài chục lời khuyên ngắn như "giữ cho đơn giản", "lưu lại kết quả của phép tính đắt", "gom thành lô nếu được". Lampson nhận giải Turing năm 1992.
  3. Lập luận đầu cuối — năm 1981, Saltzer, David Reed và David Clark trình bày bài End-to-End Arguments in System Design, in chính thức năm 1984: việc bảo đảm dữ liệu tới nơi đúng chỉ làm trọn được ở hai đầu cuộc trao đổi.
  4. Từ phòng máy tới "nhà kho" — đầu thập niên 2000. Google dựng dịch vụ trên hàng nghìn máy chủ rẻ thay vì vài máy đắt, và coi hỏng hóc là chuyện thường ngày (chuyện GFS kể trong bài Hệ phân tán). Năm 2009, Luiz André Barroso và Urs Hölzle gọi cả trung tâm dữ liệu là một máy tính cỡ nhà kho (warehouse-scale computer). Giấc mơ "tiện ích công cộng" của Multics thành sự thật dưới tên điện toán đám mây (cloud computing).

Đặt cạnh nhau:

Mỗi hệ thống tự rút kinh nghiệm
Có nguyên lý chung
Một máy hỏng
Cả dịch vụ dừng, có khi mất dữ liệu
Bản sao khác gánh thay, người dùng không thấy
Tìm một thứ
Phải biết nó nằm ở máy nào, ổ nào
Gọi bằng tên; chỗ ở đổi, tên vẫn giữ
Dữ liệu qua nhiều chặng
Tin rằng từng chặng đã kiểm là đủ
Kiểm lần cuối ở đầu nhận, so với đầu gửi
Mất điện lúc đang ghi
File dở dang, nửa cũ nửa mới
Còn nguyên bản cũ hoặc nguyên bản mới
Hệ thống chậm
Mua máy to hơn
Lưu tạm, gom lô, đo xem thời gian đi đâu

Ngày nay, nhiều nhà thuốc nhỏ, tiệm tạp hóa gia đình vẫn chạy phần mềm bán hàng trên đúng một chiếc máy tính ở quầy, cẩn thận lắm thì thêm một ổ USB sao lưu cất trong ngăn kéo ngay dưới máy. Hôm nước ngập vào tiệm, máy và bản sao lưu cùng mất một lúc. Đó là một điểm hỏng duy nhất (single point of failure), cộng với cái bẫy của những bản sao không độc lập — ý tưởng thứ tư sẽ quay lại chuyện này bằng con số.

Môn này trả lời câu hỏi gì

Môn Nguyên lý hệ thống máy tính trả lời câu hỏi: làm sao xây một hệ thống rất lớn — ghép từ những bộ phận có thể hỏng, do nhiều người viết, nối qua một mạng không tin cậy — mà vẫn đúng, vẫn nhanh, và vẫn chạy khi một phần của nó hỏng?

Môn này không dạy một hệ thống cụ thể như Hệ điều hành, Mạng máy tính hay Cơ sở dữ liệu. Nó dạy những ý tưởng mà cả ba dùng chung, để khi gặp một hệ thống lạ bạn nhận ra "đây là lưu tạm", "đây là một tầng gián tiếp", "chỗ này thiếu bản sao". Saltzer và Kaashoek gọi kẻ thù chính của người làm hệ thống là độ phức tạp (complexity).

Vì sao cần học? Vì sớm muộn, ai làm phần mềm cũng phải trả lời: máy chủ này chết thì sao, dữ liệu sai thì phát hiện ở đâu. Vòng phỏng vấn thiết kế hệ thống (system design) ở các công ty công nghệ hỏi đúng những câu đó.

Năm ý tưởng cốt lõi

1. Độ phức tạp, và bốn cách chế ngự nó

Thử nghĩ một con ngõ mà nhà nào cũng lắp máy bơm hút thẳng từ đường ống nước chung. Máy nào cũng tốt, nhưng sáng sớm cả ngõ cùng bật, áp lực tụt và nhà cuối ngõ không còn giọt nào — cái hỏng không nằm trong chiếc máy bơm nào. Saltzer và Kaashoek gọi đó là tính trồi (emergent property): tính chất chỉ xuất hiện khi các phần ghép lại. Độ phức tạp đến từ những tác động qua lại như thế, không phải từ số phần.

Hai ông nêu bốn công cụ để cắt bớt những tác động như vậy:

  • Mô-đun hóa (modularity) và trừu tượng hóa (abstraction): chia hệ thống thành các phần, mỗi phần chỉ lộ ra một giao diện và giấu mọi chi tiết bên trong — bài Nguyên lý và mẫu thiết kế phần mềm đi sâu ở cỡ một chương trình.
  • Phân tầng (layering): mỗi tầng chỉ dựa vào tầng ngay dưới. Chồng tầng trong bài Từ electron đến ứng dụng là ví dụ lớn nhất.
  • Phân cấp (hierarchy): ghép mô-đun nhỏ thành mô-đun lớn hơn, như ống từng nhà nối vào ống của ngõ, ống ngõ nối vào ống chính.

Ở cỡ hệ thống, ranh giới còn phải cứng, để một phần viết lỗi cũng không phá được phần khác: tách thành máy khách và dịch vụ (client/service) chỉ nói chuyện qua thông điệp, như trình duyệt và máy chủ web; hoặc ảo hóa (virtualization), như hệ điều hành cho mỗi tiến trình một vùng nhớ riêng.

2. Đặt tên: đường dẫn, tên miền và URL là cùng một ý

Các phần của một hệ thống tìm thấy nhau bằng tên (name). Một cơ chế đặt tên (naming scheme) gồm tên, thứ tên trỏ tới, và một ngữ cảnh (context) — bảng tra cho biết ở đây tên ấy nghĩa là gì; việc tra gọi là phân giải tên (name resolution). "Bình" trong danh bạ của bạn và "Bình" trong danh bạ của mẹ bạn là hai người khác nhau: cùng tên, khác ngữ cảnh.

Tên lớn thường ghép nhiều phần, mỗi phần được tra trong ngữ cảnh do phần trước chỉ ra, như địa chỉ nhà đọc từ tỉnh tới phường tới số nhà. Đường dẫn file đọc từ trái sang phải, tên miền đọc từ phải sang trái — nhưng vẫn là cùng một thuật toán:

python
# Một "ngữ cảnh" là một bảng tra: tên -> giá trị. Giá trị lại có thể là một ngữ cảnh khác.
goc = {
    "home": {"an": {"bai-tap": {"he-thong.txt": "<nội dung file>"}}},
    "vn": {"opener": {"www": "203.0.113.10"}},
}

def phan_giai(ten, ngu_canh, dau_tach, doc_nguoc=False):
    phan = [p for p in ten.split(dau_tach) if p]
    if doc_nguoc:                     # tên miền viết từ nhỏ tới lớn, nên đọc từ phải sang
        phan.reverse()
    for p in phan:
        ngu_canh = ngu_canh[p]        # mỗi bước: tra một tên trong một ngữ cảnh
    return ngu_canh

print(phan_giai("/home/an/bai-tap/he-thong.txt", goc, "/"))   # <nội dung file>
print(phan_giai("www.opener.vn", goc, ".", doc_nguoc=True))   # 203.0.113.10

goc["vn"]["opener"]["www"] = "198.51.100.7"   # máy chủ chuyển nhà: chỉ sửa một chỗ
print(phan_giai("www.opener.vn", goc, ".", doc_nguoc=True))   # 198.51.100.7

Hai dòng cuối cho thấy sức mạnh của tên: máy chủ chuyển nhà, chỉ một chỗ phải sửa, mọi đường link vẫn gọi đúng tên cũ. Thêm một bước tra như thế giữa người gọi và thứ được gọi là gián tiếp (indirection). Nó có mặt khắp nơi, tới mức có câu nói thường gán cho David Wheeler: mọi vấn đề trong khoa học máy tính đều giải được bằng thêm một tầng gián tiếp.

URL https://opener.vn/bai-viet/he-dieu-hanh là ba cơ chế đặt tên nối lại: https là tên giao thức, opener.vn được hệ thống tên miền phân giải thành địa chỉ máy (chi tiết trong bài Mạng máy tính), còn /bai-viet/he-dieu-hanh do chính máy chủ đó phân giải thành một trang.

Mặt trái: tên mang theo cấu trúc sẽ vỡ khi cấu trúc đổi. Năm 2025, khi Việt Nam bỏ cấp huyện và gộp nhiều tỉnh, rất nhiều địa chỉ phải viết lại dù không ngôi nhà nào dời đi. Vì thế hệ thống tốt thường giữ hai loại tên: một tên cho người đọc, có thể đổi, và một mã định danh không bao giờ đổi cho máy — như số căn cước không đổi khi bạn chuyển nhà.

3. Lập luận đầu cuối: chỉ hai đầu mới biết thế nào là đúng

Bài báo của Saltzer, Reed và Clark mở đầu bằng một bài toán tưởng đơn giản: chép cẩn thận một file từ máy A sang máy B. Dọc đường có rất nhiều chỗ có thể hỏng: đọc đĩa, bộ nhớ, phần mềm, đường truyền, các máy ở giữa, ghi đĩa. Cách nghĩ tự nhiên là làm cho từng chặng thật tin cậy: chặng nào cũng kiểm gói tin bằng một mã kiểm tra (checksum) như CRC, sai thì gửi lại chặng đó.

Các tác giả kể một chuyện có thật ở MIT: một mạng nối các mạng nhỏ qua những máy cổng (gateway) — ngày nay gọi là router — chặng nào cũng có mã kiểm tra, nên lập trình viên yên tâm rằng mạng đã tin cậy. Nhưng dữ liệu không được bảo vệ lúc nằm trong bộ nhớ máy cổng. Một máy cổng bị lỗi, thỉnh thoảng tráo hai byte cạnh nhau khi chép dữ liệu — khoảng một lần trên một triệu byte. Nhiều file mã nguồn của một hệ điều hành đi qua đó nhiều lần, và một số bị hỏng; chủ của chúng phải dò lại bằng tay theo các bản in cũ. Mô phỏng lại:

python
import hashlib, zlib

def qua_router(goi, bo_nho_loi):
    du_lieu, crc = goi
    if zlib.crc32(du_lieu) != crc:              # kiểm tra của chặng: đường dây có làm hỏng gói không?
        raise ValueError("lỗi đường dây, xin gửi lại chặng này")
    b = bytearray(du_lieu)                      # router chép gói sang bộ đệm ra...
    if bo_nho_loi:                              # ...và bộ nhớ lỗi tráo hai byte cạnh nhau
        k = du_lieu.index(b"12")                # (chọn đúng chỗ số 12 cho dễ thấy)
        b[k], b[k + 1] = b[k + 1], b[k]
    du_lieu = bytes(b)
    return du_lieu, zlib.crc32(du_lieu)         # chặng sau nhận CRC mới, tính trên dữ liệu đã hỏng

don_hang = "mã hàng,số thùng\nmì tôm,12\nnước mắm,5\n".encode()
dau_van_tay = hashlib.sha256(don_hang).hexdigest()   # đầu gửi giữ "dấu vân tay" của cả file

goi = (don_hang, zlib.crc32(don_hang))
for loi in (False, True, False):                # ba router, router giữa có bộ nhớ lỗi
    goi = qua_router(goi, loi)
print("Cả ba chặng đều báo CRC khớp.")

nhan = goi[0]
print(nhan.decode().splitlines()[1])            # mì tôm,21
if hashlib.sha256(nhan).hexdigest() == dau_van_tay:
    print("Kiểm tra đầu cuối: khớp")
else:
    print("Kiểm tra đầu cuối: SAI, xin gửi lại cả file")

Mỗi chặng chỉ kiểm đường dây của nó, nên cả ba đều báo khớp; lỗi xảy ra bên trong router, giữa hai lần kiểm — và 12 thùng mì thành 21 thùng. Chỉ phép so cuối cùng, giữa dấu vân tay SHA-256 của cả file ở đầu gửi và ở đầu nhận, mới bắt được lỗi.

Đó là lập luận đầu cuối (end-to-end argument): một chức năng chỉ làm trọn được khi có sự tham gia của hai đầu, những bên biết thế nào là kết quả đúng. Bài báo không bảo bỏ kiểm tra từng chặng: nó bắt sớm lỗi đường dây, đỡ phải gửi lại cả file — nhưng đó là tối ưu hiệu năng, không phải bảo đảm đúng.

Bạn gặp lập luận này hằng ngày: trang tải phần mềm ghi kèm mã SHA-256 để bạn tự so; Git đặt tên mỗi phiên bản bằng dấu vân tay nội dung của nó; mã hóa đầu cuối (end-to-end encryption) giữ khóa ở hai chiếc điện thoại, không ở máy chủ giữa đường. Internet cũng vậy: tầng IP chỉ "cố gắng hết sức", còn TCP ở hai máy lo gửi lại.

4. Chịu lỗi: thêm bản sao, đếm số chín

Không ai làm được máy không bao giờ hỏng, nhưng có thể làm hệ thống chạy tiếp khi máy hỏng — gọi là chịu lỗi (fault tolerance): phát hiện lỗi, khoanh vùng để nó không lan, rồi che nó đi bằng dư thừa (redundancy) — giữ nhiều bản sao (replica), bản này chết thì bản kia thay.

Thước đo là độ sẵn sàng (availability): tỷ lệ thời gian hệ thống phục vụ được, thường gọi theo số chữ số 9 — 99,9% là "ba số chín". Giả sử mỗi máy chạy được 99% thời gian, và các máy hỏng độc lập với nhau:

python
PHUT_MOI_NAM = 365 * 24 * 60

def phut_hong(san_sang):
    return (1 - san_sang) * PHUT_MOI_NAM

mot_may = 0.99                                   # mỗi máy chạy được 99% thời gian
for so_ban in (1, 2, 3):
    san_sang = 1 - (1 - mot_may) ** so_ban       # chỉ hỏng khi MỌI bản sao cùng hỏng
    print(f"{so_ban} bản sao: {san_sang:.4%}, hỏng {phut_hong(san_sang):7.1f} phút mỗi năm")

noi_tiep = 0.999 ** 5                            # một yêu cầu phải qua 5 dịch vụ, mỗi cái 99,9%
print(f"5 dịch vụ nối tiếp: {noi_tiep:.2%}, hỏng {phut_hong(noi_tiep):7.1f} phút mỗi năm")
text
1 bản sao: 99.0000%, hỏng  5256.0 phút mỗi năm
2 bản sao: 99.9900%, hỏng    52.6 phút mỗi năm
3 bản sao: 99.9999%, hỏng     0.5 phút mỗi năm
5 dịch vụ nối tiếp: 99.50%, hỏng  2622.7 phút mỗi năm

Một máy 99% nghe đã cao, nhưng là khoảng 3,65 ngày chết mỗi năm. Hai bản sao: chưa tới một giờ. Ba bản sao: khoảng nửa phút — "sáu số chín", ghép từ những chiếc máy chỉ có hai số chín. Đó là bí quyết của máy tính cỡ nhà kho. Dòng cuối là mặt trái: yêu cầu phải đi nối tiếp qua năm dịch vụ, mỗi cái ba số chín, thì cả chuỗi chỉ còn khoảng 99,5% — gần hai ngày chết mỗi năm.

Chữ "độc lập" là chỗ những phép tính đẹp hay sai nhất. Ba bản sao chung một tủ máy, một nguồn điện hay một phiên bản phần mềm có lỗi có thể chết cùng lúc — lỗi tương quan (correlated failure). Tháng 3 năm 2021, một trung tâm dữ liệu của OVHcloud ở Strasbourg (Pháp) bị cháy; khách hàng nào để bản sao lưu trong cùng khu đó mất cả bản chính lẫn bản sao — chuyện chiếc USB trong ngăn kéo, ở cỡ lớn hơn nhiều. Vì thế các dịch vụ lớn rải bản sao ra nhiều tòa nhà, nhiều thành phố. Các bản sao lệch nhau thì tin bản nào là việc của bài Hệ phân tán.

Còn khi máy chết giữa chừng một thao tác — mới ghi được nửa file — thì cần tính nguyên tử (atomicity): hoặc xong hết, hoặc như chưa làm gì. Saltzer và Kaashoek có một "quy tắc vàng": đừng bao giờ sửa bản duy nhất. Trình soạn thảo cẩn thận ghi bản mới ra một file tạm, đẩy hẳn xuống đĩa, rồi đổi tên file tạm đè lên file cũ. Trên Linux và macOS, phép đổi tên đó không chia cắt được: mất điện lúc nào bạn cũng còn nguyên bản cũ hoặc nguyên bản mới. Điểm cam kết (commit point) là lúc một cái tên chuyển sang trỏ vào bản mới — ý tưởng thứ hai quay lại. Nhật ký hệ thống file (Hệ điều hành) và giao dịch (Hệ cơ sở dữ liệu) là những phiên bản công phu hơn của cùng ý này.

5. Hiệu năng: lưu tạm và gom lô, ở mọi tầng

Hai lời khuyên của Lampson được dùng khắp ngành: lưu tạm (caching) kết quả của việc đắt, và gom lô (batching) những việc nhỏ.

Lưu tạm là giữ ở gần một bản sao của thứ ở xa, như ghi số điện thoại hay gọi ra tờ giấy dán cạnh bàn thay vì lần nào cũng lật danh bạ. Nó có ở mọi tầng, từ bộ nhớ đệm trong bộ xử lý (bài Kiến trúc máy tính) tới mạng phân phối nội dung (CDN). Ví dụ, một trang hiện 200 thẻ học liệu thuộc năm khóa học, mỗi lần hỏi máy chủ ở xa mất 20 ms:

python
import time
from functools import lru_cache

def lay_khoa_hoc(ma):                  # giả lập hỏi một máy chủ ở xa: mỗi lần 20 ms
    time.sleep(0.02)
    return {"ma": ma, "ten": f"Khóa {ma}"}

@lru_cache(maxsize=1000)
def lay_co_luu_tam(ma):
    return lay_khoa_hoc(ma)

# một trang hiện 200 thẻ học liệu, nhưng chỉ thuộc về 5 khóa học
yeu_cau = ["6.033", "COS316", "15-213", "CS110", "6.826"] * 40

for ham in (lay_khoa_hoc, lay_co_luu_tam):
    t = time.perf_counter()
    for ma in yeu_cau:
        ham(ma)
    print(f"{ham.__name__}: {time.perf_counter() - t:.2f} giây")
print(lay_co_luu_tam.cache_info())    # hits=195, misses=5

Không lưu tạm: 200 lần hỏi, mất vài giây. Có lưu tạm: chỉ 5 lần hỏi thật, 195 lần còn lại lấy ngay trong bộ nhớ — nhanh hơn vài chục lần. Cái giá là dữ liệu cũ: khóa học vừa đổi tên mà bản lưu tạm chưa biết. Chọn lúc bỏ bản lưu tạm khó tới mức thành câu đùa của nghề, thường gán cho Phil Karlton: khoa học máy tính chỉ có hai việc khó — làm mất hiệu lực bộ nhớ đệm, và đặt tên.

Gom lô là chờ thêm một chút để mỗi chuyến chở được nhiều, như shipper gom các đơn cùng tuyến. Mỗi lần ghi đĩa hay gửi qua mạng đều tốn một khoản cố định, nên một lần ghi lớn rẻ hơn nhiều lần ghi nhỏ. Cơ sở dữ liệu gom nhật ký của nhiều giao dịch rồi ghi xuống đĩa một lần; năm 1984, John Nagle đề xuất cho TCP gom những mẩu dữ liệu nhỏ thành một gói. Cái giá: thông lượng (throughput) tăng, nhưng từng việc chờ lâu hơn — độ trễ (latency) tăng. Không lời khuyên nào miễn phí; môn học dạy bạn đọc ra mình đang đổi cái gì lấy cái gì.

Nguyên lý hệ thống nằm ở đâu trong chồng tầng

Môn này không thuộc một tầng nào trong chồng tầng của bài Từ electron đến ứng dụng. Nó là những ý tưởng lặp lại ở mọi tầng, chỉ đổi tên gọi:

Ý tưởng
Phần cứng
Hệ điều hành
Mạng
Dịch vụ và ứng dụng
Đặt tên
Địa chỉ bộ nhớ
Đường dẫn file, mã tiến trình
Địa chỉ IP, tên miền
URL, mã người dùng, mã phiên bản Git
Lưu tạm
Bộ nhớ đệm L1–L3
Bộ đệm trang đĩa
Bản lưu câu trả lời DNS
Bộ nhớ đệm trình duyệt, CDN
Dư thừa
RAM có mã sửa lỗi (ECC)
Ghép nhiều ổ đĩa (RAID)
Nhiều đường đi giữa hai mạng
Bản sao ở nhiều trung tâm dữ liệu
Nguyên tử
Lệnh so sánh và hoán đổi (compare-and-swap)
Nhật ký hệ thống file
Gói tin tới nguyên vẹn hoặc bị bỏ hẳn
Giao dịch cơ sở dữ liệu

Lập luận đầu cuối trả lời câu hỏi đứng trên cả bảng: một chức năng nên đặt ở cột nào.

Đưa lên

Một hệ thống trông như một cỗ máy duy nhất và đáng tin: tên không đổi, dữ liệu không mất, thao tác hoặc xong hết hoặc chưa làm gì, trả lời nhanh.

Giấu đi

Hàng nghìn máy, những ổ cứng hỏng mỗi ngày, các bản sao và việc giữ chúng khớp nhau, đường mạng chập chờn, các bản lưu tạm và những lô đang chờ ghi.

Học trước và học sau

· 6 môn

Cấu trúc tính toán

Computation Structures

Chương trình chạy thế nào ở tầng dưới: bộ nhớ, bộ xử lý, hợp ngữ. Nên học trước.

Xem chủ đề trên OpenER: Computation Structures

Hệ điều hành

Operating Systems

Những nguyên lý trong bài, gói gọn trong một máy. Học trước hoặc song song.

Xem chủ đề trên OpenER: Operating Systems

Mạng máy tính

Computer Networks

Lập luận đầu cuối ở cỡ cả hành tinh, và DNS — cơ chế đặt tên lớn nhất thế giới.

Xem chủ đề trên OpenER: Computer Networks

Hệ cơ sở dữ liệu

Database Systems

Tính nguyên tử làm tới nơi tới chốn: giao dịch, khóa, nhật ký ghi trước.

Xem chủ đề trên OpenER: Database Systems

Hệ phân tán

Distributed Systems

Học sau: khi bản sao nằm trên nhiều máy — đồng thuận, đồng hồ, nhất quán và định lý CAP.

Xem chủ đề trên OpenER: Distributed Systems

An toàn máy tính

Computer Security

6.033 dành bốn tuần cuối cho bảo mật — khi thứ gây lỗi không còn là ổ cứng hỏng mà là con người cố ý.

Xem chủ đề trên OpenER: Computer Security

Ứng dụng thật và nghề nghiệp

  • Kỹ sư backend và kiến trúc sư hệ thống: viết và phản biện tài liệu thiết kế (design doc) — chỗ nào lưu tạm, chỗ nào cần bản sao, máy này chết thì sao.
  • Kỹ sư độ tin cậy (site reliability engineer — SRE) và DevOps: đặt mục tiêu "ba số chín" hay "bốn số chín", đo nó, viết báo cáo sau sự cố (postmortem) để tìm điểm hỏng duy nhất tiếp theo.
  • Hạ tầng đám mây và lưu trữ: giữ dữ liệu của hàng triệu người trên hàng nghìn ổ cứng có thể hỏng bất cứ lúc nào.
  • Nghiên cứu hệ thống: các hội nghị SOSP, OSDI — nơi GFS và MapReduce ra mắt.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • nhìn một hệ thống lạ và chỉ ra nó dùng tên, lưu tạm, bản sao, điểm cam kết ở đâu;
  • tính độ sẵn sàng của một thiết kế và tìm ra điểm hỏng duy nhất của nó;
  • quyết định một phép kiểm tra nên đặt ở giữa đường hay ở hai đầu;
  • lưu dữ liệu sao cho mất điện giữa chừng không để lại trạng thái nửa vời.

Nên biết trước: lập trình ở mức viết được chương trình vài trăm dòng, cấu trúc dữ liệu cơ bản, và cách máy chạy chương trình ở tầng dưới (chủ đề Computation Structures).

Bắt đầu trên OpenER: trang chủ đề Principles of Computer Systems có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Khóa chính là MIT 6.033 (Spring 2018) trên MIT OpenCourseWare; Princeton COS 316 đi qua các chủ đề tương tự bằng ví dụ hiện đại như Git và CDN. Chưa vững chuyện chương trình chạy trên máy thật thì học CMU 15-213 trước; muốn tự viết code hệ thống, có Stanford CS 110. Đi xa hơn, MIT 6.826 dựa trên ghi chú của Butler Lampson dạy cách đặc tả và lập luận chặt chẽ về hệ thống.

Lời khuyên cho môn này: đọc bài báo gốc. Phần lớn buổi thảo luận của 6.033 xoay quanh một bài báo — về Unix, DNS, MapReduce — và bài lập luận đầu cuối hay bài của Lampson đều đọc xong trong một buổi tối.

Tài liệu tham khảo

  • Jerome H. Saltzer, M. Frans Kaashoek — Principles of Computer System Design: An Introduction, Morgan Kaufmann, 2009; các chương 7–11 đọc miễn phí trên MIT OpenCourseWare.
  • MIT 6.033 Computer System Engineering (Spring 2018) — MIT OpenCourseWare.
  • Princeton COS 316 Principles of Computer System Design (Fall 2024) — trang khóa học.
  • MIT 6.826 Principles of Computer Systems (Spring 2002) — MIT OpenCourseWare.
  • J. H. Saltzer, D. P. Reed, D. D. Clark — "End-to-End Arguments in System Design", ACM Transactions on Computer Systems, 1984.
  • Butler W. Lampson — "Hints for Computer System Design", ACM Symposium on Operating Systems Principles (SOSP), 1983.
  • F. J. Corbató, V. A. Vyssotsky — "Introduction and Overview of the Multics System", AFIPS Fall Joint Computer Conference, 1965.
  • Sanjay Ghemawat, Howard Gobioff, Shun-Tak Leung — "The Google File System", SOSP 2003.
  • Luiz André Barroso, Urs Hölzle và cộng sự — The Datacenter as a Computer: An Introduction to the Design of Warehouse-Scale Machines, Morgan & Claypool, bản đầu năm 2009.
  • Betsy Beyer và cộng sự — Site Reliability Engineering: How Google Runs Production Systems, O'Reilly, 2016, đọc miễn phí tại sre.google.

Ban biên tập OpenER, “Nguyên lý hệ thống máy tính: những ý tưởng giữ cho hệ thống lớn đứng vững”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.