Picat ist eine logikbasierte, multiparadigmatische Programmiersprache von Neng-Fa Zhou (City University of New York), die erstmals 2013 veröffentlicht wurde. Sie verbindet Logikprogrammierung, funktionale Programmierung, Constraint Solving, dynamische Programmierung mit Tabling und Skripting — speziell entworfen für kombinatorische Suchprobleme und Planung.

Start und REPL

picat             # interaktive REPL starten
picat programm.pi # Skript ausführen

Constraint Solving: CP, SAT und MIP

Picat bietet eine gemeinsame Schnittstelle zu drei Solver-Modulen — CP (Constraint Programming), SAT (Boolesche Erfüllbarkeit) und MIP (Mixed Integer Programming). Derselbe Code kann durch einfaches Umschalten des Moduls mit verschiedenen Lösern laufen:

import cp.
main =>
    Vars = [X, Y],
    Vars :: 1..10,
    X + Y #= 12,
    solve(Vars),
    writeln(Vars).

Die Direktiven import cp., import sat. bzw. import mip. wählen das Solver-Modul; #= ist das Gleichheits-Constraint, :: legt die Domäne fest, solve sucht eine Lösung.

Tabling und Planung

Die table-Direktive speichert Zwischenergebnisse von Prädikaten (Memoization) und macht dynamische Programmierung natürlich — so lassen sich z.B. Fibonacci-Folgen oder kürzeste Pfade ohne explizite Schleifen formulieren. Das integrierte planner-Modul löst Planungsaufgaben mit heuristischer Suche und dem best_plan-Prädikat.

Sprachmittel

• Funktionen und Prädikate gleichberechtigt (funktional-logische Programmierung)
• Pattern-Matching und List-Comprehensions
• Strukturen, Arrays, Maps und Pools für Datensammlungen
• Strikte Typprüfung optional

Verwandte Grundlagen: Answer-Set-Programming-Befehle, Clingo-Befehle, Prolog-Befehle.

Answer Set Programming (ASP) ist ein deklaratives Paradigma der Logikprogrammierung, bei dem ein Problem als logisches Programm beschrieben wird und ein Answer-Set-Solver die Lösungen — die sogenannten stable models — berechnet. Die Semantik geht auf Michael Gelfond und Vladimir Lifschitz (1988) zurück und erweitert die klassische Logikprogrammierung um default negation (Negation als Fehlen von Beweisen).

Grundidee

Ein ASP-Programm besteht aus Fakten, Regeln und Constraints. Regeln haben die Form Kopf :- Körper; der Kopf gilt, wenn alle Bedingungen im Körper erfüllt sind. Constraints sind Regeln ohne Kopf — sie schließen unerwünschte Lösungen aus. Ein Stable Model ist eine Menge von atomaren Aussagen, die alle Regeln erfüllt und sich selbst „stützt“.

Typische Befehle

Der klassische Workflow trennt Grounding und Solving. Das Potassco-Ökosystem der Universität Potsdam bündelt beides:

gringo programm.lp | clasp -n 0

Der Grounder gringo instanziiert die Variablen (erzeugt ein variablenfreies Programm), der Solver clasp berechnet die Stable Models. Das moderne Werkzeug clingo vereint beide Schritte in einem Programm:

clingo programm.lp -n 0

Wichtige Optionen: -n 0 liefert alle Modelle, --stats zeigt Statistiken, --opt-mode=optN steuert die Optimierung, --enum-mode beeinflusst die Modell-Aufzählung. Neben Potassco gibt es mit DLV einen weiteren verbreiteten ASP-Solver.

Einsatzgebiete

• Konfigurations- und Planungsprobleme (z.B. Produktkonfiguration)
• Diagnose und Fehlererkennung in technischen Systemen
• Wissensrepräsentation mit nichtmonotonem Schließen
• Kombinatorische Optimierung (Team-Zusammenstellung, Stundenplanung)

Verwandte Grundlagen: Clingo-Befehle, Picat-Befehle, Prolog-Befehle.

Opa ist eine quelloffene, funktionale Programmiersprache für skalierbare Web-Anwendungen, entwickelt von MLstate (einem Spin-off des INRIA-Umfelds). Die zentrale Idee: Client, Server und Datenbank werden in einer Sprache geschrieben und mit durchgängiger statischer Typprüfung zu Webstandards kompiliert — JavaScript für den Browser, Node.js auf dem Server.

Ein Sprache für den ganzen Stack

In Opa definiert der Entwickler Datenbank-Schemata, Server-Logik und Client-UI gemeinsam. Der Compiler trennt den Code automatisch auf, generiert die nötige Serialisierung (JSON) und stellt die Verbindung zwischen Client und Server her. Typspezifische Prüfungen verhindern ganze Fehlerklassen (z. B. inkonsistente Datenbankzugriffe) schon zur Compilezeit.

Erste Schritte

opa hello.opa             # kompiliert und startet die Anwendung
opa --help                # Optionen anzeigen

Server-Beispiel

function start() {
    Resource.page("Hallo Opa", <h1>Hallo Welt</h1>)
}

Server.start(Server.http, { title: "Hallo", page: start })

Dabei liefert Server.start den HTTP-Endpunkt, Resource.page baut eine HTML-Seite, und die XML-artige Syntax <h1>…</h1> ist direkt in die Sprache eingebettet (typspezifische Syntax wie in Wyvern).

Datenbank-Zugriff

database /@register       // Datenbank registrieren
type User = { name: string, email: string }
db /users = Map.empty     // persistentes Map-Schema

function addUser(u) {
    /users[u.name] = u
}

Der Pfad-Präfix /@ markiert Datenbank-Deklarationen, einfache Zuweisungen an Pfade speichern Werte persistent. Die Serialisierung übernimmt der Compiler vollständig.

Praxis-Tipps

• Opa unterstützt das MVC-Muster und bietet Scaffolding, um schnell zu einer laufenden Anwendung zu kommen.
• Der Compiler erzeugt Client- und Server-Code aus einem Quelltext — für kleine Apps ist ein einziges opa app.opa der schnellste Weg.
• Das Projekt ist heute vor allem historisch/akademisch interessant, zeigt aber modernes Full-Stack-Design (eine Sprache, durchgängige Typen) bereits 2011.

Verwandte Grundlagen: JavaScript-Befehle, OCaml-Befehle, Haskell-Befehle, Elm-Befehle, Oz-Befehle, Wyvern-Befehle.

Oz ist eine multiparadigmatische Programmiersprache, die im Programming Systems Lab der Université catholique de Louvain und der Universität des Saarlandes für die Programmierausbildung entwickelt wurde. Das kanonische Lehrbuch „Concepts, Techniques, and Models of Computer Programming“ (Peter van Roy, Seif Haridi) baut vollständig auf Oz auf. Die Implementierung heißt Mozart (Mozart 2 als aktuelle Version).

Kernkonzepte

Oz vereint funktionale, logische, constraintbasierte, objektorientierte und nebenläufige Programmierung in einer einzigen Sprache. Zentrale Idee sind Datenfluss-Variablen: Eine Variable ist zunächst ungebunden und wird erst durch eine Zuweisung (X = 42) determiniert — lesende Operationen warten automatisch, bis der Wert verfügbar ist. Auf dieser Basis entstehen nebenläufige Programme ohne explizite Locks. Ein weiteres Alleinstellungsmerkmal sind Ports als leichtgewichtiges Actor-Modell, konzeptionell verwandt mit Erlangs Message-Passing-Prozessen.

Der Compiler: ozc

ozc -c Foo.oz            # kompiliert Foo.oz zu Foo.ozf (gepickelter Code)
ozc -x Foo.oz            # kompiliert und erzeugt ausführbare Datei (Unix: Foo, Windows: Foo.exe)
ozengine Foo.ozf         # führt eine .ozf-Datei aus
ozemulator                # startet den grafischen Oz-Emulator
ozwish                    # Tcl/Tk-Shell für Oz
{Browse 'Hallo Welt'}     # Ausgabe im Oz-Browser (Emulator)

Syntax-Highlights

local X in
   X = 42
   {Browse X}
end

fun {Fakultaet N}
   if N =< 0 then 1 else N * {Fakultaet N-1} end
end

Constraints und Suche

Oz enthält eine ausgereifte Constraint-Programmierung über endliche Domänen (FD). Variablen erhalten eine Domäne, Constraints schränken sie ein, und die eingebaute Suche findet Lösungen:

declare
proc {VierFarben Problem}
   %% Variablen mit FD.int-Domäne deklarieren
in
   {FD.distribute ff Problem}
end
{Search.base.all VierFarben}

Die Prozeduren Choice und fail steuern die Suchverzweigung, Search sammelt Lösungen. In der OPI (Emacs-Schnittstelle) wird Code mit oz-compile-command (Standard: ozc -c %s) kompiliert.

Praxis-Tipps

• Im interaktiven Modus brauchen Definitionen ein declare vor der ersten Verwendung.
• Aus .ozf-Dateien lassen sich mit ozc -x plattformunabhängig ausführbare Programme erzeugen.
• Für Lernzwecke ist die Kombination aus Emacs-OPI und {Browse} am schnellsten — der Browser zeigt Werte und Datenfluss direkt an.

Verwandte Grundlagen: Euler-Befehle, PL/0-Befehle, Simula-Befehle, Scheme-Befehle, Wyvern-Befehle, Opa-Befehle.