10.25.2026

Trùng Tu Nhà Cổ Bằng Lời Nói: Dùng Claude Opus để Chuyển mã nguồn từ Visual Basic 6 sang C#.NET

Written by: Claude AI.

Curator/Editor: Học Trò.


Bạn đọc thân mến,

Ở sở làm tôi đang chuyển một số code cũ của mình viết từ Visual Basic 6 sang C#.NET. Đầu tiên tôi gắng làm một cái dễ, nhưng compile được. Sau đó tôi bảo GitHub Copilot với Model Claude Opus 5.5 tạo ra một solution mới từ cái đó, rồi xem code cũ coi cách tôi viết WinForm ra sao, logic ra sao, xong viết lại như vậy, nhưng với C#. Kết quả mỹ mãn. Tôi có chừng 30 cái program như vậy cho CAD, tôi làm xong 20 cái rồi! Điều quan trọng là mình phải làm từ từ, từ dễ tới khó, và phải ghi rằng nó viết xuống những điều nó nghĩ, để sau này nó đọc lại và đủ thông minh để làm cái tiếp. 30 programs này nếu làm tay mất khoảng 1000 giờ, bây giờ dùng GitHub Copilot với Opus 5.5 sẽ chỉ tốn 100 giờ!!! Nó viết code thật gọn và giỏi.

Bài viết sau đây là tôi nhờ nó viết, không dựa vào quy trình tôi đang làm ở sở. Tôi bảo nó tra trên mạng coi người ta làm ra sao, rồi viết bài. Tôi cũng sẽ học hỏi được nhiều mẹo.

Thân mến,

Học Trò
10/25/2026


Chuyển mã VB6, COBOL, FORTRAN sang VB.NET và C# bằng cách trò chuyện với AI — cái gì chạy, cái gì gãy, và làm sao chứng minh

Ai từng thấy người ta trùng tu một ngôi nhà rường cổ ở Huế hay một căn nhà gỗ ở Hội An đều biết: không ai đập đi xây lại. Người thợ đo từng cây cột, đánh số từng thanh kèo, chụp ảnh từng mộng gỗ, rồi thay từng phần mục, trong khi gia đình vẫn sống trong nhà. Phần mềm cũ cũng là những ngôi nhà cổ như thế. Một chương trình viết bằng Visual Basic 6 năm 1999, bằng COBOL năm 1983, hay bằng FORTRAN 77 do một kỹ sư đã nghỉ hưu từ mười năm trước — vẫn đang tính lương, tính phí bảo hiểm, tính tải trọng cho cây dầm. Ba mươi năm nay, lời khuyên chuẩn là đừng đụng vào, vì hiểu nó tốn hơn thay nó, mà thay nó là cách nhiều sự nghiệp kết thúc. Năm 2025–2026, lời khuyên ấy bắt đầu đổi, không phải vì ngôn ngữ cũ dễ hơn, mà vì việc *hiểu chúng trở nên rẻ. Một agent như GitHub Copilot hay Claude Code có thể đọc mười nghìn dòng VB6 trong một đêm, giải thích từng thủ tục làm gì, đề xuất bản tương đương bằng C#, và viết các bài kiểm thử để so hai bản. Người viết bài này đã tự làm một lần chuyển đổi như thế ở chỗ làm, bằng GitHub Copilot, chỉ bằng cách ra lệnh — và không thể cho xem một dòng nào, vì mã nguồn thuộc về công ty. Ràng buộc ấy chi phối toàn bộ bài viết. Mọi đoạn mã dưới đây đều là ví dụ tự viết để minh họa, không lấy từ hệ thống thật nào.*


1. Những ngôi nhà cổ vẫn có người ở

Vì sao chương trình cũ vẫn còn đó

Bài nào về mã cũ cũng mở đầu bằng con số, và con số thường sai theo một cách đáng học. Con số hay được trích nhất là về COBOL, thường được gán cho một biểu đồ của Reuters năm 2017: khoảng 220 tỷ dòng đang chạy, 43% hệ thống ngân hàng dựa trên nó, phần lớn giao dịch ATM đi qua nó. Tôi không mở được bản gốc để kiểm, và con số đã chín năm tuổi. Nên coi đó là cỡ độ lớn, không phải phép đo. Mà cỡ độ lớn mới là điều đáng nói: một phần rất lớn hệ thống ống nước tài chính của thế giới vẫn chạy bằng một ngôn ngữ thiết kế năm 1959.

Visual Basic 6 thì lì lợm một cách lặng lẽ hơn. Tuyên bố hỗ trợ của Microsoft, vẫn được cập nhật năm 2026, là một kiệt tác của sự lưỡng lự. Nó "khuyến khích mạnh mẽ" khách hàng chuyển khỏi VB6, và ngay câu sau hứa hẹn tương thích theo kiểu "It Just Works" — cứ thế mà chạy: bộ thư viện chạy (runtime) của VB6 được hỗ trợ suốt vòng đời các phiên bản Windows còn được hỗ trợ, kể cả Windows 11 và Windows Server 2025, dù chỉ cho "lỗi hồi quy nghiêm trọng và vấn đề bảo mật nghiêm trọng". Còn môi trường lập trình thì khác hẳn: bộ IDE của VB6 "không còn được hỗ trợ từ ngày 8/4/2008", và vì "không có cách nào được hỗ trợ để tạo hay bảo trì ứng dụng Visual Basic 6", Microsoft "khuyến nghị mạnh mẽ" thay thế chúng. Vậy là hàng nghìn ứng dụng doanh nghiệp chạy trên một runtime được hỗ trợ, được bảo trì bằng một công cụ không được hỗ trợ, chưa từng có bản 64-bit, bởi những lập trình viên ngày càng khó tìm.

FORTRAN — viết là Fortran từ chuẩn 1990 — lại là chuyện khác. Nó chưa bao giờ chết trong tính toán khoa học và kỹ thuật, và Fortran hiện đại là một ngôn ngữ mạnh, vẫn đang phát triển. Bài toán mã cũ ở đây thường là FORTRAN 77 trở về trước: mã viết theo cột cố định, kiểu biến ngầm định, khối COMMON, lệnh GOTO, do chuyên gia ngành viết chứ không phải kỹ sư phần mềm, nằm trong những quy trình kỹ thuật không ai dám động vào vì con số nó cho ra đã được tin.

Vì sao những chương trình này chưa được viết lại? Không phải vì chưa ai thử. Lý do, như bài viết tháng 2/2026 của Anthropic về COBOL nói thẳng, là "hiểu mã làm gì là bước đắt nhất". Đọc từng dòng thì không khó. Khó là hiểu nó như một hệ thống: quy tắc nghiệp vụ là gì, cái nào còn cần, hành vi lạ nào là lỗi và hành vi lạ nào là "tính năng" mà một báo cáo nào đó đang dựa vào, những phụ thuộc không ai ghi chép nằm ở đâu. Martin Fowler, khi nói về kế hoạch "nghe thì đơn giản" là thay cả hệ thống cũ một lần, viết rằng "chúng tôi đã thấy kế hoạch ấy cháy rụi phần lớn các lần" (Strangler Fig). Nhà cổ đứng được vì nó chứa hàng chục năm quyết định không được ghi ở đâu khác, và moi được những quyết định ấy ra xưa nay vẫn là phần tốn kém.


2. Ba lối trùng tu

Đập đi xây lại, chép nguyên mẫu, và trò chuyện

Nên nhìn thời điểm hiện nay như thế hệ thứ ba trong ba thế hệ, vì mỗi thế hệ giải được một phần bài toán và để lại một phần khác.

Đập đi xây lại. Thế hệ thứ nhất là viết lại: một nhóm đọc hệ thống cũ, viết yêu cầu, rồi dựng hệ thống mới. Được mã hiện đại và cơ hội sửa sai lầm thiết kế. Nhưng chậm, đắt, và nguy hiểm, vì yêu cầu do người rút ra từ một bộ mã họ chỉ hiểu một phần thì bao giờ cũng thiếu. Phần lớn những vụ "cháy rụi" Fowler nói tới thuộc loại này.

Chép nguyên mẫu. Thế hệ thứ hai là công cụ chuyển đổi tự động: phân tích ngôn ngữ cũ rồi xuất ra ngôn ngữ mới theo luật. Microsoft từng kèm trình nâng cấp VB6 trong các bản Visual Studio .NET đầu tiên và xuất bản cả một cuốn hướng dẫn nâng cấp VB6 lên VB.NET, đến nay vẫn được dẫn từ trang hỗ trợ VB6; công cụ chuyển đổi thương mại cho VB6, COBOL, Fortran đã có từ hàng chục năm. AWS Transform cho mainframe, phát hành chính thức tháng 5/2025, là một hậu duệ hiện đại: chuyển COBOL và JCL sang Java mà, theo AWS, vẫn giữ tương đương về chức năng. Chuyển đổi theo luật nhanh và, nếu làm tốt, trung thành. Điểm yếu thì ngược với viết lại: trung thành quá mức. Nó tái tạo nguyên cấu trúc cũ — biến toàn cục, luồng điều khiển kiểu GOTO, bố cục dữ liệu thiết kế cho ổ đĩa thập niên 1980 — trong một cú pháp mới, ra một bộ mã biên dịch được bằng ngôn ngữ hiện đại nhưng đọc lên như bản dịch của người không nói được ngôn ngữ ấy. Chính quy trình của AWS thừa nhận điều này khi đưa thêm một bước tùy chọn dùng mô hình ngôn ngữ để sắp xếp lại mã cho "giống Java bản địa".

Trò chuyện. Thế hệ thứ ba, đến cùng các agent lập trình đủ giỏi năm 2025, dùng mô hình ngôn ngữ để làm điều hai thế hệ trước không làm rẻ được: hiểu. Agent đọc một module và giải thích logic nghiệp vụ bằng lời thường, đề xuất thiết kế mới, dịch, rồi sửa bản dịch cho đúng "giọng" ngôn ngữ mới, viết kiểm thử, và giải thích từng bước cho người kiểm tra. Làm được cho một thủ tục hay mười nghìn. Điểm yếu thì là điểm yếu cả loạt bài này cứ gặp: có thể sai một cách tự tin, và có thể không nhất quán giữa các lần chạy. Phương pháp phải được xây quanh điều đó.

Ba lối không loại trừ nhau. Thực hành tốt nhất năm 2026 kết hợp cả ba: công cụ phân tích theo luật để vẽ bản đồ hệ thống, agent để giải thích và đề xuất, con người để quyết định, và kiểm thử — thật nhiều kiểm thử — để soát lại. Như người thợ trùng tu: có thước đo, có bản vẽ cũ, có tay nghề, và có một quy trình nghiệm thu từng hạng mục.


3. Khi việc "hiểu" trở nên rẻ

Một bài blog, một cú rơi cổ phiếu, và một lời phản biện

Khoảnh khắc sự dịch chuyển này lộ ra với người ngoài ngành là ngày 23/2/2026. Anthropic đăng bài AI giúp phá rào cản chi phí của việc hiện đại hóa COBOL, lập luận rằng vì AI tự động hóa được phần khám phá và phân tích chiếm phần lớn công sức, các nhóm có thể đi "trong vài quý thay vì vài năm". Bài khuyên đi từng bước: bắt đầu với một thành phần có ranh giới rõ và độ phức tạp vừa phải; dùng AI để vẽ phụ thuộc, lần dòng dữ liệu, ghi lại quy trình; để kỹ sư quyết định kiến trúc đích; định nghĩa kiểm thử xác nhận mã mới cho ra cùng kết quả với mã cũ trước khi đổi bất cứ gì; rồi chuyển dần, bọc thành phần cũ sau API, chạy song song cũ và mới.

IBM — mà máy mainframe chạy phần lớn COBOL của thế giới — đóng cửa hôm ấy giảm 13,2%, cú rơi một ngày lớn nhất kể từ tháng 10/2000, theo Techzine. Các công ty tư vấn có mảng hiện đại hóa mainframe cũng giảm. Cũng như vụ bán tháo cổ phiếu phần mềm sau plugin Cowork cùng tháng, phản ứng thị trường đo niềm tin chứ không đo tác động. IBM đã có công cụ chuyển COBOL sang Java có AI hỗ trợ từ 2023, và chẳng có gì về COBOL thay đổi qua một đêm.

Phản hồi hữu ích nhất đến một tuần sau, từ công ty tư vấn Thoughtworks, bài của Alessio Ferri và Shodhan Sheth, Claude Code và hiện đại hóa COBOL: thực tế ra sao? Ai định làm chuyển đổi nên đọc trọn, và những điểm của nó áp dụng y nguyên cho VB6 và Fortran:

  • Vấn đề là quy mô, không phải độ khó đọc. "Vấn đề chính của các hệ thống COBOL lớn hiếm khi là mã không đọc được", mà là "chuyện quy mô và gánh nặng nhận thức".
  • Vẽ bản đồ là một quá trình nhiều tầng, không phải một lời nhắc. Chia nhỏ bộ mã; tóm tắt từng phần tại chỗ; rút ra các thực thể — bảng dữ liệu, copybook, giao dịch, job, màn hình — rồi suy ra quan hệ; tổng hợp dần lên; kết hợp với công cụ phân tích tĩnh và truy vết dữ liệu sẵn có.
  • Dịch không phải là hiện đại hóa. Chuyển thẳng có thể mang theo nguyên những ràng buộc và nợ kỹ thuật cũ. "Một hệ thống lớn hơn mã" — nó là hạ tầng, dữ liệu, vận hành, tích hợp, con người.
  • Độ đúng là điểm yếu. Agent mạnh về thời gian và chi phí, kém chắc chắn hơn về độ đúng; nó bịa và bỏ sót bối cảnh, và chạy cùng một việc nhiều lần có thể cho kết quả xê dịch.
  • Chuyên gia nghiệp vụ vẫn cần, và kết luận trung thực là "chưa ngã ngũ".

Ví dụ đáng học còn lại là Morgan Stanley. Tới giữa năm 2025, ngân hàng này đã tự làm một công cụ nội bộ tên DevGen.AI, dựa trên mô hình của OpenAI tinh chỉnh bằng chính mã của họ. Theo bản tóm tắt trên Slashdot, nó đã rà khoảng chín triệu dòng mã cũ và tiết kiệm ước tính 280.000 giờ công lập trình. Lựa chọn thiết kế mới là chỗ thú vị: nó không dịch thẳng mã cũ. Nó biến mã cũ — COBOL, PL/I — thành bản mô tả bằng tiếng Anh thường, để mười lăm nghìn lập trình viên của ngân hàng dùng mà viết lại bằng ngôn ngữ hiện đại. Đó chính là bước "hiểu", được tự động hóa, còn phần viết lại để cho người.

Gộp lại — tuyên bố của nhà cung cấp, cơn hoảng của thị trường, lời phản biện của nhà tư vấn, và thiết kế của ngân hàng — đều chỉ về một kết luận. Thứ trở nên rẻ năm 2025–26 không phải là việc chuyển đổi. Mà là việc thấu hiểu. Mọi phần khác — quyết định giữ gì, thiết kế đích, chứng minh tương đương, chuyển giao — vẫn là lao động. Nhưng thấu hiểu là bước từng làm mọi bước khác trở nên không kham nổi, và đó là bước một cuộc trò chuyện với agent làm tốt.


4. Dịch sát hay viết lại từ bản mô tả

Và vì sao câu trả lời thường là "cả hai, theo thứ tự ấy"

Có hai cách dùng agent trên mã cũ khác nhau tận gốc, và chọn giữa chúng — hay sắp thứ tự cho chúng — là quyết định thật sự đầu tiên.

Dịch sát. Bảo agent chuyển mã cũ sang ngôn ngữ mới, từng thủ tục, giữ hành vi càng sát càng tốt. Kết quả đối chiếu được với bản gốc từng dòng, từng bài kiểm thử, ít nguy cơ lặng lẽ đánh rơi một quy tắc. Cái giá là thừa hưởng nguyên thiết kế cũ. Một form VB6 nhét logic nghiệp vụ trong sự kiện bấm nút thành một form WinForms nhét logic nghiệp vụ trong sự kiện bấm nút.

Viết lại từ bản mô tả. Bảo agent giải thích mã cũ làm gì, bằng lời và bằng đặc tả có cấu trúc — đầu vào, đầu ra, quy tắc, trường hợp biên — rồi dựng mã mới từ đặc tả, có thể với thiết kế khác. Đây là lối Morgan Stanley. Được thiết kế hiện đại và tài liệu như một sản phẩm phụ. Cái giá là mọi quy tắc phải sống sót qua một vòng đi về bằng ngôn ngữ tự nhiên, mà ngôn ngữ tự nhiên là chỗ những quy tắc tinh tế hay chết: "làm tròn hai chữ số thập phân" không nói làm tròn kiểu nào, mà lựa chọn của mã cũ có thể quan trọng với kiểm toán viên.

Trên thực tế, con đường an toàn nhất cho phần lớn hệ thống là một trình tự:

  1. Mô tả trước, để hiểu. Cho agent ghi chép hệ thống — chưa phải để dựng lại, mà để con người thấy có gì, quyết định cái gì còn cần, và tìm chuyên gia để hỏi những chỗ chưa rõ. Như người thợ trùng tu đo vẽ toàn bộ ngôi nhà trước khi tháo một thanh kèo.
  2. Ghi lại hành vi. Biến những hành vi quan trọng thành bài kiểm thử chạy trên hệ thống cũ (mục 10).
  3. Dịch sát, từng phần, tới khi mã mới qua đúng những bài kiểm thử mà mã cũ qua. Ở giai đoạn này, cưỡng lại ý muốn cải tiến.
  4. Sửa cho đúng giọng ngôn ngữ mới, với bộ kiểm thử làm lưới an toàn. Giờ mới cải thiện thiết kế, từng thay đổi một, chạy lại kiểm thử tương đương sau mỗi thay đổi.
  5. Bóp nghẹt dần. Đưa mã mới vào dùng từ từ — mô hình "cây đa bóp cổ" (strangler fig) của Fowler: xây chức năng mới quanh hệ thống cũ, chuyển hành vi sang từng phần, chấp nhận một kiến trúc chuyển tiếp trong đó cũ và mới cùng sống, và chỉ dỡ cái cũ khi không còn gì gọi tới nó. Như thay từng cây cột trong khi mái nhà vẫn được chống.

Trình tự này tách hai loại rủi ro. Dịch có nguy cơ đổi hành vi; tái cấu trúc có nguy cơ đổi hành vi trong lúc đổi cấu trúc. Làm chúng ở hai lượt riêng, lượt nào cũng có kiểm thử soát, thì khi có gì gãy, ta biết loại thay đổi nào làm gãy.


5. Quy trình từng bước

Một sổ tay chuyển đổi bằng trò chuyện

Dưới đây là một phương pháp chung để chuyển một module mã cũ bằng cách ra lệnh, dù công cụ là GitHub Copilot ở chế độ agent, Claude Code, hay agent nào khác. Các lời nhắc mẫu viết bằng tiếng Việt cho dễ đọc — các công cụ này hiểu tiếng Việt tốt, dù nhiều người vẫn quen ra lệnh bằng tiếng Anh. Đó là ví dụ, không phải thần chú.

Bước 0 — Đặt luật nhà một lần. Cả hai công cụ lớn đều đọc một tệp chỉ dẫn cấp dự án: GitHub Copilot đọc .github/copilot-instructions.md, Claude Code đọc CLAUDE.md. Ghi vào đó những luật thường trực của cuộc chuyển đổi, để phiên làm việc nào cũng bắt đầu với chúng: ngôn ngữ và phiên bản framework đích; quy ước đặt tên; cách ánh xạ kiểu dữ liệu (ví dụ: "kiểu Currency của VB6 và trường số thập phân của COBOL luôn thành decimal của C#, không bao giờ là double"); luật rằng lượt dịch không được đổi hành vi; kiểm thử nằm đâu, chạy thế nào. Riêng tệp này đã ngăn được phần lớn sự xê dịch mà Thoughtworks cảnh báo, vì agent thôi tự quyết lại quy ước ở mỗi phiên.

Bước 1 — Kiểm kê. Xin bản đồ trước khi xin bất cứ dòng mã nào.

Liệt kê mọi module, form, class và thủ tục trong dự án. Với mỗi cái, một dòng về việc nó làm, nó gọi module nào, module nào gọi nó, và nó đụng tới tệp, bảng dữ liệu hay thành phần ngoài nào. Đánh dấu mọi chỗ dùng control COM/ActiveX, đọc ghi tệp, biến toàn cục, hoặc On Error Resume Next.

Với hệ thống lớn, làm từng phần và lưu kết quả thành tệp trong kho mã, để bản đồ tích lũy dần và kiểm được.

Bước 2 — Giải thích sâu một phần. Chọn một phần có ranh giới rõ, độ phức tạp vừa phải.

Giải thích thủ tục TinhPhi như đang viết đặc tả cho một lập trình viên mới. Liệt kê đầu vào, đầu ra, tác dụng phụ. Liệt kê mọi quy tắc nghiệp vụ, kể cả trường hợp biên, xử lý lỗi, mọi chỗ làm tròn hay cắt bớt. Chỗ nào không chắc thì ghi CHƯA CHẮC và nói vì sao.

Câu "chỗ nào không chắc thì ghi CHƯA CHẮC" quan trọng hơn mọi câu khác. Agent hữu ích hơn hẳn khi được mời nói ra sự không chắc chắn, và danh sách CHƯA CHẮC chính là danh sách câu hỏi mang đi hỏi chuyên gia nghiệp vụ.

Bước 3 — Ghi lại hành vi cũ. Trước khi dịch, chụp lại hành vi.

Đề xuất các ca kiểm thử cho TinhPhi đủ để phát hiện bất kỳ thay đổi hành vi nào: giá trị thường, giá trị biên, số không và số âm, giá trị lớn nhất mà trường dữ liệu chứa được, và mọi nhánh trong mã. Với mỗi ca, cho đầu vào. Đừng đoán đầu ra; chúng tôi sẽ ghi đầu ra bằng cách chạy bản gốc.

Rồi chạy mã cũ với những đầu vào ấy và ghi kết quả — gọi là "mẫu vàng" (golden master). Agent có thể viết luôn bộ khung chạy. Kết quả mong đợi phải đến từ hệ thống cũ, không bao giờ từ mô hình.

Bước 4 — Dịch sát.

Dịch TinhPhi sang C# trong namespace Legacy.Phi. Giữ nguyên hành vi, kể cả làm tròn, cắt bớt và các trường hợp lỗi, kể cả chỗ trông như sai. Không tái cấu trúc. Ghi chú ở mọi chỗ bạn phải chọn một điều mà bản gốc không nói rõ.

Bước 5 — So. Chạy mã đã dịch với mẫu vàng. Mỗi chỗ lệch là một lỗi dịch, một phụ thuộc ẩn (biến toàn cục mã cũ đọc), hoặc một khác biệt về môi trường chạy (dấu chấm động, ngày tháng, xử lý chuỗi). Bảo agent giải thích từng chỗ lệch trước khi sửa; lời giải thích là chỗ hệ thống dạy ta một điều gì đó.

Bước 6 — Tái cấu trúc. Chỉ khi bản dịch sát đã qua hết:

Tái cấu trúc TinhPhi cho đúng phong cách C#: thay trạng thái toàn cục bằng tham số, tách thành phương thức nhỏ, dùng LINQ ở chỗ rõ ràng hơn. Sau mỗi thay đổi, kiểm thử tương đương phải vẫn qua. Cho tôi xem kế hoạch trước khi bắt đầu.

Bước 7 — Đọc lại như một người đi trước. Đọc kết quả như đọc pull request của đồng nghiệp. Agent viết; bạn chịu trách nhiệm. Bài về năng suất trong loạt này nói về "nghịch lý giám sát": giám sát agent cho giỏi cần kỹ năng phán xét việc nó làm. Trong chuyển đổi mã, kỹ năng ấy gồm cả việc hiểu ngôn ngữ cũ đủ để nhận ra một bản dịch trung thành-mà-không-trung-thành — đó là lý do người rành VB6, COBOL hay FORTRAN không bị agent làm cho vô dụng. Họ trở thành người nghiệm thu.

Bước 8 — Lặp lại, và giữ bản đồ cập nhật. Sang phần kế tiếp. Cập nhật bản kiểm kê, tệp chỉ dẫn, danh sách CHƯA CHẮC khi học thêm. Một cuộc chuyển đổi là một cuộc trò chuyện dài, và các tệp trong kho mã là trí nhớ của nó.


6. Một ví dụ bịa, đi từ đầu tới cuối

Phương pháp áp vào một module không có thật

Để các bước cụ thể mà không đụng tới mã thật của ai, đây là phương pháp áp vào một ví dụ bịa: một module VB6 tên modPhiVanChuyen, tưởng tượng ra cho bài này, trong một ứng dụng bán hàng. Không có gì dưới đây đến từ hệ thống thật.

Kiểm kê. Bản đồ của agent cho thấy module có ba hàm công khai, được gọi từ một form đặt hàng và một báo cáo cuối ngày, đọc một biến toàn cục gVungGiao đặt lúc đăng nhập, và mở một bảng Access chứa biểu phí theo cân nặng. Nó đánh dấu một chỗ On Error Resume Next và một tham số kiểu Variant.

Giải thích. Được bảo giải thích hàm TinhPhiShip, agent viết một trang đặc tả: phí cơ bản theo vùng, cộng phụ phí theo mỗi kilôgam vượt mức, miễn phí cho đơn trên một ngưỡng, làm tròn tới đơn vị tiền. Danh sách CHƯA CHẮC có ba mục. Nó không biết tham số Variant có bao giờ nhận Null không. Nó thấy ngưỡng miễn phí so bằng > chứ không phải >=, nên đơn đúng bằng ngưỡng vẫn bị tính phí, và hỏi có cố ý không. Và nó để ý rằng On Error Resume Next quanh chỗ tra biểu phí nghĩa là nếu bảng bị thiếu, phí sẽ lặng lẽ thành không.

Hỏi chuyên gia. Người phụ trách nghiệp vụ xác nhận Null được truyền khi khách chưa chọn địa chỉ; nói dấu > có lẽ là lỗi nhưng chính sách đã in trên website theo đúng cách tính ấy, nên giữ; và giật mình về chuyện phí lặng lẽ thành không — điều giải thích một khiếu nại lạ từ một chi nhánh mấy năm trước.

Ghi hành vi cũ. Agent đề xuất bốn mươi tổ hợp đầu vào: từng vùng, cân nặng quanh các mức, đơn quanh ngưỡng miễn phí, khách chưa có địa chỉ, và trường hợp thiếu bảng. Một bộ khung nhỏ gọi hàm VB6 cũ qua giao diện COM sẵn có và ghi lại kết quả. Đó là mẫu vàng.

Dịch sát. Bản C# trung thành giữ phép tính decimal, giữ dấu > (kèm ghi chú dẫn quyết định của chuyên gia), một tham số khách hàng kiểu nullable rõ ràng, và — có chủ ý — giữ cả cái lỗi bị nuốt, bọc trong một phương thức đặt tên rõ ràng có ghi nhật ký. Ba mươi tám trên bốn mươi bài qua ngay.

Giải thích chỗ lệch. Hai bài lệch một đơn vị tiền. Được hỏi vì sao, agent tìm ra mã cũ làm tròn bằng hàm Round của VB6, vốn làm tròn kiểu ngân hàng (nửa về số chẵn), trong khi bản dịch dùng làm tròn nửa ra xa số không vì tệp chỉ dẫn ghi vậy cho mã kiểu COBOL. Thêm một dòng vào tệp chỉ dẫn — "Round của VB6 ánh xạ tới MidpointRounding.ToEven" — và cả bốn mươi bài qua.

Tái cấu trúc. Kiểm thử xanh rồi, biến toàn cục thành tham số, phần tra biểu phí chuyển ra sau một interface, và cái lỗi lặng lẽ thành một phương án dự phòng có ghi nhật ký mà giờ doanh nghiệp đã biết và chọn. Kiểm thử vẫn xanh sau từng bước.

Chuyển giao. Form đặt hàng gọi thành phần C# mới qua một lớp chuyển tiếp mỏng, còn báo cáo vẫn gọi module cũ; cả hai chạy một tháng, kết quả so mỗi đêm. Không có chỗ khác. Module cũ được cho nghỉ hưu.

Ví dụ bịa thì nhỏ, nhưng chứa đủ hình dạng của công việc thật: agent nhanh và phần lớn đúng; sản phẩm quý nhất của nó là danh sách những điều nó chưa chắc; chuyên gia quyết định thế nào là "đúng"; kiểm thử bắt được chỗ lệch một đồng mà mắt người có thể bỏ sót; và hiểu biết thu được — rằng một bảng bị thiếu đã lặng lẽ làm mất phí suốt mấy năm — đáng giá dù cuộc chuyển đổi có xong hay không.


7. Bẫy khi chuyển VB6 sang VB.NET hay C#

Chỗ một bản dịch trông trung thành mà sai

VB6 và VB.NET trông giống nhau đến mức người ta tưởng chuyển đổi chủ yếu là đổi cú pháp. Không phải. Hai ngôn ngữ chung từ khóa mà không chung ngữ nghĩa, và phần lớn lỗi chuyển đổi nằm trong khe hở ấy. Agent biết rõ những khác biệt này khi được hỏi, nhưng không phải lúc nào cũng tự áp dụng, nên chúng thuộc về tệp chỉ dẫn và danh sách kiểm tra khi đọc lại.

Kích thước số nguyên đã đổi. Trong VB6, Integer là 16-bit, Long là 32-bit. Trong VB.NET và C#, Integer/int là 32-bit, Long/long là 64-bit. Một Integer VB6 tràn ở 32.767 — và mã dựa vào chuyện tràn ấy, hay bắt lỗi tràn ấy — sẽ cư xử khác sau một bản dịch đổi-từ-khóa-cho-từ-khóa.

Variant không phải Object. Variant mang theo kiểu con và tự chuyển đổi ngầm, kể cả hai giá trị nổi tiếng Empty và Null với luật so sánh riêng. Ánh xạ mọi Variant thành Object thì biên dịch được rồi hỏng lúc chạy, hoặc tệ hơn, lặng lẽ đổi kết quả so sánh.

Xử lý lỗi mang tính cấu trúc. On Error GoTo và On Error Resume Next không có tương đương trực tiếp trong C#; VB.NET vẫn giữ chúng cho tương thích — tự nó cũng là một cái bẫy. Resume Next nghĩa là "lờ lỗi đi mà chạy tiếp" — đôi khi cố ý, thường là vô tình. Mỗi chỗ dùng cần một quyết định.

Tham số mặc định truyền tham chiếu. VB6 truyền ByRef nếu không nói gì; VB.NET và C# truyền theo giá trị. Một thủ tục VB6 sửa tham số để trả về kết quả thứ hai sẽ lặng lẽ thôi làm thế.

Mảng và tập hợp bắt đầu ở chỗ khác nhau. Mảng VB6 có thể có cận dưới bất kỳ, Option Base 1 đổi cận mặc định; Collection của VB6 đánh số từ 1. Mảng .NET đánh số từ 0. Lệch một đơn vị là lỗi kinh điển của chuyển đổi VB6.

Chuỗi độ dài cố định, Currency, Date, thuộc tính mặc định, ràng buộc muộn, và nền tảng xung quanh — form với mảng control, DoEvents, recordset DAO/ADO, control ActiveX của bên thứ ba, Format$ với mẫu riêng của VB6, lệnh in, khai báo Windows API rải rác. Tuyên bố hỗ trợ của Microsoft ghi rõ control OCX của bên thứ ba hoàn toàn không được họ hỗ trợ; đó thường là phần khó nhất.

Một ví dụ tự viết về bẫy số nguyên. Giả sử một hàm VB6 đếm số dòng hóa đơn:

' VB6 (minh họa)
Function DemDong(ds As Collection) As Integer
    Dim i As Integer, dem As Integer
    For i = 1 To ds.Count
        If ds(i).SoLuong > 0 Then dem = dem + 1
    Next i
    DemDong = dem
End Function

Bản dịch ngây thơ:

// Ngây thơ
int DemDong(List<DongHoaDon> ds)
{
    int dem = 0;
    for (int i = 1; i <= ds.Count; i++)      // sai: List đánh số từ 0
        if (ds[i].SoLuong > 0) dem++;
    return dem;
}

vừa lệch chỉ số (bỏ phần tử đầu, văng lỗi ở phần tử cuối), vừa lặng lẽ bỏ giới hạn 32.767 của Integer VB6 — một giới hạn mà mã cũ có thể đã từng gây lỗi tràn và có một đoạn bắt lỗi ở chỗ khác dựa vào đó. Bản trung thành phải duyệt từ 0, và quyết định có ý thức: giữ short để tái tạo giới hạn cũ, hay dùng int và ghi chú rằng hành vi khi tràn đã thay đổi theo chủ ý.


8. Bẫy khi chuyển COBOL sang C#

Số thập phân, bố cục dữ liệu, và cái mainframe quanh mã

Bẫy của COBOL ít nằm ở cú pháp hơn là ở hai thứ mà ngôn ngữ hiện đại xử lý khác: dữ liệu thập phân, và môi trường chương trình chạy.

Mệnh đề PIC định nghĩa phép tính. Một trường khai báo PIC S9(5)V99 là số có dấu với năm chữ số nguyên và hai chữ số thập phân ngầm. Phép tính trên nó là thập phân, dấu phẩy cố định, và kết quả vượt quá trường sẽ bị cắt mất ở bên trái — chữ số hàng cao lặng lẽ biến mất — trừ khi có ON SIZE ERROR bắt lại. Ánh xạ tự nhiên sang C# là decimal, kiểu cơ số mười, nhưng decimal không tự cắt khi tràn như trường COBOL, và chứa nhiều chữ số hơn trường.

Làm tròn là tường minh, mặc định là cắt bớt. COMPUTE X ROUNDED = ... thì làm tròn; không có ROUNDED thì cắt. Math.Round của C# mặc định làm tròn kiểu ngân hàng (nửa về số chẵn); ROUNDED của COBOL theo truyền thống làm tròn nửa ra xa số không. Sai chỗ này tạo ra chênh lệch một xu trên một phần nhỏ giao dịch — đúng loại chênh lệch qua được kiểm thử qua loa và trượt ở kiểm toán.

Định dạng lưu trữ. COMP-3 (số thập phân nén), COMP (nhị phân), định dạng hiển thị quyết định cách số nằm trong bản ghi và tệp. Dữ liệu chuyển từ tệp mainframe phải được giải mã đúng, thường từ EBCDIC chứ không phải ASCII — điều cũng đổi thứ tự sắp xếp ký tự.

REDEFINES, copybook, điều kiện cấp 88, PERFORM THRU, GO TO — cùng một vùng byte nhìn theo nhiều cấu trúc; định nghĩa bản ghi dùng chung qua nhiều chương trình; tên điều kiện thành boolean hay enum; luồng điều khiển chạy qua một dải đoạn văn.

Mainframe là một phần của chương trình. Chương trình lô được JCL điều phối; chương trình trực tuyến chạy dưới CICS; dữ liệu nằm trong VSAM, IMS hay DB2. Mã COBOL một mình không mô tả một job lô làm gì — JCL quyết định tệp nào vào, tệp nào ra, theo thứ tự nào. Đó là ý của Thoughtworks khi nói "một hệ thống lớn hơn mã".

Một ví dụ tự viết về bẫy cắt bên trái:

      * COBOL (minh họa)
       01  WS-TONG      PIC S9(5)V99.
           ADD WS-TIEN-HD TO WS-TONG.

Nếu WS-TONG đang là 99.990,00 và cộng thêm 20,00, kết quả đúng về toán học là 100.010,00 — nhưng trường chỉ chứa năm chữ số nguyên, nên COBOL (không có ON SIZE ERROR) lặng lẽ cắt còn 00.010,00. Bản C# ngây thơ tong += tienHd; sẽ cho 100.010,00 — "đúng hơn", nhưng khác hành vi cũ. Bản trung thành phải chọn tái tạo đúng sự cắt bớt ấy:

// Tái tạo trường PIC S9(5)V99: cắt chữ số hàng cao khi tràn
decimal CongPic5V2(decimal a, decimal b)
{
    decimal r = a + b;
    return r % 100_000m;   // giữ năm chữ số nguyên, như COBOL không có SIZE ERROR
}

hoặc ném lỗi và để con người quyết định — vì một tổng bị cắt thường là một con bọ chưa ai phát hiện. Bài kiểm thử mẫu vàng phải có giá trị sát giới hạn trường, nếu không chỗ này sẽ không bao giờ lộ ra.


9. Bẫy khi chuyển FORTRAN sang C#

Mảng, con số, và câu hỏi có nên dịch hay không

FORTRAN cũ thường là mã khoa học hay kỹ thuật, nơi độ đúng được đo bằng những con số kỹ sư đã tin. Điều đó đổi bản chất cuộc chuyển đổi: câu hỏi không phải "có làm đúng quy tắc nghiệp vụ không" mà "có tính ra cùng giá trị không, trong sai số cho phép".

Mảng theo cột và đánh số từ 1. FORTRAN lưu A(I,J) với chỉ số đầu chạy nhanh nhất; mảng C# về bản chất theo hàng và đánh số từ 0. Một bản dịch giữ thứ tự vòng lặp mà đổi quy ước chỉ số có thể đúng mà rất chậm; một bản "sửa" thứ tự thiếu cẩn thận có thể sai.

Kiểu ngầm định. Nếu không có IMPLICIT NONE, biến bắt đầu bằng I tới N là số nguyên, còn lại là số thực. Một biến gõ sai chính tả trong FORTRAN cũ lặng lẽ tạo ra một biến mới. Nên bảo agent đánh dấu mọi biến kiểu ngầm định, vì vài cái trong số đó là lỗi mà kết quả cũ đã lặng lẽ "hấp thụ".

COMMON và EQUIVALENCE. Vùng nhớ toàn cục dùng chung và biến chồng lên nhau tràn ngập trong mã cũ. Bản dịch trung thành là một đối tượng trạng thái dùng chung; bản đúng giọng C# là tham số và giá trị trả về — chỉ tới được sau khi đã chứng minh tương đương.

Dấu chấm động không mang đi được tới bit cuối. Trình biên dịch khác, mức tối ưu khác, tập lệnh khác có thể đổi thứ tự phép tính, nên kết quả FORTRAN có khi đã khác nhau giữa hai bản build của cùng một mã. Kiểm thử tương đương cho mã số học phải dùng sai số cho phép do người hiểu vật lý hay kỹ thuật chọn — và chính sai số ấy là một quyết định thiết kế cần ghi lại.

Có nên dịch không? Với lõi tính toán, câu trả lời thành thật đôi khi là không. Fortran hiện đại là ngôn ngữ được hỗ trợ, hiệu năng cao. Một lối thường gặp là giữ lõi tính toán đã được kiểm chứng bằng Fortran (hiện đại hóa theo chuẩn mới nếu cần), biên dịch thành thư viện native, rồi gọi từ ứng dụng C# cho mọi thứ xung quanh — nhập liệu, xuất kết quả, giao diện, tích hợp. Như trùng tu nhà cổ: có những cây cột lim trăm năm vẫn chắc, thay đi mới là phá.

Nghiên cứu về dịch Fortran bằng mô hình ngôn ngữ đang sôi nổi và thận trọng. Một nghiên cứu do Los Alamos dẫn dắt, dịch mã FORTRAN cũ sang C++ có LLM hỗ trợ (2025), đặt mục tiêu đo độ biên dịch được và độ giống kết quả, vì theo lời tác giả việc dịch như vậy "chưa được đánh giá hay định lượng kỹ về tính dùng được". Công trình có đồng tác giả ở Lawrence Livermore, Fortran2CPP, dùng hội thoại nhiều lượt giữa các agent để cải thiện bản dịch. Đích ở đó là C++, không phải C#, nhưng bài học áp dụng được: coi kết quả của agent là bản nháp mà hành vi số học phải được xác minh.

Một ví dụ tự viết về bẫy kiểu ngầm định:

C     FORTRAN 77 (minh họa)
      TONG = 0.0
      DO 20 K = 1, N
        TONG = TONG + X(K)
   20 CONTINUE
      TB = TONGG / N

Dòng cuối gõ nhầm TONGG. Không có IMPLICIT NONE, FORTRAN lặng lẽ tạo biến thực mới TONGG — giá trị không xác định, thường là không — và TB sai. Nếu kết quả cũ đã sai như thế suốt nhiều năm, một bản dịch "đúng" sang C# sẽ cho kết quả khác. Agent được dặn đánh dấu mọi biến ngầm định sẽ chỉ ra TONGG ngay; còn việc sửa hay tái tạo lỗi là quyết định của người hiểu con số ấy được dùng vào đâu.


10. Chứng minh tương đương

Phần làm cho mọi phần khác an toàn

Mọi nguồn trong bài — bài của chính Anthropic, lời phản biện của Thoughtworks, sự nhấn mạnh của AWS về tương đương chức năng, mô hình "cây đa bóp cổ" của Fowler — đồng ý một điều: chuyển đổi chỉ tốt bằng bằng chứng rằng hệ thống mới làm đúng điều hệ thống cũ làm. Agent làm việc dịch rẻ đi. Nó không làm việc chứng minh rẻ đi — dù làm cho việc dựng bằng chứng rẻ hơn nhiều.

Kiểm thử ghi nhận hành vi. Michael Feathers, trong cuốn Working Effectively with Legacy Code, định nghĩa mã cũ là mã không có kiểm thử, và đề xuất "kiểm thử ghi nhận" (characterization tests): ghi lại mã thật sự làm gì, chứ không phải nó nên làm gì. Trong chuyển đổi, hành vi của hệ thống cũ là đặc tả — kể cả lỗi — cho tới khi con người quyết định khác.

Mẫu vàng. Với hệ thống lô, chạy chương trình cũ trên một tập lớn đầu vào thật (đã ẩn danh), giữ kết quả, và đòi chương trình mới tái tạo y hệt. Với job lô COBOL và tính toán FORTRAN, đây thường là tài sản kiểm thử quý nhất của cả dự án.

Kiểm thử đối chiếu. Đưa cùng đầu vào sinh tự động cho cả hai hệ thống rồi so. Agent viết giỏi những bộ sinh đầu vào chạm biên: kích thước trường lớn nhất, số không, số âm, chuỗi rỗng, ngày cuối tháng, năm nhuận.

Sai số, một cách có chủ ý. Logic nghiệp vụ thập phân phải khớp tuyệt đối. Kết quả kỹ thuật dấu chấm động phải khớp trong sai số đã thống nhất với chuyên gia. Ngày giờ cần cẩn thận với mốc thời gian và múi giờ của từng môi trường.

Chạy song song. Trước khi chuyển hẳn, chạy cũ và mới cùng lúc trên dữ liệu thật, so kết quả, điều tra từng chỗ khác.

Agent đứng ở đâu. Agent đề xuất ca kiểm thử, viết bộ khung, sinh đầu vào, giải thích chỗ lệch, sửa bản dịch. Nó không bao giờ được cung cấp kết quả mong đợi cho kiểm thử ghi nhận; kết quả ấy đến từ việc chạy hệ thống gốc. Phỏng đoán của agent về chuyện mã cũ trả về gì chính là thứ đang bị kiểm tra.


11. Dữ liệu, con người, và tài liệu

Ba phần của cuộc trùng tu mà mã nguồn không kể

Dữ liệu là một dự án riêng. Ứng dụng VB6 hay lưu dữ liệu trong cơ sở Access (Jet), tệp phẳng, tệp INI, hay một lược đồ SQL Server thiết kế từ thập niên 1990; cách Jet xử lý ngày, chuỗi rỗng và Null, so sánh không phân biệt hoa thường đều phải được tái tạo hoặc đổi có chủ ý. Hệ thống COBOL giữ dữ liệu trong VSAM, tệp tuần tự, IMS hay DB2, với bố cục do copybook định nghĩa, số nén, chữ EBCDIC, và những trường đổi nghĩa tùy một mã nằm chỗ khác trong bản ghi. Chương trình FORTRAN thường đọc "bộ bìa" nhập liệu định dạng cố định và xuất kết quả mà công cụ hạ nguồn — hay bảng tính của kỹ sư — đọc theo vị trí cột. Agent giúp được nhiều: đọc copybook rồi sinh cả class C# lẫn bộ đọc bản ghi nén; viết kịch bản chuyển và, quan trọng hơn, báo cáo đối soát so số bản ghi, tổng các trường then chốt, mẫu ngẫu nhiên giữa kho cũ và mới. Nhưng luật vẫn vậy: agent viết phép soát, và phép soát — không phải lời cam đoan của agent — quyết định dữ liệu có đến nơi nguyên vẹn không.

Con người đổi vai. Một cuộc chuyển đổi lớn bằng trò chuyện cần bốn vai. Chuyên gia nghiệp vụ biết hệ thống để làm gì; đóng góp chính của họ là trả lời danh sách CHƯA CHẮC và quyết định hành vi lạ nào cần giữ — thời gian của họ là thứ khan hiếm nhất. Người đọc mã cũ rành ngôn ngữ cũ; giờ họ trước hết là người nghiệm thu, người phát hiện bản dịch đúng cú pháp mà sai ngữ nghĩa. Tổ chức nào nghĩ agent làm những người này thừa sẽ hiểu ra họ cần thiết thế nào ở chỗ lệch làm tròn đầu tiên trên môi trường thật. Người giữ kiểm thử dựng và duy trì bộ mẫu vàng, quyết định sai số cùng chuyên gia — trong nhiều nhóm đây là vai quan trọng nhất. Và người điều khiển agent viết tệp chỉ dẫn, chia việc, ra lệnh, soát lại. Tiến độ nên đo bằng tương đương, không bằng số dòng: "312 trên 540 thủ tục đã dịch" nói ít; "212 thủ tục qua kiểm thử mẫu vàng, 58 đang chạy thật sau lớp chuyển tiếp" nói nhiều.

Tài liệu là lãi ngầm. Kết thúc một cuộc chuyển đổi bằng trò chuyện, hệ thống có tài liệu — nhiều khi lần đầu tiên. Mỗi phần agent giải thích ở bước 2 là một bản đặc tả. Mỗi mục CHƯA CHẮC được chuyên gia trả lời thành một quy tắc nghiệp vụ được ghi lại. Bản kiểm kê thành sơ đồ kiến trúc. Bộ kiểm thử ghi nhận thành tài liệu chạy được về chuyện hệ thống thật sự làm gì. DevGen.AI của Morgan Stanley được dựng quanh đúng sản phẩm ấy, vì bản mô tả có giá trị tự thân: chúng cho bất kỳ lập trình viên nào, chứ không riêng nhóm chuyên gia ngày càng ít, làm việc được với hệ thống. Như người thợ trùng tu để lại bộ hồ sơ đo vẽ cho đời sau — thứ mà người dựng nhà ban đầu chưa bao giờ để lại.


12. Giữ bí mật mã nguồn

Ràng buộc đã định hình bài viết này

Phần lớn hệ thống cũ thuộc về công ty, và mã của nó là bí mật. Bài này không có dòng mã nào từ cuộc chuyển đổi của chính người viết vì đúng lý do đó. Ai làm việc này ở công ty cũng gặp câu hỏi ấy trước tiên: có được gửi mã này cho một dịch vụ AI không, và theo điều khoản nào?

Câu trả lời tùy vào gói dịch vụ và hợp đồng, không tùy vào thương hiệu, và phải được bộ phận an ninh và pháp chế của công ty xác nhận. Điều khoản công bố của hai nhà cung cấp cho thấy nên tìm gì.

GitHub Copilot. Bài của GitHub về Trung tâm Tin cậy Copilot nói Copilot for Business "không dùng mã của bạn để huấn luyện" mô hình, khác với gói cá nhân nơi người dùng có thể chọn tham gia, và mô tả lời nhắc trong trình soạn thảo chỉ được gửi đi để tạo gợi ý theo thời gian thực rồi xóa. Thời gian lưu cho các bề mặt khác, như dòng lệnh hay agent, có thể khác, nên tổ chức cần kiểm tra mục hỏi đáp hiện hành cho đúng những bề mặt lập trình viên của mình dùng.

Anthropic. Điều khoản thương mại của Anthropic ghi: "Anthropic không được huấn luyện mô hình trên Nội dung Khách hàng từ Dịch vụ", và khách hàng "giữ mọi quyền với Đầu vào" và "sở hữu Đầu ra". Những điều khoản ấy áp cho dùng thương mại như API và gói doanh nghiệp; gói cá nhân có điều khoản riêng.

Ngoài hợp đồng, vài thói quen giảm rủi ro bất kể nhà cung cấp nào: dùng gói doanh nghiệp công ty đã duyệt, không dùng tài khoản cá nhân cho mã của công ty; dùng cơ chế loại trừ nội dung và tệp bỏ qua để giữ bí mật, thông tin đăng nhập và tệp nhạy cảm ngoài tầm với của agent; không bao giờ dán dữ liệu thật — mẫu vàng phải dùng dữ liệu đã ẩn danh hay tổng hợp; nhốt agent trong hộp cát, như bài về lạm dụng trong loạt này lập luận; và khi chia sẻ điều đã học, hãy viết về phương pháp, không phải về mã — đúng như bài này làm.


13. VB.NET hay C#?

Chọn ngôn ngữ đích cho hai mươi năm tới

Một bộ mã VB6 dễ kéo cả nhóm về phía VB.NET, vì cú pháp quen và VB.NET còn giữ những tính năng tương thích như On Error. Đó là một đích hợp lệ: Microsoft nói năm 2020 rằng Visual Basic được hỗ trợ trên .NET hiện đại cho thư viện lớp, ứng dụng console, Windows Forms, WPF, worker service và ASP.NET Core Web API. Nhưng cũng bài ấy viết: "chúng tôi không có kế hoạch phát triển Visual Basic như một ngôn ngữ", và những tính năng .NET tương lai cần thay đổi ngôn ngữ "có thể không được hỗ trợ trong Visual Basic".

Với một hệ thống còn phải sống hai mươi năm, C# thường là đích an toàn hơn, và agent dịch VB6 sang C# dễ như sang VB.NET. VB.NET hợp lý như một bậc đệm khi cả nhóm thạo VB và mục tiêu trước mắt là thoát khỏi bộ IDE không còn được hỗ trợ cho nhanh. Còn COBOL và FORTRAN thì đích tự nhiên là C# (hoặc giữ lõi Fortran và gọi từ C#, như mục 9 bàn).

Còn công cụ thì sao? GitHub Copilot ở chế độ agent, với khả năng nâng cấp .NET cho những dự án .NET Framework cũ (GitHub changelog), hợp tự nhiên với những nơi xoay quanh VB6 và .NET, đã sẵn trong Visual Studio. Claude Code mạnh ở những phiên dài, nhiều tệp, và ở các bước nặng phân tích mà bài của Anthropic mô tả. AWS Transform được dựng riêng cho COBOL mainframe sang Java ở quy mô lớn. Cuộc chuyển đổi của chính người viết được làm bằng Copilot, chỉ bằng ra lệnh — và đó là điểm thành thật: một phương pháp kỷ luật với một công cụ phổ thông thường thắng một công cụ chuyên dụng mà dùng không có phương pháp.


14. Đôi lời của người trong cuộc

Những gì nói được mà không cần cho xem mã

Người viết đã hoàn tất một cuộc chuyển đổi mã cũ ở chỗ làm, bằng GitHub Copilot, bằng cách ra lệnh chứ không tự tay viết mã mới. Mã nguồn ở lại trong công ty, và chi tiết của hệ thống không phải của tôi để chia sẻ. Điều nói được thì hẹp hơn nhưng, tôi nghĩ, hữu ích hơn: việc này làm được. Một lập trình viên bình thường, với một công cụ phổ thông, một phương pháp rõ ràng và kỷ luật kiểm thử, có thể đưa mã cũ thật sang một ngôn ngữ .NET hiện đại qua trò chuyện.

Những bài học chung là những điều các nguồn ở trên đã dự báo, và ai định làm cũng nên chờ đón: agent nhanh nhất ở đúng những phần từng chậm nhất — đọc, giải thích, viết nháp. Thời gian của con người dời sang quyết định và soát lại. Tệp chỉ dẫn và bản kiểm kê là thứ giữ cho một cuộc chuyển đổi dài được nhất quán. Bộ kiểm thử là thứ làm cho việc tin vào kết quả trở nên an toàn. Và hiểu biết về ngôn ngữ cũ không trở nên vô dụng; nó thành con mắt của người nghiệm thu, bắt được bản dịch biên dịch được, qua được cái liếc mắt, mà sai.


15. Khi nào không nên chuyển

Những ngoại lệ thành thật

Một bài lập luận rằng chuyển đổi đã rẻ đi nợ người đọc những trường hợp nó vẫn là nước đi sai.

Khi hệ thống cũ ổn định, được hỗ trợ, ít thay đổi. Ứng dụng VB6 chạy trên runtime được hỗ trợ trên Windows 11. Một job lô COBOL chạy không đổi mười lăm năm có thể rẻ hơn khi bọc sau một API thay vì thay thế. Chuyển đổi được biện minh bằng những gì nó mở ra — tính năng mới, người mới, nền tảng mới — không phải bằng tuổi tác. Nhà cổ chưa mục thì chưa cần thay cột.

Khi con số đã được tin và mã không phải là vấn đề. Lõi khoa học đã kiểm chứng thường nên hiện đại hóa tại chỗ hoặc bọc lại.

Khi không ai nói được thế nào là đúng. Nếu không ghi nhận được đầu ra — không có đầu vào tiêu biểu, không có chuyên gia, không có tiêu chí nghiệm thu — thì chuyển đổi chỉ thay một hệ thống không ai hiểu bằng một hệ thống không ai kiểm chứng được. Dự án đầu tiên lúc ấy là ghi nhận hành vi, không phải dịch.

Khi tổ chức không chịu đổi. Lời khuyên cuối trong bài "cây đa bóp cổ" của Fowler áp dụng ở đây: hệ thống cũ phản chiếu những quy trình đã sinh ra nó, và không đổi quy trình thì hệ thống mới thành mớ rối mới. Agent dịch mã trong một buổi chiều. Nó không dịch được một nền văn hóa.


Kết: Trò chuyện với ngôi nhà cũ

Ba mươi năm, mã cũ là thứ phải chịu đựng hoặc trốn chạy. Chương trình cũ mù mờ, người hiểu nó lần lượt nghỉ hưu, và mỗi lần định thay nó là một lần đặt cược cả doanh nghiệp. Điều thay đổi năm 2025–2026 là mã cũ trở thành thứ có thể trò chuyện được. Agent đọc một đoạn COBOL hay một form VB6 rồi nói cho ta nó làm gì, bằng lời thường, kèm những chỗ nó chưa chắc. Nó viết nháp bản C# và viết luôn kiểm thử để soát. Nó giải thích vì sao một bài kiểm thử trượt. Ngôi nhà cũ biết kể chuyện về chính mình.

Điều đó không làm việc chuyển đổi dễ. Nó làm việc chuyển đổi làm được. Bước đắt nhất — thấu hiểu — đã rẻ đi; những bước quan trọng nhất — quyết định, kiểm chứng, chuyển giao an toàn — vẫn là việc của con người, nay có công cụ tốt hơn nhiều. Phương pháp hiệu quả là lời khuyên cũ nhất của nghề phần mềm, áp dụng với một người phụ tá mới: hiểu trước khi đổi, kiểm thử trước khi tin, mỗi lần đổi một thứ, và giữ hệ thống cũ chạy cho tới khi hệ thống mới đã xứng đáng thay nó. Cũng là lời khuyên của người thợ trùng tu: đo trước khi tháo, thay từng cột một, và đừng bao giờ dỡ mái khi gia đình còn đang ở trong nhà.

Cuộc chuyển đổi của người viết không cho xem được. Nhưng phương pháp thì cho xem được, và kết luận đã thúc đẩy bài này cũng vậy: nếu bạn có một chương trình VB6, COBOL hay FORTRAN mà ai cũng ngại đụng, thì nỗi sợ giờ chủ yếu nằm ở khâu kiểm thử, không còn ở khâu dịch. Hãy bắt đầu bằng kiểm thử.


Phụ lục A: Bảng kiểm tra các bẫy

Ngôn ngữ cũ Bẫy Cách xử lý trung thành
VB6 Integer 16-bit, Long 32-bit Ánh xạ có chủ ý sang short/int
VB6 Variant, Empty, Null Xác định kiểu thật; đừng mặc định object
VB6 On Error Resume Next / GoTo Quyết định từng chỗ; đừng bọc đại trà
VB6 Tham số mặc định ByRef Dùng ref/out hoặc trả về tuple
VB6 Option Base, Collection đánh số từ 1 Ánh xạ chỉ số tường minh
VB6 Round làm tròn kiểu ngân hàng MidpointRounding.ToEven
VB6 ActiveX/OCX, DAO/ADO, DoEvents Thay bằng control .NET, ADO.NET/ORM, async
COBOL Giới hạn PIC, cắt chữ số hàng cao Tái tạo giới hạn; kiểm thử sát biên
COBOL ROUNDED và cắt bớt mặc định MidpointRounding.AwayFromZero; cắt tường minh
COBOL COMP-3, EBCDIC, thứ tự sắp xếp Giải mã đúng; kiểm tra giả định sắp xếp
COBOL REDEFINES, copybook Ánh xạ kiểu nhất quán từ bản kiểm kê
COBOL JCL, CICS, VSAM/DB2 Coi là một phần hệ thống
FORTRAN Mảng theo cột, đánh số từ 1 Quyết định bố cục tường minh
FORTRAN Kiểu ngầm định Đánh dấu mọi biến ngầm định
FORTRAN COMMON, EQUIVALENCE Đối tượng trạng thái trước, tái cấu trúc sau
FORTRAN Dấu chấm động Sai số thống nhất với chuyên gia

Phụ lục B: Mẫu lời nhắc

  • Kiểm kê: "Liệt kê mọi module và thủ tục; mỗi cái một dòng về mục đích, ai gọi nó, nó gọi ai, đụng tệp/bảng nào; đánh dấu biến toàn cục, COM, đọc ghi tệp, lỗi bị nuốt."
  • Giải thích: "Giải thích phần này như một đặc tả: đầu vào, đầu ra, tác dụng phụ, mọi quy tắc và trường hợp biên, làm tròn/cắt bớt. Chỗ nào chưa chắc ghi CHƯA CHẮC kèm lý do."
  • Ghi nhận: "Đề xuất đầu vào kiểm thử đủ phát hiện mọi thay đổi hành vi, kể cả biên và mọi nhánh. Đừng đoán đầu ra."
  • Dịch: "Dịch sát sang C#; giữ nguyên hành vi kể cả lỗi rõ ràng; không tái cấu trúc; ghi chú mọi lựa chọn mà bản gốc để ngỏ."
  • Giải thích chỗ lệch: "Bài kiểm thử này lệch giữa cũ và mới. Giải thích nguyên nhân trước khi sửa."
  • Tái cấu trúc: "Tái cấu trúc theo phong cách C# từng bước nhỏ; kiểm thử tương đương phải qua sau mỗi bước; cho xem kế hoạch trước."

Nguồn tham khảo


Written by: Claude AI.

Curator/Editor: Học Trò.

Mọi trích dẫn đều phải ghi chú với dòng trên và nói rõ bài khảo luận được lấy từ trang https://hoctroviet.blogspot.com/

No comments: