COBOL-moderniseringsintelligentie

Wij bouwen de kaart van uw codebase voordat we één regel aanraken.

De meeste moderniseringsprojecten mislukken omdat tools code als tekst lezen, niet als topologie. CodeGraph parseert uw mainframe-estate tot een getypeerde kennisgraaf en lost de volledige transitieve afhankelijkheidsafsluiting van een wijziging op, over copybooks, REDEFINES, COMP-3, DB2 en JCL, met file:line-herkomst voor elke rand en een bewijs van hoeveel het kon oplossen. De kaart is het product. Vertaling is een stroomafwaartse use case.

9/9 vs 3/9

Afhankelijkheden hersteld: graaf vs. enkel-bestandvenster

Op de TRN-LIMIT-fixture, tegen een bekende ground-truth-set

97.1%

Referenties opgelost (33 of 34), 1 gemarkeerd voor beoordeling

Deterministische volledigheidspoort, hetzelfde resultaat bij elke run

47 / 70

Knopen en randen over 7 knooptypen

De meegeleverde synthetische bank-fixture

Dit is een uitvoerbare demo. Het estate is synthetisch en voor de demo opgesteld, de graaf is in-memory plus SQLite, en de DB2-, JCL- en naïeve enkel-bestandweergaven zijn bestandsfixtures en simulaties, geen live connectors.

Modernisering faalt bij begrip, niet bij vertaling

De faalmodus is contextuele blindheid, en een groter model neemt die niet weg.

70 to 80% van de mainframe-moderniseringsprojecten haalt de doelstellingen niet (sector-meta-analyse, 2025). Niet omdat de vertaling verkeerd is, maar omdat de tools code als tekst behandelen in plaats van als topologie. Een commodity-vertaler leest het ene bestand dat hij kan zien. Het feit dat ertoe doet is onzichtbaar in een enkel-bestand-contextvenster.

De inzet is niet academisch. Ongeveer 220 billion regels COBOL draaien nog in productie, goed voor ongeveer 95% van de ATM-transacties, 43% van de banksystemen, en 3 trillion dollars aan activiteit per dag (Reuters, 2017), tegenover een geschatte 1.52 trillion dollars aan opgebouwde Amerikaanse technische schuld (CISQ, 2022). Dit is de kern van de bank- en verzekeringsstack, en het is precies de code die niemand blind wil aanraken.

De concrete parabel is een wire-transferprogramma dat rekent op een veld genaamd TRN-LIMIT. In het ene bestand dat een vertaler kan zien, lijkt de rekenkunde triviaal. Maar TRN-LIMIT is een COMP-3 packed decimal, drie copybooks verderop gedefinieerd, de interpretatie ervan wordt gekozen door een flag die in een ander programma wordt gezet, en die flag wordt geschreven door een JCL-batchjob om 2 a.m. die draait vóór de wire-job. Met alleen de zichtbare feiten produceert een model een gewone long; de Java compileert, slaagt voor unittests en corrumpeert daarna de database bij de eerste live wire-transfer. Die referentiële-integriteitsfout komt boven in UAT. De fout was contextuele blindheid.

Dit verdwijnt niet naarmate modellen verbeteren. Een echt estate is 1 tot 10 miljoen regels of meer en past in geen enkel contextvenster, nu of in de toekomst. Het moeilijke deel is het exacte transitieve stuk ophalen dat een wijziging raakt en bewijzen dat u alles hebt gevonden. Dat is een topologie-, retrieval- en bewijsprobleem, geen redeneerkwaliteitsprobleem. Agents adviseren, code beslist.

Hoe CodeGraph werkt

Parseer het estate tot een getypeerde graaf, en voer daarna deterministische analyses uit. Er zit geen LLM in het kritieke pad.

De pipeline draait Fixture estate, daarna parsen (COBOL, copybooks, JCL, DB2 DDL), daarna een getypeerde kennisgraaf bouwen, daarna transitieve-afsluitingsimpact plus herkomst, daarna de deterministische analyses, daarna een audit- en bewijsexport, daarna het interactieve dashboard. Bij het laden draait de app dit live via Server-Sent Events, zodat elke fase vertelt met haar echte gemeten latentie in een console, panelen progressief vullen, en een persistente faserail u de Input-, Processing- en Output-trace van elke fase laat openen. Eén bediening speelt de hele run opnieuw af.

De CodeGraph-interface die haar live analysepipeline over het WIRETXN-programma draait, met latentie per fase in de console: scannen, parsen, graaf bouwen, impactafsluiting, feiten herstellen, en plannen en auditen.
De live pipeline: scannen, parsen, graaf bouwen, impactafsluiting, feiten herstellen, en plannen en auditen, elke fase met haar echte gemeten latentie.

De getypeerde kennisgraaf

Gebouwd met networkx en vastgehouden in-memory plus SQLite, heeft de graaf zeven knooptypen (program, copybook, variable, table, jcl, dataset, en een onopgeloste placeholder) en getypeerde randen zoals DEFINES, IMPORTS, REDEFINES, CONTROLS_TYPE_OF, WRITES_VAR, REFERENCES, CALLS, READS and WRITES, EXECUTES, USES_DATASET en PRECEDES. Op de meegeleverde fixture heeft de graaf 47 knopen en 70 randen: 14 programs, 5 copybooks, 17 variables, 3 DB2-tables, 3 JCL-jobs, 4 datasets, en 1 onopgeloste knoop.

Vier deterministische analyses

Dit zijn gewone graafalgoritmen, geen modelaanroepen, dus dezelfde fixture levert bij elke run hetzelfde resultaat.

1. Impactafsluiting met herkomst

Het transitieve afhankelijkheidsstuk van een wijziging, waarbij elke rand haar file:line-bron draagt, zodat u niet alleen ziet wat geraakt wordt maar ook waar het bewijs staat.

2. Naïeve versus graaf-recall

De afsluiting van de graaf, gescoord tegen de bekende ground-truth-afhankelijkheidsset van de fixture, versus een gesimuleerd enkel-bestandvenster, wat een tekstgebaseerde tool daadwerkelijk aan een model voedt.

3. Extractievolgorde

Een koppelings- en blast-radius-score per programma (koppeling gewogen drie, COMP-3-traps gewogen twee, JCL-criticaliteit gewogen twee, onopgeloste calls gewogen vijf) die een veilige strangler-fig-migratievolgorde rangschikt.

4. Bereikbaarheid van dode code en volledigheidspoort

Elke PERFORM, CALL, COPY en DB2-referentie moet oplossen of worden gemarkeerd als needs review, nooit stilzwijgend weggelaten. Onbereikbare paragraphs worden gerapporteerd als illustratie, niet gescoord als kopmetriek.

Eén schakelaar maakt het verschil tastbaar. Vink de naïeve AI-contextweergave aan en de graaf dimt tot het enkele bronbestand met een paar regels context. Zes van de negen wire-transferfeiten verdwijnen, een rode banner vermeldt het gevolg, en terugschakelen herstelt 9/9 met bewijsstukken. Die schakelaar is een illustratie van welke context de retrieval-laag moet leveren, niet de bron van waarde.

Wanneer u klaar bent, schrijft Export JSON een migration-evidence.json-bestand, en Evidence report rendert een afdrukbaar Codebase Topology and Completeness Report: de knoop- en randensamenvatting, closures per module met file:line-herkomst, het recall-resultaat en de methode, de gerangschikte extractievolgorde, de dode-codelijst, en een tijdstempel. Wij positioneren dat als een DORA ICT-assetinventaris en een SOC-2 change-controlbewijs. Een optionele Pydantic-AI-laag kan vragen beantwoorden over de afsluiting, maar die staat standaard uit en is key-gated, en de deterministische demo registreert het resultaat zonder enige key.

De TRN-LIMIT-wire-transferafsluiting, van begin tot eind uitgewerkt

Eén wijziging op één veld, opgelost tegen een bekende ground-truth-set. Elk beeld hieronder is een screenshot van de draaiende app.

Negen feiten, en zes die één enkel bestand niet kan zien

De standaardweergave opent op het wire-transfersubsysteem met TRN-LIMIT geselecteerd. Het impactpaneel toont graaf-retrieval op 9/9 (100%) tegenover een naïeve enkel-bestandcontext van 3/9 (33%), gescoord tegen de bekende ground-truth-afhankelijkheidsset van de fixture. Drie feiten zijn zichtbaar in het ene bestand: WIRETXN gebruikt TRN-LIMIT in een COMPUTE (WIRETXN.cbl:33), copybook CBACCT wordt op naam geïmporteerd (WIRETXN.cbl:13), en er vindt een UPDATE plaats op DB2-tabel ACCOUNTS (WIRETXN.cbl:37). De zes die de correctheid bepalen zijn dat niet: TRN-LIMIT is een PIC S9(9)V99 COMP-3 packed decimal die een BigDecimal moet worden en geen long (CBACCT.cpy:11), TRN-LIMIT-ALPHA REDEFINES het als tekst over dezelfde zes bytes (CBACCT.cpy:12), LIMIT-TYPE-FLAG bepaalt welke interpretatie live is (CBACCT.cpy:13), twee programma's (LIMITSET en BATCHUPD) schrijven die flag, en de JCL-job NIGHTLY om 02:00 draait vóór WIREJOB zodat de flag gezet is voordat de wire draait.

Het TRN-LIMIT-impactpaneel: graaf-retrieval 9/9 versus naïef enkel-bestand 3/9, met feiten F1 tot F3 gemarkeerd als in-file en F4 tot F9 gemarkeerd als verborgen en critical of high, elk met file:line-herkomst.
Graaf-retrieval 9/9 versus naïef enkel-bestand 3/9. De drie zichtbare feiten zijn in-file; de zes die het type bepalen zijn verborgen voor een enkel-bestandweergave, elk met file:line-herkomst.

Het kernmoment: schakel naar een enkel-bestandvenster en zie zes feiten verdwijnen

Vink de naïeve AI-contextweergave aan en de graaf dimt tot wat binnen WIRETXN.cbl leeft. Het COMP-3-type, de REDEFINES-overlay, de sturende flag, de twee cross-module schrijvers daarvan, en de JCL-voorganger om 02:00 grijzen allemaal uit, en een rode banner vermeldt het gevolg: met alleen de drie zichtbare feiten produceert een model een gewone long TRN_LIMIT en schrijft gecorrumpeerde bytes in ACCOUNTS.TRN_LIMIT, wat de UAT-fout is. Dit is exact de kloof van contextuele blindheid die een tekstvenstertool structureel niet kan dichten, in één klik zichtbaar gemaakt.

De naïeve enkel-bestandcontextweergave: een rode banner legt uit dat slechts 3 of 9 feiten binnen WIRETXN.cbl leven, en feiten F4 tot F9 zijn uitgegrijst, inclusief het COMP-3-type, de REDEFINES-overlay, de sturende flag, en de JCL-voorganger om 02:00.
De naïeve enkel-bestandweergave: zes feiten dimmen uit en een rode banner vermeldt de resulterende productiefout. Schakel terug en 9/9 keert terug met bewijsstukken.

Een veilige extractievolgorde, gerangschikt op blast-radius

De extractieweergave rangschikt alle 14 programma's op een koppelings- en blast-radius-score. AUDITLOG is de veilige eerste extractie op rank 1 met een risk score van 0 en nul koppeling. WIRETXN staat op rank 11 (risk 4, één COMP-3-trap plus JCL-criticaliteit). DISPATCH staat op rank 12 (risk 5) vanwege zijn onopgeloste dynamische CALL, en het god-programma ACCTMGR extraheert als laatste op rank 14 (koppeling 5, risk 15). Dat is een strangler-fig-volgorde die u kunt verdedigen, laagste risico eerst, hoogste koppeling laatst.

De extractievolgorde-tabel die 14 programma's rangschikt op koppeling, COMP-3-traps, JCL-criticaliteit en risk score, met AUDITLOG eerst op risk 0 en het god-programma ACCTMGR laatst op risk 15, naast een legacy-naar-gemoderniseerd-diffweergave.
De strangler-fig-volgorde: AUDITLOG eerst op risk 0, ACCTMGR laatst op risk 15, met de reden voor elke rank in de koppelings-, traps- en JCL-kolommen.

Een volledigheidspoort die markeert wat ze niet kan oplossen

Het audittabblad rapporteert 97.1% van de referenties opgelost, dat is 33 of 34, met exact één gemarkeerd voor beoordeling en niet stilzwijgend weggelaten. Die ene is de dynamische CALL WS-PROGNAME van DISPATCH, waarvan het doel tijdens runtime wordt berekend (DISPATCH.cbl:15) en dus niet statisch kan worden opgelost. Het tabblad somt ook dode code op via bereikbaarheid: de LEGACY-FORMAT-paragraph van AUDITLOG en de OLD-LIMIT-CHECK-paragraph van WIRETXN zijn onbereikbaar. Weigeren een oplossing te faken is het eerlijke gedrag, en het is het gedrag dat een toezichthouder wil zien.

Het audittabblad met 97.1% referenties opgelost en 1 gemarkeerd voor beoordeling, waarbij de dynamische CALL WS-PROGNAME van DISPATCH wordt uitgelicht als gemarkeerd niet stilzwijgend weggelaten, en een dode-codelijst die AUDITLOG LEGACY-FORMAT en WIRETXN OLD-LIMIT-CHECK noemt.
97.1% opgelost, 1 gemarkeerd. De onoplosbare dynamische CALL is gemarkeerd voor beoordeling, niet weggelaten, en de dode-codelijst wordt ernaast gerapporteerd.

Een exporteerbaar auditartefact

Alles hierboven exporteert naar een afdrukbaar Codebase Topology and Completeness Report: de samenvatting van 47 knopen en 70 randen, de 97.1% dekking, de negen TRN-LIMIT-afhankelijkheidsfeiten met hun enkel-bestandzichtbaarheid en file:line-herkomst, de gerangschikte extractievolgorde, en een generatietijdstempel. Omdat het estate synthetisch en opgesteld is, is de ware afhankelijkheidsset bekend vanuit de constructie, wat het recall-cijfer tot een reproduceerbare gelabelde meting maakt in plaats van een claim. Wij schrijven 9/9, 3/9 en 97.1% toe aan deze meegeleverde fixture, nooit als een open-world-garantie over willekeurige COBOL-estates.

Het afdrukbare Codebase Topology and Completeness Report met 47 knopen, 70 randen, 97.1% referenties opgelost, de TRN-LIMIT-afhankelijkheidsfeiten F1 tot F9 met enkel-bestandzichtbaarheid en herkomst, en de strangler-fig-extractievolgorde.
Het exporteerbare Codebase Topology and Completeness Report: knoop- en randensamenvatting, de negen afhankelijkheidsfeiten met herkomst, en de gerangschikte extractievolgorde, gepositioneerd als een DORA ICT-assetinventaris.

Een enkel-bestand-contextvenster versus de graaf

Dezelfde schakelaar waarmee de demo vergelijkt, naast elkaar, op de wire-transferfixture.

Dimensie Enkel-bestand-contextvenster CodeGraph-kennisgraaf
TRN-LIMIT-afhankelijkheden hersteld 3 of 9 9 of 9, tegen een bekende ground-truth-set
COMP-3-type over copybooks Onzichtbaar Opgelost met file:line-herkomst
REDEFINES-overlay en sturende flag Onzichtbaar Opgelost, inclusief schrijvers over modules heen
Alleen-JCL-ordeningsrand (NIGHTLY before WIREJOB) Onzichtbaar Gemodelleerd als een PRECEDES-rand
Volledigheidsbewijs Geen 97.1% opgelost, onopgeloste gemarkeerd voor beoordeling
Veilige extractievolgorde Geen Gerangschikt op koppeling en blast-radius
Auditartefact Geen Exporteerbaar topologie- en volledigheidsrapport

Wat deze demo niet doet

  • ✓ Het vertaalt COBOL niet naar Java. CodeGraph is de begripslaag, de kaart. Vertaling is een stroomafwaartse use case die het bewust niet uitvoert.
  • ✓ Het gebruikt geen live connectors. De graaf is in-memory plus SQLite, DB2, JCL en scheduler-inputs zijn bestandsfixtures, en de naïeve enkel-bestandweergave is een gesimuleerd contextvenster. Neo4j of Memgraph is het genoemde productiepad, hier niet meegeleverd.
  • ✓ Het presenteert de bank, haar programma's of enig cijfer niet als de codebase van een echte klant. Het estate is synthetisch en voor deze demo opgesteld. Er is geen casestudy en geen implementatieresultaat.
  • ✓ Het claimt geen volledige IBM Enterprise COBOL-dialectdekking. De parser dekt een realistische synthetische subset, niet elk dialect, ALTER of OCCURS DEPENDING ON, en claimt niet beter te zijn dan de parser van enige leverancier.
  • ✓ Het presenteert 9/9, 3/9 of 97.1% niet als open-world-garanties. Het zijn metingen op de meegeleverde synthetische wire-transferfixture, waarvan de ground-truth-set bekend is vanuit de constructie.
  • ✓ Het bevat geen klanten, casestudy's, testimonials of ROI-cijfers. Die bestaan nog niet. Dit is een demo die het mechanisme bewijst.

Vragen die kopers daadwerkelijk stellen

Is dit een COBOL-naar-Java-vertaler?

Nee. CodeGraph is de begripslaag, geen vertaler, en het plakt bewust geen COBOL om Java uit te spugen. Het bouwt een getypeerde afhankelijkheidsgraaf van uw estate en lost het exacte transitieve stuk op dat een wijziging raakt, met file:line-herkomst en een volledigheidsbewijs. Vertaling is een stroomafwaartse use case, en elk vertaalhulpmiddel heeft deze kaart nog steeds nodig om te weten wat een wijziging daadwerkelijk raakt.

Lost een groter contextvenster of een beter model dit niet gewoon op?

Nee, en dat is het duurzame punt. Een echt estate is 1 tot 10 miljoen regels of meer en past in geen enkel contextvenster, nu of in de toekomst. Het moeilijke deel is het exacte transitieve stuk ophalen en bewijzen dat u alles hebt gevonden, wat een topologie-, retrieval- en bewijsprobleem is, geen redeneerkwaliteitsprobleem. Een perfect model kan een toezichthouder nog steeds niet bewijzen welke afhankelijkheden zijn opgehaald, heeft nog steeds een veilige extractievolgorde nodig, en is nog steeds een ICT-assetinventaris verschuldigd.

Hoe bewijst u dat u elke afhankelijkheid voor een auditor hebt gevonden?

De volledigheidspoort vereist dat elke PERFORM, CALL, COPY en DB2-referentie ofwel oplost ofwel wordt gemarkeerd voor beoordeling, nooit stilzwijgend weggelaten. Op de meegeleverde fixture is dat 33 of 34 referenties opgelost, wat 97.1% dekking is, met de ene onoplosbare referentie gemarkeerd. U kunt een afdrukbaar Codebase Topology and Completeness Report exporteren met de knoop- en randensamenvatting, closures per module met file:line-herkomst, het recall-resultaat en de methode, de gerangschikte extractievolgorde, en de dode-codelijst, gepositioneerd als een DORA ICT-assetinventaris en een SOC-2 change-controlbewijs.

Wat gebeurt er met een afhankelijkheid die u niet kunt oplossen, zoals een dynamische CALL?

Die wordt gemarkeerd voor beoordeling, niet stilzwijgend weggelaten, en dat eerlijke gedrag is het punt. Op de fixture is de ene onoplosbare referentie de dynamische CALL WS-PROGNAME van DISPATCH, waarvan het doel tijdens runtime wordt berekend (DISPATCH.cbl:15), dus het kan niet statisch worden opgelost. CodeGraph registreert het als needs review en rangschikt DISPATCH precies daarom bijna aan het eind van de veilige extractievolgorde.

Verbindt dit met onze mainframe, DB2 of z/OS-scheduler?

Niet in deze demo. De graaf is in-memory plus SQLite, en de DB2-, JCL- en scheduler-inputs zijn bestandsfixtures, terwijl de naïeve enkel-bestandweergave een gesimuleerd contextvenster is. Een productie-implementatie zou een graafplatform zoals Neo4j of Memgraph noemen en uw echte estate inlezen, maar niets hier impliceert een live z/OS-pipeline. De demo bewijst het mechanisme op een synthetisch estate, geen implementatie.

Hoe verschilt dit van IBM watsonx Code Assistant of de toolchain van een grote SI?

Wij claimen niet beter te zijn dan de parser van IBM of van een system integrator, en de demo-parser dekt een realistische synthetische subset van COBOL, niet elk dialect, ALTER of OCCURS DEPENDING ON. Het onderscheid is het deliverable: een repository-bewuste kennisgraaf plus een volledigheidsbewijs en een veilige extractievolgorde, in plaats van een per-bestandvertaling. Het is de begripslaag die elke vertaalinspanning eerst nodig heeft, en het is de laag die een beter basismodel niet wegneemt.

Is dit een live product of een demo?

Het is een uitvoerbare demo die het mechanisme bewijst, geen uitgerolde pipeline. Het bank-estate is synthetisch en voor deze demo opgesteld, dus de ware afhankelijkheidsset is bekend vanuit de constructie, wat de recall-metriek tot een reproduceerbare gelabelde meting maakt in plaats van een claim. Het parsen, de graaf en alle vier analyses zijn deterministisch gewoon Python (FastAPI plus networkx, Cytoscape.js UI) die draaien zonder API-key en zonder database. Een optionele LLM-laag voor vraagbeantwoording bestaat maar staat standaard uit, en de waarde hangt er niet van af.

Technisch onderzoek

Het onderzoek achter deze demo — de architectuur, het verificatieontwerp en de enterprise-blauwdruk.

Plant u een mainframe-modernisering?

De begripslaag is het moeilijke deel. Wij bouwen eerst de kaart.

Als uw team afweegt hoe een COBOL-estate te moderniseren zonder een UAT-verrassing van een afhankelijkheid die niemand kon zien, horen we oprecht graag hoe u erover denkt. Het probleem is sectorbreed en de antwoorden zullen dat ook zijn.

Topologiebeoordeling

  • ✓ Breng in kaart waar een wijziging kan reiken over copybooks, DB2 en JCL
  • ✓ Los de transitieve afsluiting op met file:line-herkomst
  • ✓ Scoreer de recall van afhankelijkheidsretrieval tegen een ground-truth-set
  • ✓ Lever het volledigheidsbewijs dat uw auditors nodig hebben

Bouw de kaart

  • ✓ Een getypeerde kennisgraaf over uw echte estate
  • ✓ Een volledigheidspoort die markeert wat ze niet kan oplossen
  • ✓ Een gerangschikte, verdedigbare strangler-fig-extractievolgorde
  • ✓ Een exporteerbaar DORA ICT-asset- en SOC-2 change-controlrapport
Social

Ook gepubliceerd op