Enterprise-Sprachen

3 Billionen Dollar. Jeden Tag. Das ist das Transaktionsvolumen, das auf COBOL-Code läuft – einer Sprache, die älter ist als die meisten Menschen, die sie noch verstehen.

Grace Hopper und CODASYL

1959 brachte Grace Hopper – eine der brillantesten Köpfe der Computergeschichte – eine Gruppe von Unternehmen zusammen: das CODASYL-Komitee. Ihr Ziel: Eine Sprache, die wie Englisch lesbar ist.

• COBOL = Common Business-Oriented Language
• Selbstdokumentierend – Code liest sich wie Prosa
• Portabel – läuft auf verschiedenen Mainframes
• Business-fokussiert – Dezimalzahlen, Berichte, Dateien

Die Design-Philosophie

Hopper glaubte: Manager sollten Programme lesen können. Das Ergebnis ist heute kontrovers – aber funktional:

MULTIPLY PRICE BY QUANTITY GIVING TOTAL.

Kein Mensch schreibt heute so. Aber kein Code überlebte so lange.

Fun Fact: Grace Hopper erfand auch den Compiler und prägte den Begriff "Debugging" – als sie eine echte Motte aus einem Computer entfernte.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. INVOICE-CALC.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 PRICE         PIC 9(5)V99.
       01 QUANTITY      PIC 9(3).
       01 SUBTOTAL      PIC 9(7)V99.
       01 TAX-RATE      PIC V99 VALUE 0.19.
       01 TAX-AMOUNT    PIC 9(6)V99.
       01 TOTAL         PIC 9(8)V99.

       PROCEDURE DIVISION.
           MULTIPLY PRICE BY QUANTITY
               GIVING SUBTOTAL.
           MULTIPLY SUBTOTAL BY TAX-RATE
               GIVING TAX-AMOUNT.
           ADD SUBTOTAL TAX-AMOUNT
               GIVING TOTAL.

           DISPLAY "TOTAL: " TOTAL.
           STOP RUN.

      * Lesbar wie Englisch - 1959's Vision
      * Läuft 2024 noch auf Mainframes

1964 kündigte IBM das System/360 an – die wichtigste Produktankündigung in der Geschichte der Computer. Eine Familie von Rechnern, alle kompatibel, alle mit COBOL.

Das System/360

• $5 Milliarden Entwicklungskosten (inflationsbereinigt: ~$50 Mrd.)
• Kompatibilität – Software läuft auf allen Modellen
• CICS – Transaktionsverarbeitung in Echtzeit
• IMS – Datenbankmanagement

Die Dominanz

IBM dominierte den Enterprise-Markt für Jahrzehnte:

• z/Series – der Nachfolger, heute noch verkauft
• JCL – Job Control Language für Batch-Verarbeitung
• TSO/ISPF – die "IDE" der Mainframe-Welt

Warum Mainframes nicht sterben

Ein moderner IBM z16 Mainframe kann:

• 19 Milliarden verschlüsselte Transaktionen pro Tag
• 99,999% Verfügbarkeit (5 Minuten Downtime pro Jahr)
• Alten COBOL-Code aus den 70ern ausführen

Fun Fact: 92 der 100 größten Banken weltweit nutzen IBM Mainframes. Das Internet-Banking, das Sie nutzen, läuft wahrscheinlich auf 50 Jahre altem Code.

//PAYROLL  JOB (ACCT),'MONTHLY PAYROLL',
//         CLASS=A,MSGCLASS=X
//*
//* IBM Mainframe Job Control Language
//* Batch-Verarbeitung der 1960er Jahre
//*
//STEP1    EXEC PGM=PAYROLL
//INFILE   DD DSN=PROD.EMPLOYEE.MASTER,DISP=SHR
//OUTFILE  DD DSN=PROD.PAYROLL.OUTPUT,
//            DISP=(NEW,CATLG,DELETE),
//            SPACE=(CYL,(10,5)),
//            DCB=(RECFM=FB,LRECL=200)
//SYSPRINT DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//*
//* Dieser Job könnte aus 1975 stammen
//* Er läuft 2024 noch genauso

Seit den 90ern versucht die IT-Welt, COBOL loszuwerden. Java, .NET, SOA – alles sollte der Mainframe-Killer sein. Keines wurde es.

Java EE (1995)

Suns Versprechen: "Write once, run anywhere." Enterprise JavaBeans, Application Server, Middleware-Monster. Java wurde tatsächlich wichtig – aber ersetzte COBOL nicht.

.NET (2002)

Microsofts Antwort: Ein komplettes Enterprise-Framework. C#, ASP.NET, SQL Server – eine geschlossene Welt. Erfolgreich, aber Mainframes blieben.

Y2K - Die unerwartete Renaissance

1999 wurde COBOL plötzlich kritisch. Der Millennium-Bug drohte, weil COBOL-Programme Jahreszahlen zweistellig speicherten. Die Lösung: COBOL-Programmierer aus dem Ruhestand zurückholen.

• $300 Milliarden wurden weltweit für Y2K ausgegeben
• Viele Rentner verdienten $100+/Stunde
• Das Ergebnis: Der Code wurde repariert, nicht ersetzt

Fun Fact: Nach Y2K gab es Diskussionen, COBOL endlich abzulösen. 20 Jahre später läuft mehr COBOL-Code als je zuvor.

// Java EE - Der "COBOL-Killer" der 90er

@Stateless
public class InvoiceService {

    @PersistenceContext
    private EntityManager em;

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public BigDecimal calculateTotal(Long invoiceId) {
        Invoice invoice = em.find(Invoice.class, invoiceId);

        BigDecimal subtotal = invoice.getPrice()
            .multiply(invoice.getQuantity());

        BigDecimal tax = subtotal
            .multiply(new BigDecimal("0.19"));

        return subtotal.add(tax);
    }
}

// Java: 20 Zeilen + Annotations + XML-Config
// COBOL: 15 Zeilen, läuft seit 1975

// Beide machen dasselbe.
// COBOL läuft auf einem Mainframe mit 99,999% Uptime.

Die Wahrheit ist unbequem: Legacy-Systeme abzulösen ist teuer, riskant und oft unnötig. Stattdessen baut man Brücken.

Die Kosten der Ablösung

• Commonwealth Bank of Australia: $750 Millionen, 5 Jahre
• TSB Bank UK: Ablösung gescheitert, Milliardenverlust
• Viele Projekte: Abgebrochen nach Jahren und Millionen

Die moderne Strategie: APIs

Statt den Mainframe zu ersetzen, stellt man APIs davor:

• REST APIs vor CICS-Transaktionen
• Microservices für neue Funktionen
• Event-Streaming (Kafka) für Integration

Das Strangler Fig Pattern

Martin Fowler beschrieb es: Wie eine Würgefeige langsam einen Baum ersetzt, können neue Services langsam Legacy-Funktionen übernehmen – ohne Big Bang.

Der Mainframe wird zum "System of Record" – die Wahrheit. Moderne Services drum herum liefern UX und Agilität.

Fun Fact: Manche Unternehmen zahlen COBOL-Entwicklern inzwischen mehr als JavaScript-Entwicklern. Die Nachfrage übersteigt das Angebot.

// Moderne API vor Legacy-Mainframe

// Node.js Service als Brücke
app.post('/api/v1/transfer', async (req, res) => {
    const { from, to, amount } = req.body;

    // Validierung im modernen Service
    if (amount > 10000) {
        await complianceCheck(from, to, amount);
    }

    // Der eigentliche Transfer: COBOL auf dem Mainframe
    const result = await mainframeGateway.execute({
        transaction: 'XFER001',
        params: {
            'FROM-ACCT': from.padStart(10, '0'),
            'TO-ACCT': to.padStart(10, '0'),
            'AMOUNT': (amount * 100).toString().padStart(12, '0')
        }
    });

    // Moderne Response
    res.json({
        transactionId: result.txId,
        status: 'completed',
        timestamp: new Date().toISOString()
    });
});

// Frontend: React
// API: Node.js
// Kernlogik: COBOL von 1985

Die neueste Entwicklung: KI versteht COBOL. GitHub Copilot, AWS Mainframe Modernization, IBM watsonx – alle können Legacy-Code analysieren und transformieren.

Was KI heute kann

• Code-Analyse – Millionen Zeilen COBOL verstehen
• Dokumentation – vergessenen Code erklären
• Transformation – COBOL zu Java/C# konvertieren
• Testing – Testfälle aus Production-Daten generieren

Die neue Strategie

Statt "alles neu schreiben" oder "alles behalten":

• Verstehen – KI dokumentiert Legacy-Code
• Modernisieren – kritische Teile neu schreiben
• Integrieren – APIs, Events, Cloud
• Koexistieren – Alt und Neu parallel

Die Ironie der Geschichte

Grace Hopper wollte, dass Computer menschliche Sprache verstehen. 65 Jahre später erklärt eine KI in menschlicher Sprache, was Hoppers Code-Generation bedeutet.

COBOL stirbt nicht – es wird von KI verstanden und in die Zukunft getragen.

> Analysiere COBOL-Programm PAYROLL.cbl

KI-Analyse:
─────────────────────────────────────────
Programm: PAYROLL (ca. 1978)
Zeilen: 4,847
Komplexität: Mittel

Hauptfunktionen:
1. Mitarbeiterdaten aus VSAM lesen
2. Gehalt berechnen (Basis + Überstunden)
3. Steuern berechnen (7 verschiedene Länder)
4. Ausgabe in Report-Format

Abhängigkeiten:
- EMPLOYEE-MASTER (IMS)
- TAX-TABLES (VSAM)
- CICS Transaction PAYR

Risiken:
⚠ Hardcodierte Steuersätze (Zeile 2341-2567)
⚠ Y2K-Fix von 1999 (Zeile 891)
⚠ Keine Unit Tests vorhanden

Empfehlung:
→ Steuertabellen externalisieren
→ API-Layer für moderne Integration
→ Kernlogik behalten (bewährt seit 46 Jahren)

// KI versteht Legacy-Code besser als Menschen