Programmierparadigma
aus Wikipedia, der freien Enzyklopädie
Ein Programmierparadigma ist das einer Programmiersprache oder Programmiertechnik zugrundeliegende Prinzip.
Grundlegend für den Entwurf von Programmiersprachen sind die Paradigmen der imperativen und der deklarativen Programmierung. Beim letzteren sind als wichtige Ausprägungen die Paradigmen der funktionalen Programmierung und der logischen Programmierung zu nennen. Alle weiteren Programmierparadigmen sind Verfeinerungen dieser Prinzipien.
| Name | funktional | imperativ | objektorientiert | deklarativ | logisch | nebenläufig |
| Ada | X | X | X | X | ||
| C | X | |||||
| Prolog | X | X | ||||
| Scheme | X | X | X | X |
Neben den Programmierparadigmen gibt es noch eine Reihe weiterer Kriterien für die Entwicklung einer möglichst fehlerfreien und wartbaren Software wie z. B. Lesbarkeit des Programmcodes, Redundanzfreiheit, Modularität und Nebenwirkungsfreiheit. Diese sollten unter jedem Paradigma soweit wie möglich eingehalten werden. Die besondere Leistung der Programmierparadigmen besteht gerade darin, die Einhaltung dieser Basiskriterien zu vereinfachen, nahezulegen oder mehr oder weniger zu erzwingen - im günstigsten Fall automatisch zu realisieren.
Oft kann an den „Bürgern erster Klasse“ („First Class Citizens“ – FCCs) einer Programmiersprache – also den Formen von Daten, die direkt verwendet werden können – erkannt werden, welchem Paradigma die Sprache gehorcht. In Java (objektorientiert) zum Beispiel sind Objekte FCCs, in LISP (funktional) ist jedes Stück Programm FCC, in Perl sind es Zeichenketten, Arrays und Hashes.
Inhaltsverzeichnis |
[Bearbeiten] Imperative Programmierparadigmen
Hauptartikel: Imperative Programmierung
Bei allen imperativen Programmiersprachen versteht man ein Computerprogramm als lineare Folge von Befehlen, die der Rechner in einer definierten Reihenfolge abarbeitet. Imperative Programmiersprachen bilden die Architektur des Von-Neumann-Rechners auf die Programmierung ab: Durch den Mikrocode wird auf Prozessorebene angegeben, wie der Computer mit welchen Daten (die zu verarbeitenden Werte) zu verfahren hat. Dieses Konzept wird durch Befehle realisiert. Die Befehle manipulieren dabei den Zustand der Speicherbereiche oder Speichermedien, die die zu verarbeitenden und die auszugebenden Daten enthalten. Daten werden häufig in Variablen gespeichert. Die Werte in Variablen können sich im Programmablauf ändern. Daher kann man sie auch als zustandsorientierte Programmierung bezeichnen. Durch die Reihenfolge der Befehle ist die zeitliche Abfolge vorgegeben. Um reagierende Programme schreiben zu können, gibt es Sprungbefehle, die die Abfolge der Befehle dynamisch verändern. Die Unterscheidung zwischen Befehlen und Daten ist in der Von-Neumann-Architektur jedoch nicht vorgesehen.
Beispiel Quicksort: Pascal ist eine typische imperative Programmiersprache. 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:
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.
[Bearbeiten] Strukturierte Programmierung
Hauptartikel: Strukturierte Programmiersprache
Eine Weiterentwicklung imperativer Sprachen markierte der legendäre Aufsatz „Go To Statement Considered Harmful“ von Edsger W. Dijkstra aus dem Jahr 1968. Darin wird der Verzicht, oder zumindest die Einschränkung der absoluten Sprunganweisungen (Goto) gefordert. Statt dessen sollen Kontrollstrukturen, wie z. B. „do...while“, „while“, „repeat...until“ verwendet werden.
[Bearbeiten] Prozedurale Programmierung
Hauptartikel: Prozedurale Programmierung
Den Ansatz, Programme in kleinere Teilaufgaben aufzuspalten, bezeichnet man als prozedurale Programmierung. Der Unterschied zu funktionaler Programmierung besteht hier darin, dass Prozeduren im Gegensatz zu Funktionen keinen Rückgabewert haben. Die entstehenden Teilprogramme werden Prozeduren genannt. Praktisch alle aktuellen imperativen Programmiersprachen beinhalten den prozeduralen Ansatz.
Prozedurale Programmierung zielt darauf ab, Quelltexte wiederverwendbar zu machen. Universelle Prozeduren müssen nur einmal programmiert werden, die verkleinerten Probleme sind einfacher zu lösen. Die Entwicklung prozeduraler Programmiersprachen und -Techniken waren ein wesentlicher Schritt zwischen Assemblersprache und Hochsprachen, indem sie Abstraktion und Zerlegung von Algorithmen ermöglichen.
[Bearbeiten] Modulare Programmierung
Hauptartikel: Modulare Programmierung
Modulare Programmierung war der erste Versuch, der wachsenden Größe von Softwareprojekten Herr zu werden. In der modularen Programmierung wird der prozedurale Ansatz erweitert, indem Prozeduren zusammen mit Daten in logischen Einheiten zusammengefasst werden. Die Software wird so in größere funktionale Teilblöcke zerlegt, die einzeln geplant, programmiert und getestet werden können. Die entstehenden Unterprogramme werden als Module bezeichnet. Am Ende können die Einzelteile dann logisch miteinander verknüpft werden und die Software ist einsatzbereit. Die normierte Programmierung beschreibt dabei den Versuch diesen Ablauf zu standardisieren.
[Bearbeiten] Programmierung mit abstrakten Datentypen
Hauptartikel: Abstrakter Datentyp
Die Programmierung mit abstrakten Datentypen behandelt Daten und Funktionen zur Behandlung dieser Daten als Einheit.
[Bearbeiten] Objektorientierung
Hauptartikel: Objektorientierung
Klassen sind instanziierbare Module und Grundelemente in der objektorientierten Programmierung. Nach dem objektorientierten Programmierparadigma werden Objekte mit Daten und den darauf arbeitenden Routinen zu Einheiten zusammengefasst. Ein Computerprogramm ist realisiert als eine Menge interagierender Objekte. Im Unterschied dazu werden beim prozeduralen Paradigma die Daten von den darauf arbeitenden Routinen getrennt gehalten.
[Bearbeiten] Deklarative Programmierparadigmen
Hauptartikel: Deklarative Programmierung
Die Idee einer deklarativen Programmierung ist der historisch jüngere Ansatz. Im Gegensatz zu imperativen Programmierparadigmen, bei denen das Wie im Vordergrund steht, fragt man in der deklarativen Programmierung nach dem Was, das berechnet werden soll. Es wird also nicht mehr der Lösungsweg programmiert, sondern nur noch angegeben, welches Ergebnis gewünscht ist. Zu diesem Zweck beruhen deklarative Paradigmen auf mathematischen, rechnerunabhängigen Theorien.
- Aufgrund der referenziellen Transparenz gibt es keine Nebeneffekte. Programme sind damit teilweise 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.
- Architekturunabhängigkeit
- geringe Akzeptanz (man spricht gern von sogenannten Akademikersprachen)
Zu den deklarativen Programmiersprachen gehören:
- funktionale Sprachen (u.a. LISP, ML, Miranda, Gofer, Haskell)
- logische Sprachen (u.a. Prolog)
- funktional-logische Sprachen (u.a. Babel, Escher, Curry, Oz)
- mengen-orientierte Abfragesprachen (u.a. SQL)
Beispiel Quicksort: Haskell ist eine typische deklarative Programmiersprache. 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:
quicksort [] = [] quicksort [x:xs] = quicksort [n | n<-xs, n<x] ++ [x] ++ quicksort [n | n<-xs, n>=x]
[Bearbeiten] Constraintprogrammierung
Hauptartikel: Constraintprogrammierung
Bei der Constraintprogrammierung werden sog. Constraints (engl. Vorgaben) (math. Gleichungen) definiert. Sie wird als natürliche Weiterentwicklung der logischen Programmierung verstanden. Logische und Constraintprogrammierung werden typischerweise in Kombination eingesetzt.
[Bearbeiten] Funktionale Programmierung
Hauptartikel: Funktionale Programmierung
Die Aufgabenstellung und die bekannten Prämissen werden hier als funktionaler Ausdruck formuliert. Das selbstständige Anwenden von Funktionsersetzung und Auswertung seitens des Interpreters oder Compilers lösen dann die Aufgabenstellung. Das Programm kann als Abbildung der Eingabe auf die Ausgabe aufgefasst werden.
[Bearbeiten] Logische Programmierung
Hauptartikel: Logische Programmierung
Die Aufgabenstellung und ihre Prämissen werden als logische Aussagen (Regeln) formuliert (vgl. funktionale Programmierung, s.o.). Der Interpreter versucht dann, die gewünschte Lösungsaussage mit Hilfe des Horn-Verfahrens herzuleiten. (Siehe auch Horn-Klauseln) z.B. Prolog Bei anderen regelbasierten Sprachen wie OPS-5, XSLT oder Prolog werden Regeln gegen eine Datenmenge auf ihre Instanziierbarkeit geprüft. Aus allen Regelinstanziierungen wird eine (mehrere, alle) ausgewählt und die zur Regel gehörenden Anweisungen werden ausgeführt.
[Bearbeiten] Sonstiges
[Bearbeiten] Agentenorientierte Programmierung
Hauptartikel: Agentenorientierte Programmierung
Bei der agentenorientierten Programmierung steht der Begriff des autonomen und planenden Agenten im Vordergrund, der selbstständig und in Kooperation mit anderen Agenten Probleme löst.
[Bearbeiten] Aspektorientierte Programmierung
Hauptartikel: Aspektorientierte Programmierung
Bei der aspektorientierten Programmierung wird der objektorientierte Begriff der Klasse zum Aspekt erweitert und ermöglicht so orthogonale Programmierung.
[Bearbeiten] Generative Programmierung
Hauptartikel: Generative Programmierung
Generative Programmierung ist ein Überbegriff für die programmatische Erzeugung von Sourcecode (Siehe Buch: Generative Programming, Krzysztof Czarnecki, W. Eisenecker)
[Bearbeiten] Generische Programmierung
Hauptartikel: Generische Programmierung
In der generischen Programmierung wird versucht die Algorithmen für mehrere Datentypen verwendbar zu gestalten.
[Bearbeiten] Subjektorientierte Programmierung
Hauptartikel: Subjektorientierte Programmierung
Die Subjektorientierte Programmierung ist eine Erweiterung der objektorientierten Programmierung. Sie soll vor allem die Schwächen der objektorientierten Programmierung bei der Entwicklung großer Anwendungen und der Integration unabhängig entwickelter Anwendungen ausgleichen.
[Bearbeiten] Datenstromorientierte Programmierung
Hauptartikel: Datenstromorientierte Programmierung
Es wird von einem kontinuierlichen Datenfluss ausgegangen (meist Audio- oder Videodaten), der (oft in Echtzeit) verändert und ausgegeben wird.
[Bearbeiten] Weblinks
- Forschungsbericht Multiparadigmen-Programmiersprachen von Martin Grabmüller, Technische Universität Berlin
