Programmierparadigmen: Welche Programmierprinzipien gibt es?
Programmierparadigmen sind grundlegende Prinzipien bei der Entwicklung von Software. Am besten stellt man sie sich als fundamental unterschiedliche Programmierstile vor, die entsprechend unterschiedlich strukturierten Softwarecode zur Folge haben.
Das klassische Konzept ist dabei die imperative Programmierung, bei der im Quellcode klar definiert wird, welche Schritte ein Programm in welcher Reihenfolge zu erledigen hat. Unterarten sind die prozedurale und die objektorientierte Programmierung. Nach dem Prinzip der deklarativen Programmierung wird ausschließlich beschrieben, was eine Software erledigen soll (also nur das Ergebnis und nicht die einzelnen Schritte). Untergeordnet sind die funktionale und die logische Programmierung. Wie unterscheiden sich die genannten Software-Paradigmen voneinander?
Imperative Programmierung: Der Klassiker der Programmierparadigmen
Unter den Paradigmen für die Software-Programmierung ist die imperative Programmierung der „Klassiker“. Die ersten Programmiersprachen und dementsprechend auch die ersten Computerprogramme bauten gänzlich auf diesem klassischen Ansatz auf, der eine geregelte Abfolge festgelegter Befehle (von lat. imperare „befehlen“) bzw. Handlungsanweisungen vorsieht. Unter anderem liegt dies Programmierparadigma beispielsweise den Urgesteinen Pascal und C sowie allen Assemblersprachen zugrunde. Bei der imperativen Programmierung liegt der Fokus unter anderem darauf, so nah wie möglich am System zu arbeiten. Der daraus resultierende Programmcode ist deshalb leicht verständlich, aber auch sehr umfangreich.
Mit der strukturierten, der prozeduralen und der modularen Programmierung sind dem imperativen Programmierparadigma drei weitere wichtige Ansätze zum Schreiben bzw. Strukturieren von Softwarecode untergeordnet.
Mehr zum Paradigma der Imperativen Programmierung erfahren Sie in unserem entsprechenden Artikel, der tiefer in die Thematik einsteigt.
Strukturierte Programmierung
Beim strukturierten Programmierungsansatz handelt es sich um eine vereinfachte Form der imperativen Programmierung. Die entscheidende Änderung zum Grundprinzip: Anstelle der absoluten Sprungbefehle (Anweisungen, die dazu führen, dass die Verarbeitung nicht mit dem nachfolgenden Befehl, sondern an anderer Stelle weitergeführt wird) sieht dieses Paradigma für die Software-Programmierung den Einsatz von Kontrollschleifen bzw. -strukturen vor. Ein Beispiel hierfür ist die Nutzung von „do…while“, um eine Anweisung automatisch solange auszuführen, wie eine bestimmte Bedingung wahr ist (mindestens ein Mal).
Prozedurale Programmierung
Das prozedurale Programmierparadigma erweitert den imperativen Ansatz um die Möglichkeit, Algorithmen in überschaubare Teile aufzugliedern. Diese werden als Prozeduren oder – je nach Programmiersprache – auch als Unterprogramme, Routinen oder Funktionen bezeichnet. Sinn und Zweck dieser Aufteilung ist es, den Programmcode übersichtlicher zu machen und unnötige Code-Wiederholungen zu vermeiden. Durch die Abstraktion der Algorithmen stellt das prozedurale Software-Paradigma einen entscheidenden Schritt von einfachen Assemblersprachen hin zu komplexeren Hochsprachen dar.
Modulare Programmierung
Auch die modulare Programmierung wird als Unterform des imperativen Programmierparadigmas eingestuft. Sie ist der prozeduralen Herangehensweise grundsätzlich sehr ähnlich bzw. überträgt diesen Programmierstil auf die Anforderungen und Ansprüche großer und umfangreicher Softwareprojekte. Hierfür wird der Quellcode gezielt in logische, voneinander unabhängige Teilblöcke aufgespaltet, um für mehr Übersichtlichkeit zu sorgen und den Debugging-Prozess (Fehlerbehebung) zu vereinfachen. Die einzelnen Teilblöcke, die Module genannt werden, lassen sich nämlich einzeln testen, bevor sie im späteren Verlauf zu einer gemeinsamen Anwendung verknüpft werden.
Deklarative Programmierung: Software-Paradigmen der jüngeren Vergangenheit
Parallel zur kontinuierlichen Weiterentwicklung von Hard- und Software entwickelte sich mit dem deklarativen Ansatz ein alternatives Paradigma zur Code-Programmierung. Das grundlegende Prinzip der deklarativen Programmierung besteht dabei in er Beschreibung des gewünschten Endergebnisses. Es geht also in der ersten Linie um das „Was“ des Ergebnisses und nicht um das „Wie“ der Lösungsschritte, wie das bei der imperativen Programmierung der Fall ist. Dies führt dazu, dass Code aus deklarativer Programmierung aufgrund des hohen Abstraktionsgrades schwerer verständlich, dafür aber sehr kurz und präzise ist.
Zwischen den Unterformen des deklarativen Programmierparadigmas selbst gibt es größere Unterschiede als innerhalb des imperativen Stils. Zudem ist die genaue Definition bzw. Einteilung nicht immer trennscharf. Die zwei wichtigsten Ansätze des deklarativen Programmierparadigmas sind die funktionale und die logische Programmierung.
Mehr zum Paradigma der Deklarativen Programmierung erfahren Sie im entsprechenden Artikel, der tiefer in die Thematik einsteigt.
Funktionale Programmierung
Funktionen gibt es in jeder höheren Programmiersprache. Die funktionale Herangehensweise in der Software-Entwicklung behandelt Funktionen allerdings auf besondere Art und Weise:
Ein funktional programmiertes Programm besteht aus aneinandergereihten Funktionsaufrufen, wobei jedes Programmteil als Funktion aufgefasst werden kann. Funktionen können dabei innerhalb der funktionalen Programmierung verschiedene „Gestalten“ annehmen. Sie lassen sich beispielsweise wie Daten miteinander verknüpfen oder können in Form von Parametern genutzt werden. Darüber hinaus können sie als Funktionsergebnisse weiterverwendet werden. Im Umkehrschluss führt das Paradigma dazu, dass es keine eigenständigen Zuweisungen von Werten gibt.
Die Unterform der deklarativen Programmierung ist sehr wichtig für die Informatik im Allgemeinen - und gleichzeitig sehr vielfältig einsetzbar. Die spezielle Behandlung von Funktionen erlaubt es funktional arbeitenden Programmierern, weitreichende neue Berechnungsvorschriften aus Funktionen zusammenzusetzen und anzuwenden.
Mehr zur Methode der Funktionalen Programmierung erfahren Sie im entsprechenden Artikel, der tiefer in die Thematik einsteigt.
Logische Programmierung
Das logische Software-Paradigma, das auch als prädikative Programmierung bezeichnet wird, beruht auf der mathematischen Logik. Anstelle einer Folge von Anweisungen enthält eine Software, die nach diesem Prinzip programmiert wird, eine Menge von Grundsätzen, die sich als Sammlung von Fakten und Annahmen verstehen lässt. Jegliche Anfragen an das Programm werden verarbeitet, indem der Interpreter auf diese Grundsätze zurückgreift und zuvor definierte Regeln auf diese anwendet, um zum gewünschten Ergebnis zu kommen.
Programmierparadigmen im Vergleich: Imperative und deklarative Programmierung
| Imperatives Programmierparadigma | Deklaratives Programmierparadigma |
|---|---|
| „Wie?“ | „Was?“ |
| Klassiker | Neue Strömung |
| Ein Programm nach diesem Paradigma besteht aus aufeinanderfolgenden Anweisungen, die dem Computer vorgeben, was er in welcher Abfolge berechnen und tun soll. | Ein Programm nach diesem Paradigma besteht aus Anweisungen, wie das Programm mit einer Eingabe zu verfahren hat. Berechnungen erfolgen durch die Manipulation von Werten, kontrolliert wird der Ablauf durch das Verfahren der Rekursion. |
| Der Name kommt von „imperare“, dem lateinischen Wort für „befehlen“ | Der Name von „declarare“, dem lateinischen Wort für „bezeichnen“. |
| Der gewünschte Lösungsweg wird vorgegeben | Das gewünschte Ergebnis wird vorgegeben. |
| Typische Programmiersprachen sind C, Pascal, Fortran, ALGOL sowie alle sogenannten Assembler-Sprachen | Typische Programmiersprachen sind Lisp, ML, Haskell, F#, Prolog und Oz |