Fortress war eine von Sun Microsystems Laboratories entwickelte Forschungssprache für paralleles Rechnen. Das Projekt wurde maßgeblich von Guy L. Steele Jr. geleitet und 2006 erstmals vorgestellt. Fortress sollte die Lehren aus Java auf die Programmierung von Multicore- und Massiv-Parallel-Systemen übertragen — der Name ist bewusst an „Fortran“ angelehnt, weil numerisches Rechnen im Fokus stand.

Design und Besonderheiten

• Parallele Schleifen als Sprachkonstrukt: for i <- 1:10 do ... end führt Iterationen automatisch parallel aus.
• Locales und Regionen: Verteilte Speicherhierarchien werden explizit adressiert (do ... in locale).
• Mathematische Notation: Unicode-basierte Syntax erlaubt x := 1, griechische Symbole und Formeln wie im Mathematikbuch; Kommentare (*) ... *).
• Beliebig große Zahlen: Die Typen ZZ (unbegrenzte Ganzzahlen) und RR (reelle Zahlen) sind eingebaut — kein Overflow wie bei festen Breiten.
• Zwanglose Parallelität: Ausdrücke sind nebenläufig auswertbar, wo es keine Abhängigkeiten gibt; atomic-Blöcke und Transaktionen ergänzen das Modell.

Kommandozeile

fortress script.frs    // Interpreter fuer Fortress-Programme
fortressc              // Compiler (JVM-Backend)
fortress -e "..."      // Ausdruck direkt auswerten
fortress -p file.frs   // Parser-Test

Ein klassisches Hallo-Welt-Programm:

component hello
  export Executable
  run() = println("Hallo Fortress")
end

Projektende

Nach der Übernahme von Sun durch Oracle wurde das Fortress-Projekt im Juli 2012 eingestellt. Die Spezifikation (Version 1.0) und die Referenzimplementierung wurden als Open Source veröffentlicht und sind weiterhin archiviert. Fortress gilt heute als wichtiger Meilenstein der Parallelsprachen-Forschung — viele Ideen wie explizite Nebenläufigkeit und mathematische Syntax fanden später Eingang in andere Sprachen.

Verwandte Grundlagen

Fortress steht in der Tradition von Java-Befehle (Sun-Herkunft) und Haskell-Befehle (funktionale Wurzeln). Parallelitäts-Konzepte vertiefen Nebenläufigkeit, Multikern-Prozessor und Amdahlsches Gesetz.

Klong ist eine kleine, leicht erlernbare Array-Programmiersprache, die Nils M. Holm als vereinfachte Variante von K entwickelt hat. Sie übernimmt die kompakte Symbolik der K-Familie, vermeidet aber deren Mehrdeutigkeiten und ist dadurch deutlich zugänglicher. Der Name stammt von „K-long“.

Erste Schritte

Klong läuft als Interpreter (Programm kg) mit interaktiver REPL. Einfache Ausdrücke werden direkt ausgewertet:

kg
?"Hallo Klong"
1+2*3

Variablen weist man mit : zu, Funktionen definiert man mit f:{...} und ruft sie mit f(x) auf. Kommentare beginnen mit //.

Monaden, Diaden und Arrays

• Monade: Operator mit einem Argument, z.B. -x (Negation), #x (Länge), |x (Reverse), ^x (Aufsteigend sortieren).
• Diade: Operator mit zwei Argumenten, z.B. a+b, a*b, a!b (Permutation/Index), a?b (Finden), a@b (Teil-Array/Index).
• Listen werden in eckigen Klammern geschrieben: a:[1 2 3 4 5], Zugriff über a@1 (nullbasiert).
• Wie in der K-Familie gilt: Operatoren arbeiten automatisch elementweise auf Arrays — a*2 verdoppelt jedes Element.

Kontrollfluss

:{[x] ...}          // anonyme Funktion (Lambda)
:{x*2}              // Verdoppeln
{x*x}'[1 2 3]       // each-Map: [1 4 9]
+/[1 2 3 4]         // Summe: 10 (Fold mit +)
:> 1 2 3            // sortiert aufsteigend
&[1 2 3]>[2 1 3]   // & = Tiefe/Depth, > = groesser

Klong ist bewusst auf die Kernkonzepte der K-Familie reduziert (Atome, Arrays, Verben, Adverbien), besitzt aber auch einen eingebauten JSON-artigen Ausgabe-Modus. Als Implementierung existiert neben dem klassischen C-Interpreter mit KlongPy eine vektorisierte Python-Variante mit optionaler GPU-Beschleunigung über PyTorch.

Verwandte Grundlagen

Klong gehört zur Familie der Array-Sprachen: APL-Befehle, Q-Befehle (kdb+), K-Befehle, J-Befehle, Nial-Befehle, Ivy-Befehle und BQN-Befehle. Datenanalytisch sinnvoll sind auch Python-Befehle.

Futhark ist eine rein funktionale, datenparallele Array-Programmiersprache, die an der Universität Kopenhagen (UCPH) im Projekt HIPERFIT entwickelt wurde. Sie gehört zur ML-Familie und übersetzt hochsprachliche Array-Programme in effizienten parallelen Code für GPUs (OpenCL, CUDA) und CPUs.

Erste Schritte

Ein Futhark-Programm (Endung .fut) besteht aus let-Bindungen und einer main-Funktion:

let double (x: i32) : i32 = x * 2
let main (xs: []i32) : []i32 = map double xs

Typische Typen sind i32, i64, f32, f64, bool sowie Arrays mit [] (z.B. []i32) und Tupel.

Die wichtigsten Kommandos

futhark repl            // interaktive REPL zum Ausprobieren
futhark c program.fut   // sequenzieller C-Code (CPU, zum Testen)
futhark opencl program.fut  // GPU-Code ueber OpenCL
futhark cuda program.fut    // GPU-Code ueber CUDA
futhark py program.fut      // Python-Erweiterungsmodul
futhark bench program.fut   // Benchmark gegen C-Referenz
futhark test program.fut    // Tests ausfuehren
futhark dev               // Entwickler-/Debug-Backend

Die kompilierten Backends erzeugen lauffähige Programme, die aus anderen Sprachen (C, Python, Rust) eingebunden werden können.

Datenparallele Kernoperationen (SOACs)

• map — elementweise Abbildung (entspricht parallel for).
• reduce — parallele Faltung, z.B. reduce (+) 0 xs für die Summe.
• scan — parallele Präfixsumme.
• map2, zip, filter, partition — weitere Array-Operationen.
• Verschachtelte Parallelität wird automatisch flach transformiert (Flattening) und auf die GPU-Einheiten verteilt.

Dank der reinen Funktionalität (keine Seiteneffekte) kann der Compiler Speicherzugriffe frei umordnen und dadurch hohe Auslastung der GPU-Kerne erreichen. Die Sprache ist Open Source (ISC-Lizenz) und unter futhark-lang.org dokumentiert.

Verwandte Grundlagen

Futhark ergänzt die Familie der Array-Sprachen: APL-Befehle, Q-Befehle, BQN-Befehle, Ivy-Befehle. Von der ML-Tradition her ist OCaml-Befehle verwandt, für GPU-nahe Arbeit auch WebGPU-Befehle.

yq ist ein Kommandozeilen-Werkzeug zum Lesen und Verändern von YAML-Dateien. Die verbreitetste Implementierung stammt von Mike Farah (Go, mikefarah/yq) und verwendet eine an jq angelehnte Ausdruckssprache — wer jq kennt, findet sich sofort zurecht. Zusätzlich zu YAML verarbeitet yq auch JSON, XML, INI, TOML, CSV und Properties-Dateien.

Grundlagen

yq eval '.spec.replicas' deploy.yaml   # Wert lesen
yq eval '.' datei.yaml                 # YAML hübsch ausgeben / validieren
yq eval '.a.b = 2' -i datei.yaml       # Wert setzen (-i: in-place)
yq eval 'del(.metadata.uid)' -i pod.yaml  # Feld entfernen

Der Ausdruck .spec.replicas greift verschachtelt in die YAML-Struktur. Ohne -i schreibt yq das Ergebnis auf die Standardausgabe, die Datei bleibt unverändert.

Mehrere Dokumente und Merges

yq eval-all 'select(di == 0)' multi.yaml    # erstes Dokument eines Multi-Doc
yq eval-all 'select(di == 0) * select(di == 1)' a.yaml b.yaml  # Dokumente mergen
yq eval '.a' file1.yaml file2.yaml           # je Datei auswerten

Mit eval-all verarbeitet yq mehrere Dokumente gleichzeitig; di ist der Dokument-Index. Damit lassen sich Helm-Werte, Kubernetes-Manifeste oder CI-Konfigurationen zusammenführen.

Praxis-Tipps

• Für Kubernetes-Manifeste kann yq direkt mit kubectl kombiniert werden: kubectl get deploy -o yaml | yq eval '.spec'.
• Es gibt eine zweite, ältere Python-Implementierung (kislyuk/yq), die jq-Syntax direkt nutzt und YAML über jq verarbeitet — die Kommandos unterscheiden sich leicht.
• YAML selbst ist im Glossar unter YAML erklärt, der Überblick über Datenformate unter YAML, TOML und JSON.

Verwandte Werkzeuge: Neben jq für JSON passen kubectl und Terraform, deren Konfigurationen ebenfalls YAML-basiert sind, in dieselbe Werkzeugkiste.