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

Trước khi có thiết kế phần mềm

Nguyên lý và mẫu thiết kế phần mềm: viết code để còn sửa được

Vì sao code chạy đúng vẫn có thể là code tồi: che giấu thông tin, khớp nối và cố kết, mẫu Strategy và Observer, tái cấu trúc, nợ kỹ thuật.

Ban biên tập OpenER

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

Một cửa hàng nhỏ bán gốm Bát Tràng qua mạng nhờ cậu em họ biết lập trình làm trang web. Quy tắc phí giao hàng lúc đầu rất đơn giản: 30.000 đồng mỗi đơn, đơn từ 500.000 đồng thì miễn phí. Mười dòng code, viết xong trong một buổi chiều.

Rồi yêu cầu bắt đầu tới. Nội thành chỉ tính 20.000 đồng. Gốm nặng, nên đơn trên 2 kg cộng 10.000 đồng mỗi ký. Khách thân thiết có ưu đãi riêng. Tết thì miễn phí hết. Thêm giao tiết kiệm, giao hỏa tốc. Có đơn mới thì nhắn tin cho khách, trừ kho, cộng điểm. Mỗi lần, cậu em thêm vài dòng if — vào trang giỏ hàng, trang thanh toán và chỗ in hóa đơn, vì cả ba nơi đều tự tính phí. Có lần cậu quên sửa một chỗ: giỏ hàng ghi phí 30.000 đồng, hóa đơn ghi 40.000.

Lần sửa đầu tiên mất mười lăm phút. Lần thứ mười mất hai ngày, và cậu bắt đầu ngại đụng vào. Code không sai — nó vẫn chạy, vẫn tính ra tiền. Cái hỏng là hình dạng của nó: quy tắc mới nào cũng phải len vào giữa quy tắc cũ, và một thay đổi nhỏ kéo theo sửa ở nhiều nơi.

Môn Nguyên lý và mẫu thiết kế phần mềm (Software Engineering Principles and Patterns) dạy cách tổ chức code sao cho khi yêu cầu thay đổi — mà yêu cầu thì lúc nào cũng thay đổi — ta chỉ phải sửa ít chỗ, sửa an toàn, và người khác đọc vào là hiểu.

Trước khi có thiết kế phần mềm

Tới thập niên 1960, phần mềm lớn tới mức dự án trễ hạn, vượt ngân sách, đầy lỗi thành chuyện thường — người ta gọi đó là khủng hoảng phần mềm (software crisis); bài Nhập môn công nghệ phần mềm kể chuyện ấy và hội nghị NATO năm 1968. Ở đây ta theo một sợi chỉ hẹp hơn: con người học cách chia chương trình thành nhiều phần ra sao.

  1. Lập trình có cấu trúc (structured programming) — cuối thập niên 1960: bỏ những cú nhảy goto lung tung, như bài Lập trình đã kể. Từng đoạn code đọc được, nhưng chương trình lớn nên chia thành những phần nào thì chưa ai trả lời.
  2. Che giấu thông tin (information hiding) — năm 1972, David Parnas đăng bài On the Criteria To Be Used in Decomposing Systems into Modules trên tạp chí Communications of the ACM. Ông chia một chương trình tạo chỉ mục từ khóa (KWIC) theo hai cách. Cách quen thuộc: mỗi mô-đun (module) là một bước xử lý — đọc vào, xoay vòng các dòng, sắp xếp, in ra. Cách của ông: mỗi mô-đun giấu một quyết định thiết kế dễ thay đổi, chẳng hạn dữ liệu được lưu ra sao. Khi đổi cách lưu dữ liệu, cách thứ nhất phải sửa mọi mô-đun, cách thứ hai chỉ sửa một. Cũng trong mấy năm đó, Larry Constantine và cộng sự đặt tên cho hai thước đo khớp nối (coupling) và cố kết (cohesion); Barbara Liskov và Stephen Zilles đưa ra kiểu dữ liệu trừu tượng (abstract data type) — kiểu dữ liệu định nghĩa bằng các thao tác trên nó, không bằng cách nó được lưu.
  3. Hướng đối tượng (object-oriented) — từ ngôn ngữ Simula 67 ở Na Uy và Smalltalk ở Xerox PARC, rồi phổ biến qua C++ và Java. Đối tượng gói dữ liệu cùng thao tác và giấu phần bên trong: che giấu thông tin thành một tính năng có sẵn của ngôn ngữ.
  4. Mẫu thiết kế (design pattern) — năm 1994, Erich Gamma, Richard Helm, Ralph Johnson và John Vlissides, thường gọi là "Bộ tứ" (Gang of Four), xuất bản cuốn Design Patterns: 23 lời giải cho những vấn đề thiết kế lặp đi lặp lại, mỗi lời giải một cái tên. Ý tưởng mượn từ kiến trúc sư Christopher Alexander, người năm 1977 cùng các cộng sự viết A Pattern Language về những "mẫu" lặp lại trong nhà cửa, kiểu "phòng nào cũng nên có ánh sáng từ hai phía".
  5. Sống chung với thay đổi — năm 1992, Ward Cunningham đưa ra phép so sánh nợ kỹ thuật (technical debt). Năm 1999, Martin Fowler xuất bản Refactoring, gom việc sửa lại cấu trúc code đang chạy thành một danh mục những bước nhỏ, bước nào cũng có tên.

Đặt cạnh nhau:

Code không được thiết kế
Code được thiết kế cho thay đổi
Thêm một quy tắc mới
Len vào giữa các if cũ, sửa ở nhiều nơi, sợ bỏ sót
Thêm một phần mới, phần cũ gần như không đụng tới
Một chỗ có lỗi
Lan sang những chỗ tưởng không liên quan
Khoanh được trong một mô-đun
Đổi thư viện hay nhà cung cấp
Viết lại nửa chương trình
Thay một mô-đun
Trao đổi trong nhóm
Giải thích lại từ đầu mỗi lần
"Chỗ này dùng Strategy" — một từ là đủ
Tốc độ làm tính năng mới
Chậm dần theo từng tháng
Giữ được đều

Code không được thiết kế vẫn có ở khắp nơi, và có hẳn một cái tên: năm 1997, Brian Foote và Joseph Yoder gọi nó là "quả bóng bùn lớn" (big ball of mud) — mọi thứ dính vào mọi thứ, không ai dám chạm. Ở nhiều công ty, đó là phần mềm nội bộ đã qua tay năm, sáu lớp lập trình viên: thêm một cột vào báo cáo cũng phải sửa ở chục màn hình, và có những đoạn code cứ để nguyên đó vì chẳng ai biết còn chỗ nào gọi tới. Nói cho công bằng, script chạy một lần rồi bỏ thì cứ viết cho nhanh: thiết kế là một khoản đầu tư, chỉ sinh lời khi code còn sống lâu và còn phải sửa.

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

Môn này trả lời câu hỏi: chia một chương trình thành những phần nào, và nối chúng với nhau ra sao, để nó thay đổi được mà không gãy?

Lập trình dạy viết một hàm cho đúng và dễ đọc. Nhập môn công nghệ phần mềm dạy làm phần mềm cùng nhiều người. Kiểm thử phần mềm dạy kiểm chứng code chạy đúng. Môn này nhìn vào cấu trúc của code: ranh giới giữa các phần, cái gì được lộ ra, cái gì được giấu đi.

Vì sao cần học? Vì phần mềm thật được viết một lần nhưng được sửa hàng trăm lần, bởi nhiều người; phần lớn công sức của nghề là đọc và sửa code đã có. Khi AI viết code nhanh hơn người, câu hỏi "chia thế nào, giấu cái gì" càng quan trọng: code sinh ra càng nhanh càng mau thành bùn.

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

1. Mô-đun và che giấu thông tin: giao diện và phần cài đặt

Ở cây ATM, bạn cắm thẻ, nhập mã, nhận tiền. Ngân hàng có thể thay cả hệ thống máy chủ phía sau, bạn vẫn rút tiền như cũ. Thao tác bạn thấy là giao diện (interface); mọi thứ phía sau là phần cài đặt (implementation). Thiết kế tốt là khi phần cài đặt đổi được mà giao diện không phải đổi.

Lỗi "giỏ hàng 30.000, hóa đơn 40.000" xảy ra vì quy tắc tính phí nằm ở ba nơi. Cách chữa đầu tiên là gom nó vào một mô-đun và chỉ lộ ra đúng một hàm:

python
# phi_giao_hang.py — mô-đun duy nhất biết quy tắc tính phí

_PHI_THEO_VUNG = {"noi_thanh": 20_000, "ngoai_thanh": 30_000}   # dấu _ nghĩa là "chuyện nội bộ"
_MIEN_PHI_TU = 500_000

def phi_giao(tong_tien, vung):
    """Phí giao hàng (đồng). Đây là giao diện; mọi thứ khác là chi tiết."""
    if tong_tien >= _MIEN_PHI_TU:
        return 0
    return _PHI_THEO_VUNG[vung]

print(phi_giao(450_000, "noi_thanh"), phi_giao(450_000, "ngoai_thanh"), phi_giao(600_000, "noi_thanh"))
# 20000 30000 0

Giỏ hàng, thanh toán và hóa đơn đều gọi phi_giao. Mai kia bảng phí chuyển vào cơ sở dữ liệu hay lấy thẳng từ hãng giao hàng, chỉ mô-đun này phải sửa. Đó chính là ý của Parnas: mỗi mô-đun giấu một quyết định có thể thay đổi. Câu hỏi để chia mô-đun không phải "chương trình làm những bước nào", mà là "cái gì có thể đổi, và làm sao để mỗi lần đổi chỉ chạm một chỗ".

Giao diện tốt thường nhỏ mà giấu được nhiều — John Ousterhout gọi đó là mô-đun sâu (deep module), với ví dụ đọc ghi file trên Unix: vài lời gọi open, read, write, close giấu cả hệ thống file, bộ đệm, ổ đĩa mà bài Hệ điều hành kể.

2. Khớp nối và cố kết: ít dây giữa các phần, nhiều gắn bó trong mỗi phần

Ở một công ty nhỏ, kế toán muốn biết hàng xuất đi bao nhiêu thì đọc phiếu xuất kho, chứ không tự vào kho đếm thùng. Nhờ vậy, kho có sắp lại kệ hay đổi thủ kho, kế toán vẫn làm việc như cũ. Hai phòng khớp nối lỏng: chỉ nói chuyện qua một tờ phiếu đã thống nhất.

  • Khớp nối (coupling) đo một phần phải biết bao nhiêu về những phần khác. Một hàm gửi tin nhắn mà phải đi qua don.khach_hang.dia_chi.so_dien_thoai là đang biết quá nhiều về bên trong của đơn hàng, khách hàng và địa chỉ; đổi một trong ba là nó gãy theo.
  • Cố kết (cohesion) đo những thứ nằm chung một phần có thật sự thuộc về nhau không. Một file tien_ich.py chứa cả hàm tính phí, hàm định dạng ngày và hàm gửi email là cố kết thấp: ba lý do để sửa nằm chung một chỗ.

Mục tiêu là khớp nối lỏng, cố kết cao. Phép thử đơn giản: một yêu cầu nhỏ thay đổi thì phải sửa bao nhiêu file? "Một" là cách chia đang tốt; "năm, và mong là không sót" là các phần đang buộc vào nhau quá chặt. Năm nguyên lý thiết kế lớp gọi tắt là SOLID phần lớn là cách cụ thể để giữ hai thước đo này; hướng dẫn học của chủ đề đi qua từng nguyên lý.

3. Mẫu thiết kế: những lời giải có tên

Một mẫu thiết kế là lời giải đã được kiểm chứng cho một vấn đề thiết kế hay lặp lại, cộng với một cái tên để mọi người gọi giống nhau. Bộ tứ chia 23 mẫu thành ba nhóm: tạo (creational) — tạo đối tượng sao cho linh hoạt; cấu trúc (structural) — ghép các phần với nhau; hành vi (behavioral) — chia việc và cách các phần trao đổi. Hai mẫu hành vi dưới đây có mặt ở gần như mọi phần mềm.

Strategy — đổi cách làm mà không đổi chỗ gọi. Cửa hàng có ba cách giao: tiêu chuẩn, tiết kiệm, hỏa tốc, mỗi cách một công thức. Thay vì một chuỗi if cach == "tieu_chuan": ... elif ... trong hàm tính tiền, mỗi cách giao là một chiến lược riêng, cùng một "hình dạng" — nhận một đơn, trả về số tiền:

python
def giao_tieu_chuan(don):
    return 30_000

def giao_tiet_kiem(don):
    return 18_000 if don["can_kg"] <= 2 else 25_000

def giao_hoa_toc(don):
    return 40_000 + 5_000 * don["so_km"]

CACH_GIAO = {"tieu_chuan": giao_tieu_chuan, "tiet_kiem": giao_tiet_kiem, "hoa_toc": giao_hoa_toc}

def phi_theo_cach_giao(don, cach):
    return CACH_GIAO[cach](don)        # không cần biết công thức bên trong

don = {"can_kg": 3, "so_km": 6}
for cach in CACH_GIAO:
    print(cach, phi_theo_cach_giao(don, cach))
# tieu_chuan 30000
# tiet_kiem 25000
# hoa_toc 70000

Mai thêm "giao qua đêm"? Viết thêm một hàm, thêm một dòng vào bảng; phi_theo_cach_giao không phải sửa một chữ. Đây là nguyên lý mở – đóng (open–closed principle): mở cho việc mở rộng, đóng với việc sửa đổi. Trong Java, Strategy thường là một interface và mỗi chiến lược một lớp; trong Python, hàm cũng là một giá trị nên một bảng các hàm là đủ. Mẫu là một ý tưởng, không phải đoạn code để chép.

Observer — báo tin cho những ai quan tâm. Khi có đơn mới, cần nhắn tin cho khách, trừ kho, cộng điểm thành viên. Nếu dat_hang gọi thẳng từng việc, thêm việc nào là phải sửa nó, và nó phải biết về mọi phần khác của hệ thống. Observer đảo chiều: dat_hang chỉ phát sự kiện "có đơn mới"; phần nào quan tâm thì tự đăng ký nghe:

python
class SuKien:
    def __init__(self):
        self._nguoi_nghe = []

    def dang_ky(self, ham):
        self._nguoi_nghe.append(ham)

    def phat(self, du_lieu):
        for ham in self._nguoi_nghe:
            ham(du_lieu)

co_don_moi = SuKien()

def nhan_tin_khach(don): print(f"Nhắn khách: đã nhận đơn {don['ma']}")
def tru_kho(don):        print(f"Kho: trừ {don['so_luong']} {don['san_pham']}")
def cong_diem(don):      print(f"Thành viên: cộng {don['tong_tien'] // 10_000} điểm")

for ham in (nhan_tin_khach, tru_kho, cong_diem):
    co_don_moi.dang_ky(ham)

def dat_hang(don):
    # ... kiểm tra, lưu đơn vào cơ sở dữ liệu ...
    co_don_moi.phat(don)               # không biết ai đang nghe

dat_hang({"ma": "DH0042", "san_pham": "bình men lam", "so_luong": 2, "tong_tien": 450_000})
# Nhắn khách: đã nhận đơn DH0042
# Kho: trừ 2 bình men lam
# Thành viên: cộng 45 điểm

Muốn thêm "báo cho người đóng gói", chỉ cần đăng ký thêm một hàm; dat_hang giữ nguyên. Lệnh addEventListener("click", ...) trên trang web cũng là đăng ký nghe sự kiện như vậy — xem bài Ứng dụng web.

Nhưng mẫu nào cũng có giá: đọc dat_hang giờ không thấy chuyện gì xảy ra sau khi đặt hàng, phải đi tìm mọi chỗ đăng ký. Lỗi kinh điển của người mới học là cài mẫu khắp nơi "phòng khi cần", biến mười dòng code thành năm lớp. Mẫu đáng dùng khi vấn đề nó giải quyết đã thật sự xuất hiện.

4. Tái cấu trúc: sửa hình dạng, giữ nguyên hành vi

Đây là hàm tính phí của cửa hàng gốm sau một năm "thêm if":

python
def tinh_phi(t, kg, nt, vip, tet):
    if tet:
        return 0
    if nt:
        p = 20000
    else:
        p = 30000
    if kg > 2:
        p = p + (kg - 2) * 10000
    if t >= 500000 and not vip:
        p = 0
    if vip:
        if t >= 300000:
            p = 0
        else:
            p = p * 0.5
    return p

Nó chạy đúng. Nhưng người đọc phải đoán t, nt là gì; các con số không có tên; vip bị xét ở hai chỗ; còn p * 0.5 lặng lẽ biến tiền thành số thực — điều bài Lập trình đã dặn tránh. Kent Beck gọi những dấu hiệu như vậy là mùi code (code smell): chưa phải lỗi, nhưng báo rằng cấu trúc có vấn đề.

Tái cấu trúc (refactoring) là sửa cấu trúc của code mà không đổi hành vi, bằng những bước nhỏ, bước nào cũng kiểm lại ngay. Trước khi đụng vào, hãy ghim hành vi hiện tại: chạy hàm cũ trên một bảng đầu vào và lưu kết quả.

python
from itertools import product

dau_vao = list(product([100_000, 299_000, 300_000, 499_000, 500_000],   # tổng tiền (đồng)
                       [1, 2, 3, 5],                                     # cân nặng (kg)
                       [True, False], [True, False], [True, False]))     # nội thành? VIP? Tết?
ket_qua_cu = {x: tinh_phi(*x) for x in dau_vao}

Rồi đi từng bước, sau mỗi bước so lại với ket_qua_cu:

  1. Đặt tên: t thành tong_tien, nt thành noi_thanh; số 500000 thành hằng MIEN_PHI_TU.
  2. Tách hàm (extract function): phần tính phí theo vùng và cân nặng tách thành phi_co_ban.
  3. Thoát sớm (guard clause) thay cho if lồng nhau: các trường hợp miễn phí được return ngay ở đầu hàm, nên thứ tự quy tắc đọc thẳng từ trên xuống.
  4. Tiền là số nguyên: p * 0.5 thành phi // 2.

Kết quả:

python
PHI_NOI_THANH, PHI_NGOAI_THANH = 20_000, 30_000
CAN_KHONG_PHU_PHI, PHU_PHI_MOI_KG = 2, 10_000
MIEN_PHI_TU, MIEN_PHI_TU_VIP = 500_000, 300_000

def phi_co_ban(noi_thanh, can_kg):
    phi = PHI_NOI_THANH if noi_thanh else PHI_NGOAI_THANH
    if can_kg > CAN_KHONG_PHU_PHI:
        phi += (can_kg - CAN_KHONG_PHU_PHI) * PHU_PHI_MOI_KG
    return phi

def phi_giao_hang(tong_tien, can_kg, noi_thanh, la_vip, dang_tet):
    if dang_tet:
        return 0                                   # Tết: miễn phí mọi đơn
    if tong_tien >= (MIEN_PHI_TU_VIP if la_vip else MIEN_PHI_TU):
        return 0
    phi = phi_co_ban(noi_thanh, can_kg)
    return phi // 2 if la_vip else phi             # khách thân thiết: giảm nửa phí

print(all(phi_giao_hang(*x) == ket_qua_cu[x] for x in dau_vao), len(dau_vao))   # True 160

Cả 160 trường hợp cho cùng giá trị với hàm cũ — nhưng giờ đọc lên là hiểu, và đổi ngưỡng miễn phí là sửa một dòng. Phép so sánh "cũ và mới" ở trên là dạng thô sơ nhất của kiểm thử; muốn làm bài bản, xem Kiểm thử phần mềm. Không có kiểm thử thì đó không phải tái cấu trúc, mà là sửa code rồi cầu may.

Chỉ khi quy tắc khuyến mãi còn đổi liên tục — theo mùa, theo hạng thành viên, theo mã giảm giá — bước tiếp theo mới là tách chúng thành các chiến lược như ở ý 3. Mẫu thiết kế tốt thường là đích đến của nhiều lần tái cấu trúc, không phải điểm xuất phát.

5. Nợ kỹ thuật: lối tắt hôm nay, tiền lãi ngày mai

Ward Cunningham làm một phần mềm quản lý đầu tư, và cần giải thích cho cấp trên — những người làm tài chính — vì sao phải sửa lại code đang chạy tốt. Ông dùng ngôn ngữ của họ: đưa code ra khi hiểu biết còn non giống như vay nợ. Vay một ít giúp đi nhanh hơn, miễn là sớm trả bằng cách viết lại cho đúng; không trả thì mỗi phút làm việc trên code chưa đúng là một khoản tiền lãi.

  • Tiền gốc là công sửa cấu trúc cho đúng — như lần tái cấu trúc hàm tinh_phi ở trên.
  • Tiền lãi là thời gian cộng thêm vào mọi thay đổi sau đó — như hai ngày cho một lần thêm quy tắc, và lần quên sửa hóa đơn.
  • Lãi mẹ đẻ lãi con: code đã rối thì việc mới khó viết cho tử tế, nên lại cộng thêm nợ.

Khoản nợ nổi tiếng nhất là sự cố năm 2000 (Y2K). Thập niên 1960–1970, bộ nhớ rất đắt, nên nhiều chương trình lưu năm bằng hai chữ số: "68" thay cho "1968" — một khoản vay hợp lý lúc ấy. Nợ đến hạn cuối thập niên 1990: sang năm 2000, "00" có thể bị hiểu là 1900. Thế giới bỏ ra số tiền ước tính tới hàng trăm tỷ đô-la để rà soát và sửa. Cái khó là tìm ra chỗ phải sửa: cách xử lý ngày tháng không được giấu sau mô-đun nào, mà nằm rải rác trong hàng triệu dòng code — đúng điều Parnas đã nói từ năm 1972.

Nợ không phải lúc nào cũng xấu. Viết vội một if cho kịp đợt bán Tết là quyết định kinh doanh hợp lý — miễn là có ghi lại, và qua Tết có người quay lại trả. Khoản nợ nguy hiểm nhất là khoản không ai biết mình đang mang. Nhóm tốt ghi nợ thành danh sách, trả đều đặn, và sửa chỗ nào thì để chỗ đó sạch hơn lúc mình đến.

Thiết kế phần mềm nằm ở đâu trong chồng tầng

Trong bài Từ electron đến ứng dụng, máy tính là một chồng tầng, mỗi tầng giữ một hợp đồng: đưa lên những gì, giấu đi những gì. Môn này nằm ở tầng phần mềm ứng dụng, và việc của nó là dựng những tầng nhỏ bên trong chương trình của chính bạn theo đúng tinh thần ấy: mô-đun tính phí là một tầng nhỏ, giao diện là hợp đồng.

Hợp đồng giữa các mô-đun cũng có thể rò rỉ. Hàm tinh_phi cũ trả về 15000.0 cho một đơn nhỏ của khách thân thiết ở ngoại thành; phép so sánh == ở ý 4 coi nó bằng 15000, nhưng hóa đơn in thẳng con số ra thì vẫn khác: "15000.0 đ" thành "15000 đ". Người dùng một mô-đun dựa vào mọi thứ họ thấy được, không chỉ những gì ghi trong giao diện.

Đưa lên

Những giao diện nhỏ và rõ ràng — hàm, lớp, mô-đun — kèm lời hứa về hành vi, để phần code khác dùng được mà không cần biết bên trong.

Giấu đi

Những quyết định dễ thay đổi: dữ liệu lưu ở đâu và ra sao, dùng thuật toán nào, nhà cung cấp nào, quy tắc kinh doanh cụ thể là gì.

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

· 5 môn

Lập trình

Programming

Hàm, đặt tên, code viết cho người đọc — nền trực tiếp của môn này, cần vững trước.

Xem chủ đề trên OpenER: Programming

Cấu trúc dữ liệu và giải thuật

Data Structures and Algorithms

Ngăn xếp, hàng đợi, bảng băm là những kiểu dữ liệu trừu tượng đầu tiên bạn gặp: một giao diện, nhiều cách cài đặt.

Xem chủ đề trên OpenER: Data Structures and Algorithms

Nhập môn công nghệ phần mềm

Introduction to Software Engineering

Học trước hoặc song song: môn đó lo quy trình và làm việc nhóm, môn này lo cấu trúc của code mà cả nhóm cùng sửa.

Xem chủ đề trên OpenER: Introduction to Software Engineering

Kiểm thử phần mềm

Software Testing

Không có kiểm thử thì không tái cấu trúc an toàn được; code khớp nối lỏng thì dễ kiểm thử hơn hẳn.

Xem chủ đề trên OpenER: Software Testing

Ứng dụng web

Web Applications

Nơi dùng ngay: framework web dựng từ chính những ý này — sự kiện, tách phần hiển thị khỏi dữ liệu, chia tầng.

Xem chủ đề trên OpenER: Web Applications

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

  • Kỹ sư phần mềm ở mọi mảng — web, di động, backend, game: chia mô-đun, đặt tên, tái cấu trúc là việc hằng ngày, và bị soi kỹ nhất khi đồng nghiệp đọc code của bạn (code review). Câu phỏng vấn kiểu "thiết kế phần tính phí cho nhiều hãng giao hàng" kiểm tra đúng những ý này.
  • Bảo trì hệ thống lâu năm: ngân hàng, bảo hiểm, hàng không chạy những hệ thống hàng chục năm tuổi, rất cần người biết tái cấu trúc an toàn.
  • Viết thư viện và framework: nơi giao diện quan trọng nhất, vì hàng nghìn người sẽ dựa vào nó.
  • Trưởng nhóm, kiến trúc sư phần mềm: vạch ranh giới giữa các phần, quyết định lúc nào trả nợ, lúc nào chấp nhận vay.
  • Làm việc cùng AI: công cụ sinh code viết từng hàm rất giỏi; chia hệ thống ra sao và giữ nó khỏi thành bùn vẫn là việc của người.

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

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

  • chia chương trình thành mô-đun theo những gì có thể thay đổi, với giao diện nhỏ mà giấu được nhiều;
  • nhìn một đoạn code và gọi tên được vấn đề của nó — khớp nối chặt, cố kết thấp, một mùi code cụ thể;
  • tái cấu trúc từng bước nhỏ có kiểm thử giữ lưng, thay vì "đập đi viết lại";
  • nhận ra khi nào một mẫu như Strategy hay Observer giúp ích, khi nào nó chỉ thêm rắc rối;
  • giải thích nợ kỹ thuật cho người không làm kỹ thuật bằng ngôn ngữ của chi phí.

Nên biết trước: lập trình vững ít nhất một ngôn ngữ, đã viết vài chương trình dài vài trăm dòng — tốt nhất là đã từng khổ vì sửa code của chính mình, vì môn này dễ hiểu nhất khi bạn đã thấy cái đau mà nó chữa. Biết chút lập trình hướng đối tượng (lớp, interface) sẽ giúp đọc tài liệu về mẫu thiết kế, vốn phần lớn dùng Java (riêng sách của Bộ tứ dùng C++ và Smalltalk).

Bắt đầu trên OpenER: trang chủ đề Software Engineering Principles and Patterns 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.005 Software Construction: đặc tả, bất biến và kiểu dữ liệu trừu tượng trước, mẫu thiết kế sau, có bài đọc và bài tập đầy đủ. Muốn học qua một dự án Java, có khóa của Đại học British Columbia trên edX; muốn một chuỗi bài riêng về mẫu thiết kế, xem khóa CMU 17-214.

Lời khuyên: đừng học thuộc 23 mẫu. Lấy một chương trình cũ của chính bạn, nghĩ ra một yêu cầu mới, đếm xem phải sửa bao nhiêu chỗ — rồi tái cấu trúc cho tới khi lần sau chỉ còn phải sửa một chỗ. Làm vậy một lần dạy bạn nhiều hơn đọc mười định nghĩa.

Tài liệu tham khảo

  • MIT 6.005 Software Construction (Spring 2016) — bài đọc, bài tập và đề thi trên MIT OpenCourseWare.
  • Carnegie Mellon University 17-214 Principles of Software Construction: Objects, Design, and Concurrency — slide và bài tập theo tuần.
  • David L. Parnas — "On the Criteria To Be Used in Decomposing Systems into Modules", Communications of the ACM, 1972.
  • Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides — Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994.
  • Martin Fowler — Refactoring: Improving the Design of Existing Code, Addison-Wesley, 1999; bản thứ hai năm 2018.
  • John Ousterhout — A Philosophy of Software Design, Yaknyam Press, 2018; viết từ khóa CS 190 của Đại học Stanford.
  • Harry Percival, Bob Gregory — Architecture Patterns with Python, O'Reilly, 2020; đọc miễn phí tại cosmicpython.com.
  • Ward Cunningham — "The WyCash Portfolio Management System", báo cáo kinh nghiệm tại hội nghị OOPSLA 1992.

Ban biên tập OpenER, “Nguyên lý và mẫu thiết kế phần mềm: viết code để còn sửa được”, 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.