Oude infrastructuur draait nog steeds de wereld — nu met een moderne laag eromheen.
De reflex is bekend: een oud systeem opent, en je denkt "We moeten het herschrijven." Maar wat als de echte winst niet zit in slopen, maar in verbinden? De middleware-strategie transformeert legacy-systemen van gesloten monolithen naar API-gedreven bouwstenen — zonder één regel COBOL of VBScript te vervangen.
De kern: legacy-code is geen tech-schuld, het is bedrijfslogica die al bewezen waarde levert. De kunst is er een laag overheen bouwen die deze logica toegankelijk maakt voor de moderne stack.
Waarom Wrappen Niet Voldoende Is
Een wrapper — denk aan COM-bridging voor VB6 of IIS-hosting voor Classic ASP — lost het aanroep-probleem op, maar niet het observabiliteits- en testbaarheid-probleem. Veel bedrijven hebben wrappers gebouwd en zitten dan met een systeem dat nog steeds onvoorspelbaar is bij piekbelasting, waarvan niemand weet welke business-rule exact triggert, en waar geen geautomatiseerde tests naartoe kunnen. De middleware-strategie gaat één stap verder: tussen het legacy-systeem en de rest van de organisatie schuif je eenPython/FastAPI-laag die drie dingen doet:
1. Business Semantic Layer
Vertaal legacy-datastructures naar semantische modellen die business developers begrijpen. Een COBOL-rekord met velden KLNR(08) en BETR(12,3) wordt een JSON-object met duidelijke beschrijvingen en validatieregels.
2. Observability Bridge
Injecteer tracing, metrics en logging in legacy-anonieme processen. Een Python-agent die heartbeat-data van een VB6-applicatie naar Prometheus stuurt — zodat je weet wanneer het systeem traag wordt, voordat de gebruiker er last van heeft.
3. Contract-Gedreven Tests
Bouw een API-contract op basis van bestaande gebruikspatronen. Zodra de legacy-applicatie al jaren lang dezelfde antwoorden geeft, is dat je testbaseline. Elke wijziging in het gedrag wordt direct gesignaleerd.
4. AI-Assisted Reverse Engineering
Gebruik LLMs om ongedocumenteerde code te analyseren, dataflows te visualiseren en business-logic te documenteren. Geen nostalgische reis, maar een meetbare versnelling van kennisoverdracht.
Concrete Architectuur: Classic ASP → FastAPI → Modern Frontend
Neem een typisch Case: een 20-jarige Classic ASP-toepassing met VBScript-logic, een MS Access-database en geen enkel testbestand. De middleware-strategie ziet er zo uit:Stap 1: IIS-hosted Python Bridge
ASPPY draait de Classic ASP-code in een moderne Python-runtime. De bridge exposeert elke "pagina" als een REST-endpoint:
# legacy_bridge.py from fastapi import FastAPI, Query import win32com.client app = FastAPI() @app.get("/legacy/klant/{id}") def get_klant(id: int): conn = win32com.client.Dispatch("ADODB.Connection") conn.Open("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\data\\db.mdb") rs = conn.Execute(f"SELECT * FROM Klanten WHERE ID={id}") return {"naam": rs.Fields("Naam").Value, "adres": rs.Fields("Adres").Value} Stap 2: Semantic Mapping Layer
Een tweede Python-laag mapt de ruwe legacy-data naar een consistent model:
@app.get("/api/v1/klant/{id}") def get_klant_gemoderniseerd(id: int): ruw = get_legacy_data(id) return { "customer_id": str(ruw["id"]), "full_name": f"{ruw['voornaam']} {ruw['achternaam']}", "address": Address( street=ruw["straat"], postal_code=ruw["postcode"][:4], city=ruw["woonplaats"], ), "risk_score": calculate_risk(ruw), } Stap 3: Observability & Contracts
OpenTelemetry-tracing via de bridge, Prometheus-metrics van query-tijden, en een JSON Schema dat het API-contract definieert. Zodra het contract stabiel is, kun je beginnen met het vervangen van individuele endpoints — één voor één.
AI als Versterker, Niet als Vervanger
De meeste verhalen over AI en legacy tech draaien om "AI schrijft de code opnieuw." Het krachtigere gebruik is kleiner en directer:- Data Dictionary Generatie: Een script scant een VB6-project, extrahert alle variabelen, databasevelden en API-calls, en voegt ze via een LLM-API om in gestructureerde documentatie. Resultaat: een doorzoekbaar kennisdatabank van een systeem waar geen enkele developer meer de vingers aan durft te leggen.
- Anomaliëdetectie op Legacy Logs: Python-pandas + een lichtgewicht ML-model (of zelfs statistische grenzen) scannen dagelijks de applicatiedetails van een COBOL-batchjob. Afwijkingen in verwerkingstijd of recordaantallen triggers een alert — weken voordat het tot een fout leidt.
- Smart Contract Testing: Een AI-model leert het bestaande API-gedrag en genereert duizenden testcases uit de productie-data. Elke nieuwe release van de middleware wordt automatisch vergeleken met deze baseline. Geen regressie meer onverwacht.
De Strangler Fig in Actie
De middleware-laag maakt het Strangler Fig-patroon praktisch uitvoerbaar op legacy-systemen die traditioneel "te groot om te vervangen" werden genoemd:| Fase | Action | Risico |
|---|---|---|
| 0-3 maanden | Bridge bouwen, observability injecteren, API-contract vastleggen | Laag — geen wijziging in legacy-code zelf |
| 3-9 maanden | Eerste 20% van endpoints vervangen door nieuwe implementatie | Middel — contract-testing vangt regressies |
| 9-18 maanden | Geleidelijke migratie van alle kritieke pads; legacy draait parallel als fallback | Middel — A/B-verkeer mogelijk via middleware routing |
| 18+ maanden | Legacy-systeem uitzetten of consolideren. De API-laag blijft als contract. | Het systeem is nu eigen van het moderne team |
Waarom Dit Nu Werkt
De middleware-strategie profiteert van drie ontwikkelingen die samen niet eerder mogelijk waren:
- Python's COM/OLE-ondersteuning (via
pywin32,cffi) maakt naadloze integratie met VB6, Classic ASP en Windows-embedded systemen. - FastAPI + OpenTelemetry leveren een productieklare API-laag met ingebouwde observabiliteit — geen custom boilerplate meer nodig.
- LLMs met context-windows van 100K+ tokens kunnen nu een volledig VB6-project in één keer analyseren en documenteren, zonder dat je handmatig door duizenden bestanden hoeft te scrollen.
