Deklarative Programmierung

Die deklarative Programmierung ist ein Programmierparadigma, bei dem die Beschreibung des Problems im Vordergrund steht. Der Lösungsweg wird dann automatisch ermittelt. Zu den deklarativen Programmiersprachen gehören:

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

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. Der Unterschied soll an folgendem populären Beispiel demonstriert werden.

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;
       tmp:=a[j]; a[j]:=a[i]; a[i]:=tmp;
     until j<=i;
     a[i]:=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.

Derselbe Sortierungsalgorithmus 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.

Vorteile

• Die Programme sind kürzer und leichter zu verstehen als vergleichbare imperative Programme.
• Es gibt keine Nebenwirkungen aufgrund der referentiellen Transparenz. Programme sind damit partiell auswertbar und ermöglichen so z. B. die Behandlung unendlicher Datenstrukturen.
• Beweise (z. B. Korrektheitsbeweis, Beweise über Programmeigenschaften) sind dank mathematischer Basis (u. a. Lambda-Kalkül) uneingeschränkt durchführbar.

Nachteile

• Performanz: Der angegebene Quicksort-Algorithmus läuft in Pascal wesentlicher schneller als in Haskell und ist demnach für die Verarbeitung größerer Datenmengen besser geeignet.
• Deklarative Programmierparadigmen stehen insbesondere imperativen und objektorientierten Paradigmen in ihrer Akzeptanz nach. Man spricht gern von sogenannten Akademiker-Sprachen.