Suốt series này bạn đã học các pattern, tức là những lời giải tốt được đúc kết. Bài khép lại này đi theo hướng ngược: các anti-pattern, những lời giải nghe có vẻ ổn nhưng lại kéo dự án xuống. Biết mặt chúng cũng quan trọng ngang biết pattern, vì phần lớn nợ kỹ thuật (technical debt) sinh ra từ đây.
Anti-pattern là gì
Một anti-pattern (phản mẫu) là cách làm lặp đi lặp lại, trông như giải quyết được vấn đề, nhưng về lâu dài lại tạo ra hậu quả xấu. Nó khác với một lỗi (bug) ở chỗ: bug là code chạy sai, còn anti-pattern là code chạy đúng nhưng khó sống chung. Nó khó đọc, khó sửa, khó mở rộng, và thường lôi kéo thêm anti-pattern khác.
Điểm nguy hiểm là anti-pattern hiếm khi do ai đó cố tình làm bậy. Nó xuất hiện từ những quyết định hợp lý trong ngắn hạn: copy một đoạn cho nhanh, nhét thêm một method vào class sẵn có, hardcode một con số để kịp deadline. Từng bước một thì vô hại, gộp lại theo thời gian thành một mớ khó gỡ. Vì vậy cách tốt nhất để tránh là nhận diện sớm, khi chúng còn nhỏ.
God Object (class ôm quá nhiều trách nhiệm)
Định nghĩa: một class (hoặc module) biết quá nhiều và làm quá nhiều thứ. Nó thường tên chung chung như Manager, Helper, Utils, System và dài hàng nghìn dòng.
Triệu chứng: mở file ra phải cuộn mãi; class có vài chục method chẳng liên quan gì nhau (vừa gọi database, vừa gửi email, vừa xử lý logic nghiệp vụ, vừa format chuỗi); sửa một tính năng nhỏ cũng phải đụng vào đây và ai cũng sợ đụng vì dễ vỡ chỗ khác.
Vì sao hại: class gánh mọi thứ thì mọi thay đổi đều dồn về một chỗ, dẫn tới coupling cao, test gần như bất khả thi (muốn test một mảnh phải dựng cả thế giới), và nhiều người sửa cùng file gây xung đột liên tục.
Cách tránh: áp dụng Single Responsibility Principle (chữ S trong SOLID): mỗi class chỉ nên có một lý do để thay đổi. Khi thấy một class phình ra, hãy hỏi "class này đang làm mấy việc?" rồi tách mỗi việc thành một class riêng. Ví dụ before/after ở cuối bài minh hoạ đúng thao tác tách này.
Spaghetti code (luồng rối như mì)
Định nghĩa: code không có cấu trúc rõ ràng, luồng điều khiển nhảy loạn xạ, mọi thứ dính vào nhau như đĩa mì rối.
Triệu chứng: hàm dài, lồng if/else nhiều tầng; biến toàn cục dùng khắp nơi; đọc một đoạn phải nhảy qua lại mười chỗ mới hiểu; không tách được đâu là tầng giao diện, đâu là logic, đâu là dữ liệu.
Vì sao hại: bạn không thể suy luận về từng phần một cách độc lập. Sửa chỗ này vỡ chỗ kia vì mọi thứ ngầm phụ thuộc lẫn nhau. Người mới vào gần như không thể đọc hiểu.
Cách tránh: chia code thành các hàm/module nhỏ, mỗi cái làm một việc và có tên nói rõ nó làm gì. Tách các tầng (giao diện, nghiệp vụ, dữ liệu) rành mạch. Hạn chế trạng thái toàn cục. Đây chính là tinh thần KISS (Keep It Simple): ưu tiên luồng thẳng, dễ đọc thay vì khôn khéo mà rối.
Golden Hammer (một búa nện mọi cái đinh)
Định nghĩa: "Khi bạn chỉ có một cái búa, mọi thứ trông đều giống cái đinh." Bạn quen một công cụ, một ngôn ngữ hay một pattern rồi ép nó vào mọi bài toán, kể cả khi không hợp.
Triệu chứng: mọi vấn đề đều được giải bằng đúng một cách; nhét design pattern vào chỗ không cần (một CRUD đơn giản mà có Factory, Strategy, Observer chồng lên nhau); chọn database hay framework theo thói quen chứ không theo nhu cầu bài toán.
Vì sao hại: công cụ sai chỗ làm giải pháp phức tạp hơn mức cần thiết. Bạn trả giá bằng code khó hiểu và hiệu năng kém chỉ để thoả mãn thói quen.
Cách tránh: xuất phát từ bài toán, không từ công cụ. Hỏi "cái này thật sự cần gì?" trước khi chọn cách giải. Chính series này đã nhắc đi nhắc lại: chỉ dùng pattern khi cơn đau đã xuất hiện, đừng nhét pattern cho sang. Lạm dụng Singleton là ví dụ kinh điển của Golden Hammer, đã bàn kỹ ở bài Singleton là gì và vì sao hay bị làm sai.
Copy-paste programming (lặp code)
Định nghĩa: giải quyết nhu cầu mới bằng cách copy một đoạn code cũ rồi sửa vài dòng, thay vì tách phần chung ra dùng lại.
Triệu chứng: cùng một khối logic xuất hiện ở nhiều nơi gần như y hệt; sửa một bug phải đi tìm và sửa ở năm chỗ khác nhau; và thường bạn quên mất một chỗ.
Vì sao hại: mỗi bản copy là một chỗ phải bảo trì riêng. Khi logic thay đổi, các bản dễ trôi ra khác nhau, sinh bug âm thầm. Đây là kẻ thù trực tiếp của nguyên tắc DRY (Don't Repeat Yourself).
Cách tránh: khi định copy lần thứ hai, hãy dừng lại và tách phần chung thành một hàm/class dùng chung. Nhưng đừng cực đoan: hai đoạn trông giống nhau chưa chắc cùng một lý do tồn tại. Gộp bừa hai thứ tình cờ giống nhau lại tạo ra coupling sai. Chỉ gộp khi chúng thật sự là một khái niệm.
Magic numbers / strings (số và chuỗi cứng không tên)
Định nghĩa: các con số hoặc chuỗi được viết thẳng vào code mà không có tên giải thích ý nghĩa, ví dụ if status == 3 hay total * 0.08.
Triệu chứng: đọc code thấy những con số bí ẩn không rõ ở đâu ra; cùng một giá trị (như thuế suất) rải rác nhiều nơi; muốn đổi phải dò tìm và sửa từng chỗ, dễ sót.
Vì sao hại: người đọc không hiểu 0.08 nghĩa là gì (thuế? phí? chiết khấu?). Khi giá trị đổi, bạn phải sửa nhiều nơi và rất dễ bỏ quên một chỗ, tạo bug lệch dữ liệu.
Cách tránh: đặt tên cho giá trị bằng một hằng số (constant) rõ nghĩa, khai báo một chỗ. Vừa đọc hiểu ngay, vừa đổi một chỗ áp dụng toàn bộ. Đây là ví dụ before/after tôi sẽ chạy thật ở dưới.
Premature optimization (tối ưu quá sớm)
Định nghĩa: tối ưu hiệu năng cho một đoạn code trước khi biết nó có thật sự chậm hay không. Câu nói nổi tiếng của Donald Knuth: "premature optimization is the root of all evil" (tối ưu quá sớm là cội nguồn của mọi tai hoạ).
Triệu chứng: viết code khó hiểu, dùng thủ thuật khôn lỏi để "chạy nhanh" ở những chỗ chẳng ai gọi tới nhiều; dựng cache, đánh index, gom batch cho phần vốn không phải điểm nghẽn; dành hàng giờ tối ưu một hàm chạy mỗi ngày một lần.
Vì sao hại: bạn đánh đổi thứ quý nhất (sự đơn giản, dễ đọc) để lấy tốc độ ở nơi không cần, trong khi điểm nghẽn thật sự vẫn nằm đâu đó chưa ai đo. Code khó hiểu hơn mà tổng thể chẳng nhanh hơn.
Cách tránh: viết code rõ ràng, đúng trước đã. Khi nghi ngờ chậm thì đo (profiling) để tìm điểm nghẽn thật, rồi mới tối ưu đúng chỗ đó. Đây là tinh thần YAGNI (You Aren't Gonna Need It): đừng làm thứ chưa cần. Lưu ý: chọn đúng thuật toán/cấu trúc dữ liệu ngay từ đầu không phải premature optimization, đó là thiết kế đúng.
Lava flow (code chết không ai dám xoá)
Định nghĩa: những đoạn code cũ, không còn dùng hoặc không ai hiểu, nhưng vẫn nằm lại trong dự án vì "không rõ xoá đi có vỡ gì không". Giống dung nham nguội lại thành đá, cứng ngắc và chắn đường.
Triệu chứng: hàm không nơi nào gọi vẫn còn đó; những khối code bị comment lại "để phòng khi cần"; biến, config, flag không ai nhớ để làm gì; comment kiểu "đừng đụng vào, không hiểu sao nhưng nó cần".
Vì sao hại: code chết làm nhiễu, khiến người đọc mất thời gian hiểu thứ vô dụng, và làm mọi thay đổi rủi ro hơn vì không ai chắc phần nào còn sống. Nó tích tụ dần cho tới khi không ai dám động vào cả module.
Cách tránh: mạnh dạn xoá code chết. Bạn có version control (git) để phục hồi nếu cần, nên không việc gì phải giữ code trong file cho "an tâm". Có test và review giúp bạn xoá tự tin hơn. Nguyên tắc: nếu không dùng, hãy xoá; đừng comment lại rồi để đó.
Ví dụ before/after (chạy được)
Hãy lấy một hàm tính lương thực nhận. Bản before dính hai anti-pattern cùng lúc: Magic numbers (những con số 40, 0.08, 50000, 0.1 không tên) và God Function (một hàm ôm cả tính lương lẫn tính thuế):
# BEFORE: magic numbers rai rac, mot ham om moi thu
def tinh_tien(gio_luong, so_gio):
luong = gio_luong * so_gio
if so_gio > 40:
luong += gio_luong * (so_gio - 40) * 0.5
thue = luong * 0.08
if luong > 50000:
thue += (luong - 50000) * 0.1
return luong - thue
print(round(tinh_tien(100, 45), 2))
Code chạy đúng, nhưng đọc vào bạn không biết 0.08 là thuế hay phí, 40 là số giờ chuẩn hay gì. Muốn đổi thuế suất phải dò trong thân hàm. Bản after đặt tên cho từng giá trị và tách trách nhiệm ra ba hàm nhỏ, mỗi hàm một việc:
GIO_CHUAN_TUAN = 40
HE_SO_TANG_CA = 0.5
THUE_SUAT_CO_BAN = 0.08
NGUONG_THUE_CAO = 50000
THUE_SUAT_CAO = 0.1
def luong_gross(gio_luong, so_gio):
luong = gio_luong * so_gio
if so_gio > GIO_CHUAN_TUAN:
gio_tang_ca = so_gio - GIO_CHUAN_TUAN
luong += gio_luong * gio_tang_ca * HE_SO_TANG_CA
return luong
def tien_thue(luong):
thue = luong * THUE_SUAT_CO_BAN
if luong > NGUONG_THUE_CAO:
thue += (luong - NGUONG_THUE_CAO) * THUE_SUAT_CAO
return thue
def luong_thuc_nhan(gio_luong, so_gio):
luong = luong_gross(gio_luong, so_gio)
return luong - tien_thue(luong)
print(round(luong_thuc_nhan(100, 45), 2))
Cùng kết quả 4370.0, nhưng bản after đọc là hiểu: đâu là quy tắc tăng ca, đâu là quy tắc thuế. Đổi thuế suất chỉ sửa một hằng số. Muốn test riêng phần tính thuế thì gọi thẳng tien_thue mà không cần dựng cả phép tính lương. Một thao tác nhỏ nhưng gỡ được đúng hai anti-pattern quen mặt.
Phát hiện sớm bằng công cụ và quy trình
Bảy thứ ở trên hiếm khi xuất hiện trọn vẹn trong một lần commit. Chúng lớn dần, mỗi ngày một chút. Nên cách rẻ nhất là để máy canh giúp bạn, thay vì trông chờ vào trí nhớ con người lúc review.
- Linter chạy tự động trong CI.
ruff,flake8haypylintbắt được code chết, biến khai báo rồi không dùng, import thừa, hàm vượt ngưỡng phức tạp. Kèm formatter để khỏi cãi nhau về style. Quan trọng là đặt chúng ở bước bắt buộc của pipeline, không phải thứ tuỳ tâm ai nhớ thì chạy ở máy mình. - Đo độ phức tạp vòng lặp (cyclomatic complexity). Dùng
radonhoặc bật quy tắcC901(max-complexity) để chặn hàm và class phình quá mức. Con số này nhích lên đều đặn là tín hiệu sớm của God Object và Spaghetti code, thường xuất hiện trước khi mắt người kịp thấy file đã dài quá. - Đo độ phủ test (coverage). Vùng không có test thường trùng đúng với vùng không ai dám sửa, và đó chính là mầm mống của Lava flow. Đọc báo cáo coverage để biết phần nào của hệ thống đang bị bỏ rơi.
- Kiểm tra trùng lặp mã.
jscpd, hoặc tính năng duplication của SonarQube, cho bạn thấy Copy-paste programming khi nó mới có hai ba bản, trước lúc kịp lan ra khắp dự án. - Quy trình, không chỉ công cụ. Một checklist ngắn khi review code (hàm này đang làm mấy việc? con số này đã có tên chưa? đoạn cũ kia còn ai gọi không?) và một quy ước dứt khoát: xoá code chết ngay thay vì comment lại để đó. Git đã nhớ hộ bạn rồi.
- Riêng với Premature optimization. Đặt luật: phải có số đo (profile hoặc benchmark) trước khi tối ưu, và số đo đó đi kèm trong mô tả pull request. Đây là cách rẻ nhất để chặn nó, vì phần lớn tối ưu quá sớm không sống nổi qua một câu hỏi duy nhất: "đo ở đâu?".
Công cụ không thay được người đọc code, nhưng nó biến những thứ mơ hồ thành con số cụ thể chạy trong pipeline mỗi lần push. Mà cơn đau lúc còn nhỏ luôn là cơn đau rẻ nhất để chữa.
Tóm tắt: nguyên tắc chung để tránh
Nhìn lại cả 7 cái, bạn sẽ thấy chúng không cần 7 liều thuốc khác nhau. Vài nguyên tắc nền tảng đã chữa gần hết:
- SOLID, đặc biệt Single Responsibility, là thuốc cho God Object và Spaghetti code: mỗi thứ một trách nhiệm, phụ thuộc vào abstraction thay vì chi tiết cụ thể.
- DRY chặn Copy-paste programming: một tri thức chỉ nên có một nơi định nghĩa. Đặt hằng số có tên cũng là một dạng DRY cho các giá trị.
- KISS (Keep It Simple) đẩy lùi Golden Hammer và Spaghetti: chọn cách đơn giản nhất giải được bài toán, đừng khôn khéo quá mức.
- YAGNI (You Aren't Gonna Need It) chặn Premature optimization và cả việc nhét pattern bừa: chỉ làm khi thật sự cần, đo trước khi tối ưu. Mặt trái của việc nhét pattern bừa đã bàn riêng ở bài Over-engineering: khi design pattern hại nhiều hơn lợi.
- Với Lava flow: hãy tin vào git và test, mạnh dạn xoá thứ không dùng.
Nói ngắn gọn: anti-pattern thường là hệ quả của việc bỏ qua các nguyên tắc thiết kế cơ bản. Nắm chắc SOLID, DRY, KISS, YAGNI thì bạn tránh được phần lớn chúng một cách tự nhiên, không cần thuộc lòng từng cái tên.
- Kai