Model-Driven Legacy System Modernization at Scale
This experience report presents and evaluates a four-stage, model-driven approach that successfully modernizes a large-scale legacy .NET application by inserting an enriched, technology-agnostic intermediate model to enable the semi-automatic migration of UI components while preserving functionality and improving maintainability.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you own a massive, historic factory that has been running non-stop for 20 years. It produces the goods your entire city relies on. The problem? The factory was built with old blueprints, uses rusty machinery, and the only people who know how to fix the weird, custom-made levers are the original builders, who are now retiring.
You know you need to upgrade to a modern, automated factory to keep up with the times, but you can't just shut it down and start over. That would be too risky and expensive.
This paper describes a clever "middleman" strategy to modernize this factory without stopping production. Here is how they did it, explained simply:
The Problem: The "Old Factory"
The researchers worked on a huge software system (a "Terminal Operating System" for a major European port) that has been running since 2006. It's like that old factory:
- It works: It handles critical tasks like moving cargo and billing.
- It's stuck: It's built on very old technology (.NET Framework and ASP.NET Web Forms) that is hard to maintain.
- It's messy: Over 15 years, people added thousands of custom parts. Some are standard, but many are unique, hand-crafted "bespoke" pieces that don't fit standard molds.
- The risk: If you try to rebuild it manually, it will take forever, cost a fortune, and you might break the things that are currently working.
The Solution: The "Universal Translator" Blueprint
Instead of trying to translate the old factory directly into a new one (which is like trying to translate a poem word-for-word into a different language and hoping the meaning stays the same), the team invented a Universal Translator Blueprint.
They created a three-step process:
1. The "Archaeologist" Phase (Analysis)
First, they didn't just look at the code; they mapped it out. They used software to scan the old factory and create a detailed, technology-neutral map.
- Analogy: Imagine taking a photo of every single machine, wire, and lever in the old factory and writing down exactly what each one does (e.g., "This lever opens the gate," "This button prints a receipt"), without worrying about how it does it yet.
2. The "Universal Blueprint" Phase (Enrichment)
This is the most important part. They took that messy map and turned it into a clean, simple, "technology-agnostic" model.
- Analogy: They created a master blueprint that says, "We need a Gate Opener," "We need a Receipt Printer," and "We need a Navigation System." They stripped away the old, rusty details and focused purely on the function. They also added "sticky notes" (metadata) to explain the rules, like "This button must be red" or "This form needs a password."
- Why this helps: Because this blueprint doesn't care if the old factory used gears or steam, and it doesn't care if the new factory uses electricity or solar power, it can be used to build any modern version.
3. The "Builder" Phase (Synthesis & Transition)
Now, they used that clean blueprint to automatically build the new factory.
- Analogy: They fed the "Gate Opener" instruction into a modern 3D printer (the new technology, Next.js/React) which instantly printed a brand-new, sleek, modern Gate Opener.
- The Result: For standard parts (like buttons, text boxes, and standard forms), the computer did almost all the work. It generated thousands of new pages that looked and acted exactly like the old ones but ran on modern, fast technology.
What Worked and What Didn't
The paper is honest about the limits of this approach:
- The Magic (Automation): For the "standard" parts of the factory (the 30 common types of buttons and forms), the system was like a photocopier. It worked perfectly, automatically translating 1,500 web pages and preserving how they worked.
- The Challenge (Manual Work): The factory had some weird, custom-made "bespoke" machines that no one had seen before. The computer couldn't figure out how to translate these automatically.
- Analogy: If the old factory had a lever made of a specific piece of driftwood that only the original builder knew how to use, the 3D printer couldn't guess how to make a modern version of it. Humans had to step in and manually redesign those specific, unique parts.
The Payoff
By using this "Universal Blueprint" method, the team achieved:
- Safety: They didn't have to guess. The blueprint ensured the new system did exactly what the old one did.
- Speed: They automated the boring, repetitive parts, saving years of manual coding.
- Future-Proofing: The new system is easier to understand and fix because it's built on a clean, modern foundation, not a pile of old, tangled wires.
In a Nutshell
This paper shows that you don't have to tear down a historic, critical building to modernize it. Instead, you can create a smart, middle-layer blueprint that understands the old building's purpose, strips away the old bricks, and uses that understanding to automatically construct a modern, efficient version—leaving humans to only fix the unique, weird quirks that the computer can't figure out.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.