Có một cảm giác rất quen khi ngồi code: déjà vu. Bạn nhìn đoạn code mình đang gõ và thấy nó... y hệt cái gì đó bạn đã viết tuần trước. Dự án càng lớn thì chuyện này càng khó tránh: một logic nghiệp vụ (business logic) nào đó cứ lặp đi lặp lại ở nhiều nơi. Và mỗi lần nghiệp vụ thay đổi, bạn lại phải đi lùng sục sửa từng chỗ một - sót một chỗ là sinh bug.
Bài thuốc cho nỗi đau đó có một cái tên rất gọn: DRY - Don't Repeat Yourself. Trong bài này tôi sẽ cùng bạn đi qua: DRY thực sự nghĩa là gì, vì sao trùng lặp lại nguy hiểm, ba cách áp dụng phổ biến, và - quan trọng không kém - khi nào bạn không nên cố ép DRY.
DRY là gì?
Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.
Tạm dịch: "Mỗi mẩu kiến thức phải có một biểu diễn duy nhất, rõ ràng và có thẩm quyền (authoritative) trong hệ thống."
Nguyên tắc này được Andy Hunt và Dave Thomas phát biểu chính thức năm 1999 trong cuốn The Pragmatic Programmer. Điểm tôi muốn bạn để ý ở đây là từ khóa kiến thức (knowledge), chứ không phải code. DRY không nói "đừng bao giờ gõ hai đoạn code giống nhau". Nó nói: một quyết định, một quy tắc nghiệp vụ, một công thức... chỉ nên tồn tại ở một nơi. Sự phân biệt này rất quan trọng, và tôi sẽ quay lại nó ở phần cuối bài.
Vì sao trùng lặp lại nguy hiểm?
Gốc rễ của mọi rắc rối là: bạn có nhiều bản sao của cùng một kiến thức. Mà kiến thức thì hay thay đổi. Ngay khi nó đổi, bạn phải đi sửa tất cả các bản sao - nếu không, các bản sao sẽ "cãi nhau", cho ra kết quả mâu thuẫn (contradictory) trong cùng một hệ thống.
Ví von đời thường: hãy tưởng tượng số điện thoại của bạn được ghi trong sổ tay, dán trên tủ lạnh, lưu trong 3 group chat và in trên một tấm danh thiếp cũ. Đổi số điện thoại là một cơn ác mộng - bạn chắc chắn sẽ quên mất một chỗ. Còn nếu mọi người đều tra một nguồn duy nhất (ví dụ danh bạ chung), bạn chỉ cần sửa một lần.
Vậy vì sao trùng lặp cứ len lỏi vào codebase? Vài lý do thường gặp:
- Lỗi từ khâu thiết kế lan ra sau. Một quyết định thiết kế sai được sao chép qua nhiều module. Phát hiện sớm thì sửa còn rẻ; càng để lâu càng đắt.
- Áp lực deadline. Khi bị hạn chót dí, copy-paste "cho chạy được đã" luôn hấp dẫn hơn viết code sạch. Đây là mầm mống của nợ kỹ thuật (technical debt).
- Trùng lặp vô tình. Ở tổ chức lớn, hai nhóm có thể viết lại cùng một chức năng mà không hề biết. Thủ phạm chính là thiếu giao tiếp giữa các nhóm.
- Trùng lặp do môi trường "bắt buộc". Đôi khi công nghệ hoặc kiến trúc ép bạn lặp lại (ví dụ định nghĩa lại kiểu dữ liệu ở cả frontend lẫn backend), và cần chút khéo léo để né.
Ba cách áp dụng DRY
DRY chỉ là một nguyên tắc - cách triển khai thì tùy ngữ cảnh. Dưới đây là ba hướng phổ biến nhất.
1. Trừu tượng hóa (Abstraction)
Đây là cách hay dùng khi thiết kế class/hàm. Khi nhiều chỗ dùng chung một logic, bạn tách logic đó ra một nơi duy nhất (một hàm, một class cơ sở, hoặc một thành phần được "hợp thành" - composition) rồi tái sử dụng.
Hãy xem một ví dụ "trước và sau". Giả sử ta tính giá cuối cùng sau thuế cho vài loại sản phẩm, và thuế suất là 10%:
# TRƯỚC - cùng một "kiến thức" (thuế 10%) rải ở 3 chỗ
def gia_sach(gia):
return gia + gia * 0.10
def gia_but(gia):
return gia + gia * 0.10
def gia_vo(gia):
return gia + gia * 0.10
print(gia_sach(100), gia_but(20), gia_vo(15))
110.0 22.0 16.5
Vấn đề: hôm nay nhà nước đổi thuế thành 8%, bạn phải sửa ba chỗ. Sót một chỗ là sai giá. Áp dụng DRY, ta gom "kiến thức thuế" về một nơi:
# SAU - thuế suất chỉ định nghĩa MỘT lần
THUE_SUAT = 0.10
def gia_sau_thue(gia, thue=THUE_SUAT):
return gia + gia * thue
print(gia_sau_thue(100), gia_sau_thue(20), gia_sau_thue(15))
110.0 22.0 16.5
Giờ đổi thuế chỉ cần sửa đúng một dòng THUE_SUAT. Ngoài kế thừa (inheritance), bạn cũng nên cân nhắc hợp thành (composition) khi muốn linh hoạt hơn và tránh các ràng buộc cứng nhắc của cây kế thừa.
2. Tự động hóa & giao tiếp (Automation)
Không phải trùng lặp nào cũng nằm trong code - nhiều khi nó nằm ở con người và quy trình. Ở tổ chức nhiều nhóm, hai đội có thể vô tình làm trùng việc của nhau. Cách xử lý là: khuyến khích giao tiếp chéo giữa các nhóm, chia sẻ thư viện dùng chung, và tự động hóa những thứ hay bị làm lại thủ công (sinh code, kiểm tra trùng lặp trong CI...).
Điểm mấu chốt: loại bỏ trùng lặp một lần là chưa đủ. Nó phải là một hoạt động liên tục. Thiếu giám sát, trùng lặp sẽ âm thầm mọc lại.
3. Chuẩn hóa dữ liệu (Normalization)
Đây là DRY trong thiết kế cơ sở dữ liệu. Nếu bạn lưu cùng một dữ liệu ở nhiều bảng/cột, bạn tạo ra dữ liệu dư thừa (redundant) và rất khó bảo trì. Cách làm chuẩn: tách phần dữ liệu lặp ra một thực thể (entity) riêng, rồi các nơi khác tham chiếu tới nó (thường qua khóa ngoại - foreign key).
Chuẩn hóa giúp dữ liệu nhất quán, giữ được tính toàn vẹn (integrity), và tạo ra một "nguồn sự thật duy nhất" (single source of truth). Tôi có một bài riêng đi sâu vào chuyện này, bạn xem ở phần liên quan cuối bài nhé.
Những điều cần ghi nhớ
Đây không phải luật cứng, mà là vài điểm hữu ích để né các cạm bẫy (pitfall) quen thuộc.
Làm cho việc tái sử dụng thật dễ. Một trừu tượng khó hiểu, không tài liệu, sẽ bị lập trình viên khác né và... viết lại từ đầu. Trừu tượng tốt phải dễ dùng và có tài liệu rõ ràng, chứ không phải một rào cản.
Đường tắt hôm nay là nợ ngày mai. Copy-paste "cho kịp deadline" gần như luôn sinh nợ kỹ thuật. Phát hiện muộn thì chi phí sửa có thể đắt gấp nhiều lần so với làm đúng ngay từ đầu.
Ưu tiên giao tiếp và nắm bối cảnh dự án. Trong công ty lớn, hãy để ý các dự án khác - nhất là những cái liên quan tới mình. Vừa để tái sử dụng công sức của người khác, vừa để đóng góp ngược lại.
Cẩn thận: lạm dụng DRY
Hãy nhớ lại phần đầu bài: DRY nói về kiến thức, không phải về hình dạng của code. Hai hàm hôm nay tình cờ giống nhau nhưng sẽ tiến hóa theo hai hướng khác nhau thì không phải trùng lặp - gộp chúng lại chỉ khiến bạn khổ về sau. Trong tình huống này, sống chung với một chút lặp lại còn dễ thở hơn nhiều.
Một lỗi liên quan là tối ưu hóa quá sớm (premature optimization): khái quát hóa (generalize) một chức năng trước khi nó thực sự lặp lại. Quy tắc kinh nghiệm phổ biến là "Rule of Three" (nguyên gốc của Don Roberts, được Martin Fowler phổ biến trong Refactoring): cứ để trùng lặp cho tới lần thứ ba mới tách ra trừu tượng - lúc đó bạn đã đủ dữ kiện để biết phần nào thật sự chung.
Rule of Three: khi nào mới nên gom?
Tôi nói kỹ hơn về quy tắc này vì nó dễ nhớ và hợp với cách làm việc hằng ngày. Nó không phải luật cứng, chỉ là một kinh nghiệm để bạn khỏi phải cân nhắc lại từ đầu mỗi lần thấy hai đoạn code hao hao nhau:
- Lần 1. Bạn viết một đoạn code và thấy nó hơi giống cái gì đó. Cứ để yên, chưa đủ dữ kiện để biết cái gì thật sự chung.
- Lần 2. Bạn thấy một đoạn na ná đoạn cũ. Bắt đầu để ý, ghi nhận lại (trong đầu hoặc bằng một dòng ghi chú) nhưng chưa vội gom: hai mẫu thì vẫn chưa đủ để kết luận.
- Lần 3. Đến lúc này abstraction thường đã đáng giá. Ba biến thể cho bạn thấy rõ phần nào lặp lại ở cả ba, phần nào chỉ là đặc thù của từng chỗ.
Vì sao phải đợi? Vì gom quá sớm, khi mới có đúng hai chỗ, rất dễ tạo ra một abstraction sai. Và abstraction sai đắt hơn trùng lặp: mỗi khi xuất hiện biến thể mới, bạn phải uốn cong nó bằng một tham số cờ (flag), rồi tham số thứ hai, rồi một nhánh if chỉ dành cho một lời gọi duy nhất. Đến lúc muốn gỡ ra thì cả chục chỗ đã phụ thuộc vào nó. Ngược lại, hai đoạn code trùng nhau mà bạn để yên thì lúc nào gom cũng được.
Cùng họ với cạm bẫy này là việc dựng sẵn tầng trừu tượng cho một nhu cầu chưa tồn tại. Tôi có bàn kỹ hơn trong bài Over-engineering: khi design pattern hại nhiều hơn lợi.
DRY trong hệ thống thật
Ra khỏi ví dụ mười dòng, DRY đáng giá nhất ở những chỗ mà sai lệch giữa hai bản sao gây hậu quả thật, chứ không phải ở những chỗ code trông giống nhau. Vài chỗ tôi luôn ưu tiên giữ một nguồn sự thật duy nhất:
- Quy tắc nghiệp vụ. Công thức tính thuế, tính phí, quy tắc kiểm tra quyền. Nếu quy tắc tính phí nằm cả trong service, trong job báo cáo và trong một câu SQL nào đó, sớm muộn ba chỗ sẽ cho ba con số khác nhau và bạn sẽ phải đi giải thích với kế toán.
- Schema và kiểu dữ liệu dùng chung giữa API và client. Đừng gõ tay cùng một kiểu dữ liệu ở hai nơi. Sinh code từ một đặc tả OpenAPI (hoặc protobuf, GraphQL schema) là ví dụ sạch nhất của hướng "tự động hóa" ở trên: kiến thức nằm ở đặc tả, code hai phía chỉ là sản phẩm sinh ra từ nó.
- Migration và model phải khớp. Cột trong database và trường trong model là hai biểu diễn của cùng một kiến thức. Hãy để một bên sinh ra bên kia, hoặc ít nhất có một test nổ khi chúng lệch nhau.
- Cấu hình lặp giữa các môi trường. Copy nguyên file cấu hình cho dev, staging, production rồi sửa tay vài dòng là cách nhanh nhất để có một biến chỉ sai ở đúng production. Tách phần chung ra base, mỗi môi trường chỉ giữ phần khác biệt.
Nhưng có một mặt trái tôi muốn bạn nắm, nhất là nếu bạn làm backend nhiều service: chia sẻ code giữa các service làm giảm lặp nhưng tạo coupling giữa các service. Một thư viện dùng chung (shared library) nghe rất DRY, cho tới ngày bạn cần đổi một hàm trong đó: bây giờ bạn phải phát hành phiên bản mới, đi điều phối với năm đội khác để họ nâng phiên bản, và các service đó không còn triển khai độc lập được nữa. Ranh giới service sinh ra chính là để các đội đi độc lập, nên nhiều đội cố tình chấp nhận duplication qua ranh giới service (mỗi service tự giữ bản DTO của mình, tự giữ vài hàm tiện ích) để đổi lấy tính độc lập triển khai. DRY mạnh bên trong một ranh giới, và nên được cân nhắc lại khi đi qua ranh giới.
Trade-off
Không có nguyên tắc nào miễn phí. Đây là hai mặt của DRY, nói thật lòng:
Được:
- Kiến thức nghiệp vụ có một nguồn sự thật duy nhất, ai cũng biết đi đâu để đọc quy tắc.
- Sửa một chỗ là đúng mọi nơi, không phải đi lùng sục bằng grep.
- Giảm rủi ro quên cập nhật một bản sao, loại bug âm thầm và khó truy nhất.
- Codebase nhỏ hơn, test cũng ít trùng hơn: một quy tắc chỉ cần một bộ test tử tế.
Phải trả giá:
- Abstraction sai do gom quá sớm, khi bạn chưa thấy đủ biến thể để biết cái gì mới thật sự chung.
- Tham số cờ mọc thêm mỗi lần có biến thể mới, cho tới khi hàm dùng chung thành một mớ
ifkhông ai dám đụng. - Module dùng chung kéo theo coupling: đổi nó là phải điều phối với mọi nơi đang dùng, đặc biệt đau khi các nơi đó thuộc đội khác hoặc service khác.
- Đọc khó hơn: để hiểu một hàm đôi khi bạn phải nhảy qua ba file, trong khi bản copy-paste thì đọc một chỗ là hiểu.
- Dễ bị đẩy thành giáo điều, sinh ra những lớp base và helper tồn tại chỉ vì "không được lặp". Đó là cửa ngõ dẫn tới các anti-pattern thường gặp.
Tóm lại
- DRY = một kiến thức, một nơi định nghĩa. Đích đến là: kiến thức đổi thì chỉ sửa một chỗ.
- Trùng lặp nguy hiểm vì các bản sao dễ "cãi nhau" khi cập nhật thiếu chỗ.
- Ba cách áp dụng: trừu tượng hóa (code), tự động hóa & giao tiếp (quy trình), chuẩn hóa (dữ liệu).
- Đừng lạm dụng: DRY nói về kiến thức, không phải hình dạng code. Trừu tượng sai đắt hơn trùng lặp. Nhớ "Rule of Three".
- DRY là một công cụ để cân chỉnh, áp dụng khi hợp lý và buông khi không cần - chứ không phải giáo điều.
Nguồn tham khảo
- Andy Hunt & Dave Thomas - The Pragmatic Programmer (1999), chương "The Evils of Duplication" (nơi phát biểu nguyên tắc DRY). pragprog.com
- Martin Fowler - Refactoring: Improving the Design of Existing Code (quy tắc "Rule of Three", Fowler dẫn lại lời Don Roberts). martinfowler.com
- Sandi Metz - "The Wrong Abstraction" (2016). sandimetz.com
- E. F. Codd - "A Relational Model of Data for Large Shared Data Banks", Communications of the ACM (1970) - nền tảng lý thuyết cho chuẩn hóa. dl.acm.org
- Kai