Ngôn ngữ lập trình và trình biên dịch: một dòng code đi đường nào để máy chạy được
Một dòng code thành việc máy làm ra sao: văn phạm và phân tích cú pháp, thông dịch và biên dịch, tối ưu, kiểu, thu gom rác — và vì sao các ngôn ngữ khác nhau.
Ban biên tập OpenER
Cập nhật 09/11/2026 · 20 phút đọc · CC BY 4.0
Bạn gõ vào Python một dòng tiền = số_ly * (giá + trân_châu) rồi bấm chạy, kết quả hiện ra ngay. Nhưng bộ xử lý trong máy không biết chữ "số_ly", không biết dấu ngoặc, cũng không biết phép cộng trong ngoặc phải làm trước phép nhân. Như bài Cấu trúc tính toán cho thấy, nó chỉ biết đọc từng lệnh máy — một dãy bit — rồi làm theo. Giữa dòng chữ bạn gõ và dãy bit đó là một chương trình khác: nó đọc code của bạn như người đọc một câu văn, soát ngữ pháp, hiểu nghĩa, rồi viết lại thành lệnh cho máy.
Chương trình ấy là trình biên dịch (compiler) hoặc trình thông dịch (interpreter). Môn học về chúng cũng trả lời một câu hỏi người học lập trình nào cũng từng thắc mắc: vì sao có nhiều ngôn ngữ đến thế? Vì sao cùng một vòng lặp, viết bằng C chạy nhanh hơn Python nhiều lần; vì sao TypeScript báo lỗi trước khi chạy, còn Python đợi tới lúc chạy mới báo?
Trước khi có trình biên dịch đủ tốt
Bài Lập trình đã kể chặng đầu: từ mã máy, hợp ngữ tới trình biên dịch A-0 của Grace Hopper năm 1952. Nhưng có trình biên dịch chưa phải là xong. Các hệ thống "lập trình tự động" (automatic programming) đầu thập niên 1950 phần lớn sinh ra chương trình chậm hơn code viết tay nhiều lần, và giới lập trình viên thời đó tin rằng máy không bao giờ viết code giỏi bằng người. Máy thời đó lại đắt tới mức không ai chịu đổi tốc độ lấy tiện lợi.
Niềm tin ấy đổi dần qua từng bước:
- FORTRAN (1957). Nhóm của John Backus ở IBM mất khoảng 18 người-năm làm trình biên dịch FORTRAN cho máy IBM 704. Backus kể lại: thiết kế ngôn ngữ là phần dễ; phần khó là làm cho chương trình dịch ra chạy nhanh, vì nếu nó chỉ nhanh bằng nửa code viết tay thì khó ai chịu dùng. Nhóm dồn sức vào tối ưu hóa (optimization), và code FORTRAN sinh ra nhanh gần bằng code của chuyên gia.
- Lisp (1958). John McCarthy ở MIT làm Lisp cho các chương trình trí tuệ nhân tạo, vốn tạo ra rồi bỏ đi rất nhiều danh sách nhỏ. Để người lập trình khỏi phải tự dọn, ông nghĩ ra thu gom rác (garbage collection): máy tự tìm những vùng nhớ không còn ai dùng để thu hồi.
- BNF và ALGOL 60 (1959–1960). Backus đề xuất một ký pháp để viết văn phạm (grammar) của ngôn ngữ; Peter Naur dùng nó trong bản báo cáo về ALGOL 60. Lần đầu tiên cú pháp của một ngôn ngữ được định nghĩa chính xác trên giấy, thay vì "trình biên dịch nhận gì thì là đúng". Ký pháp ấy về sau mang tên dạng Backus–Naur (Backus–Naur form — BNF).
- C và Unix (1972–1973). Dennis Ritchie ở Bell Labs làm ra C: đủ gần máy để viết hệ điều hành, đủ xa máy để không gắn chết vào một loại bộ xử lý. Năm 1973, nhân Unix được viết lại bằng C; đưa Unix sang máy mới phần lớn chỉ còn là viết trình biên dịch C cho máy đó và sửa một phần nhỏ gắn với phần cứng — một lý do Unix lan ra khắp nơi, thành ông tổ của Linux, macOS, Android như bài Hệ điều hành kể.
- Java (1995). Sun Microsystems dịch Java ra bytecode cho một máy ảo (virtual machine), JVM, thay vì cho một bộ xử lý thật. Máy nào có JVM là chạy được mọi chương trình Java: "viết một lần, chạy mọi nơi" (write once, run anywhere). Java cũng đưa thu gom rác vào dòng chính của ngành phần mềm.
- LLVM (2003). Chris Lattner và Vikram Adve ở Đại học Illinois công bố LLVM 1.0: một biểu diễn trung gian (intermediate representation — IR) dùng chung, kèm bộ tối ưu và bộ sinh mã cho nhiều loại máy. Làm ngôn ngữ mới chỉ cần viết phần dịch xuống IR; Clang (C, C++), Swift, Rust đều đứng trên LLVM — như dòng LLVM IR trong Hình 14 của bài Từ electron đến ứng dụng.
Đặt cạnh nhau:
Khi trình biên dịch còn kém | Khi trình biên dịch đủ tốt | |
|---|---|---|
Muốn chạy nhanh | Viết tay hợp ngữ | Viết ngôn ngữ bậc cao, để trình biên dịch tối ưu |
Chuyển sang máy khác | Viết lại gần hết | Biên dịch lại, hoặc chạy trên máy ảo |
Thế nào là đúng cú pháp | Trình biên dịch nhận gì thì là đúng | Có văn phạm viết rõ |
Thu hồi bộ nhớ | Người lập trình tự lo | Ở nhiều ngôn ngữ, thu gom rác làm thay |
Làm ngôn ngữ mới | Viết trọn trình biên dịch cho từng loại máy | Viết phần đầu, dùng lại LLVM hay một máy ảo |
Cột bên trái còn ở một chỗ đáng ngạc nhiên: Python, một trong những ngôn ngữ phổ biến nhất hôm nay. Trình thông dịch chuẩn CPython dịch code ra bytecode rồi thông dịch từng lệnh, không dịch ra mã máy; tới Python 3.13 (10/2024) mới có một trình biên dịch tức thời (JIT) thử nghiệm, mặc định còn tắt. Vì vậy phần tính toán nặng được đẩy xuống những thư viện viết bằng C như NumPy.
Môn này trả lời câu hỏi gì
Môn học có hai nửa, ở nhiều trường dạy thành hai môn riêng:
- Ngôn ngữ lập trình (programming languages): một chương trình nghĩa là gì? Biến thuộc phạm vi nào, kiểu dữ liệu bảo đảm được điều gì, bộ nhớ do ai quản lý.
- Trình biên dịch (compilers): làm sao dịch chương trình đó xuống máy mà không đổi nghĩa, và cho nó chạy càng nhanh càng tốt?
Câu trả lời cho "vì sao các ngôn ngữ khác nhau" nằm ở đây: mỗi ngôn ngữ là một bộ lựa chọn cho vài câu hỏi thiết kế — kiểm tra kiểu lúc nào, ai thu hồi bộ nhớ, dịch xuống máy lúc nào.
Ngôn ngữ | Kiểm tra kiểu | Thu hồi bộ nhớ | Dịch xuống máy |
|---|---|---|---|
C | Trước khi chạy | Người lập trình tự gọi free | Biên dịch trước ra mã máy |
Python | Lúc chạy | Đếm tham chiếu, thêm bộ gom chu trình | Dịch ra bytecode rồi thông dịch |
Java | Phần lớn trước khi chạy | Thu gom rác | Ra bytecode; máy ảo thông dịch, rồi dịch tức thời phần chạy nhiều |
JavaScript | Lúc chạy | Thu gom rác | Thông dịch, rồi dịch tức thời phần chạy nhiều |
Rust | Trước khi chạy | Trình biên dịch tự chèn lệnh giải phóng | Biên dịch trước, qua LLVM |
TypeScript | Trước khi chạy, rồi xóa kiểu | Như JavaScript | Dịch sang JavaScript |
Vì sao cần học, khi ít ai sẽ viết trình biên dịch? Vì ai làm phần mềm cũng làm việc với ngôn ngữ mỗi ngày: JSON, SQL, file cấu hình đều có văn phạm và bộ phân tích riêng; TypeScript, ESLint, Prettier đều đọc code, dựng cây, biến đổi cây, in ra code. Hiểu môn này, bạn đọc được thông báo lỗi, đoán được trình biên dịch sẽ làm gì với code của mình, và chọn ngôn ngữ bằng lý lẽ thay vì thói quen.
Năm ý tưởng cốt lõi
Cả năm ý dưới đây dùng chung một ngôn ngữ tí hon: biểu thức số học có cộng, trừ, nhân, chia, ngoặc và tên biến — đủ nhỏ để viết trọn trong bài, đủ thật để thấy từng chặng của một trình biên dịch. Các đoạn code chạy nối tiếp nhau.
1. Văn phạm và phân tích cú pháp: từ chuỗi ký tự thành cây
Câu "Ông già đi nhanh quá" có hai nghĩa: ông già / đi nhanh quá và ông / già đi nhanh quá. Người đọc dựa vào ngữ cảnh để chọn. Máy không có ngữ cảnh, nên ngôn ngữ lập trình được thiết kế để mỗi đoạn code chỉ có một cách hiểu: 2 + 3 * 4 phải là 2 cộng với (3 nhân 4).
Hai chặng đầu của mọi trình biên dịch làm việc đó. Phân tích từ vựng (lexical analysis) tách chuỗi ký tự thành các từ tố (token) — số, tên, dấu phép tính — như tách một câu thành từng từ. Phân tích cú pháp (parsing) ghép các từ tố thành một cây cú pháp (syntax tree) theo văn phạm. Bài Lý thuyết tính toán đã cho thấy vì sao chặng này cần văn phạm phi ngữ cảnh; ở đây ta viết nó theo cách đơn giản nhất, phân tích đệ quy xuống (recursive descent): mỗi quy tắc văn phạm thành một hàm.
import re
# Văn phạm của ngôn ngữ, viết theo kiểu BNF:
# bieu_thuc ::= hang { ("+" | "-") hang }
# hang ::= nhan_to { ("*" | "/") nhan_to }
# nhan_to ::= số | tên | "(" bieu_thuc ")"
def tach_tu(nguon):
"""Phân tích từ vựng: chuỗi ký tự -> danh sách từ tố."""
return re.findall(r"\d+(?:\.\d+)?|[^\W\d]\w*|\S", nguon)
class BoPhanTich:
def __init__(self, nguon):
self.tu, self.vt = tach_tu(nguon), 0
def xem(self):
return self.tu[self.vt] if self.vt < len(self.tu) else None
def lay(self):
t = self.xem()
self.vt += 1
return t
def bieu_thuc(self): # mỗi quy tắc văn phạm là một hàm
cay = self.hang()
while self.xem() in ("+", "-"):
cay = (self.lay(), cay, self.hang())
return cay
def hang(self):
cay = self.nhan_to()
while self.xem() in ("*", "/"):
cay = (self.lay(), cay, self.nhan_to())
return cay
def nhan_to(self):
t = self.lay()
if t == "(":
cay = self.bieu_thuc()
if self.lay() != ")":
raise SyntaxError("thiếu dấu đóng ngoặc")
return cay
if t and t[0].isdigit():
return float(t) if "." in t else int(t)
if t and (t[0].isalpha() or t[0] == "_"):
return t
raise SyntaxError(f"không hiểu từ tố {t!r}")
def phan_tich(nguon):
p = BoPhanTich(nguon)
cay = p.bieu_thuc()
if p.xem() is not None:
raise SyntaxError(f"thừa từ tố {p.xem()!r}")
return cay
print(tach_tu("số_ly * (giá + trân_châu)"))
print(phan_tich("2 + 3 * 4"))
print(phan_tich("(2 + 3) * 4"))
print(phan_tich("số_ly * (giá + trân_châu)"))
try:
phan_tich("(2 + 3")
except SyntaxError as loi:
print("Lỗi cú pháp:", loi)['số_ly', '*', '(', 'giá', '+', 'trân_châu', ')']
('+', 2, ('*', 3, 4))
('*', ('+', 2, 3), 4)
('*', 'số_ly', ('+', 'giá', 'trân_châu'))
Lỗi cú pháp: thiếu dấu đóng ngoặcMỗi bộ ba (phép tính, nhánh trái, nhánh phải) là một nút của cây. Thứ tự ưu tiên nằm ở cách xếp tầng văn phạm: bieu_thuc gồm các hang nối bằng dấu cộng trừ, mỗi hang gồm các nhan_to nối bằng dấu nhân chia. Phép nhân ở tầng sâu hơn nên được ghép trước — quy tắc "nhân chia trước, cộng trừ sau" của tiểu học, viết thành ba hàm. Vòng while ghép từ trái sang phải, nên 10 - 4 - 3 là (10 − 4) − 3 = 3, không phải 9.
Tên biến có dấu mà bộ tách từ vẫn chạy, vì \w của Python nhận mọi chữ cái Unicode. Chính Python cho đặt tên biến có dấu từ bản 3.0 (2008). Bài Lập trình đã chỉ ra một chữ có dấu có thể được lưu theo hai cách; bộ phân tích từ vựng của Python chuẩn hóa mọi tên biến về một dạng (NFKC) trước khi so, nên hai cách lưu vẫn là một biến:
import unicodedata
ten_gop = "điểm" # chữ có dấu, lưu gộp (NFC)
ten_tach = unicodedata.normalize("NFD", ten_gop) # cùng chữ đó, dấu lưu tách rời
print(ten_gop == ten_tach) # False: hai chuỗi khác nhau
exec(f"{ten_gop} = 9\nprint({ten_tach} + 1)") # 10: với Python vẫn là một biếnChuỗi thì giữ nguyên, tên biến thì chuẩn hóa — một quyết định nhỏ của người thiết kế ngôn ngữ. Dù vậy, các nhóm làm phần mềm thường vẫn đặt tên tiếng Anh không dấu: gõ được trên mọi bàn phím, và tránh những chữ trông y hệt mà khác mã — chữ "а" Kirin và chữ "a" Latin là hai biến khác nhau.
2. Thông dịch và biên dịch: dịch từng câu hay dịch cả cuốn sách
Tiếng Việt có sẵn hai chữ cho hai cách dịch. Người phiên dịch ngồi cạnh khách, nghe câu nào dịch câu đó. Người biên dịch nhận cả cuốn sách, dịch xong mới giao, và người đọc bản dịch không cần ai ngồi cạnh. Trình thông dịch cũng đi trên cây cú pháp và tính ngay; trình biên dịch dịch cả cây thành một dãy lệnh, rồi một cỗ máy chạy dãy lệnh đó — bao nhiêu lần cũng được, không cần dịch lại.
Dưới đây là cả hai cho ngôn ngữ ở ý 1. Cỗ máy đích là một máy ngăn xếp (stack machine) dài chừng chục dòng: lệnh nạp đặt một giá trị lên đỉnh ngăn xếp, lệnh tính lấy hai giá trị trên cùng ra và đặt kết quả vào.
import operator
PHEP = {"+": operator.add, "-": operator.sub, "*": operator.mul, "/": operator.truediv}
def tinh(cay, bien):
"""Thông dịch: đi thẳng trên cây, gặp nút nào tính nút đó."""
if isinstance(cay, tuple):
op, trai, phai = cay
return PHEP[op](tinh(trai, bien), tinh(phai, bien))
return bien[cay] if isinstance(cay, str) else cay
def bien_dich(cay, ma):
"""Biên dịch: đổi cây thành dãy lệnh cho một máy ngăn xếp."""
if isinstance(cay, tuple):
op, trai, phai = cay
bien_dich(trai, ma)
bien_dich(phai, ma)
ma.append((op,))
elif isinstance(cay, str):
ma.append(("NẠP_BIẾN", cay))
else:
ma.append(("NẠP_SỐ", cay))
return ma
def chay(ma, bien):
"""Máy ảo: làm từng lệnh trên một ngăn xếp."""
ngan_xep = []
for lenh in ma:
if lenh[0] == "NẠP_SỐ":
ngan_xep.append(lenh[1])
elif lenh[0] == "NẠP_BIẾN":
ngan_xep.append(bien[lenh[1]])
else:
phai, trai = ngan_xep.pop(), ngan_xep.pop()
ngan_xep.append(PHEP[lenh[0]](trai, phai))
return ngan_xep.pop()
cay = phan_tich("số_ly * (giá + trân_châu)")
bien = {"số_ly": 3, "giá": 45_000, "trân_châu": 5_000}
print(tinh(cay, bien))
ma = bien_dich(cay, [])
for lenh in ma:
print(lenh)
print(chay(ma, bien))150000
('NẠP_BIẾN', 'số_ly')
('NẠP_BIẾN', 'giá')
('NẠP_BIẾN', 'trân_châu')
('+',)
('*',)
150000Hai cách cho cùng kết quả — ba ly trà sữa 45.000 đồng, mỗi ly thêm 5.000 đồng trân châu — nhưng khác ở chỗ việc được làm khi nào. Trình thông dịch đi lại cả cây mỗi lần chạy. Trình biên dịch đi cây đúng một lần; sau đó máy ảo chỉ đọc một dãy lệnh phẳng, nhanh hơn, và lưu lại được — đổi lại phải thêm một bước dịch.
Đây không phải đồ chơi xa thực tế. CPython làm đúng như vậy: dịch code ra bytecode (các file .pyc trong thư mục __pycache__), rồi một vòng lặp viết bằng C đọc từng lệnh, làm việc trên một ngăn xếp như hàm chay. Máy ảo Java cũng là máy ngăn xếp. Bộ xử lý thật thì dùng thanh ghi, như cỗ máy đồ chơi trong bài Cấu trúc tính toán, nên trình biên dịch ra mã máy phải giải thêm bài toán giữ giá trị nào ở thanh ghi nào. Cách thứ ba là biên dịch tức thời (just-in-time compilation — JIT) của Java và JavaScript: thông dịch trước, đo xem đoạn nào chạy nhiều, rồi dịch riêng những đoạn đó ra mã máy.
3. Tối ưu hóa: làm ít việc hơn mà không đổi nghĩa
Bài học của FORTRAN là trình biên dịch tốt không chỉ dịch đúng mà còn dịch khéo. Phép tối ưu đơn giản nhất là gập hằng số (constant folding): nhánh nào chỉ toàn số thì tính luôn lúc biên dịch, khỏi để mỗi lần chạy tính lại. Viết thành một hàm đi trên chính cái cây ở ý 1:
def gap_hang(cay):
"""Tối ưu: nhánh nào chỉ toàn số thì tính luôn lúc biên dịch."""
if not isinstance(cay, tuple):
return cay
op, trai, phai = cay[0], gap_hang(cay[1]), gap_hang(cay[2])
la_so = lambda x: isinstance(x, (int, float))
if la_so(trai) and la_so(phai) and not (op == "/" and phai == 0):
return PHEP[op](trai, phai) # chia cho 0 thì để lúc chạy báo lỗi
return (op, trai, phai)
for nguon in ["giờ * (60 * 60)", "giờ * 60 * 60"]:
cay = gap_hang(phan_tich(nguon))
print(cay, "->", len(bien_dich(cay, [])), "lệnh")('*', 'giờ', 3600) -> 3 lệnh
('*', ('*', 'giờ', 60), 60) -> 5 lệnhDòng thứ hai mới thú vị. giờ * 60 * 60 trông như cùng một phép tính, nhưng theo văn phạm nó là (giờ × 60) × 60: không nhánh nào toàn số, nên không gập được gì. CPython cũng y như vậy — module dis cho xem bytecode nó sinh ra:
import dis
dis.dis("giờ * (60 * 60)") 0 0 RESUME 0
1 2 LOAD_NAME 0 (giờ)
4 LOAD_CONST 0 (3600)
6 BINARY_OP 5 (*)
10 RETURN_VALUEĐổi thành giờ * 60 * 60 thì dis hiện hai lần nạp số 60 và hai phép nhân. Hình dạng của cây quyết định trình biên dịch làm được gì.
Hàm gap_hang còn một chỗ đáng để ý: chia cho 0 thì không gập. Nếu gập, chương trình sẽ báo lỗi ngay lúc dịch, kể cả khi dòng đó không bao giờ chạy tới — CPython cũng để nguyên 1/0 trong bytecode. Đó là luật vàng của tối ưu: không được đổi nghĩa của chương trình. Cũng vì vậy, trình biên dịch C không tự đổi (a + b) + c thành a + (b + c) với số thực, vì làm tròn có thể cho hai kết quả khác nhau, trừ khi người lập trình cho phép bằng cờ như -ffast-math. Trình biên dịch thật còn nhiều phép tối ưu khác: bỏ code không bao giờ chạy tới, đưa phép tính ra ngoài vòng lặp, chép thân hàm nhỏ vào chỗ gọi.
4. Kiểu: bắt lỗi trước khi chương trình chạy
Giả sử ngôn ngữ có thêm kiểu chuỗi, và biến tên_quán chứa tên quán trà sữa. Cộng tiền với tên quán là vô nghĩa, nhưng trình thông dịch ở ý 2 chỉ phát hiện khi chạy tới đúng dòng đó. Một bộ kiểm tra kiểu (type checker) phát hiện ngay từ đầu, khi chưa có giá trị nào: nó đi trên cây và suy ra loại giá trị mỗi nhánh sẽ cho.
def kieu(cay, khai_bao):
"""Kiểm tra kiểu: suy ra kiểu của biểu thức mà không cần biết giá trị nào."""
if isinstance(cay, tuple):
op, trai, phai = cay
kt, kp = kieu(trai, khai_bao), kieu(phai, khai_bao)
if kt != "số" or kp != "số":
raise TypeError(f"phép {op} cần hai số, nhưng gặp {kt} {op} {kp}")
return "số"
return khai_bao[cay] if isinstance(cay, str) else "số"
khai_bao = {"số_ly": "số", "giá": "số", "tên_quán": "chuỗi"}
print(kieu(phan_tich("số_ly * giá"), khai_bao))
try:
kieu(phan_tich("số_ly * giá + tên_quán"), khai_bao)
except TypeError as loi:
print("Lỗi kiểu:", loi)số
Lỗi kiểu: phép + cần hai số, nhưng gặp số + chuỗiHàm tinh làm việc với giá trị (3, 45.000…), hàm kieu làm việc với loại giá trị ("số", "chuỗi"). Cùng một cách đi cây, nhưng "tính" ở mức trừu tượng hơn — nên bộ kiểm tra kiểu thấy được lỗi ở cả những nhánh if mà kiểm thử chưa từng chạy qua. Đó là khác biệt giữa kiểu tĩnh (static typing), kiểm tra trước khi chạy như C, Java, Rust, và kiểu động (dynamic typing), kiểm tra lúc chạy như Python, JavaScript.
Hai phía đang gặp nhau ở giữa: TypeScript thêm kiểu vào JavaScript; Python cho viết chú thích kiểu (type hint) để công cụ như mypy kiểm tra trước. Nhờ suy luận kiểu (type inference), có từ ngôn ngữ ML của Robin Milner những năm 1970, Rust, Kotlin, Swift tự suy ra kiểu của phần lớn biến. Bài Phương pháp hình thức đi tiếp theo hướng này: kiểu "có thể rỗng" chặn lỗi null, và vì sao hệ thống kiểu là một cỗ máy chứng minh nhỏ.
5. Bộ nhớ: ai dọn dẹp sau chương trình
Chương trình tạo ra đối tượng liên tục, và ai đó phải thu hồi chúng khi không dùng nữa. Có ba câu trả lời:
- Người lập trình tự làm, như
mallocvàfreetrong C: nhanh, nhưng quên thu hồi thì rò rỉ bộ nhớ, thu hồi rồi vẫn dùng tiếp thì thành lỗ hổng an toàn bộ nhớ (memory safety) — lớp lỗi mà bài Bảo mật phần mềm cho thấy là gốc của phần lớn lỗ hổng nghiêm trọng. - Bộ thu gom rác làm lúc chương trình chạy, theo ý tưởng của McCarthy.
- Trình biên dịch làm, như ở Rust: quy tắc sở hữu cho nó biết lúc nào một giá trị hết được dùng, và nó tự chèn lệnh giải phóng vào đúng chỗ.
Bộ thu gom rác có hai họ chính. Đếm tham chiếu (reference counting) ghi cho mỗi đối tượng số chỗ đang trỏ tới nó; về 0 là thu hồi. Đánh dấu và quét (mark and sweep) — cách McCarthy làm cho Lisp — thỉnh thoảng đi từ những biến chương trình đang dùng, gọi là gốc (root), đánh dấu mọi thứ tới được, rồi quét bỏ phần còn lại. Thử cả hai trên một "đống" (heap) năm đối tượng:
# "Đống" (heap): mỗi đối tượng ghi những đối tượng nó trỏ tới
dong = {"A": ["B"], "B": [], "C": ["D"], "D": ["C"], "E": []}
goc = ["A"] # biến của chương trình giờ chỉ còn trỏ tới A
# Đếm tham chiếu (ở đây đếm một lần cho gọn; thật ra số đếm đổi theo mỗi lần gán)
dem = {x: 0 for x in dong}
for x in goc + [y for ds in dong.values() for y in ds]:
dem[x] += 1
print("Đếm tham chiếu thu hồi:", [x for x in dong if dem[x] == 0])
# Đánh dấu và quét: đi từ gốc, đánh dấu mọi thứ tới được, quét bỏ phần còn lại
da_tham, can_tham = set(), list(goc)
while can_tham:
x = can_tham.pop()
if x not in da_tham:
da_tham.add(x)
can_tham.extend(dong[x])
print("Đánh dấu và quét thu hồi:", [x for x in dong if x not in da_tham])Đếm tham chiếu thu hồi: ['E']
Đánh dấu và quét thu hồi: ['C', 'D', 'E']C và D trỏ vào nhau, nhưng chương trình không còn đường nào tới chúng — rác thật sự. Vậy mà đếm tham chiếu không thu hồi được, vì mỗi đối tượng vẫn còn một chỗ trỏ tới: đối tượng kia. Đó là điểm yếu kinh điển của đếm tham chiếu, chu trình (cycle). Vì thế CPython thêm một bộ gom chu trình chạy định kỳ (module gc); Swift để người lập trình đánh dấu tham chiếu "yếu" (weak) để cắt vòng; Java, Go, JavaScript dùng những biến thể tinh vi của đánh dấu và quét, chạy song song với chương trình để mỗi lần dừng thật ngắn.
Ngôn ngữ lập trình và trình biên dịch nằm ở đâu trong chồng tầng
Trong chồng tầng của bài Từ electron đến ứng dụng, môn này là cây cầu từ tầng phần mềm xuống tầng kiến trúc tập lệnh (ISA): phía trên là ngôn ngữ con người viết, phía dưới là lệnh bộ xử lý hiểu. Hình 14 của bài đó vẽ một dòng C đi qua từng chặng; bài này mở từng chặng ra xem bên trong. Mỗi ngôn ngữ còn mang theo một môi trường chạy (runtime) — bộ thu gom rác, máy ảo, thư viện chuẩn — chạy cùng chương trình của bạn.
Đưa lên
Một ngôn ngữ có nghĩa rõ ràng — biến, hàm, kiểu, bộ nhớ được quản lý — kèm lời hứa: chương trình trên máy làm đúng điều code nguồn nói, dù đã tối ưu tới đâu.
Giấu đi
Thanh ghi nào giữ giá trị nào, lệnh máy nào được sinh ra, vùng nhớ nào được cấp và thu hồi lúc nào — cùng mọi khác biệt giữa các loại bộ xử lý.
Học trước và học sau
· 6 mônLập trình
Programming
Phải viết vững một ngôn ngữ trước khi tự làm một ngôn ngữ. Học trước.
Cấu trúc dữ liệu và giải thuật
Data Structures and Algorithms
Cây, đệ quy, ngăn xếp, bảng băm — nguyên liệu hằng ngày của trình biên dịch. Học trước.
Lý thuyết tính toán
Theory of Computation
Máy trạng thái và văn phạm phi ngữ cảnh đứng sau bộ tách từ và bộ phân tích cú pháp. Nên học trước, hiểu trực giác là đủ.
Kiến trúc máy tính
Computer Architecture and Engineering
Đích đến của trình biên dịch: thanh ghi, đường ống, bộ nhớ đệm — biết máy chạy thế nào mới sinh được mã nhanh.
Xem chủ đề trên OpenER: Computer Architecture and Engineering
Phương pháp hình thức
Formal Methods for Software Engineering
Ngữ nghĩa và hệ thống kiểu chính xác tới mức chứng minh được, kể cả chứng minh một trình biên dịch dịch đúng. Học sau.
Xem chủ đề trên OpenER: Formal Methods for Software Engineering
Bảo mật phần mềm
Software Security
Chọn ngôn ngữ là chọn một lớp lỗi; an toàn bộ nhớ và phân tích tĩnh. Học sau hoặc song song.
Ứng dụng thật và nghề nghiệp
- Kỹ sư trình biên dịch và môi trường chạy: GCC, LLVM, máy ảo Java, V8 (bộ máy JavaScript của Chrome). Mỗi loại chip mới, kể cả chip AI, cần trình biên dịch riêng; trình biên dịch cho học máy như XLA hay Triton biến mô hình thành chương trình chạy trên GPU.
- Công cụ cho lập trình viên: linter, formatter, gạch đỏ lỗi trong trình soạn thảo — phía sau là bộ phân tích cú pháp và bộ kiểm tra kiểu chạy lại mỗi khi bạn gõ phím, thường qua giao thức LSP (Language Server Protocol).
- Ngôn ngữ chuyên dụng (domain-specific language — DSL): ngôn ngữ truy vấn, công thức tính lương, quy tắc khuyến mãi. Hệ quản trị cơ sở dữ liệu cũng dịch mỗi câu SQL thành một kế hoạch chạy rồi tối ưu kế hoạch đó, như bài Hệ cơ sở dữ liệu kể.
- Dịch giữa các ngôn ngữ và phân tích tĩnh: TypeScript sang JavaScript, Rust sang WebAssembly để chạy trong trình duyệt; công cụ đọc code như dữ liệu để tìm lỗ hổng mà không cần chạy.
Học xong làm được gì, bắt đầu từ đâu
Sau môn này bạn có thể:
- viết bộ phân tích cú pháp cho một ngôn ngữ nhỏ — công thức, truy vấn, file cấu hình;
- viết một trình thông dịch có biến, hàm, bao đóng (closure), rồi một máy ảo bytecode cho nó;
- giải thích một ngôn ngữ đã chọn gì cho kiểu, bộ nhớ, thời điểm dịch, và hệ quả của từng lựa chọn;
- đọc bytecode hay hợp ngữ do trình biên dịch sinh ra để hiểu vì sao code chạy chậm.
Nên biết trước: lập trình vững một ngôn ngữ, đệ quy và cây (chủ đề Data Structures and Algorithms), trực giác về văn phạm và máy trạng thái (chủ đề Theory of Computation). Đây là môn nâng cao.
Bắt đầu trên OpenER: trang chủ đề Programming Languages and Compilers có các khóa học đã chọn lọc, và hướng dẫn học đi qua sáu bước, từ bộ quét từ vựng tới máy ảo bytecode, thu gom rác và tối ưu. Khóa chính là Compilers của Stanford trên edX, đi trọn đường từ phân tích từ vựng tới sinh mã; đọc song song sách mở Crafting Interpreters, nơi bạn tự viết một ngôn ngữ hai lần — một trình thông dịch đi trên cây, rồi một máy ảo bytecode. Nửa "ngôn ngữ" — ngữ nghĩa, hàm bậc cao, hệ thống kiểu — có khóa Programming Languages của Đại học Washington trên Coursera. Ngoài ra có MIT 6.035, khóa Compiler Design trên NPTEL, và bước nâng cao CMU 15-411.
Lời khuyên: tự làm một ngôn ngữ, dù nhỏ. Lấy các đoạn code ở ý 1 và ý 2, thêm phép so sánh, rồi nếu … thì … không thì …, rồi phép gán và vòng lặp. Tới lúc bạn tự hỏi "biến này thuộc phạm vi nào", bạn đã đứng giữa môn học.
Tài liệu tham khảo
- Robert Nystrom — Crafting Interpreters (2021), đọc miễn phí tại craftinginterpreters.com.
- Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman — Compilers: Principles, Techniques, and Tools, bản thứ hai, Addison-Wesley, 2006.
- Stanford — Compilers (Alex Aiken), khóa tự học trên edX.
- University of Washington — Programming Languages (Dan Grossman), trên Coursera.
- MIT 6.035 Computer Language Engineering (Spring 2010) trên MIT OpenCourseWare; Carnegie Mellon 15-411 Compiler Design.
- Benjamin C. Pierce — Types and Programming Languages, MIT Press, 2002.
- John Backus — "The History of FORTRAN I, II, and III", hội nghị ACM History of Programming Languages, 1978.
- John McCarthy — "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I", Communications of the ACM, 1960.
- Chris Lattner, Vikram Adve — "LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation", CGO 2004.
- Tài liệu chính thức của Python: mục Lexical analysis (tên định danh, PEP 3131) và module
dis.