Intelligence per la modernizzazione COBOL

Costruiamo la mappa del tuo codebase prima di toccare una sola riga.

La maggior parte dei progetti di modernizzazione fallisce perché gli strumenti leggono il codice come testo, non come topologia. CodeGraph analizza il tuo patrimonio mainframe in un grafo di conoscenza tipizzato e risolve la chiusura transitiva completa delle dipendenze di una modifica, attraverso copybook, REDEFINES, COMP-3, DB2 e JCL, con provenienza file:line per ogni arco e una prova di quanto è riuscito a risolvere. La mappa è il prodotto. La traduzione è un caso d'uso a valle.

9/9 vs 3/9

Dipendenze recuperate: grafo vs finestra a file singolo

Sul fixture TRN-LIMIT, rispetto a un insieme ground-truth noto

97.1%

Riferimenti risolti (33 of 34), 1 segnalato per revisione

Gate di completezza deterministico, stesso risultato a ogni esecuzione

47 / 70

Nodi e archi su 7 tipi di nodo

Il fixture bancario sintetico incluso

Questa è una demo eseguibile. Il patrimonio è sintetico e scritto per la demo, il grafo è in-memory più SQLite, e le viste DB2, JCL e naive a file singolo sono fixture di file e simulazioni, non connettori live.

La modernizzazione fallisce nella comprensione, non nella traduzione

La modalità di fallimento è la cecità contestuale, e un modello più grande non la elimina.

Il 70 to 80% dei progetti di modernizzazione mainframe non raggiunge gli obiettivi (meta-analisi di settore, 2025). Non perché la traduzione sia sbagliata, ma perché gli strumenti trattano il codice come testo invece che come topologia. Un traduttore commodity legge l'unico file che può vedere. Il fatto che conta davvero è invisibile in una finestra di contesto a file singolo.

La posta in gioco non è accademica. Circa 220 billion di righe di COBOL girano ancora in produzione, trasportando circa il 95% delle transazioni ATM, il 43% dei sistemi bancari e 3 trillion dollars di attività al giorno (Reuters, 2017), a fronte di una stima di 1.52 trillion dollars di debito tecnico USA accumulato (CISQ, 2022). Questo è il cuore dello stack bancario e assicurativo, ed è esattamente il codice che nessuno vuole toccare alla cieca.

La parabola concreta è un programma di bonifico che calcola su un campo chiamato TRN-LIMIT. Nell'unico file che un traduttore può vedere, l'aritmetica sembra banale. Ma TRN-LIMIT è un decimale impacchettato COMP-3 definito tre copybook più in là, la sua interpretazione è scelta da un flag impostato in un programma diverso, e quel flag è scritto da un job batch JCL delle 2 a.m. che gira prima del job dei bonifici. Con i soli fatti visibili, un modello emette un plain long, il Java compila, supera i test unitari e poi corrompe il database al primo bonifico live. Quel fallimento di integrità referenziale emerge in UAT. Il fallimento era cecità contestuale.

Questo non invecchia man mano che i modelli migliorano. Un patrimonio reale è da 1 to 10 million di righe o più e non entra in nessuna finestra di contesto, presente o futura. La parte difficile è recuperare l'esatta fetta transitiva che una modifica tocca e dimostrare di averla trovata tutta. È un problema di topologia, retrieval ed evidenza, non un problema di qualità del ragionamento. Gli agenti consigliano, il codice decide.

Come funziona CodeGraph

Analizza il patrimonio in un grafo tipizzato, poi esegue analisi deterministiche. Nessun LLM è nel percorso critico.

La pipeline esegue Fixture estate, poi parse (COBOL, copybook, JCL, DB2 DDL), poi costruisce un grafo di conoscenza tipizzato, poi impatto a chiusura transitiva più provenienza, poi le analisi deterministiche, poi un audit e l'export delle evidenze, poi la dashboard interattiva. Al caricamento l'app esegue questo in diretta su Server-Sent Events, così ogni fase narra con la sua latenza reale misurata in una console, i pannelli si riempiono progressivamente, e una barra di fase persistente consente di aprire la traccia Input, Processing e Output di qualsiasi fase. Un unico controllo riesegue l'intera corsa.

L'interfaccia CodeGraph che esegue la sua pipeline di analisi live sul programma WIRETXN, con la latenza per fase mostrata nella console: scan, parse, build graph, impact closure, recover facts, e plan and audit.
La pipeline live: scan, parse, build graph, impact closure, recover facts, e plan and audit, ogni fase con la sua latenza reale misurata.

Il grafo di conoscenza tipizzato

Costruito con networkx e tenuto in-memory più SQLite, il grafo ha sette tipi di nodo (program, copybook, variable, table, jcl, dataset, e un placeholder unresolved) e archi tipizzati come DEFINES, IMPORTS, REDEFINES, CONTROLS_TYPE_OF, WRITES_VAR, REFERENCES, CALLS, READS and WRITES, EXECUTES, USES_DATASET, e PRECEDES. Sul fixture incluso il grafo ha 47 nodi e 70 archi: 14 programmi, 5 copybook, 17 variabili, 3 tabelle DB2, 3 job JCL, 4 dataset, e 1 nodo unresolved.

Quattro analisi deterministiche

Sono algoritmi di grafo semplici, non chiamate a un modello, quindi lo stesso fixture produce lo stesso risultato a ogni esecuzione.

1. Chiusura di impatto con provenienza

La fetta transitiva di dipendenze di una modifica, con ogni arco che porta la sua sorgente file:line, così vedi non solo cosa è interessato ma dove vive l'evidenza.

2. Recall naive versus grafo

La chiusura del grafo valutata rispetto all'insieme noto di dipendenze ground-truth del fixture, versus una finestra a file singolo simulata, che è ciò che uno strumento basato su testo alimenta davvero a un modello.

3. Sequenza di estrazione

Un punteggio di accoppiamento e raggio d'impatto per programma (accoppiamento pesato tre, trappole COMP-3 pesate due, criticità JCL pesata due, chiamate unresolved pesate cinque) che classifica un ordine di migrazione strangler-fig sicuro.

4. Raggiungibilità del dead-code e gate di completezza

Ogni PERFORM, CALL, COPY e riferimento DB2 deve risolversi o essere segnalato come da revisionare, mai scartato in silenzio. I paragrafi irraggiungibili sono riportati come illustrazione, non valutati come metrica in evidenza.

Un solo toggle rende la differenza tangibile. Attiva la vista naive AI context e il grafo si attenua al singolo file sorgente con poche righe di contesto. Sei dei nove fatti sul bonifico svaniscono, un banner rosso dichiara la conseguenza, e tornare indietro ripristina 9/9 con le ricevute. Quel toggle è un'illustrazione di quale contesto lo strato di retrieval deve fornire, non la fonte del valore.

Quando hai finito, Export JSON scrive un file migration-evidence.json, e Evidence report genera un Codebase Topology and Completeness Report stampabile: il riepilogo di nodi e archi, le chiusure per modulo con provenienza file:line, il risultato e il metodo di recall, la sequenza di estrazione classificata, l'elenco del dead-code e un timestamp. Lo posizioniamo come inventario di asset ICT DORA e come ricevuta di change-control SOC-2. Uno strato opzionale Pydantic-AI può rispondere a domande sulla chiusura, ma è disattivato di default e protetto da chiave, e la demo deterministica registra il risultato senza alcuna chiave.

La chiusura del bonifico TRN-LIMIT, svolta da un capo all'altro

Una modifica su un campo, risolta rispetto a un insieme ground-truth noto. Ogni immagine sotto è uno screenshot dell'app in esecuzione.

Nove fatti, e sei che un singolo file non può vedere

La vista predefinita si apre sul sottosistema dei bonifici con TRN-LIMIT selezionato. Il pannello di impatto mostra il retrieval del grafo a 9/9 (100%) contro un contesto naive a file singolo di 3/9 (33%), valutato rispetto all'insieme noto di dipendenze ground-truth del fixture. Tre fatti sono visibili nell'unico file: WIRETXN usa TRN-LIMIT in un COMPUTE (WIRETXN.cbl:33), il copybook CBACCT è importato per nome (WIRETXN.cbl:13), e avviene un UPDATE sulla tabella DB2 ACCOUNTS (WIRETXN.cbl:37). I sei che decidono la correttezza non lo sono: TRN-LIMIT è un decimale impacchettato PIC S9(9)V99 COMP-3 che deve diventare un BigDecimal e non un long (CBACCT.cpy:11), TRN-LIMIT-ALPHA lo REDEFINES come testo sugli stessi sei byte (CBACCT.cpy:12), LIMIT-TYPE-FLAG decide quale interpretazione è attiva (CBACCT.cpy:13), due programmi (LIMITSET e BATCHUPD) scrivono quel flag, e il job JCL NIGHTLY alle 02:00 gira prima di WIREJOB così il flag è impostato prima che il bonifico parta.

Il pannello di impatto TRN-LIMIT: retrieval del grafo 9/9 versus naive a file singolo 3/9, con i fatti F1 to F3 marcati in-file e F4 to F9 marcati nascosti e critical o high, ciascuno con la sua provenienza file:line.
Retrieval del grafo 9/9 versus naive a file singolo 3/9. I tre fatti visibili sono in-file; i sei che decidono il tipo sono nascosti a una vista a file singolo, ciascuno con provenienza file:line.

Il colpo decisivo: passa a una finestra a file singolo e guarda sei fatti svanire

Attiva la vista naive AI context e il grafo si attenua a ciò che vive dentro WIRETXN.cbl. Il tipo COMP-3, l'overlay REDEFINES, il flag di controllo, i suoi due writer cross-modulo e il predecessore JCL delle 02:00 passano tutti in grigio, e un banner rosso dichiara la conseguenza: con i soli tre fatti visibili, un modello emette un plain long TRN_LIMIT e scrive byte corrotti in ACCOUNTS.TRN_LIMIT, che è il fallimento in UAT. Questo è esattamente il gap di cecità contestuale che uno strumento a finestra di testo non può chiudere strutturalmente, reso visibile in un clic.

La vista naive a file singolo: un banner rosso spiega che solo 3 of 9 fatti vivono dentro WIRETXN.cbl, e i fatti F4 to F9 sono in grigio, incluso il tipo COMP-3, l'overlay REDEFINES, il flag di controllo e il predecessore JCL delle 02:00.
La vista naive a file singolo: sei fatti si attenuano e un banner rosso dichiara il fallimento in produzione che ne risulta. Torna indietro e 9/9 ritorna con le ricevute.

Un ordine di estrazione sicuro, classificato per raggio d'impatto

La vista di estrazione classifica tutti i 14 programmi per un punteggio di accoppiamento e raggio d'impatto. AUDITLOG è la prima estrazione sicura al rank 1 con un punteggio di rischio di 0 e accoppiamento zero. WIRETXN sta al rank 11 (risk 4, una trappola COMP-3 più criticità JCL). DISPATCH è al rank 12 (risk 5) per la sua CALL dinamica unresolved, e il god-program ACCTMGR si estrae per ultimo al rank 14 (coupling 5, risk 15). È un ordine strangler-fig che puoi difendere, rischio più basso per primo, accoppiamento più alto per ultimo.

La tabella della sequenza di estrazione che classifica 14 programmi per accoppiamento, trappole COMP-3, criticità JCL e punteggio di rischio, con AUDITLOG primo a risk 0 e il god-program ACCTMGR ultimo a risk 15, accanto a una vista diff da legacy a modernizzato.
L'ordine strangler-fig: AUDITLOG primo a risk 0, ACCTMGR ultimo a risk 15, con il motivo di ciascun rango mostrato nelle colonne coupling, traps e JCL.

Un gate di completezza che segnala ciò che non può risolvere

La scheda audit riporta il 97.1% dei riferimenti risolti, cioè 33 of 34, con esattamente uno segnalato per revisione e non scartato in silenzio. Quella è la CALL dinamica WS-PROGNAME di DISPATCH, il cui target è calcolato a runtime (DISPATCH.cbl:15) e quindi non può essere risolto staticamente. La scheda elenca anche il dead-code per raggiungibilità: il paragrafo LEGACY-FORMAT di AUDITLOG e il paragrafo OLD-LIMIT-CHECK di WIRETXN sono irraggiungibili. Rifiutare di inventare una risoluzione è il comportamento onesto, ed è il comportamento che un regolatore vuole vedere.

La scheda audit che mostra il 97.1% dei riferimenti risolti e 1 segnalato per revisione, con la CALL dinamica WS-PROGNAME di DISPATCH evidenziata come segnalata non scartata in silenzio, e un elenco di dead-code che nomina AUDITLOG LEGACY-FORMAT e WIRETXN OLD-LIMIT-CHECK.
97.1% risolto, 1 segnalato. La CALL dinamica irrisolvibile è marcata per revisione, non scartata, e l'elenco del dead-code è riportato accanto.

Un artefatto di audit esportabile

Tutto quanto sopra si esporta in un Codebase Topology and Completeness Report stampabile: il riepilogo 47-node, 70-edge, la copertura del 97.1%, i nove fatti di dipendenza TRN-LIMIT con la loro visibilità a file singolo e la provenienza file:line, la sequenza di estrazione classificata e un timestamp di generazione. Poiché il patrimonio è sintetico e scritto apposta, l'insieme vero delle dipendenze è noto per costruzione, ed è ciò che rende la cifra di recall una misura etichettata riproducibile piuttosto che una pretesa. Attribuiamo 9/9, 3/9 e 97.1% a questo fixture incluso, mai come garanzia open-world su patrimoni COBOL arbitrari.

Il Codebase Topology and Completeness Report stampabile che mostra 47 nodi, 70 archi, il 97.1% dei riferimenti risolti, i fatti di dipendenza TRN-LIMIT F1 to F9 con visibilità a file singolo e provenienza, e la sequenza di estrazione strangler-fig.
Il Codebase Topology and Completeness Report esportabile: riepilogo di nodi e archi, i nove fatti di dipendenza con provenienza, e la sequenza di estrazione classificata, posizionato come inventario di asset ICT DORA.

Una finestra di contesto a file singolo versus il grafo

Lo stesso toggle che la demo confronta, affiancato, sul fixture dei bonifici.

Dimensione Finestra di contesto a file singolo Grafo di conoscenza CodeGraph
Dipendenze TRN-LIMIT recuperate 3 of 9 9 of 9, rispetto a un insieme ground-truth noto
Tipo COMP-3 attraverso i copybook Invisibile Risolto con provenienza file:line
Overlay REDEFINES e flag di controllo Invisibile Risolto, inclusi i writer cross-modulo
Arco di ordinamento solo-JCL (NIGHTLY before WIREJOB) Invisibile Modellato come un arco PRECEDES
Prova di completezza Nessuna 97.1% risolto, gli unresolved segnalati per revisione
Ordine di estrazione sicuro Nessuno Classificato per accoppiamento e raggio d'impatto
Artefatto di audit Nessuno Report di topologia e completezza esportabile

Cosa questa demo non fa

  • ✓ Non traduce COBOL in Java. CodeGraph è lo strato di comprensione, la mappa. La traduzione è un caso d'uso a valle che deliberatamente non esegue.
  • ✓ Non usa connettori live. Il grafo è in-memory più SQLite, gli input DB2, JCL e dello scheduler sono fixture di file, e la vista naive a file singolo è una finestra di contesto simulata. Neo4j o Memgraph è il percorso di produzione nominato, non incluso qui.
  • ✓ Non presenta la banca, i suoi programmi o alcun numero come il codebase di un cliente reale. Il patrimonio è sintetico e scritto per questa demo. Non c'è case study e non c'è risultato di deployment.
  • ✓ Non pretende la copertura completa del dialetto IBM Enterprise COBOL. Il parser copre un sottoinsieme sintetico realistico, non ogni dialetto, ALTER o OCCURS DEPENDING ON, e non pretende di battere il parser di nessun vendor.
  • ✓ Non presenta 9/9, 3/9 o 97.1% come garanzie open-world. Sono misure sul fixture sintetico di bonifico incluso, il cui insieme ground-truth è noto per costruzione.
  • ✓ Non porta clienti, case study, testimonianze o cifre di ROI. Non ne esistono ancora. Questa è una demo che prova il meccanismo.

Domande che i buyer fanno davvero

È un traduttore da COBOL a Java?

No. CodeGraph è lo strato di comprensione, non un traduttore, e deliberatamente non incolla COBOL ed emette Java. Costruisce un grafo di dipendenze tipizzato del tuo patrimonio e risolve l'esatta fetta transitiva che una modifica tocca, con provenienza file:line e una prova di completezza. La traduzione è un caso d'uso a valle, e ogni strumento di traduzione ha comunque bisogno di questa mappa per sapere cosa una modifica tocca davvero.

Una finestra di contesto più grande o un modello migliore non risolveranno semplicemente questo?

No, e questo è il punto duraturo. Un patrimonio reale è da 1 to 10 million di righe o più e non entra in nessuna finestra di contesto, presente o futura. La parte difficile è recuperare l'esatta fetta transitiva e dimostrare di averla trovata tutta, che è un problema di topologia, retrieval ed evidenza, non un problema di qualità del ragionamento. Un modello perfetto ancora non può dimostrare a un regolatore quali dipendenze sono state recuperate, ha comunque bisogno di un ordine di estrazione sicuro, ed è comunque tenuto a un inventario di asset ICT.

Come dimostri a un auditor di aver trovato ogni dipendenza?

Il gate di completezza richiede che ogni PERFORM, CALL, COPY e riferimento DB2 si risolva oppure sia segnalato per revisione, mai scartato in silenzio. Sul fixture incluso sono 33 of 34 riferimenti risolti, cioè copertura del 97.1%, con l'unico riferimento irrisolvibile segnalato. Puoi esportare un Codebase Topology and Completeness Report stampabile con il riepilogo di nodi e archi, le chiusure per modulo con provenienza file:line, il risultato e il metodo di recall, la sequenza di estrazione classificata e l'elenco del dead-code, posizionato come inventario di asset ICT DORA e come ricevuta di change-control SOC-2.

Cosa succede con una dipendenza che non puoi risolvere, come una CALL dinamica?

Viene segnalata per revisione, non scartata in silenzio, e quel comportamento di onestà è il punto. Sul fixture l'unico riferimento irrisolvibile è la CALL dinamica WS-PROGNAME di DISPATCH, il cui target è calcolato a runtime (DISPATCH.cbl:15), quindi non può essere risolto staticamente. CodeGraph lo registra come da revisionare e classifica DISPATCH vicino alla fine dell'ordine di estrazione sicuro proprio per quel motivo.

Si collega al nostro mainframe, DB2 o scheduler z/OS?

Non in questa demo. Il grafo è in-memory più SQLite, e gli input DB2, JCL e dello scheduler sono fixture di file, mentre la vista naive a file singolo è una finestra di contesto simulata. Un deployment di produzione nominerebbe una piattaforma di grafo come Neo4j o Memgraph e leggerebbe il tuo patrimonio reale, ma nulla qui implica una pipeline z/OS live. La demo prova il meccanismo su un patrimonio sintetico, non un deployment.

In che modo è diverso da IBM watsonx Code Assistant o dalla toolchain di un grande SI?

Non pretendiamo di battere il parser di IBM o di un system integrator, e il parser della demo copre un sottoinsieme sintetico realistico di COBOL, non ogni dialetto, ALTER o OCCURS DEPENDING ON. La distinzione è il deliverable: un grafo di conoscenza repository-aware più una prova di completezza e un ordine di estrazione sicuro, piuttosto che una traduzione per file. È lo strato di comprensione di cui ogni sforzo di traduzione ha bisogno per primo, ed è lo strato che un modello di base migliore non elimina.

È un prodotto live o una demo?

È una demo eseguibile che prova il meccanismo, non una pipeline deployata. Il patrimonio bancario è sintetico e scritto per questa demo, quindi l'insieme vero delle dipendenze è noto per costruzione, ed è ciò che rende la metrica di recall una misura etichettata riproducibile piuttosto che una pretesa. Il parse, il grafo e tutte e quattro le analisi sono Python deterministico semplice (FastAPI più networkx, UI Cytoscape.js) che girano senza API key e senza database. Esiste uno strato LLM opzionale per il question answering ma è disattivato di default, e il valore non dipende da esso.

Ricerca tecnica

La ricerca dietro questa demo — l'architettura, il design di verifica e il blueprint enterprise.

Stai pianificando una modernizzazione mainframe?

Lo strato di comprensione è la parte difficile. Costruiamo prima la mappa.

Se il tuo team sta valutando come modernizzare un patrimonio COBOL senza una sorpresa in UAT da una dipendenza che nessuno poteva vedere, ci piacerebbe davvero sentire come ci state pensando. Il problema è di tutto il settore e anche le risposte lo saranno.

Assessment di topologia

  • ✓ Mappa dove una modifica può arrivare attraverso copybook, DB2 e JCL
  • ✓ Risolvi la chiusura transitiva con provenienza file:line
  • ✓ Valuta il recall del retrieval delle dipendenze rispetto a un insieme ground-truth
  • ✓ Produci la prova di completezza di cui i tuoi auditor hanno bisogno

Costruisci la mappa

  • ✓ Un grafo di conoscenza tipizzato sul tuo patrimonio reale
  • ✓ Un gate di completezza che segnala ciò che non può risolvere
  • ✓ Un ordine di estrazione strangler-fig classificato e difendibile
  • ✓ Un report esportabile di asset ICT DORA e change-control SOC-2
Social

Pubblicato anche su