Wikipedia · einfach zusammengefasst · Stand
Programmierparadigma
Grundlegend für den Entwurf von Programmiersprachen sind die Paradigmen der imperativen und der deklarativen Programmierung. Beim letzteren sind als wichtige …
Inhalt6 Abschnitte
Grundidee und Einordnung
Ein Programmierparadigma ist ein fundamentaler Programmierstil. Es legt grundlegende Prinzipien fest, nach denen Programme und Programmiersprachen aufgebaut sind. Diese Prinzipien sollen Entwickler dabei unterstützen, guten Code zu erstellen, und können eine bestimmte Herangehensweise an Probleme nahelegen oder erzwingen.
Paradigmen unterscheiden sich vor allem darin, wie sie statische Programmelemente wie Objekte, Methoden, Variablen und Konstanten sowie dynamische Elemente wie Zuweisungen, Kontrollfluss und Datenfluss darstellen. Grundlegend sind die imperative und die deklarative Programmierung. Wichtige deklarative Ausprägungen sind die funktionale und die logische Programmierung.
Die Paradigmen schließen einander nicht aus. Viele Programmiersprachen unterstützen mehrere zugleich; solche Sprachen heißen multiparadigmatisch. Dennoch werden Sprachen häufig nach ihrer vorherrschenden Charakteristik etwa als objektorientiert, prozedural oder deklarativ bezeichnet. Einige Merkmale ergeben sich hauptsächlich aus der Sprache selbst, andere auch aus dem individuellen Programmierstil, beispielsweise eine strukturierte oder modulare Arbeitsweise.
Hinweise auf das Paradigma geben oft die „Bürger erster Klasse“ oder „First Class Citizens“ (FCCs): Das sind Datenformen, die in einer Sprache direkt verwendet werden können. In Java sind beispielsweise Objekte FCCs, in Lisp jedes Stück Programm und in Perl Zeichenketten, Arrays und Hashes.
Unabhängig vom Paradigma sind für möglichst fehlerfreie und wartbare Software unter anderem lesbarer Programmcode, Redundanzfreiheit, Modularität und Nebenwirkungsfreiheit wichtig.
Imperative Ansätze
Bei der imperativen Programmierung besteht der Quellcode aus einer Folge von Befehlen. Diese schreiben vor, was der Computer in welcher Reihenfolge tun soll. Auch objektorientierte Sprachen wie C#, Visual Basic, C++ und Java unterstützen in erster Linie ebenfalls imperative Programmierung.
Die strukturierte Programmierung schränkt insbesondere absolute Sprunganweisungen wie Goto ein. Als wichtiger Ausgangspunkt gilt Edsger W. Dijkstras Aufsatz „Go To Statement Considered Harmful“ von 1968. Statt unübersichtlicher Sprünge sollen Kontrollstrukturen wie „if… then…“, „case… of…“, „while… do…“ und „repeat… until…“ eingesetzt werden.
Bei der prozeduralen Programmierung wird ein Programm in kleinere Teilaufgaben zerlegt. Die entstehenden Teilprogramme heißen Prozeduren. Dieser Ansatz ist in praktisch allen aktuellen imperativen Programmiersprachen enthalten. Er ermöglicht die Abstraktion und Zerlegung von Algorithmen und war deshalb ein wesentlicher Entwicklungsschritt zwischen Assemblersprache und Hochsprachen.
Die modulare Programmierung erweitert dieses Prinzip: Prozeduren und zugehörige Daten werden zu logischen Einheiten, den Modulen, zusammengefasst. Größere funktionale Teilblöcke können dadurch getrennt geplant, programmiert und getestet und anschließend miteinander verknüpft werden. Die normierte Programmierung versucht, diesen Ablauf zu standardisieren. Die erste streng modularisierte Programmiersprache war 1978 Modula-2.
Bei der Programmierung mit abstrakten Datentypen bilden Daten und die Funktionen zu ihrer Bearbeitung eine Einheit.
Deklarative, funktionale und logische Programmierung
Deklarative Programmierung beschreibt, was berechnet werden soll, nicht den genauen Lösungsweg. Im Gegensatz dazu steht bei imperativen Programmen das Wie im Vordergrund. Deklarative Paradigmen beruhen auf mathematischen, von einer bestimmten Rechnerarchitektur unabhängigen Theorien.
Referenzielle Transparenz bedeutet hier, dass Ausdrücke ohne Änderung der Bedeutung durch ihre Werte ersetzt werden können; dadurch entstehen keine Nebeneffekte. Programme können teilweise ausgewertet werden, was beispielsweise die Behandlung unendlicher Datenstrukturen ermöglicht. Aufgrund der mathematischen Basis, unter anderem des Lambda-Kalküls, sind Korrektheitsbeweise und Beweise über Programmeigenschaften uneingeschränkt durchführbar. Weitere Merkmale sind Architekturunabhängigkeit und teilweise geringe Akzeptanz; solche Sprachen werden mitunter als „Akademikersprachen“ bezeichnet.
Zu den deklarativen Sprachen zählen funktionale Sprachen wie Lisp, ML, Miranda, Gofer, Haskell, F# und Scala, logische Sprachen wie Prolog, funktional-logische Sprachen wie Babel, Escher, Curry und Oz sowie mengenorientierte Abfragesprachen wie SQL.
In der funktionalen Programmierung werden die Aufgabe und die bekannten Voraussetzungen als funktionaler Ausdruck formuliert. Interpreter oder Compiler lösen die Aufgabe durch Funktionsersetzung und Auswertung. Ein Programm lässt sich dabei als Abbildung einer Eingabe auf eine Ausgabe auffassen.
In der logischen Programmierung werden Aufgabe und Voraussetzungen als logische Aussagen beziehungsweise Regeln formuliert. Der Interpreter versucht, daraus die gewünschte Lösungsaussage herzuleiten. Bei regelbasierten Sprachen wie OPS-5, XSLT oder Prolog werden Regeln darauf geprüft, ob sie sich auf eine Datenmenge anwenden lassen. Anschließend werden eine, mehrere oder alle möglichen Regelinstanziierungen ausgewählt und die zugehörigen Anweisungen ausgeführt.
Die Constraintprogrammierung definiert Constraints, also Bedingungen oder Einschränkungen, die eine Lösung erfüllen muss. Sie gilt als natürliche Weiterentwicklung der logischen Programmierung und wird typischerweise mit ihr kombiniert.
Objekte und wiederverwendbare Komponenten
In der objektorientierten Programmierung sind Klassen instanziierbare Module und grundlegende Programmelemente. Objekte fassen Daten und die darauf arbeitenden Routinen zu Einheiten zusammen. Beim prozeduralen Paradigma werden die Daten dagegen von den Routinen getrennt gehalten, die sie verarbeiten. Ein objektorientiertes Programm besteht somit aus einer Menge interagierender Objekte. Dieser Ansatz lässt sich gut mit ereignisorientierter Programmierung verbinden, etwa bei interaktiven grafischen Benutzeroberflächen.
Die komponentenbasierte Softwareentwicklung arbeitet mit abstrakten und generischen Komponentenmodellen. Dadurch können Softwarekomponenten mit streng definierten Schnittstellen entstehen. Wiederverwendbare Softwarebausteine können den Entwicklungsaufwand und die Fehleranfälligkeit verringern sowie die Informationssicherheit erhöhen. Vollständige und strenge Datenkapselung erleichtert außerdem die Portabilität von Daten und Programmen.
Weitere spezialisierte Paradigmen
Bei der agentenorientierten Programmierung steht ein autonomer und planender Agent im Mittelpunkt. Er löst Probleme selbstständig und in Zusammenarbeit mit anderen Agenten.
Die aspektorientierte Programmierung erweitert den objektorientierten Begriff der Klasse zum Aspekt und ermöglicht dadurch orthogonale Programmierung.
Generative Programmierung bezeichnet allgemein die programmatische Erzeugung von Sourcecode. Generische Programmierung versucht dagegen, Algorithmen so zu gestalten, dass sie für mehrere Datentypen verwendbar sind.
Datenstromorientierte Programmierung geht von einem kontinuierlichen Datenfluss aus, meist Audio- oder Videodaten. Dieser Datenstrom wird häufig in Echtzeit verändert und ausgegeben.
Bei der Graphersetzung werden Daten als Graphen modelliert. Berechnungen werden durch Graphersetzungsregeln beschrieben, deren gesteuerte Anwendung einen vorhandenen Arbeitsgraphen schrittweise umformt.
Verkettung und Kombination in der Praxis
In der konkatenativen Programmierung entstehen Programme durch die einfache Verkettung von Programmierwörtern. Alle Wörter arbeiten auf derselben weitergereichten Datenstruktur, ohne dass eine komplexe Syntax erforderlich ist. Deshalb kann beispielsweise die Folge „A B C“ verwendet werden, wo andere Sprachen „C(B(A(x)))“ schreiben müssten. Konkatenative Sprachen sind aus Implementierungsgründen meist stapelbasiert; Beispiele sind Forth, Joy, Cat und PostScript. Applikative Sprachen wenden dagegen Funktionen auf Argumente an. Dazu gehören die meisten imperativen und funktionalen Sprachen.
Multiparadigmatische Sprachen verbinden verschiedene Paradigmen. Beispiele sind F-Sharp, Rust, Lisp, OCaml, Swift und Wolfram Language.
Eine unter MS Access mit VBA entwickelte Anwendung zeigt, wie Paradigmen praktisch zusammenwirken können: Funktionale Komponenten können ereignis- und objektorientiert aufgebaut sein, etwa durch eine Aktion „beim Öffnen von Formular X“. Der VBA-Code kann zugleich strukturiert, modular und prozedural sein, weil er aus Modulen, Makros und Prozeduren besteht. Er ist außerdem imperativ, wenn seine Befehle in der codierten Reihenfolge ausgeführt werden. Formulare, Berichte und SQL-Aufrufe sind hingegen deklarativ, weil der Entwickler das gewünschte Ergebnis festlegt, aber nicht den genauen Ausführungsweg.
Auch das Quicksort-Beispiel in Haskell veranschaulicht deklarative Programmierung: Der Programmierer beschreibt den Umgang mit der Eingabe, ohne den Berechnungsablauf in den Mittelpunkt zu stellen. Die Berechnung erfolgt durch Wertemanipulation. Als wichtigste Kontrollstruktur dient Rekursion, aus Effizienzgründen insbesondere Endrekursion.
