Die deklarative Programmierung ist ein Programmierparadigma, das auf mathematischer rechnerunabhängiger Theorie beruht. Zu den deklarativen Programmiersprachen gehören:

• funktionale Sprachen (u. a. LISP, ML, Miranda, Gofer, Haskell, Erlang)
• logische Sprachen (u. a. Prolog)
• funktional-logische Sprachen (u.a. Babel, Escher, Curry, Oz)
• Datenflusssprachen (wie Val oder Linda)

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.

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 könnte 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, insbesondere aus Effektivitätsgründen die Endrekursion.

• 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.

• 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.