imported>Prüm: /* Einzelnachweise */

2024-04-15T04:20:31Z

Einzelnachweise

Neue Seite

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 [[Imperative Programmierung|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 (Programmiersprache)|Haskell]], [[Lisp]], [[Prolog (Programmiersprache)|Prolog]], [[Extensible Application Markup Language|XAML]] und im weiteren Sinne auch [[SQL]] und [[XSL Transformation|XSLT]]. Den deklarativen Sprachen stehen die weiter verbreiteten imperativen Sprachen wie [[C (Programmiersprache)|C]], [[C++]] oder [[Java (Programmiersprache)|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:
* [[Abfragesprache]]n (z. B. [[SQL]])
* [[Datenflusssprache]]n (z. B. Val oder [[Linda (Programmiersprache)|Linda]])
* funktional-logische Sprachen (z. B. Babel, Escher, [[Curry (Programmiersprache)|Curry]], [[Oz (Programmiersprache)|Oz]])
* [[Funktionale Programmierung|funktionale Sprachen]] (z. B. [[ML (Programmiersprache)|ML]], [[Miranda (Programmiersprache)|Miranda]], [[Gofer]], [[Haskell (Programmiersprache)|Haskell]], [[Erlang (Programmiersprache)|Erlang]])
* [[Logische Programmierung|logische Sprachen]] (z. B. [[Prolog (Programmiersprache)|Prolog]])
* [[Synchrone Programmiersprache]]n (z. B. [[Lustre (Programmiersprache)|Lustre]])
* Aufbauwerkzeuge (z. B. [[make]] oder [[Apache Ant|Ant]])
* [[Transformationssprache]]n (z. B. [[XSL Transformation|XSLT]])

== Beispiel ==
Der [[Quicksort]]-Sortierungsalgorithmus kann in der imperativen Programmiersprache [[Pascal (Programmiersprache)|Pascal]] folgendermaßen aufgeschrieben werden:

<syntaxhighlight lang="Pascal">
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;
</syntaxhighlight>

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 (Programmiersprache)|Haskell]] folgendermaßen formuliert werden:

<syntaxhighlight lang="Haskell">
quicksort [] = []
quicksort (x:xs) = quicksort [n | n<-xs, n<x] ++ [x] ++ quicksort [n | n<-xs, n>=x]
</syntaxhighlight>

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.
* [[Beweis (Logik)|Beweise]] (z. B. [[Korrektheit (Informatik)|Korrektheitsbeweis]], Beweise über Programmeigenschaften) sind dank einfacherer mathematischer Basis (u. a. [[Lambda-Kalkül]]) leichter durchführbar, falls überhaupt möglich.
* Es gibt keine [[Wirkung (Informatik)|Nebenwirkungen]] aufgrund der [[Referentielle Transparenz|referentiellen Transparenz]]. Programme sind damit partiell auswertbar und ermöglichen so z. B. die Behandlung unendlicher Datenstrukturen.<ref>{{Internetquelle
| autor=Manuel M. T. Charkravarty
| hrsg=TU Berlin
| url=http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz
| format=.ps.gz 343KiB
| sprache=en
| titel=On the Massively Parallel Execution of Declarative Programs
| titelerg=Dissertation
| seiten=166
| datum=1997-02-14
| zugriff=2011-10-16
}}</ref>

== Siehe auch ==
* [[Domain-driven Design]], ein Ansatz für den Entwurf des Domänenmodells, der ein deklaratives Design propagiert

== Einzelnachweise ==
<references />

[[Kategorie:Programmierparadigma]]

Deklarative Programmierung - Versionsgeschichte

imported>Prüm: /* Einzelnachweise */