imported>SchlurcherBot: Bot: http → https

2026-01-05T01:09:03Z

Bot: http → https

Neue Seite

Ein '''Programmierparadigma''' ist ein fundamentaler [[Programmierstil]].<ref name="Stroustrup"/> „Der [[Programmierung]] liegen je nach Design der einzelnen Programmiersprache verschiedene Prinzipien zugrunde. Diese sollen den Entwickler bei der Erstellung von ‚gutem Code‘ unterstützen, in manchen Fällen sogar zu einer bestimmten Herangehensweise bei der Lösung von Problemen zwingen“.<ref Name="GKIT" />

Programmierparadigmen unterscheiden sich durch ihre Konzepte für die Repräsentation von statischen (wie beispielsweise [[Objekt (Programmierung)|Objekte]], [[Methode (Programmierung)|Methoden]], [[Variable (Programmierung)|Variablen]], [[Konstante (Programmierung)|Konstanten]]) und dynamischen (wie beispielsweise [[Zuweisung]]en, [[Kontrollstruktur|Kontrollfluss]], [[Datenfluss]]) Programmelementen.

Grundlegend für den [[Entwurf]] von [[Programmiersprache]]n sind die [[Paradigma|Paradigmen]] der ''imperativen'' und der ''deklarativen'' Programmierung. Beim letzteren sind als wichtige Ausprägungen die Paradigmen der [[Funktionale Programmierung|funktionalen Programmierung]] und der [[Logische Programmierung|logischen Programmierung]] zu nennen.

Die verschiedenen Paradigmen sind, bezogen auf einzelne [[Computerprogramm]]e, nicht als konkurrierende bzw. alternative Programmierstile zu verstehen. Vielmehr können „viele Programmiersprachen mehrere Paradigmen gleichzeitig unterstützen“.<ref name="MSLIB" />

;Beispiel
:In einer unter [[Microsoft Access|MS Access]] und mit [[Visual Basic for Applications|VBA]] entwickelten [[Anwendungssoftware|Anwendung]] sind die funktionalen Komponenten ''ereignis- und objektorientiert'' angelegt (Bsp.: „beim Öffnen von Formular X“). Der VBA-Code ist ''strukturiert/modular/prozedural'' (denn er besteht aus Modulen, Makros, Prozeduren etc.); und er ist gleichzeitig ''imperativ'', weil er „Befehle“ enthält, die (innerhalb der Prozeduren…) exakt in der codierten Folge ausgeführt werden. Formulare und Berichte sowie die [[SQL]]-Aufrufe sind ''deklarativ'', weil der Entwickler hier nur das WAS und nicht das WIE festlegt.

Trotzdem werden Programmiersprachen häufig – nach ihrer Grund-Charakteristik – z. B. als objektorientierte, prozedurale oder deklarative Sprache bezeichnet. Die ein Paradigma bestimmenden Merkmale beruhen überwiegend auf den Eigenschaften der angewendeten ''Programmiersprachen'' (wie z. B. bei [[Objektorientierte Programmierung|OOP]], deklarativ …), zum Teil aber auch auf dem individuellen ''Stil'', der beim Programmieren praktiziert wird (z. B. strukturiert, modular).

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 (Programmiersprache)|Java]] (objektorientiert) zum Beispiel sind Objekte FCCs, in [[Lisp]] ist jedes Stück Programm FCC, in [[Perl (Programmiersprache)|Perl]] sind es Zeichenketten, Arrays und Hashes. 

Neben den Programmierparadigmen gibt es noch eine Reihe weiterer Kriterien für die Entwicklung einer möglichst fehlerfreien und wartbaren Software – wie zum Beispiel [[Lesbarkeit]] des Programmcodes, [[Redundanzfreiheit]], [[Modul (Software)|Modularität]] und [[Seiteneffekt|Nebenwirkungsfreiheit]]. Diese sollten unter jedem Paradigma so weit wie möglich eingehalten werden. Siehe auch [[Programmierstil]].

== Imperative Programmierung ==
{{Hauptartikel|Imperative Programmierung}}

Bei der imperativen Programmierung „besteht ein [[Computerprogramm|Programm]] (Anm.: d. h. hier der [[Quellcode]]) aus einer Folge von Befehlen, die vorgeben, in welcher Reihenfolge was vom Computer getan werden soll“.<ref name="GKIT" /> Die Bezeichnung basiert auf lateinisch „imperare“ („anordnen“, „befehlen“).

{{Zitat|Text=Die meisten […] Programmiersprachen, darunter auch [[Objektorientierte Programmiersprache|OOP]]-Sprachen wie C#, Visual Basic, C++ und Java, unterstützen in erster Linie [auch] die imperative […] Programmierung.
|Autor=|Quelle=|ref=<ref name="MSLIB" />
}}

=== Strukturierte Programmierung ===

{{Hauptartikel|Strukturierte Programmierung}}

Eine Weiterentwicklung imperativer Sprachen markierte der 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 [[Sprunganweisung]]en (Goto) gefordert; stattdessen sollen [[Kontrollstruktur]]en, wie zum Beispiel „if… then…“, „case… of…“, „while… do…“, „repeat… until…“ verwendet werden.

=== Prozedurale Programmierung ===

{{Hauptartikel|Prozedurale Programmierung}}

Den Ansatz, Programme in kleinere Teilaufgaben aufzuspalten, bezeichnet man als prozedurale Programmierung. Die entstehenden Teilprogramme werden [[Prozedur (Programmierung)|Prozeduren]] genannt. Praktisch alle aktuellen imperativen Programmiersprachen beinhalten den prozeduralen Ansatz.

Die Entwicklung prozeduraler Programmiersprachen und -techniken waren ein wesentlicher Schritt zwischen [[Assemblersprache]] und [[Höhere Programmiersprache|Hochsprachen]], indem sie [[Abstraktion]] und Zerlegung von Algorithmen ermöglichen.

=== Modulare Programmierung ===

{{Hauptartikel|Modulare Programmierung}}

Modulare Programmierung war der erste Versuch, der wachsenden Größe von [[Softwareprojekt]]en Herr zu werden. In der modularen Programmierung wird der prozedurale Ansatz erweitert, indem Prozeduren zusammen mit Daten in [[Datenkapselung (Programmierung)|logischen Einheiten]] zusammengefasst werden. Die Software wird so in größere funktionale Teilblöcke zerlegt, die einzeln geplant, [[Programmieren|programmiert]] und [[Softwaretest|getestet]] werden können. Die entstehenden Unterprogramme werden als [[Modul (Software)|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. Die erste streng modularisierte Programmiersprache war 1978 [[Modula-2]].

=== Programmierung mit abstrakten Datentypen ===

{{Hauptartikel|Abstrakter Datentyp}}

Die Programmierung mit ''abstrakten Datentypen'' behandelt Daten und Funktionen zur Behandlung dieser Daten als Einheit.

== 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 [[Referenzielle Transparenz|referenziellen Transparenz]] gibt es keine [[Wirkung (Informatik)|Nebeneffekte]]. Programme sind damit teilweise auswertbar und ermöglichen so zum Beispiel die Behandlung unendlicher Datenstrukturen.
* Beweise (zum Beispiel Korrektheitsbeweis, Beweise über Programmeigenschaften) sind dank mathematischer Basis (unter anderem [[Lambda-Kalkül]]) uneingeschränkt durchführbar.
* Architekturunabhängigkeit
* teilweise geringe Akzeptanz (man spricht gern von sogenannten Akademikersprachen)

Zu den deklarativen Programmiersprachen gehören:
* [[Funktionale Programmierung|funktionale Sprachen]] (unter anderem [[Lisp]], [[ML (Programmiersprache)|ML]], [[Miranda (Programmiersprache)|Miranda]], [[Gofer]], [[Haskell (Programmiersprache)|Haskell]], [[F-Sharp|F#]], [[Scala (Programmiersprache)|Scala]])
* [[Logische Programmierung|logische Sprachen]] (unter anderem [[Prolog (Programmiersprache)|Prolog]])
* funktional-logische Sprachen (unter anderem Babel, Escher, Curry, [[Oz (Programmiersprache)|Oz]])
* mengen-orientierte Abfragesprachen (unter anderem [[SQL]])

'''Beispiel [[Quicksort]]''': [[Haskell (Programmiersprache)|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 Effizienzgründen die [[Endrekursion]]:

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

=== Funktionale Programmierung ===

{{Hauptartikel|Funktionale Programmierung}}

Die Aufgabenstellung und die bekannten [[Prämisse]]n werden hier als funktionaler Ausdruck formuliert. Das selbstständige Anwenden von Funktionsersetzung und Auswertung seitens des [[Interpreter]]s oder [[Compiler]]s lösen dann die Aufgabenstellung. Das Programm kann als Abbildung der Eingabe auf die Ausgabe aufgefasst werden.

=== Logische Programmierung ===

{{Hauptartikel|Logische Programmierung}}

Die Aufgabenstellung und ihre [[Prämisse]]n werden als logische Aussagen (Regeln) formuliert (vgl. funktionale Programmierung, s. o.). Der [[Interpreter]] versucht dann, die gewünschte Lösungsaussage herzuleiten.
Bei anderen regelbasierten Sprachen wie [[OPS-5]], [[XSLT]] oder [[Prolog (Programmiersprache)|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.

=== Constraintprogrammierung ===
{{Hauptartikel|Constraintprogrammierung}}

Bei der Constraintprogrammierung werden [[Einschränkung|Constraints]] definiert. Sie wird als natürliche Weiterentwicklung der logischen Programmierung verstanden. Logische und Constraintprogrammierung werden typischerweise in Kombination eingesetzt.

== Objektorientierte Programmierparadigmen ==

{{Hauptartikel|Objektorientierung}}

[[Klasse (Objektorientierung)|Klassen]] sind instanziierbare Module und Grundelemente in der [[Objektorientierte Programmierung|objektorientierten Programmierung]]. Nach dem objektorientierten Programmierparadigma werden Objekte mit Daten und den darauf arbeitenden [[Routine (Programmierung)|Routinen]] zu Einheiten zusammengefasst. Im Unterschied dazu werden beim prozeduralen Paradigma die Daten von den die Objekte verarbeitenden Routinen getrennt gehalten. Ein [[Computerprogramm]] ist realisiert als eine Menge interagierender [[Objekt (Programmierung)|Objekte]].

Objektorientierte Programmierung lässt sich gut mit der [[ereignisorientierte Programmierung|ereignisorientierten Programmierung]] kombinieren, z. B. bei der Programmierung interaktiver, [[Grafische Benutzeroberfläche|grafischer Benutzeroberflächen]].

== Komponentenorientierte Programmierparadigmen ==

Mithilfe der [[Komponentenbasierte Entwicklung|komponentenbasierten Entwicklung]] von Software mit abstrakten und [[Generische Programmierung|generischen]] [[Komponentenmodell]]en können [[Komponente (Software)|Softwarekomponenten]] mit streng definierten [[Schnittstelle#Softwareschnittstelle|Schnittstellen]] erstellt werden.

Durch die [[Wiederverwendbarkeit]] von Software-Bausteinen kann der [[Softwaretechnik|Entwicklungsaufwand]] und die [[Programmfehler|Fehleranfälligkeit]] reduziert sowie die [[Informationssicherheit]] erhöht werden. Durch die vollständige und strenge [[Datenkapselung (Programmierung)|Datenkapselung]] wird ferner die [[Plattformunabhängigkeit|Portabilität]] von Daten und Programmen erleichtert.

== Agentenorientierte Programmierung ==

{{Hauptartikel|Agentenorientierte Programmierung}}

Bei der ''agentenorientierten Programmierung'' steht der Begriff des [[Autonomie|autonomen]] und [[Planung|planenden]] [[Software-Agent|Agenten]] im Vordergrund, der selbstständig und in [[Kooperation]] mit anderen Agenten Probleme löst.

== Aspektorientierte Programmierung ==

{{Hauptartikel|Aspektorientierte Programmierung}}

Bei der ''aspektorientierten Programmierung'' wird der objektorientierte Begriff der [[Klasse (Objektorientierung)|Klasse]] zum Aspekt erweitert und ermöglicht so [[Orthogonalität (Informatik)|orthogonale]] Programmierung.

== 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).

== Generische Programmierung ==

{{Hauptartikel|Generische Programmierung}}

In der ''generischen Programmierung'' wird versucht, die [[Algorithmus|Algorithmen]] für mehrere [[Datentyp]]en verwendbar zu gestalten.

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

== Graphersetzung ==

{{Hauptartikel|Graphersetzungssystem}}

Bei der Graphersetzung werden die Daten in Form von [[Graph (Graphentheorie)|Graphen]] modelliert und die Berechnungen durch Graphersetzungsregeln spezifiziert, durch deren gesteuerte Anwendung ein gegebener Arbeitsgraph Stück für Stück umgeformt wird.

== Konkatenative Programmierung ==
Konkatenative Programmierung zeichnet sich dadurch aus, dass Programme durch die einfache Verkettung von (Programmier-)Wörtern gebildet werden. Diese operieren alle auf derselben Datenstruktur, welche weitergereicht wird, ohne dass dazu eine weitergehende komplexe Syntax nötig wäre. Das führt dazu, dass eine natürlichsprachliche Syntax wie ''A B C'' möglich ist, für die in anderen Sprachen beispielsweise ''C(B(A(x)))'' geschrieben werden müsste. [[Konkatenative Programmiersprache]]n sind daher meistens aus Implementierungsgründen auch [[Stapelspeicher|stapelbasierte]] Sprachen, wie zum Beispiel [[Forth (Programmiersprache)|Forth]], [[Joy (Programmiersprache)|Joy]], [[Cat (Programmiersprache)|Cat]] und [[PostScript]].
Im Gegensatz dazu sind [[applikative Programmiersprache]]n solche, die Funktionen auf Argumente anwenden. In diese Kategorie fallen die meisten imperativen und funktionalen Sprachen.<ref name="concatenative1"/><ref name="concatenative2"/>

== Multiparadigmatische Programmierung ==
Multiparadigmatische Sprachen vereinigen verschiedenen Paradigmen miteinander.
Beispiele sind [[F-Sharp]], [[Rust (Programmiersprache)|Rust]], [[Lisp]], [[OCaml]], [[Swift (Programmiersprache)|Swift]], und [[Mathematica|Wolfram Language]].

== Weblinks ==
{{Wiktionary}}
* {{Internetquelle
|url=http://cs.tu-berlin.de/cs/ifb/Ahmed/RoteReihe/2003/TR2003_15.pdf
|format=PDF; 461 kB
|titel=Multiparadigmen-Programmiersprachen
|autor=Martin Grabmüller
|hrsg=[[Technische Universität Berlin]]
|zugriff=2013-04-03
}}

== Literatur ==
* {{Literatur |Autor=John C. Mitchell, Krzysztof Apt |Titel=Concepts in Programming Languages |Verlag=Cambridge University Press |Ort= |Datum=2010 |ISBN=978-0-521-78098-8}}

== Einzelnachweise ==
<references>
<ref name="Stroustrup">{{Internetquelle
|url=https://www.stroustrup.com/hopl-almost-final.pdf
|autor=Bjarne Stroustrup
|titel=Conference on History of Programming Languages: Evolving a language in and for the real world: C++ 1991-2006
|zitat=C++ supports several programming styles or, as they are sometimes somewhat pretentiously called, “programming paradigms”.
|format=PDF
|zugriff=2010-09-20
|sprache=en
}}</ref>
<ref Name="GKIT">{{Literatur
|Titel=Grundkurs IT-Berufe
|Verlag=Vieweg
|Autor=Andreas M. Böhm, Bettina Jungkunz
|ISBN=9783528059132
|Jahr=2005
}}</ref>
<ref name="concatenative1">{{Internetquelle
|url=https://concatenative.org/wiki/view/Concatenative%20language
|titel=Concatenative language
|zugriff=2010-09-20
|sprache=en
|hrsg=Concatenative }}</ref>
<ref name="concatenative2">{{Internetquelle
|url=http://mitarbeiter.hs-heilbronn.de/~herzberg/Publications/ICSOFT.2009.pdf
|titel=Concatenative Programming
|autor=Dominikus Herzberg, Tim Reichert
|datum=2009
|zugriff=2010-09-20
|sprache=en
|format=PDF; 315 kB
|archiv-url=https://web.archive.org/web/20120227190132/http://mitarbeiter.hs-heilbronn.de/~herzberg/Publications/ICSOFT.2009.pdf
|archiv-datum=2012-02-27
}}</ref>
<ref name="MSLIB">{{Internetquelle
|url=https://msdn.microsoft.com/de-de/library/bb669144.aspx
|titel=Funktionale Programmierung oder imperative Programmierung?
|werk=[[MSDN]]
|hrsg=[[Microsoft]]
|zugriff=2013-04-03
}}</ref>

</references>

{{Normdaten|TYP=s|GND=4308224-5}}

[[Kategorie:Programmierparadigma| ]]

Programmierparadigma - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https