Tôi từng đọc một pull request chỉ để hiểu một việc rất nhỏ: tính giá sau giảm cho khách. Nghe thì một phép nhân là xong. Nhưng để lần ra phép nhân đó, tôi phải mở năm file: một interface, ba class chiến lược, một factory, rồi mới tới chỗ gọi. Mỗi file vài chục dòng, đầy tên rất "kiến trúc". Cuối cùng toàn bộ mớ đó làm đúng một việc: lấy giá nhân với một hệ số. Người viết nghĩ mình đang áp Strategy và Factory cho gọn gàng. Thực ra họ vừa dựng một mê cung cho thứ đáng lẽ nằm gọn trong ba dòng.
Đó là over-engineering (thiết kế thừa mứa): giải một bài toán đơn giản bằng một bộ máy phức tạp hơn nhiều so với mức bài toán đòi hỏi. Và design pattern, trớ trêu thay, là một trong những nguồn over-engineering phổ biến nhất, vì nó cho người ta cảm giác đang làm đúng bài bản.
Over-engineering là gì
Over-engineering là khi bạn trả trước cho một sự linh hoạt (flexibility) mà bạn chưa bao giờ dùng tới. Bạn thêm interface, thêm tầng gián tiếp (indirection), thêm điểm mở rộng "để sau này dễ đổi", trong khi cái "sau này" đó có thể không bao giờ đến.
Vấn đề nằm ở chỗ: pattern sinh ra để giải một loại vấn đề cụ thể. Strategy giải bài toán "có nhiều thuật toán thay thế nhau và cần đổi lúc chạy". Factory giải bài toán "việc tạo đối tượng phức tạp và cần tách khỏi nơi dùng". Nếu bạn chỉ có một cách làm, và việc tạo đối tượng chỉ là gọi constructor, thì bạn đang dùng thuốc cho một căn bệnh chưa mắc.
Ở bài Design Pattern là gì? tôi có nhấn mạnh: pattern là lời giải cho một vấn đề lặp lại trong một ngữ cảnh cụ thể. Bỏ mất vế "vấn đề" và "ngữ cảnh", chỉ giữ lại "lời giải" rồi rải khắp nơi, đó chính là công thức của over-engineering.
Dấu hiệu nhận biết
Vài dấu hiệu tôi hay dùng để tự soi lại code của mình:
- Interface hoặc abstract class cho thứ chỉ có một biến thể. Bạn tạo
PaymentGatewayvới đúng một class con làStripeGateway, và chẳng có kế hoạch nào cho cái thứ hai. Interface đó không mua lại gì, chỉ thêm một file để nhảy qua nhảy lại. - Nhiều tầng gián tiếp không ai cần. Service gọi manager, manager gọi helper, helper gọi util, và mỗi tầng chỉ chuyển tiếp tham số xuống tầng dưới. Bạn phải đi qua bốn cửa để tới được một dòng logic.
- "Kiến trúc cho tương lai" chưa bao giờ tới. Code đầy điểm mở rộng, config, plugin cho những tình huống "biết đâu sau này". Sáu tháng sau nhìn lại, không tình huống nào xảy ra, nhưng bạn vẫn phải gánh sự phức tạp đó mỗi ngày.
- Đọc năm file mới hiểu một luồng đơn giản. Đây là dấu hiệu rõ nhất. Nếu một việc nhỏ mà phải mở nhiều file, nhảy qua nhiều lớp trừu tượng mới nắm được, khả năng cao là abstraction đang che giấu logic thay vì làm rõ nó.
Điểm chung: mỗi tầng trừu tượng bạn thêm vào đều hứa hẹn sự linh hoạt, nhưng không phải lời hứa nào cũng được thu hồi.
Ví dụ: cùng bài toán, bản over-engineered vs bản gọn
Bài toán rất đời: tính giá cuối sau khi giảm theo loại khách. Khách thường không giảm, khách VIP giảm 10%, nhân viên giảm 30%. Chỉ vậy thôi.
Đây là bản "làm cho ra dáng", dựng cả Strategy lẫn Factory cho một phép tính:
from abc import ABC, abstractmethod
# --- Tang 1: interface cho "chien luoc tinh gia" ---
class PricingStrategy(ABC):
@abstractmethod
def discount(self, price): ...
# --- Tang 2: moi loai khach mot class ---
class RegularPricing(PricingStrategy):
def discount(self, price): return price * 0.0
class VipPricing(PricingStrategy):
def discount(self, price): return price * 0.1
class StaffPricing(PricingStrategy):
def discount(self, price): return price * 0.3
# --- Tang 3: factory de "che giau" viec tao strategy ---
class PricingStrategyFactory:
@staticmethod
def create(customer_type):
if customer_type == "regular": return RegularPricing()
if customer_type == "vip": return VipPricing()
if customer_type == "staff": return StaffPricing()
raise ValueError(customer_type)
# --- Tang 4: service dung factory + strategy ---
class PriceCalculator:
def final_price(self, customer_type, price):
strategy = PricingStrategyFactory.create(customer_type)
return price - strategy.discount(price)
calc = PriceCalculator()
print(calc.final_price("regular", 100))
print(calc.final_price("vip", 100))
print(calc.final_price("staff", 100))
Bốn tầng, ba class, một factory, gần 40 dòng. Để làm gì? Để tra một hệ số rồi nhân. Cái if ba nhánh trong factory chính là thứ mà "dùng pattern để tránh if" lẽ ra phải loại bỏ, giờ nó vẫn nằm đó, chỉ là bị đẩy sâu thêm một tầng.
Bây giờ là bản gọn, làm đúng việc đó theo lối Pythonic:
DISCOUNTS = {"regular": 0.0, "vip": 0.1, "staff": 0.3}
def final_price(customer_type, price):
return price * (1 - DISCOUNTS[customer_type])
print(final_price("regular", 100))
print(final_price("vip", 100))
print(final_price("staff", 100))
Cùng kết quả, nhưng bốn dòng thay vì bốn tầng. Muốn thêm loại khách "sinh viên giảm 20%"? Thêm một dòng vào DISCOUNTS. Muốn đọc hiểu toàn bộ luồng? Nhìn một lần là xong, không cần mở file nào khác.
YAGNI & KISS: quy tắc thực dụng
YAGNI (You Aren't Gonna Need It) nói thẳng: đừng viết code cho nhu cầu bạn tưởng tượng ra ở tương lai. Chỉ viết cho nhu cầu đang có thật. Phần lớn "biết đâu sau này cần" hoá ra không bao giờ cần, và cái giá bạn trả là gánh sự phức tạp đó suốt quãng thời gian chờ đợi.
KISS (Keep It Simple) là mặt còn lại của cùng một đồng xu: trong hai lời giải cùng chạy đúng, chọn cái đơn giản hơn. Đơn giản không phải là lười, mà là tôn trọng người đọc code sau này, thường chính là bạn của sáu tháng sau.
Tôi hay nghĩ về abstraction như một khoản thuế đọc-hiểu. Mỗi interface, mỗi tầng gián tiếp, mỗi lớp trừu tượng đều bắt người đọc trả một khoản: phải nhảy thêm một bước, phải giữ thêm một khái niệm trong đầu. Khoản thuế đó chỉ đáng trả khi nó mua lại được sự linh hoạt mà bạn thật sự cần. Trả thuế cho một sự linh hoạt không dùng đến thì đó là lỗ ròng.
Từ đó ra một nguyên tắc thực dụng mà tôi bám theo: chỉ áp pattern khi cơn đau đã xuất hiện. Khi bạn đã lặp lại một đoạn logic tới lần thứ ba (nhớ lại DRY), khi một class đã phình to khó test, khi một thay đổi nhỏ cứ kéo theo sửa hàng loạt chỗ, đó là lúc pattern giải đúng cơn đau có thật. Còn áp pattern để "phòng xa", trước khi cơn đau xuất hiện, gần như luôn là đặt cược sai.
Over-engineering trong hệ thống thật
Ví dụ tính giá ở trên còn dễ chịu, vì cái giá của nó gói gọn trong vài file. Lên tới quy mô hệ thống, over-engineering đắt hơn nhiều: cái bạn trả không còn là số dòng code, mà là hạ tầng phải nuôi, là những đêm dò lỗi, là thời gian của mọi người sau này. Đây là những dạng tôi gặp nhiều nhất ở backend, kèm cái giá thật mà đội phải trả:
- Tách microservice từ ngày đầu khi đội có ba người và sản phẩm chưa có người dùng nào. Giá phải trả: bạn tự đẩy mình vào thế phải dựng và vận hành một hệ phân tán, phải debug một luồng đi xuyên nhiều service, phải xử lý transaction phân tán cho thứ mà một câu lệnh trong cùng một database là xong. Trong khi đó một monolith gọn gàng đã thừa sức gánh, và tách sau vẫn kịp khi ranh giới đã rõ.
- Dựng "generic repository" bọc thêm một tầng lên trên ORM. ORM vốn đã là một tầng trừu tượng lên trên database rồi. Giá phải trả: bạn mất gần hết những gì mạnh nhất của ORM (query linh hoạt, eager loading, tối ưu theo từng trường hợp), để đổi lấy một interface chỉ có
get,save,delete. Cuối cùng bạn đang viết lại một ORM, phiên bản tệ hơn. - Cấu hình hoá mọi thứ để "sau này chỉ cần đổi config là xong", rồi không ai từng đổi. Giá phải trả: logic thật nằm rải rác trong các file YAML, trình biên dịch không kiểm tra được, test cũng khó chạm tới, và lỗi chỉ lộ ra lúc chạy trên production. Bạn đã biến một thứ kiểm tra được lúc build thành một thứ chỉ phát hiện được khi đã muộn.
- Interface cùng nhà máy cho một cài đặt duy nhất tồn tại nguyên vẹn suốt ba năm. Giá phải trả: mỗi lần đọc code, ai cũng phải nhảy thêm hai file mới tới được chỗ có logic, mà kết quả chẳng đổi gì. Ba năm nhân với mọi lần đọc của mọi người, đó là một khoản thuế lớn hơn bạn tưởng.
- Tự viết framework nội bộ thay vì dùng thư viện có sẵn đã được hàng nghìn người dùng thử lửa. Giá phải trả: không tài liệu, không cộng đồng, không câu trả lời nào trên mạng khi gặp lỗi. Người viết nó nghỉ việc là cả đội ngồi nhìn nhau.
- Caching và tối ưu khi chưa hề đo. Giá phải trả: bạn tự tạo ra bài toán vô hiệu hoá cache, một trong những bài toán khó nhất trong nghề, cộng thêm cả một lớp bug dữ liệu cũ khó tái hiện. Tất cả để đổi lấy cái nhanh mà chưa ai than phiền là chậm.
- Hệ thống plugin cho một sản phẩm chưa có plugin nào. Bạn thiết kế điểm mở rộng, vòng đời, cơ chế nạp động, cho một tập rỗng. Giá phải trả: mọi tính năng lõi từ đó về sau đều phải len qua cái khung đó, kể cả khi plugin thứ nhất mãi không xuất hiện.
Điểm chung của cả bảy: cái giá được trả ngay và trả đều mỗi ngày, còn lợi ích thì mãi nằm ở thì tương lai giả định. Nhiều thứ trong danh sách này lâu dần đóng rắn thành thói quen của cả đội, lúc đó nó không còn là một quyết định nữa mà thành anti-pattern.
Khi abstraction thực sự đáng tiền
Nói nhiều về over-engineering dễ khiến bài này bị đọc thành "chống mọi trừu tượng". Không phải. Abstraction là thuế, nhưng có những lúc không đóng thuế còn đắt hơn nhiều. Vấn đề chỉ là nhận ra đúng lúc. Vài tín hiệu tôi dùng để biết đã tới lúc nên tách:
- Cùng một thay đổi phải sửa ở ba nơi trở lên. Một nơi là bình thường, hai nơi còn chịu được, ba nơi là code đang nói với bạn rằng ở đây có một khái niệm chưa được đặt tên. Đây cũng chính là cơn đau mà DRY nói tới.
- Một phần code chắc chắn sẽ bị thay. Không phải "biết đâu", mà là đã biết trước: nhà cung cấp bên thứ ba sắp đổi, hạ tầng lưu trữ đang trong kế hoạch di chuyển. Khi cái thay đổi là chắc chắn chứ không phải tưởng tượng, một ranh giới dựng sẵn là khoản đầu tư có thật.
- Cần thay bằng bản giả để test được. Mọi thứ chạm ra ngoài đều khó test như nguyên trạng: gọi mạng, đọc thời gian hiện tại, sinh số ngẫu nhiên. Tách chúng sau một ranh giới để thay bằng bản giả lúc test không phải là vẽ vời, đó là điều kiện để viết được test đáng tin.
- Ranh giới đã có người khác phụ thuộc vào. Một API công khai, một thư viện dùng chung giữa nhiều đội. Lúc này abstraction không phải để bạn dễ đổi, mà để người dùng bạn khỏi vỡ mỗi lần bạn đổi.
- Chi phí sửa sai sau này rất cao. Định dạng dữ liệu đã lưu xuống đĩa, hợp đồng của API công khai, schema của sự kiện đã phát đi. Những thứ này sai là phải migrate dữ liệu hoặc bắt cả thiên hạ sửa theo, nên nghĩ kỹ trước vẫn rẻ hơn.
Tóm tắt
- Pattern là công cụ, không phải mục tiêu. Dùng nó để giải một vấn đề có thật, không phải để code trông bài bản.
- Dấu hiệu over-engineering: interface cho thứ chỉ có một biến thể; tầng gián tiếp chỉ chuyển tiếp tham số; kiến trúc cho tương lai chưa bao giờ tới; đọc năm file mới hiểu một luồng đơn giản.
- Abstraction là thuế đọc-hiểu. Chỉ trả khi nó mua lại sự linh hoạt thật sự cần.
- YAGNI & KISS: đừng viết cho nhu cầu tưởng tượng; trong hai lời giải đúng, chọn cái đơn giản hơn.
- Chỉ áp pattern khi cơn đau đã xuất hiện (đã lặp, đã khó sửa, đã khó test), không phải để phòng xa.
- Kai