Deklarative Programmierung

Die deklarative Programmierung ist ein Programmierparadigma, bei dem die Beschreibung des Problems im Vordergrund steht. Der Lösungsweg wird dann automatisch ermittelt. Im Gegensatz zur imperativen Programmierung, bei der das Wie im Vordergrund steht, fragt man in der deklarativen Programmierung nach dem Was, das berechnet werden soll. Bekannte Vertreter deklarativer Programmiersprachen sind Haskell, Lisp, Prolog, XAML und im weiteren Sinne auch SQL und XSLT. Den deklarativen Sprachen stehen die weiter verbreiteten imperativen Sprachen wie C, C++ oder Java gegenüber.

Die Unterschiede der beiden Herangehensweisen werden bei der Implementierung eines Algorithmus am deutlichsten, den man als Kombination von Arbeits- und Steuermechanismus betrachten kann:

• Deklarative Sprachen ermöglichen eine Trennung der beiden Bestandteile.
• Dagegen ist bei Verwendung einer imperativen Programmiersprache eine Trennung von Arbeits- und Steuermechanismus kaum möglich. Imperative Sprachen beschreiben Berechnungsabläufe; damit lassen sich imperative Programme als Anweisungen an die Maschine verstehen, auf der sie ablaufen.

Deklarative Sprachen

Zu den deklarativen Sprachen gehören:

• Abfragesprachen (z. B. SQL)
• Datenflusssprachen (z. B. Val oder Linda)
• funktional-logische Sprachen (z. B. Babel, Escher, Curry, Oz)
• funktionale Sprachen (z. B. ML, Miranda, Gofer, Haskell, Erlang)
• logische Sprachen (z. B. Prolog)
• Synchrone Programmiersprachen (z. B. Lustre)
• Aufbauwerkzeuge (z. B. make oder Ant)
• Transformationssprachen (z. B. XSLT)

Beispiel

Der Quicksort-Sortierungsalgorithmus kann in der imperativen Programmiersprache Pascal folgendermaßen aufgeschrieben werden:

procedure quicksort(l, r: Integer);
var
  x, i, j, tmp: Integer;
begin
  if r > l then
  begin
    x := a[l]; i := l; j := r + 1;
    repeat
      repeat
        i := i + 1;
      until a[i] >= x;
      repeat 
        j := j - 1;
      until a[j] <= x;

      // exchange a[j] and a[i]
      tmp := a[j]; a[j] := a[i]; a[i] := tmp;
    until j <= i;

    // exchange a[j] and a[l]
    tmp := a[j]; a[j] := a[l]; a[l] := tmp;
    quicksort(l, j - 1);
    quicksort(j + 1, r);
  end
end;

Der Programmierer beschreibt, wie der Algorithmus ablaufen muss. Es wird der Lösungsweg vorgegeben, also welche einzelnen Schritte nacheinander ablaufen und wie Variablen zu verändern sind, um schließlich zum Ergebnis zu kommen.

Ein ähnlicher Algorithmus kann in der deklarativen Programmiersprache Haskell folgendermaßen formuliert werden:

quicksort [] = []
quicksort (x:xs) = quicksort [n | n<-xs, n<x] ++ [x] ++ quicksort [n | n<-xs, n>=x]

Der Programmierer beschreibt, was das Programm mit einer Eingabe macht, also wie mit welcher Eingabe umzugehen ist, wobei der Berechnungsablauf nicht von Interesse ist. Die Berechnungen erfolgen dann durch Wertemanipulation. Hauptkontrollstruktur bildet die Rekursion, aus Effizienzgründen besonders die Endrekursion. Es handelt sich hier aber nicht mehr um einen Quicksort-Algorithmus, da Quicksort ein in-Place-Verfahren ist, welches die bestehende Liste manipuliert und nicht wie der vorliegende Algorithmus eine neue Liste erzeugt.

Vorzüge

• Die Programme sind oft kürzer als vergleichbare imperative Programme.
• Beweise (z. B. Korrektheitsbeweis, Beweise über Programmeigenschaften) sind dank einfacherer mathematischer Basis (u. a. Lambda-Kalkül) leichter durchführbar, falls überhaupt möglich.
• Es gibt keine Nebenwirkungen aufgrund der referentiellen Transparenz. Programme sind damit partiell auswertbar und ermöglichen so z. B. die Behandlung unendlicher Datenstrukturen.^[1]

Siehe auch

• Domain-driven Design, ein Ansatz für den Entwurf des Domänenmodells, der ein deklaratives Design propagiert

Einzelnachweise

1. ↑ Manuel M. T. Charkravarty: On the Massively Parallel Execution of Declarative Programs. (.ps.gz 343KiB) Dissertation. TU Berlin, 14. Februar 1997, S. 166, abgerufen am 16. Oktober 2011 (englisch).