The problem
Many banks and insurers still run important work on VB6 desktop applications, classic ASP sites and COM components. The people who wrote them have moved on, the tools are long out of support, and every change is a risk. Everyone agrees they should move to Java or .NET. Few want to fund the rewrite, because they have seen one go wrong.
Rewrites go wrong in the same places. Line-by-line translation produces Java that is still VB6 in structure, with module-level state everywhere and errors swallowed by On Error Resume Next, and nobody wants to maintain it. A clean rewrite from a spec loses the behaviour nobody wrote down: the rounding rule, the date that defaults to the last working day, the field that is quietly cut to forty characters. Those differences surface after go-live, as customer complaints.
Good looks like this: one seam moved at a time, so the old system keeps running; new code that reads as if it were written for Spring Boot or .NET; and evidence, in the form of tests run against both systems, that the new code gives the same answers as the old, with every intended difference written down and approved.
How it works
Forge Port is built on demand in your engagement. We run legacy modernisation in four steps: map the code, specify it, cut seams, then rebuild and retire one seam at a time. Forge Port does the last step.
For each seam it reads three things: the legacy source (VB6 forms and modules, ASP pages, COM interfaces), the functional spec the business signed off for that seam, and a set of inputs and outputs recorded from the running system. The spec says what the code should do. The legacy source says what it actually does. The recordings settle disagreements between the two.
It is steered by your target standards: the Spring Boot or .NET version, project layout, how you handle errors, logging and transactions, and which libraries are allowed. These live in rules and skills, so every seam comes out in the same shape no matter who runs it.
It writes the new code for the seam in the target stack, and parity tests: the recorded inputs replayed against the old system and the new one, with outputs compared field by field. It also lists every place where it chose to differ from the legacy behaviour, and every legacy behaviour it could not explain.
Then it is checked. The code has to build, pass your static checks and pass the parity tests. A seam is not done while a parity test fails without an approved reason. An engineer reviews the code, and a business owner approves each listed difference, before the seam is switched over and the old code for it is retired.
Where it gets it wrong
- It carries old habits across. Translated code can keep the legacy structure. The target-stack rules catch most of it, and the reviewing engineer rejects anything that reads like VB6 written in Java.
- Parity is only as good as the recordings. A path the recorded cases never exercised is not proven. We report which parts of the legacy code the recordings reach, so the gaps are visible, and record more cases before switching over.
- Some legacy behaviour is a bug. Matching the old system exactly would keep the bug. The agent flags behaviour it suspects is wrong, and the business owner decides whether to keep it or fix it.
- Not every COM or third-party control has an equivalent. Where a component has no clean replacement, it says so and stops, rather than inventing a library or a workaround.
Why not just prompt a chatbot
A chatbot will translate a VB6 module into Java, and the result will often compile. It will not show that the Java behaves like the VB6, keep to your target architecture across hundreds of modules, or tell you which behaviour it changed. The parity harness, the target-stack rules, the one-seam-at-a-time discipline and the list of differences for sign-off are the work. They are what make a seam safe to switch over.
What you get
- In your engagement: we build Forge Port for your legacy stack and your target, and use it to rebuild and switch over one seam at a time.
- Under your brand: services firms can run it inside their own modernisation programmes and platforms, with their own target standards.
- Built to own: we build it for your codebase and target stack, and hand over the source with the parity harness.