Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

OOP & Thiết kếSenior23 phút đọc

Clean code: xử lý lỗi, boundary, test và refactor một đoạn code thật

Ôn 19 thẻ
Trong bài này

Cụm bài Clean code: 1. Đặt tên, hàm và luồng điều khiển · 2. Xử lý lỗi, boundary và refactor

Bài 1 bàn về đặt tên, hàm, class và luồng điều khiển. Bài này đi vào chỗ code sạch hay gãy nhất: xử lý lỗi, ranh giới với code người khác, test, và refactor code cũ không đổi hành vi. Phần cuối là một buổi refactor hàm checkout legacy có golden master test, và thứ nó bắt được mà mắt người bỏ sót.

Sơ đồ tóm tắt:

flowchart LR
  SDK[SDK bên thứ ba] --> AD[Adapter]
  AD -->|"bọc checked exception"| SV["Service: exception unchecked"]
  AU[ArchUnit] -.->|chặn rò rỉ kiểu| AD
  T{Test dùng gì?} -->|logic thuần| O[Object thật]
  T -->|phụ thuộc có trạng thái| FK[Fake]
  T -->|tương tác là hành vi| MK[Mock]
  GM[Golden master] --> SS[Bước nhỏ]
  SS --> CO[Tách commit refactor]

1. Xử lý lỗi

Ý chính: xử lý lỗi tốt là để lại trạng thái nhất quán, viết message đủ để chẩn đoán lúc 3 giờ sáng, và chỉ bắt lỗi ở nơi làm được gì đó.

Bốn quy tắc

Viết khung try / catch / finally trước. Với code có thể lỗi (I/O, gọi mạng, parse), viết khung xử lý lỗi trước rồi mới điền logic, để sớm trả lời: lỗi ở đây thì người gọi nhận gì? Trong Java hiện đại, finally gần như luôn là try-with-resources.

Coi khối try như một transaction. Hoặc mọi thứ trong đó thành công, hoặc trạng thái quay về như trước. Khối catch phải để lại trạng thái nhất quán.

Message có bối cảnh. Slide đưa ba thành phần: loại lỗi và mức độ; ở đâu theo dạng chủ ngữ + động từ + tân ngữ; và vì sao.

throw new PaymentException("Error");                                    // vô dụng khi đọc log lúc 3 giờ sáng
throw new PaymentException("Failed to capture payment " + paymentId
        + " for order " + orderId + ": gateway returned 402 (insufficient funds)", cause);

Message thứ hai nói ngay cái gì hỏng, với đối tượng nào, vì sao, và giữ cause để có stack trace gốc. Không đưa dữ liệu nhạy cảm (số thẻ, token) vào message, vì message đi thẳng vào log.

Xử lý tập trung. Đừng try/catch để log rồi ném lại ở mọi tầng (một lỗi bị log năm lần). Bắt ở nơi bạn làm được gì đó (retry, fallback, đổi sang lỗi domain), còn lại để nổi lên một chỗ xử lý chung. Trong Spring đó là @RestControllerAdvice trả ProblemDetail, viết kỹ ở bài xử lý lỗi Spring Boot; cơ bản ở bài exception trong Java.

Checked hay unchecked

Checked exception là loại compiler bắt phải catch hoặc khai throws; unchecked (con của RuntimeException) thì không. Checked nhắc người gọi, nhưng throws ở tầng thấp lan lên mọi chữ ký và lộ chi tiết như SQLException.

Bảng checked/unchecked của slide và cách dùng checked exception trong lambda

Slide tóm tắt:

Checked Unchecked
Định nghĩa Compiler kiểm tra; lỗi nằm ngoài tầm kiểm soát của chương trình; method phải bắt hoặc khai throws Không kiểm lúc compile; thường phản ánh lỗi logic; không cần khai throws
Ưu Nhắc người gọi phải xử lý Giữ đóng gói, chi phí thấp
Nhược Phá Open-Closed (thêm một throws ở tầng thấp lan lên mọi chữ ký phía trên), phá đóng gói (lộ chi tiết cài đặt như SQLException) Dễ quên xử lý
Dùng khi Thư viện quan trọng Ứng dụng nói chung

Checked exception và lambda không hợp nhau, vì Function.apply không khai throws. Cách gọn là bọc ở một chỗ:

@FunctionalInterface
interface IOFunction<T, R> { R apply(T t) throws IOException; }

static <T, R> Function<T, R> uncheckedIO(IOFunction<T, R> f) {
    return t -> {
        try { return f.apply(t); }
        catch (IOException e) { throw new UncheckedIOException("I/O failed for " + t, e); }
    };
}

List<String> contents = paths.stream().map(uncheckedIO(Files::readString)).toList();

2. Comment và format

Ý chính: comment chỉ để nói vì sao, còn format thì giao cho máy.

  • Nên comment: thuật toán phức tạp, lý do của quyết định không hiển nhiên (“dùng LinkedHashMap vì thứ tự hiển thị phải theo thứ tự thêm”), và hợp đồng của interface công khai: tham số nào được null, ném gì, có idempotent không.
  • Không nên comment để giải thích code làm gì; cần thì đổi tên hoặc tách hàm.

Format: Spotless với google-java-format trong build (spotlessCheck làm hỏng CI nếu sai format), Checkstyle cho quy ước đặt tên. Cấu hình một lần, hết cãi nhau về dấu ngoặc trong review.

3. Test

Ý chính: test chỉ chứa chi tiết quyết định kết quả, và kiểm hành vi chứ không chép lại cách cài đặt.

Chỉ đưa chi tiết liên quan vào test. Test “khách GOLD giảm 10% khi mua trên 1 triệu” không cần địa chỉ, ngày sinh. Dùng test data builder có mặc định hợp lệ: anOrder().tier(GOLD).subtotal("1200000").build().

Đừng lạm dụng mock. Mock mọi collaborator rồi verify từng lời gọi là chép lại implementation: đổi thứ tự gọi bên trong cũng làm test đỏ dù hành vi không đổi.

4. Boundary: nơi code của mình gặp code của người khác

Ý chính: bọc thư viện, SDK bên thứ ba sau một adapter dùng kiểu của mình, để thay đổi phía họ chỉ chạm một chỗ.

Boundary là chỗ gọi thư viện, SDK nhà cung cấp, API team khác: vùng khó đoán vì họ đổi phiên bản, đổi ngữ nghĩa, ném exception lạ. Slide khuyên:

  • Không truyền object của bên thứ ba khắp hệ thống, không nhận hay trả chúng ở API công khai.
  • Bọc boundary bằng adapter (hình trên slide là kiến trúc hexagonal, hay ports and adapters: lõi chỉ nói chuyện qua interface của mình).
  • Viết learning test.

Ví dụ: SDK gửi SMS của nhà cung cấp “Acme” có kiểu riêng, ném checked exception với mã lỗi số.

// Port: ngôn ngữ của mình, kiểu của mình
interface SmsSender { SmsResult send(PhoneNumber to, String text); }

sealed interface SmsResult {
    record Sent(String providerMessageId) implements SmsResult {}
    record Rejected(String reason) implements SmsResult {}
}

// Adapter: nơi duy nhất biết Acme tồn tại
final class AcmeSmsSender implements SmsSender {
    private final AcmeSmsClient client;

    AcmeSmsSender(AcmeSmsClient client) { this.client = client; }

    public SmsResult send(PhoneNumber to, String text) {
        try {
            AcmeSmsResponse response = client.send(to.e164(), text, Map.of("priority", "high"));
            return new SmsResult.Sent(response.messageId);
        } catch (AcmeSmsException e) {
            if (e.vendorCode / 1000 == 4) {   // 4xxx: lỗi phía mình, retry vô ích
                return new SmsResult.Rejected("provider rejected " + to.e164() + ": " + e.getMessage());
            }
            throw new SmsUnavailableException(
                    "Failed to send SMS to " + to.e164() + " via Acme (code " + e.vendorCode + ")", e);
        }
    }
}

Lợi ích: đổi nhà cung cấp là viết adapter mới, không đụng service; test service dùng fake SmsSender vài dòng; quy ước “4xxx là lỗi phía mình” nằm một chỗ. Đã chạy với JDK 21 (SDK giả lập): gửi thành công trả Sent, mã 5003 thành SmsUnavailableException vẫn giữ cause.

Trong DDD, khi phía kia là cả một model khác (ERP, core banking), lớp này lớn hơn và gọi là anti-corruption layer (lớp chống để model lạ làm hỏng model của mình). Pattern Adapter có ở bài Adapter và Factory.

Learning test kiểm giả định của mình về thư viện: “client ném mã 4001 khi số không theo E.164”, “có tự retry không”, “timeout mặc định bao nhiêu”. Nâng phiên bản SDK thì chạy lại là biết ngữ nghĩa có đổi không.

5. Refactoring

Ý chính: refactoring là đổi cấu trúc bên trong mà không đổi hành vi quan sát được. Làm an toàn nhờ test có trước và bước nhỏ.

Quy trình an toàn:

  1. Có characterization test trước (test ghi lại code đang làm gì, kể cả hành vi trông như bug).
  2. Bước nhỏ, mỗi bước chạy test; đỏ thì revert bước đó, không debug.
  3. Dùng refactor tự động của IDE (Extract Method, Rename, Change Signature): đúng hơn sửa tay, kể cả ở chỗ gọi xa.
  4. Tách commit refactor khỏi commit đổi hành vi, để reviewer chỉ hỏi một câu: hành vi có đổi không.
Bốn nhóm kỹ thuật của Fowler và ghi chú “3 classes, 10 files” trên slide

Slide liệt kê bốn nhóm kỹ thuật theo danh mục của Martin Fowler:

Nhóm Ví dụ kỹ thuật Ví dụ cụ thể
Composing methods Extract Method, Replace Temp with Query, Inline Tách domesticBaseFee(cart) khỏi hàm tính phí
Moving features between objects Move Method, Extract Class, Hide Delegate Đưa logic tính tiền một dòng vào OrderLine.amount()
Organizing data Replace Magic Number with Constant, Replace Primitive with Object, Replace Type Code with Class "GOLD" thành enum Tier, double tiền thành BigDecimal
Dealing with generalization Replace Conditional with Polymorphism, Extract Interface, Replace Inheritance with Delegation Chuỗi if (v.equals("SALE50")) thành sealed interface Voucher

Slide còn ghi “best practices: 3 in-depth classes, 10 files, unit tests” mà không giải thích. Mình hiểu là giới hạn phạm vi một lần refactor: đừng đi sâu quá khoảng ba tầng class và quá khoảng mười file trong một thay đổi, và phải có unit test trước. Ý đó khớp với quy trình bốn bước ở trên.

6. Case study: refactor hàm checkout

Ý chính: golden master 20.000 case giúp refactor hàm checkout legacy với 0 khác biệt, và bắt được một lần làm tròn lệch tiền mà mắt người bỏ sót.

Đây là bài tập về nhà của khoá học: mình tự viết một hàm checkout mang đủ “đặc sản” legacy, rồi refactor theo quy trình ở mục 5.

Code ban đầu

Method process(Map<String, Object> req) nhận request dạng map, trả chuỗi "OK:<orderId>:<total>" hoặc "ERROR:<code>".

Mùi: tên một chữ cái, magic number, double cho tiền, catch (Exception e) nuốt lỗi, lồng năm tầng, parse/tính giá/lưu/log trộn trong một hàm, trạng thái tĩnh (counter, DB), kết quả là chuỗi phải parse lại.

Đề bài tập, quy mô code và trích đoạn hàm process() legacy

Đề: refactor ít nhất 300 dòng code thật (nhiều class, có logic nghiệp vụ, ít comment, không lấy getter/setter, không lộ thông tin công ty). Không đưa code công ty lên blog được, nên mình tự viết code mẫu. Tổng khoảng 365 dòng: bản cũ 95 dòng, bản mới khoảng 205 dòng trong 6 file, golden master khoảng 65 dòng.

public String process(Map<String, Object> req) {
    String cid = (String) req.get("cid");
    String items = (String) req.get("items");   // "sku:qty:price;sku:qty:price"
    String v = (String) req.get("voucher");
    String t = (String) req.get("tier");
    String pm = (String) req.get("pm");
    double sub = 0;
    int cnt = 0;
    if (cid != null && !cid.isEmpty()) {
        if (items != null) {
            String[] arr = items.split(";");
            for (int i = 0; i < arr.length; i++) {
                try {
                    String[] p = arr[i].split(":");
                    int q = Integer.parseInt(p[1]);
                    double pr = Double.parseDouble(p[2]);
                    if (q > 0) { sub = sub + q * pr; cnt = cnt + q; }
                } catch (Exception e) {
                    // ignore bad item
                }
            }
            if (cnt == 0) return "ERROR:EMPTY";
            double d = 0;
            if (t != null) {
                if (t.equals("GOLD")) {
                    if (sub > 1000000) { d = sub * 0.1; } else { d = sub * 0.05; }
                } else if (t.equals("SILVER")) {
                    if (sub > 1000000) { d = sub * 0.05; }
                }
            }
            // ... voucher SALE50 / PCT20 / FREESHIP, phí ship 30000, giới hạn COD 5000000,
            // kiểm tra phương thức thanh toán, counter++ tĩnh, DB.add(...), System.out.println(...)

Bước 1: golden master trước khi đụng vào bất cứ thứ gì

Chưa có test, nên mình dùng golden master: sinh nhiều input, chạy qua code cũ, ghi output; mọi phiên bản sau phải ra y hệt. Seed cố định, cố ý trộn giá trị xấu, nên 20.000 case đi qua mọi nhánh.

List<Map<String, Object>> cases = cases(7, 20_000);   // seed cố định: lần nào cũng cùng bộ input

List<String> before = cases.stream().map(new legacy.OrderProcessor()::process).toList();

List<String> savedRows = new ArrayList<>();
AtomicInteger ids = new AtomicInteger(1000);
CheckoutService svc = new CheckoutService(
        (id, cid, total, pm) -> savedRows.add(id + "," + cid + "," + total + "," + pm),
        () -> "O" + ids.incrementAndGet());
List<String> after = cases.stream().map(svc::process).toList();
// so sánh before/after từng phần tử, và savedRows với legacy.OrderProcessor.DB
Bộ sinh input và phân bố 20.000 case

Bộ sinh trộn: customer id null hoặc rỗng, dòng hàng thiếu trường, số lượng âm, giá không phải số, giá 1e5, giá lẻ 7777.5, voucher và tier lạ, phương thức thanh toán lạ, đơn chạm giới hạn COD.

Kết quả Số case
Thành công 8.495
Thiếu customer 5.057
Đơn rỗng 3.948
Sai phương thức thanh toán 2.179
Vượt COD 321

Bước 2 đến 5: refactor từng bước

Năm bước, mỗi bước một kỹ thuật ở mục 5: kéo parse ra boundary, kiểu có nghĩa, đa hình thay if, lõi tính giá thuần, kết quả có kiểu. Kết quả cuối: 20.000 case, 0 khác biệt, 8.495 dòng “đã lưu” giống hệt (chạy với JDK 21).

Chi tiết năm bước và code service sau refactor

Trong dự án thật, mỗi bước dưới đây là một commit có golden master xanh (ở bài này mình chạy golden master trên bản cuối và trên các thử nghiệm ở mục sau):

  1. Kéo phần parse ra boundary: LegacyRequestParser biến map không kiểu thành OrderRequest có kiểu; mọi thứ bẩn (ép kiểu, tách chuỗi, mặc định "COD") nằm ở đây.
  2. Organizing data: record OrderLine(sku, quantity, unitPrice), enum Tier, enum PaymentMethod, BigDecimal cho tiền, hằng số có tên cho mọi ngưỡng.
  3. Replace conditional with polymorphism: sealed interface Voucher với FixedAmount, Percentage, FreeShipping và factory Voucher.fromCode(code).
  4. Tách lõi thuần: PriceCalculator.price(request) trả PriceBreakdown (subtotal, hai khoản giảm, phí ship), không I/O, không trạng thái.
  5. Kết quả có kiểu, phụ thuộc được tiêm: sealed interface CheckoutResult (Placed, Rejected với enum RejectReason); repository và bộ sinh id qua constructor. process(map) cũ chỉ còn một dòng chuyển đổi cho người gọi cũ.

Tầng service sau refactor:

CheckoutResult checkout(Map<String, Object> rawRequest) {
    return switch (parser.parse(rawRequest)) {
        case Parsed.Invalid invalid -> new CheckoutResult.Rejected(invalid.reason());
        case Parsed.UnknownPaymentMethod unknown -> new CheckoutResult.Rejected(UNSUPPORTED_PAYMENT_METHOD);
        case Parsed.Valid valid -> place(valid.request());
    };
}

private CheckoutResult place(OrderRequest request) {
    BigDecimal total = calculator.price(request).total();
    if (request.paymentMethod() == PaymentMethod.COD && total.compareTo(COD_LIMIT) > 0) {
        return new CheckoutResult.Rejected(RejectReason.COD_LIMIT_EXCEEDED);
    }
    long roundedTotal = total.setScale(0, RoundingMode.HALF_UP).longValueExact();
    String orderId = orderIds.get();
    repository.save(orderId, request.customerId(), roundedTotal, request.paymentMethod());
    return new CheckoutResult.Placed(orderId, roundedTotal);
}

Golden master bắt được gì

Mình thử một “cải tiến” trông vô hại: làm tròn tiền giảm theo hạng ngay khi tính, vì “tiền phải là số nguyên”. Golden master đỏ ngay: 338 trên 20.000 case khác nhau một đồng.

Golden master xanh chưa có nghĩa là giống hệt ở mọi input. Một probe (bộ input thử riêng) với giá trị “kỳ quặc” tìm ra bốn khác biệt, như giá NaN ở code cũ tạo đơn 0 đồng.

Bảng probe giá trị kỳ quặc và quyết định cho từng khác biệt
Dòng hàng Code cũ Code mới
A:1:NaN OK:...:0 (đặt đơn tổng 0 đồng!) ERROR:EMPTY
A:1:19900d OK:...:49900 (Double.parseDouble chấp nhận hậu tố d) ERROR:EMPTY
A:1: 19900 OK:...:49900 (bỏ qua khoảng trắng) ERROR:EMPTY
A:1:Infinity ERROR:COD_LIMIT ERROR:EMPTY
A:1:-50000 OK:...:-20000 OK:...:-20000

Quyết định:

  • Giá NaN cho đơn 0 đồng là bug, hành vi mới tốt hơn: giữ, ghi trong PR như thay đổi hành vi có chủ đích kèm test riêng.
  • Giá âm thì cả hai bản đều tạo đơn tổng âm: bug thật, nhưng sửa ở commit sau refactor, để reviewer thấy rõ đâu là refactor, đâu là sửa lỗi.
  • Dòng in ra System.out của code cũ không nằm trong golden master; nếu có hệ thống đọc log đó thì cũng phải đặc tả.

7. Code review

Ý chính: với PR refactor, ghi rõ “commit này không đổi hành vi, bằng chứng là golden master”, để reviewer tập trung vào thiết kế.

Phần còn lại của slide (checklist, quy trình, nhãn TODO/NIT/OPTIONAL/FYI, kích thước PR, bất đồng) có ở bài code review hiệu quả và bài giải quyết bất đồng và review mẫu.

8. Tổng kết

Ý chính: clean code không phải mục tiêu, mà là phương tiện giảm chi phí thay đổi; nó cân với tốc độ giao hàng, cách team cộng tác và hiệu năng.

Gói lại: bốn chữ “-able”; trừu tượng hoá giảm độ phức tạp; thiếu nhất quán sinh ra unknown unknowns; đọc và luyện. Hàm checkout cũ chạy được nhiều năm; refactor vì nó sắp bị sửa nhiều, không phải vì nó xấu.

Bài tập

Bài 1: Thêm một loại voucher

Đề: thêm voucher BIG100 giảm 100.000 cho đơn từ 1.000.000 trở lên (sau giảm theo hạng). Sau đó trả lời: voucher “mua 2 tặng 1” có thêm được theo cùng cách không?

Lời giải bài 1

Chỉ thêm một dòng vào factory, không đụng PriceCalculator hay service:

case "BIG100" -> Optional.of(new FixedAmount(new BigDecimal("100000"), new BigDecimal("1000000")));

Golden master vẫn 0 khác biệt, và hai test riêng đã chạy: đơn 1.200.000 ra 1.100.000 (miễn ship), đơn 900.000 không được giảm.

“Mua 2 tặng 1” thì không thêm được như vậy: discountOn(BigDecimal) chỉ nhận một con số, còn voucher này cần thấy từng dòng hàng, nên phải đổi chữ ký thành discountOn(List<OrderLine>, BigDecimal). Abstraction được thiết kế cho biến thể đã biết; khi biến thể mới phá vỡ giả định, sửa abstraction có ý thức thay vì nhét thêm cờ.

Ghi nhớ

  • Giải thích được vì sao catch phải để lại trạng thái nhất quán, và message lỗi tốt có những gì.
  • Biết khi nào dùng checked, khi nào unchecked, và bọc checked exception ở đâu.
  • Chọn được object thật, fake hay mock cho một phụ thuộc, và nói được lý do.
  • Mô tả được cách bọc một SDK sau adapter và chặn rò rỉ kiểu của vendor.
  • Kể được quy trình golden master và vì sao nó không phủ mọi input.

Câu hỏi phỏng vấn

Junior

Vì sao không nên catch (Exception e) {} rồi bỏ qua?

Vì lỗi biến mất không dấu vết và chương trình chạy tiếp với dữ liệu sai.

Ví dụ giá NaN thành đơn 0 đồng, mà không có log để điều tra. Bắt đúng loại mình xử lý được, xử lý thật sự, hoặc để nó nổi lên chỗ xử lý chung.

Message lỗi tốt có những gì?

Cái gì hỏng, với đối tượng nào, vì sao, và exception gốc làm cause.

Loại lỗi; id đơn hàng hay tên file; mã trả về hay giá trị sai. Không chứa dữ liệu nhạy cảm như số thẻ hay token.

Khi nào nên viết comment?

Khi cần giải thích vì sao, không phải code làm gì.

Tức là: một quyết định không hiển nhiên, thuật toán phức tạp, và hợp đồng của interface công khai trong Javadoc. Muốn giải thích code làm gì thì đổi tên hoặc tách hàm.

Mid

Checked hay unchecked exception cho lỗi nghiệp vụ trong service Spring?

Thường là unchecked, mang dữ liệu có cấu trúc, xử lý tập trung bằng @RestControllerAdvice.

Checked exception lan chữ ký qua mọi tầng, không dùng được trong lambda, và Spring cũng theo hướng unchecked (DataAccessException). Checked exception từ thư viện được bọc ở boundary kèm cause.

Mock nhiều trong unit test có vấn đề gì?

Test bị gắn vào cài đặt: refactor bên trong làm test đỏ dù hành vi không đổi, nên người ta ngại refactor.

Value object và logic thuần thì dùng thật, phụ thuộc có trạng thái thì dùng fake, mock để dành cho tương tác chính là hành vi cần kiểm. Cần nhiều mock thường là dấu hiệu class làm quá nhiều việc.

Learning test là gì?

Test kiểm hiểu biết của mình về thư viện bên thứ ba, không phải về code của mình.

Ví dụ: nó ném gì khi input sai, có tự retry không, timeout mặc định. Chạy lại khi nâng phiên bản để phát hiện thay đổi ngữ nghĩa trước khi lên production.

Senior

Bạn refactor một hàm legacy không có test như thế nào?

Golden master trước, rồi bước nhỏ bằng công cụ IDE, so sánh sau mỗi bước.

Sinh nhiều input có cả giá trị xấu, ghi output code cũ; tách commit refactor khỏi commit đổi hành vi. Thêm probe cho chỗ đổi kiểu hay thư viện, vì golden master chỉ bảo vệ những gì bộ sinh tạo ra.

Bạn bọc một SDK của nhà cung cấp như thế nào, và vì sao?

Port bằng kiểu của mình, adapter là nơi duy nhất import SDK, để đổi nhà cung cấp chỉ đụng adapter.

Định nghĩa interface SmsSender và kết quả SmsResult; adapter dịch exception và mã lỗi của họ sang ngữ nghĩa của mình, giữ cause. Đổi nhà cung cấp hay nâng major version chỉ đụng adapter, test service dùng fake. Chặn rò rỉ bằng luật ArchUnit trong CI.

Refactor làm lệch tổng tiền một đồng trên 338 trên 20.000 đơn. Bạn xử lý thế nào?

Coi đó là đổi hành vi, không phải chi tiết: revert bước đó.

Thời điểm và cách làm tròn là quy tắc nghiệp vụ, phải hỏi người sở hữu nghiệp vụ hoặc kế toán, ghi thành đặc tả có test. Nếu quyết định đổi thì làm trong commit riêng, có thông báo và kế hoạch đối soát cho các đơn cũ.

Khi nào bạn không refactor?

Khi code xấu nhưng ổn định và hiếm khi bị sửa.

Cũng không refactor khi không có cách kiểm chứng hành vi mà chi phí viết test cao hơn lợi ích, hoặc ngay trước một đợt release rủi ro. Clean code là phương tiện giảm chi phí thay đổi; chỗ nào không thay đổi thì lợi ích gần như bằng không.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
characterization test /ˌkærəktəraɪˈzeɪʃn test/ test ghi lại hành vi hiện tại “Before touching legacy code I write characterization tests.”
golden master /ˈɡəʊldən ˈmɑːstə/ bộ output chuẩn để so sánh “The golden master caught a one-dong rounding difference.”
swallow an exception /ˈswɒləʊ ən ɪkˈsepʃn/ nuốt exception, bỏ qua lỗi “The old code swallowed every exception while parsing items.”
anti-corruption layer /ˌænti kəˈrʌpʃn ˈleɪə/ lớp chống làm hỏng model “We put an anti-corruption layer in front of the ERP.”
learning test /ˈlɜːnɪŋ test/ test kiểm tra hiểu biết về thư viện “Our learning tests failed after the SDK upgrade, which saved us.”
behaviour-preserving /bɪˈheɪvjə prɪˈzɜːvɪŋ/ giữ nguyên hành vi “This commit is behaviour-preserving; the golden master proves it.”
test double /test ˈdʌbl/ đối tượng thay thế trong test “I prefer a fake over a mock as a test double for repositories.”
rounding mode /ˈraʊndɪŋ məʊd/ cách làm tròn “The rounding mode is a business rule, not an implementation detail.”

Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.