Fortran – Numerik und Hochleistungsrechnen

Fortran (Formula Translation, 1957 von IBM) ist die älteste höhere Programmiersprache und bis heute der Standard für numerische Berechnungen, Wettervorhersage und Hochleistungsrechnen (HPC). Der aktuelle Standard heißt Fortran 2023; in der Praxis dominieren Fortran 90/95 und 2008. Compiler: gfortran (GNU), Intel ifx/ifort.

Compiler & Grundlagen

• gfortran --version – Compiler-Version prüfen
• gfortran -O2 -o prog prog.f90 – optimiert kompilieren
• gfortran -g -Wall -o prog prog.f90 – Debug- und Warnungs-Modus
• gfortran -fopenmp prog.f90 – OpenMP-Parallelisierung aktivieren
• Dateiendungen: .f (Fixed Form), .f90/.f95 (Free Form)

Basissyntax

program hello
  implicit none
  print *, 'Hallo, Welt!'
end program hello

• implicit none – erzwingt explizite Variablendeklaration (Pflicht in modernem Code)
• integer :: i, real :: x, double precision :: d, character(len=20) :: s, logical :: ok
• parameter für Konstanten: real, parameter :: pi = 3.14159
• Kommentare: ! (Free Form) bzw. c in Spalte 1 (Fixed Form)

Kontrollstrukturen

do i = 1, 10
  print *, i
end do

if (x > 0) then
  print *, 'positiv'
else if (x < 0) then
  print *, 'negativ'
else
  print *, 'null'
end if

select case (n)
case (1)
  print *, 'eins'
case default
  print *, 'anders'
end select

Arrays und Matrizen

real, dimension(100) :: a        ! 1D-Array, Index 1..100
real, dimension(10,10) :: m      ! 2D-Matrix
a(i) = 1.0
m(1,:) = 0.0                     ! erste Zeile
sum(a), maxval(a), minval(a)     ! Reduktionen
matmul(m1, m2)                   ! Matrixmultiplikation
where (a > 0) a = a * 2          ! maskierte Zuweisung

Funktionen, Subroutinen und Module

function quadrat(x) result(r)
  implicit none
  real, intent(in) :: x
  real :: r
  r = x * x
end function quadrat

subroutine tausche(a, b)
  real, intent(inout) :: a, b
  real :: tmp
  tmp = a; a = b; b = tmp
end subroutine tausche

module bündelt Funktionen, Typen und Konstanten und macht sie per use modulname importierbar – so entstehen saubere, wiederverwendbare numerische Bibliotheken.

Ein-/Ausgabe

• print *, 'Text', variablen – Ausgabe auf die Konsole
• read *, var – Eingabe von der Konsole
• open(unit=10, file='daten.txt') / close(10) – Datei öffnen/schließen
• write(10, *) werte / read(10, *) werte – in/aus Datei schreiben/lesen

Verwandte Einträge: MATLAB, Julia und R für Datenanalyse, sowie die Glossar-Begriffe Array und Algorithmus.

COBOL – Geschäftslogik im Mainframe

COBOL (Common Business Oriented Language, 1959) ist die Sprache der Banken, Versicherungen und Behörden. Noch heute laufen Milliarden Zeilen COBOL in Produktionssystemen – von Kontoführung über Gehaltsabrechnung bis zur Steuerverwaltung. Der freie Compiler GnuCOBOL (Kommando cobc) macht die Sprache auch auf Linux nutzbar.

Compiler

• cobc --version – Version prüfen
• cobc -x -o prog prog.cbl – ausführbares Programm bauen
• cobc -m modul.cbl – Modul/Bibliothek kompilieren
• cobc -x -Wall prog.cbl – mit Warnungen kompilieren
• Typische Dateiendungen: .cbl, .cob

Struktur: Die vier Divisionen

Jedes COBOL-Programm besteht aus vier Pflicht-Teilen:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. hallo.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 NAME PIC X(20).

       PROCEDURE DIVISION.
       MAIN.
           DISPLAY "Wie heisst du?".
           ACCEPT NAME.
           DISPLAY "Hallo, " NAME "!".
           STOP RUN.

• IDENTIFICATION DIVISION: Name und Metadaten (PROGRAM-ID)
• ENVIRONMENT DIVISION: Dateien und Umgebung (optional in modernem COBOL)
• DATA DIVISION: Datendefinitionen, WORKING-STORAGE SECTION für Variablen
• PROCEDURE DIVISION: die ausführbare Logik

Daten: PIC-Klauseln

• 01 Name PIC X(20). – alphanumerisch (Text), 20 Zeichen
• 01 Alter PIC 9(3). – Zahl mit 3 Stellen
• 01 Betrag PIC 9(6)V99. – 6 Stellen vor, 2 Nachkommastellen (implizites Dezimalkomma)
• 01 Wahr PIC 9 VALUE 0. – Schalter (0/1)

Wichtige Befehle

• MOVE wert TO ziel – Wert zuweisen (auch MOVE a TO b)
• DISPLAY ... – Ausgabe, ACCEPT var – Eingabe
• ADD a TO b, SUBTRACT a FROM b, MULTIPLY a BY b, DIVIDE a INTO b – Arithmetik
• COMPUTE erg = a * (b + c) – formelbasierte Berechnung
• IF bedingung THEN ... ELSE ... END-IF.
• EVALUATE var WHEN 1 ... WHEN OTHER ... END-EVALUATE. – Mehrfachverzweigung
• PERFORM para. – Absatz ausführen, PERFORM UNTIL bedingung ... END-PERFORM – Schleife
• GO TO para. – Sprung (verpönt, aber in Legacy-Code allgegenwärtig)
• STOP RUN. – Programm beenden

Beispiel: Schleife und Bedingung

       PROCEDURE DIVISION.
       MAIN.
           MOVE 1 TO I.
           PERFORM UNTIL I > 5
               IF FUNCTION MOD(I, 2) = 0
                   DISPLAY I " ist gerade"
               ELSE
                   DISPLAY I " ist ungerade"
               END-IF
               ADD 1 TO I
           END-PERFORM.
           STOP RUN.

COBOL bleibt relevant, weil Kernbankensysteme darauf laufen – oft kombiniert mit SQL für Datenbankzugriffe. Verwandte Begriffe: Datenbank, Compiler und Stack.

Pascal und Delphi – strukturierte Programmierung

Pascal (Niklaus Wirth, 1970) wurde als Lehr- und Systemsprache entwickelt und ist bekannt für klare Struktur, strenge Typisierung und lesbaren Code. Delphi (Embarcadero, früher Borland) erweitert Pascal zu Object Pascal mit Klassen, Properties und einer visuellen Entwicklungsumgebung (VCL/FMX). Der freie Compiler Free Pascal (fpc) mit der IDE Lazarus hält die Sprache am Leben.

Compiler

• fpc --version – Version prüfen
• fpc prog.pas – kompilieren (erzeugt prog)
• fpc -O2 prog.pas – mit Optimierung
• fpc -gl prog.pas – Debug-Info (gdb) einbinden
• Delphi/Windows: dcc32 prog.dpr (Kommandozeilen-Compiler)

Basissyntax

program hallo;
uses crt;
var
  name: string;
begin
  write('Wie heisst du? ');
  readln(name);
  writeln('Hallo, ', name, '!');
end.

• program – Programmkopf, uses – Units/Bibliotheken einbinden
• var – Variablendeklaration: i: integer; x: real; s: string; ok: boolean; c: char;
• const – Konstanten: const pi = 3.14159;
• type – eigene Typen/Records: type Punkt = record x, y: integer; end;
• Blöcke: begin ... end (Ende des Programms mit end. – Punkt!)

Kontrollstrukturen

if x > 0 then
  writeln('positiv')
else
  writeln('negativ');

case n of
  1: writeln('eins');
  2: writeln('zwei');
else
  writeln('anders');
end;

for i := 1 to 10 do
  writeln(i);

while x < 100 do
  x := x * 2;

repeat
  readln(eingabe)
until eingabe = 'ende';

Prozeduren und Funktionen

function quadrat(x: integer): integer;
begin
  quadrat := x * x;   { Pascal weist das Ergebnis dem Funktionsnamen zu }
end;

procedure begruesse(name: string);
begin
  writeln('Hallo, ', name);
end;

Object Pascal / Delphi

type
  TPerson = class
  private
    FName: string;
  public
    constructor Create(aName: string);
    procedure Vorstellen;
  end;

constructor TPerson.Create(aName: string);
begin
  FName := aName;
end;

procedure TPerson.Vorstellen;
begin
  writeln('Ich bin ', FName);
end;

• Klassen: class mit private/public-Bereichen
• Properties: property Name: string read FName write FName;
• Vererbung: TKind = class(TPerson)
• Units: jede Unit in eigener .pas-Datei mit interface/implementation

Unit-Aufbau (Free Pascal / Lazarus)

unit meineunit;

interface
function verdoppeln(x: integer): integer;

implementation
function verdoppeln(x: integer): integer;
begin
  verdoppeln := x * 2;
end;

end.

Verwandte Einträge: C und C++ für Systemprogrammierung, Python für moderne Alternativen, sowie die Glossar-Begriffe Compiler, Adresse (Speicher) und Stack.

GraphQL ist eine Abfragesprache für APIs, die 2015 von Facebook entwickelt wurde. Anders als bei REST ruft der Client genau die Felder ab, die er braucht — in einer einzigen Anfrage.

Grundstruktur einer Query

query {
  user(id: 42) {
    name
    email
  }
}

Eine Mutation verändert Daten, eine Subscription empfängt Live-Updates:

mutation { createUser(name: "Anna") { id } }
subscription { newMessage { text } }

Schema und Typen

type User {
  id: ID!
  name: String!
  email: String
}

Ausrufezeichen (!) bedeutet: Feld ist Pflicht. ID, String, Int, Float, Boolean sind die eingebauten Skalartypen.

Variablen und Aliase

query GetUser($id: ID!) {
  user(id: $id) { name }
}

Praxis-Tipps

• Ein Endpunkt (z.B. /graphql), eine POST-Anfrage — kein Overfetching und kein Underfetching.
• Zum Testen eignen sich Tools wie GraphiQL oder Altair.
• Fehler kommen als errors-Array in der Antwort, nicht als HTTP-Statuscode.

Verwandte Grundlagen: SQL-Befehle und Python-Befehle.