Programmiersprachen und Programmierparadigmen

Eine Zeile wie x = a + b bezeichnet eine Berechnung, ohne ein Prozessorregister zu erwähnen. Abstraktion macht dies möglich: Eine Sprache verbirgt Details der darunterliegenden Ebene, sodass sich ein Programmierer auf die Aufgabe des Programms konzentrieren kann.

Was der Prozessor ausführt

Maschinencode besteht aus Befehlen, die als Binärzahlen kodiert sind. Die Befehlssatzarchitektur (ISA) eines Prozessors legt seine Befehle und deren Kodierungen fest. x86-64 ist in PCs und Servern verbreitet; ARM kommt häufig in Smartphones, Tablets und vielen Laptops vor. Für eine ISA erstellter Code muss übersetzt oder emuliert werden, damit er auf einer anderen funktioniert.

Die Hexadezimaldarstellung verkürzt die Anzeige von Befehlsbytes. Auf x86-64 schreibt B8 01 00 00 00 die Zahl 1 in das Register EAX. Die Bytes 01 D8 addieren den Wert in EBX zu EAX. Register sind kleine Speicherstellen innerhalb des Prozessors. Jeder Befehl führt eine kleine Aktion aus, etwa Daten verschieben, addieren, vergleichen oder springen. Der Befehlszyklus führt diese Befehle aus.

Namen für dieselben kleinen Aktionen

Assemblersprache ersetzt Befehlsbytes durch lesbare Namen, sogenannte Mnemonics. Die beiden x86-64-Befehle lassen sich so schreiben:

mov eax, 1
add eax, ebx

Ein Assembler wandelt Assemblersprache in Maschinencode um. Eine gewöhnliche Befehlszeile erzeugt normalerweise einen Maschinenbefehl. Registernamen und Befehle gehören weiterhin zu einer bestimmten ISA, sodass die Verwendung von Wörtern statt Bytes Assemblersprache nicht portierbar macht.

Ein Problem in weniger Zeilen beschreiben

Eine höhere Programmiersprache bietet Variablen, Ausdrücke, Bedingungen, Schleifen und Funktionen. Python, C, Java und JavaScript erlauben es dem Programmierer, Operationen zu beschreiben, ohne Register auszuwählen. Eine Anweisung benötigt häufig mehrere Maschinenbefehle. Eine vereinfachte Übersetzung von x = a + b würde:

1. Den Wert von a in ein Register laden.
2. Den Wert von b in ein anderes Register laden.
3. Die Registerwerte addieren.
4. Das Ergebnis für x speichern.

Ein tatsächlicher Compiler kann diese Schritte zusammenfassen oder umordnen und dabei das erforderliche Verhalten beibehalten.

Quellcode in einer höheren Programmiersprache lässt sich leichter lesen, ändern und prüfen. Portierbarer C-Quellcode kann einmal für ein x86-64-System und erneut für ein ARM-System kompiliert werden. Jede erstellte Version benötigt weiterhin die passende Unterstützung durch das Betriebssystem und passende Bibliotheken. Die Portierbarkeit des Quellcodes macht eine native ausführbare Datei nicht universell einsetzbar.

Warum die unteren Ebenen weiterhin wichtig sind

Assemblersprache bleibt nützlich in Startcode, einigen Betriebssystem- und Treiberroutinen, kleinen eingebetteten Systemen und bei der Sicherheitsanalyse von Programmen, deren Quellcode nicht verfügbar ist. Für gewöhnlichen Anwendungscode erzeugen moderne Compiler meist Maschinencode, dessen Leistung mit der von handgeschriebenem Assemblercode vergleichbar ist.

Der Übergang zu höheren Ebenen erfolgte allmählich. Assemblersprache verbreitete sich in den späten 1940er- und frühen 1950er-Jahren. Grace Hoppers A-0-System trug 1952 zur automatischen Übersetzung bei. IBM veröffentlichte FORTRAN 1957; COBOL folgte 1959, und Lisp entstand etwa zwischen 1958 und 1960. „Höher“ bezeichnet den Abstand zu Hardwaredetails, nicht die Schwierigkeit, die Sprache zu erlernen.

Ein Compiler übersetzt Quellcode in Zielcode. Das Ziel kann nativer Maschinencode oder eine Zwischenform wie Bytecode sein. Die Ahead-of-time-Kompilierung (AOT) findet vor der Programmausführung statt; die Just-in-time-Kompilierung erfolgt während der Ausführung.

Vom Text zu Befehlen

Bei einer Erstellung im Voraus wird eine Quelldatei in mehreren Phasen in Befehle umgewandelt:

1. Die lexikalische Analyse zerlegt Text in Token: bedeutungstragende Teile wie Namen, Operatoren und Zahlen.
2. Die syntaktische Analyse prüft die Grammatik und erstellt eine Struktur, die zeigt, wie die Teile zusammenpassen.
3. Die semantische Analyse prüft Bedeutungsregeln, darunter Deklarationen und erlaubte Typkombinationen.
4. Die Optimierung findet einen effizienteren Weg, die erforderliche Arbeit zu erledigen.
5. Die Codegenerierung erzeugt die Zielbefehle.

Betrachte die C-Anweisung total = price * 3;. Ihre sechs Token sind total, =, price, *, 3 und ;. Die Namen sind Bezeichner, 3 ist ein Ganzzahlliteral und das Semikolon beendet die Anweisung. Die syntaktische Analyse hält fest, dass die Multiplikation innerhalb der Zuweisung erfolgt: Berechne price * 3 und speichere dessen Wert anschließend in total.

Diese Phasen haben unterschiedliche Aufgaben. Eine korrekt geschriebene Folge von Token kann dennoch gegen die Grammatik verstoßen. Eine grammatisch korrekte Anweisung kann trotzdem einen Typ falsch verwenden. Token zu erkennen reicht nicht aus, um festzustellen, ob ein Programm gültig ist.

Dieselbe Arbeit mit weniger Aufwand erledigen

Angenommen, Quellcode enthält seconds_per_day = 60 * 60 * 24. Die Faktoren sind Konstanten, sodass der Compiler bei der Erstellung 60 mit 60 zu 3.600 und dann mit 24 zu 86.400 multiplizieren kann. Er kann den Endwert in die Ausgabe übernehmen, statt die Multiplikation zur Laufzeit zu wiederholen. Dies heißt Konstantenfaltung.

Eine Optimierung muss das von der Sprache geforderte Verhalten erhalten. Sie darf eine Berechnung nicht durch eine schnellere ersetzen, die andere als die geforderten Ergebnisse liefert. Das Ziel ist, Arbeit, Zeit oder Speicher zu sparen und dabei die Bedeutung des Programms beizubehalten.

Die Teile verbinden

Große Programme werden meist aus vielen Dateien erstellt. Ein Compiler kann für jede Quelldatei eine Objektdatei erzeugen. Eine Objektdatei enthält übersetzten Code, der möglicherweise noch Verbindungen zu anderem Code benötigt. Ein Linker verbindet die Teile und löst Aufrufe von Bibliotheksroutinen auf, etwa Ausgabe- oder Rechenfunktionen.

Die entstehende ausführbare Datei wird für eine Zielplattform erstellt, einschließlich einer ISA und der Konventionen des Betriebssystems. Der Benutzer benötigt den Ahead-of-time-Compiler nicht, um sie auszuführen. Gemeinsam genutzte Bibliotheken oder Laufzeitkomponenten können weiterhin erforderlich sein.

Verstehen, was eine erfolgreiche Erstellung belegt

In Java besteht int count = "five"; vor der Ausführung eine Typprüfung nicht. Text kann diese Ganzzahlvariable nicht initialisieren. Das Programm muss die erforderlichen Prüfungen zur Übersetzungszeit bestehen, bevor eine lauffähige Version vorliegt.

Andere Fehler überstehen die Übersetzung. Eine Division durch eine vom Benutzer eingegebene Null hängt von Laufzeitdaten ab. Ein Programm, das subtrahieren soll, stattdessen aber addiert, kann laufen und den falschen Wert zurückgeben. Die Übersetzung prüft Sprachregeln; Tests müssen zusätzlich prüfen, ob das Ergebnis zur beabsichtigten Aufgabe passt.

Ein Programm muss nicht zu einer nativen ausführbaren Datei werden, bevor ein Benutzer es startet. Ein Interpreter führt das Programm mithilfe eines anderen laufenden Programms aus. Viele Implementierungen verbinden Interpretation mit Kompilierung. Die hilfreiche Frage lautet daher, wie das jeweilige System Code ausführt.

Mit einem Interpreter ausführen

Ein Interpreter muss immer verfügbar sein, wenn er das Programm ausführt. Eine interaktive REPL wiederholt vier Aktionen: eine Eingabe lesen, sie auswerten, ein Ergebnis ausgeben und zur nächsten Eingabe zurückkehren. Sie gibt beim Ausprobieren kleiner Ausdrücke schnell Rückmeldung.

Interpretation bedeutet nicht zwangsläufig, rohen Quellcode Zeile für Zeile zu lesen. CPython, die Standardimplementierung von Python, übersetzt eine Datei zunächst in Bytecode. Eine virtuelle Maschine als Software führt dann diese internen Befehle aus. Der Bytecode gehört zu dieser Laufzeitumgebung; er ist nicht der native Befehlssatz des Prozessors.

Warum manche Fehler früher erscheinen

Vergleiche zwei Python-Dateien. Diese hat eine gültige Syntax:

print("start")
x = 10
print(x + "5")

Sie gibt „start“ aus, bindet x an 10 und löst dann einen TypeError aus. Die Addition dieser Ganzzahl zu einer Zeichenkette schlägt erst fehl, wenn der Ausdruck ausgeführt wird. Eine ähnliche Operation in einem nicht erreichten Zweig kann unbemerkt bleiben, bis der Zweig ausgeführt wird.

Entferne nun die schließende Klammer aus der letzten Zeile. CPython kann die Datei nicht übersetzen, weil ihre Syntax unvollständig ist. Es meldet einen Syntaxfehler, bevor eine Anweisung in dieser Datei ausgeführt wird, sodass „start“ nicht ausgegeben wird. Die Syntaxprüfung der ganzen Datei und die Laufzeitprüfung einer ausgeführten Operation finden zu unterschiedlichen Zeitpunkten statt.

Bytecode weitergeben und während der Ausführung spezialisieren

Java zeigt einen verbreiteten hybriden Weg. javac Hello.java erzeugt Hello.class, das Bytecode enthält. java Hello startet eine kompatible Java Virtual Machine (JVM). Unterschiedliche JVM-Implementierungen ermöglichen, dass dieser Bytecode auf verschiedenen Prozessorfamilien läuft. Der Bytecode ist zwischen kompatiblen Laufzeitumgebungen portierbar; jede Laufzeitumgebung muss selbst auf ihrer jeweiligen Plattform funktionieren. C# zielt in ähnlicher Weise auf eine von .NET verwendete Zwischensprache.

Ein Just-in-time-Compiler (JIT-Compiler) erzeugt während der Programmausführung Maschinencode. Die HotSpot-Laufzeitumgebung von Java beginnt gewöhnlich mit Interpretation und kompiliert häufig verwendete Methoden. JavaScript-Ausführungsumgebungen in Browsern kombinieren ebenfalls Ausführungstechniken, darunter die JIT-Kompilierung. Das Kompilieren häufig ausgeführter Teile kann die dauerhafte Geschwindigkeit verbessern, benötigt aber während der Ausführung Zeit und Speicher.

Eine Schleife, die eine Milliarde Werte addiert, läuft in kompiliertem C typischerweise viel schneller als in CPython: CPython führt bei vielen Operationen Interpreterarbeit und Typprüfungen aus. Bei einem Skript, das 20 Dateien umbenennt, kann der Entwicklungsaufwand weit mehr ins Gewicht fallen als dieser Unterschied. Miss die tatsächliche Arbeitslast, bevor du aus der Bezeichnung einer Sprache auf ihre Geschwindigkeit schließt.

Kompiliert und interpretiert beschreiben Entscheidungen bei der Implementierung. CPython verwendet Bytecode-Interpretation; PyPy nutzt JIT-Techniken. Eine Sprache kann mehr als eine Implementierung haben, und eine Implementierung kann mehrere Ausführungsmethoden verwenden.

Syntax legt die Regeln für gültigen Programmtext fest. Semantik gibt diesem Text seine Bedeutung. Ein Programm kann jede Grammatikregel befolgen und trotzdem das falsche Ergebnis berechnen. Die Prüfung seiner äußeren Form ist daher nur der erste Teil des Lesens.

Die Bestandteile und die Grammatik erkennen

Zu den Token gehören Schlüsselwörter wie if, Bezeichner wie total, Literale wie 3 oder "hello", Operatoren wie + und == sowie Satzzeichen. Eine Grammatik beschreibt, wie diese Teile Ausdrücke und Anweisungen bilden können.

Python verlangt einen Doppelpunkt nach if x > 3: und verwendet Einrückung, um die von dieser Bedingung gesteuerten Anweisungen zu kennzeichnen. C, Java und JavaScript verwenden geschweifte Klammern für Blöcke; C und Java verlangen außerdem nach vielen Anweisungen Semikolons. In diesen Sprachen hilft die Einrückung menschlichen Lesern, bestimmt aber nicht den Block.

Unterschiedliche Syntax kann eine ähnliche Aktion ausdrücken. Diese Anweisungen geben eine Begrüßung aus:

print("hello")

printf("hello\n");

System.out.println("hello");

Die C-Escape-Sequenz \n fügt einen Zeilenumbruch hinzu. Das Konzept der Ausgabe zu kennen hilft dabei, die jeweilige Ausdrucksweise jeder Sprache zu lernen.

Dieselben Symbole können Unterschiedliches bedeuten

Das vertraute Aussehen eines Symbols legt seine Bedeutung nicht für alle Sprachen fest.

Auch die Auswertungsreihenfolge ist wichtig. Die Rangfolge bewirkt, dass Multiplikation und Division vor der Addition stattfinden. Bei a = 4 und b = 6 dividiert average = a + b / 2 zuerst 6 durch 2 und addiert dann 4, was 7,0 ergibt. Die Klammern in average = (a + b) / 2 bewirken, dass zuerst die Summe gebildet wird, und ergeben 5,0.

Fehler unterscheiden

Ein Syntaxfehler verstößt gegen die Grammatik, etwa ein fehlender Python-Doppelpunkt. Ein Laufzeitfehler tritt während einer ausgeführten Operation auf, etwa bei einer Division durch null in Python. Ein logischer Fehler lässt die Ausführung zu, liefert aber ein unbeabsichtigtes Ergebnis, wie bei der falschen Durchschnittsberechnung.

Manche gültigen Ausdrücke überspringen absichtlich eine Operation. In Python verwendet x != 0 and 10 / x > 2 die Kurzschlussauswertung. Ist x null, ist die erste Bedingung falsch, sodass die rechte Seite nicht ausgewertet wird und keine Division stattfindet. Eine Umkehrung dieser Bedingungen würde diesen Schutz aufheben. Python schreibt and, or und not; C, Java und JavaScript verwenden &&, || und !.

Zuweisung und Vergleich sind eine weitere wichtige Unterscheidung. = speichert einen Wert; == prüft Gleichheit. C erlaubt if (x = 5): Es weist 5 zu und behandelt diesen Wert ungleich null als wahr. Python weist if x = 5: als ungültige Syntax zurück. Derselbe Fehler kann daher in unterschiedlichen Sprachen zu einem anderen Zeitpunkt erkannt werden.

Ein kurzes Programm lässt sich leichter verstehen, wenn du jeweils eine ausgeführte Anweisung nachverfolgst. Halte die aktuellen Werte sichtbar fest, statt von der ersten Zeile direkt zu einem vermuteten Ergebnis zu springen.

Ausdrücke und Zuweisungen

Ein Ausdruck liefert einen Wert: Beispiele sind price * 3, x > 10 und len(name). Eine Anweisung führt eine Aktion aus, etwa einen Wert zuweisen oder einen Block steuern. In total = price * 3 wird der Ausdruck auf der rechten Seite ausgewertet, bevor sein Ergebnis total zugewiesen wird.

Eine Variable ist ein Name, der sich auf einen Wert bezieht. Eine Zuweisung gibt dem Namen seinen aktuellen Wert; sie ist keine mathematische Aussage, dass beide Seiten schon immer gleich waren. Enthält count den Wert 4, liest count = count + 1 zunächst 4, addiert 1 und bindet count an 5.

Die nächste ausgeführte Anweisung verfolgen

Drei Strukturen ordnen den Kontrollfluss:

• Eine Sequenz führt Anweisungen der Reihe nach aus.
• Eine Verzweigung wählt anhand einer Bedingung einen Weg, etwa mit if und else.
• Eine Iteration wiederholt einen Block mit einer for- oder while-Schleife.

Der Strukturierungssatz, der mit Böhm und Jacopini im Jahr 1966 verbunden ist, zeigt, dass sich mit diesen Strukturen jeder Algorithmus ausdrücken lässt. Eine for-Schleife durchläuft gewöhnlich die Elemente einer Sammlung. Eine while-Schleife wiederholt sich, solange ihre Bedingung wahr bleibt.

Betrachte diese Python-Schleife:

total = 0
for n in [3, 8, 5]:
    total = total + n

Die eingerückte Zuweisung wird für jedes Element einmal ausgeführt. Eine Ablauftabelle hält den Zustand nach jeder Aktualisierung fest:

Jede neue Summe baut auf der vorherigen auf. Würdest du total innerhalb der Schleife zurücksetzen, ergäbe sich eine andere Berechnung, weil frühere Additionen verloren gingen.

Eine Funktion betreten und verlassen

Eine Funktion fasst eine Aufgabe unter einem Namen zusammen. Ein Parameter ist ein Name in der Definition; ein Argument ist ein Wert, der bei einem Aufruf übergeben wird:

def area(width, height):
    return width * height

result = area(3, 4)

Der Aufruf bindet width an 3 und height an 4. Die Multiplikation ergibt 12, und return gibt den Wert an den Aufrufer zurück. Die Ausführung wird bei der Zuweisung fortgesetzt, sodass result den Wert 12 erhält. Die Namen beschreiben eine Aufgabe, die mit anderen Argumenten wiederverwendet werden kann.

Ein Name hat einen Gültigkeitsbereich

Der Gültigkeitsbereich bestimmt, wo ein Name verwendet werden kann. Innerhalb einer Funktion erzeugte Namen sind gewöhnlich lokal für diesen Aufruf. Ein Name auf oberster Ebene ist innerhalb seines Moduls global. Getrennte Aufrufe haben getrennte lokale Bindungen, selbst wenn sie identische Namen verwenden.

count = 7

def reset():
    count = 0

reset()
print(count)

Dies gibt 7 aus. Die Zuweisung innerhalb von reset erzeugt ein lokales count; sie ersetzt nicht die globale Bindung. Eine Funktion kann stattdessen ein Ergebnis zurückgeben und den Aufrufer dieses Ergebnis zuweisen lassen.

Gültigkeitsbereich und Lebensdauer beantworten unterschiedliche Fragen. Ein lokaler Name ist für Code außerhalb der Funktion nicht allein deshalb verfügbar, weil das Objekt, auf das er verwies, noch existiert. Zurückgegebene Objekte können weiterleben, und eine zurückgegebene verschachtelte Funktion kann den Zugriff auf Variablen ihres umschließenden Aufrufs behalten; diese erhaltene Umgebung ist Teil einer Closure.

Ein Datentyp legt mögliche Werte und die darauf unterstützten Operationen fest. Eine Ganzzahl unterstützt ganzzahlige Arithmetik; ein Wahrheitswert steht für wahr oder falsch. Zeichenketten, Listen, Datensätze und Objekte verbinden oder ordnen andere Werte. Typen bestimmen auch mit, wie Werte im Speicher dargestellt werden, wobei die Größe eines Wertes vom Wert und von der Implementierung abhängen kann.

Wann werden Typen geprüft?

In Python ist count = 5 gefolgt von count = "five" gültig. Der Name verweist nun auf eine Zeichenkette. Die Auswertung von count + 1 löst dann einen TypeError aus. Bei dynamischer Typisierung haben Werte bestimmte Typen; sie schafft die Typen nicht ab.

Statische Typisierung verlangt keine sichtbare Typangabe an jeder Variablen. Typinferenz ermöglicht es einem Compiler, einen Typ aus dem umgebenden Code abzuleiten. Kotlin leitet für val n = 5 eine Ganzzahl ab, und Rust kann dies für let n = 5; tun. Pythons optionale Typhinweise sind anders: Separate Werkzeuge wie mypy können sie prüfen, aber die gewöhnliche Python-Ausführung erzwingt sie nicht.

Wann werden Werte umgewandelt?

Der Prüfzeitpunkt und die Strenge der Umwandlung sind getrennte Fragen. Python weist "3" + 4 zurück; die ausdrückliche Umwandlung in int("3") + 4 ergibt 7. JavaScript wendet für verschiedene Operatoren unterschiedliche Regeln zur automatischen Umwandlung an:

• "3" + 4 ergibt die Zeichenkette "34".
• "3" * 4 ergibt die Zahl 12.
• "3" - 4 ergibt die Zahl -1.

Die automatische Umwandlung heißt implizite Typumwandlung. Die Bezeichnungen „starke“ und „schwache“ Typisierung beschreiben informell die Strenge der Umwandlung; sie sind keine anderen Namen für statische und dynamische Typisierung. Python ist dynamisch und bei der obigen Addition gemischter Typen streng; C ist statisch und erlaubt dennoch viele implizite numerische Umwandlungen.

Pythons input() gibt eine Zeichenkette zurück. Gibt jemand „30“ ein, hat das Ergebnis weiterhin den Typ str. age + 1 schlägt fehl, während int(age) + 1 den Wert 31 ergibt, wenn age diesen Text enthält. Was auf dem Bildschirm erscheint, reicht nicht aus, um den Typ zu bestimmen.

Zahlen haben Darstellungsgrenzen

Eine vorzeichenbehaftete 32-Bit-Ganzzahl stellt Werte von −2.147.483.648 bis 2.147.483.647 dar. Javas int schlägt vom Maximum zum Minimum um, wenn 1 addiert wird. Ein vorzeichenbehafteter Überlauf in C ist undefiniertes Verhalten, sodass in C nicht von demselben Umschlagen ausgegangen werden darf. Ganzzahlen in Python wachsen, soweit der Speicher es erlaubt: 2 ** 100 ist genau 1.267.650.600.228.229.401.496.703.205.376.

Gleitkommazahlen stellen die meisten Dezimalbrüche binär nur näherungsweise dar. In Python und JavaScript ergibt 0.1 + 0.2 den Wert 0.30000000000000004. Ein direkter Vergleich dieses Ergebnisses mit 0.3 ergibt falsch.

Wenn eine Berechnung einen kleinen Fehler zulässt, vergleiche Werte mit einer für die Aufgabe gewählten Toleranz, zum Beispiel abs(a - b) < 1e-9. Eine so kleine absolute Toleranz eignet sich nur für manche Größenordnungen. Verwende für exakte Dezimalrechnungen im Rechnungswesen ganze kleinste Einheiten oder einen geeigneten Dezimaltyp. Eine Änderung des Vergleichs kann eine näherungsweise Darstellung nicht exakt machen.

Der Hauptspeicher speichert die Daten eines laufenden Programms. Jedes Byte hat eine Adresse. Sprachen stellen Namen bereit, damit Programmierer mit Werten arbeiten können, ohne für jede Operation direkte Adressen zu schreiben.

Aufrufe nutzen Rahmen; Objekte haben eine Lebensdauer

In C belegt ein int gewöhnlich 4 Bytes, und &x liefert die Adresse von x. Höhere Programmiersprachen verbergen Adressen häufig hinter Referenzen. Wichtig ist die Unterscheidung zwischen einer Bindung, die ein Objekt benennt, und dem Objekt selbst.

Der Aufrufstapel verwaltet aktive Funktionsaufrufe. Jeder Aufruf hat einen Stapelrahmen mit Informationen wie Parametern, lokalen Bindungen und der Stelle, an der die Ausführung nach der Rückkehr fortgesetzt werden soll. Ruft main die Funktion area(3, 4) auf, wird ein area-Rahmen oberhalb des Rahmens des Aufrufers hinzugefügt. Die Funktion berechnet 12, kehrt zurück und ihr Rahmen wird entfernt. Bei gewöhnlichen verschachtelten Aufrufen kehrt der neueste Aufruf zuerst zurück.

Rekursion fügt für jede noch nicht abgeschlossene Ebene einen Aufruf hinzu. Häufen sich Aufrufe immer weiter an, kann der verfügbare Stapelspeicher erschöpft werden. Python löst normalerweise nach ungefähr 1.000 verschachtelten Aufrufen einen RecursionError aus, wobei die Grenze von seinen Einstellungen abhängt. Damit eine endliche rekursive Berechnung endet, muss eine Abbruchbedingung erreicht werden.

Der Heap enthält dynamisch allokierte Objekte, etwa eine wachsende Liste oder ein Objekt, das länger als die Funktion besteht, die es erzeugt hat. Bei der Speicherallokation wird Speicher reserviert. Eine zurückgegebene Liste kann auf dem Heap bleiben, nachdem der Aufruf, der sie erzeugt hat, beendet ist.

Das Kopieren einer Referenz teilt ein Objekt

Eine Referenz bezeichnet ein Objekt. Ein Zeiger in C oder C++ stellt ausdrücklich eine Adresse dar, über die auf Daten zugegriffen wird. Das Kopieren einer Referenz kopiert den Zugriff auf das Objekt, nicht alle Daten des Objekts.

a = [1, 2]
b = a
b.append(3)

Nach der ersten Zeile gibt es eine Liste. Die zweite Zeile bindet einen weiteren Namen an sie. Die letzte Zeile verändert diese Liste, sodass sowohl a als auch b den Wert [1, 2, 3] zeigen. Diese gemeinsame Nutzung heißt Aliasing. b = a.copy() würde eine separate äußere Liste erzeugen; bei dieser Liste von Ganzzahlen ließe das Anhängen an die neue Liste a unverändert.

Vergleiche Zuweisung und Veränderung:

x = 5
y = x
y = y + 1

Die Ganzzahl 5 ist unveränderlich. Die Addition ergibt 6, und nur y wird neu gebunden. x verweist weiterhin auf 5. Python-Zahlen, -Zeichenketten und -Tupel sind unveränderlich; Listen und Wörterbücher sind veränderlich. Der feste Inhalt eines Tupels kann eine Referenz auf eine veränderliche Liste enthalten, sodass die Unveränderlichkeit des äußeren Behälters nicht jedes verschachtelte Objekt unveränderlich macht.

Dieselben Regeln auf Argumente anwenden

Wenn Python eine Liste an eine Funktion übergibt, verweist der Parameter auf dasselbe Objekt. Der Aufruf von items.append(4) innerhalb der Funktion verändert diese Liste. Die Zuweisung items = [] bindet nur den lokalen Parameternamen an eine neue Liste. Der Name des Aufrufers bleibt an das ursprüngliche Objekt gebunden.

C übergibt Argumentwerte per Wertübergabe. Damit eine Funktion die Variable eines Aufrufers über deren Adresse aktualisieren kann, übergib einen Zeiger auf sie. Stelle dir beim Nachvollziehen in jeder Sprache zwei getrennte Fragen: „Auf welches Objekt verweist dieser Name?“ und „Ändert diese Operation das Objekt oder bindet sie einen Namen an etwas anderes?“

Allokierter Speicher muss irgendwann wiederverwendbar werden. Die Herausforderung besteht darin, Daten nach ihrer letzten Verwendung freizugeben und zugleich jedes Objekt zu behalten, das das Programm noch benötigt. Sprachen weisen diese Verantwortung dem Programmierer, einem Laufzeitsystem oder vom Compiler geprüften Ownership-Regeln zu.

Manuelle Verwaltung und ihre Fehler

In C fordert malloc(n) n Bytes an und gibt bei Erfolg einen Zeiger auf den Block zurück. free(p) gibt einen durch Allokation erhaltenen Block frei. Der Programmierer muss dies zum richtigen Zeitpunkt und genau einmal tun. Auch C++ unterstützt manuelle Verwaltung, obwohl seine Standardwerkzeuge die Freigabe über die Lebensdauer von Objekten automatisieren können.

Verschiedene Fehler haben unterschiedliche Ursachen:

Ein Zeiger, der weiterhin auf freigegebenen Speicher verweist, ist ein hängender Zeiger. Der Speicher könnte für etwas anderes wiederverwendet werden, sodass ein Zugriff darauf Daten beschädigen oder das Programm zum Absturz bringen kann.

Für ein C-Array int scores[10] sind die Positionen 0 bis 9 gültig. Das Schreiben auf scores[10] geht über das Array hinaus, und C bietet keine automatische Prüfung der Schranken. Python löst einen IndexError aus, wenn Index 10 für eine Liste mit zehn Elementen verwendet wird, und verhindert so, dass dieser Zugriff benachbarten Speicher überschreibt.

Erreichbarkeit verfolgen oder Referenzen zählen

Eine verfolgende automatische Speicherbereinigung beginnt bei noch aktiven Ausgangspunkten, etwa aktiven Referenzen, folgt Verbindungen zwischen Objekten und kann nicht erreichbare Objekte freigeben. Java, C#, Go und JavaScript verwenden verfolgende Verfahren. Die Bereinigung benötigt Arbeit zur Laufzeit und Speicher; je nach Verfahren kann sie Pausen verursachen.

Die Referenzzählung verfolgt die Referenzen auf ein Objekt. Für eine neue Python-Liste lautet die vereinfachte Abfolge: a = [1, 2] liefert eine Referenz; b = a liefert eine zweite; del a entfernt eine; b = None entfernt die andere. CPython gibt diese gewöhnliche Liste normalerweise frei, wenn ihre Anzahl null erreicht.

Eine Gruppe von Objekten kann die Referenzzahlen der jeweils anderen Objekte über null halten, selbst wenn kein aktiver Teil des Programms die Gruppe erreichen kann. Das ist ein Referenzzyklus. CPython ergänzt die Referenzzählung um eine Zyklenerkennung. Referenzzählung und Verfolgung sind beides Verfahren der automatischen Speicherverwaltung.

Ownership vor der Ausführung prüfen

Rust gibt jedem Wert einen Eigentümer und prüft Regeln für das Ausleihen von Referenzen. Endet die Ownership, gibt generierter Aufräumcode den Wert frei. Sicheres Rust weist Verwendungen von Referenzen zurück, die länger als ihr gültiges Ziel bestehen könnten, ohne eine verfolgende automatische Speicherbereinigung zu benötigen. Swift verwendet automatische Referenzzählung, die der Compiler einfügt.

Speichersicherheit ist auch über Abstürze hinaus wichtig. Microsoft berichtete 2019, dass ungefähr 70 % der Schwachstellen, denen das Unternehmen jährlich CVE-Kennungen zuwies, die Speichersicherheit betrafen; Chromium meldete für 2020 einen ähnlichen Anteil schwerwiegender Fehler. Im Dezember 2023 forderten CISA, NSA, FBI und internationale Partner Softwarehersteller auf, Übergänge zu speichersicheren Sprachen zu planen.

Automatische Speicherbereinigung behält weiterhin erreichbare Objekte. Eine ständig wachsende globale Liste kann jeden alten Datensatz am Leben halten, auch nachdem die Anwendung ihn nicht mehr verwendet. Eine automatische Speicherbereinigung kann nicht entscheiden, dass diese erreichbaren Datensätze für die Aufgabe unnötig geworden sind; das Programm muss aufhören, sie zu behalten.

Ein Programmierparadigma ist eine Art, Code zu strukturieren und über Berechnungen nachzudenken. Bei der imperativen Programmierung gibt ein Programm Befehle, die seinen Zustand ändern: die Werte, die Variablen und Objekte aktuell enthalten.

Zustandsänderungen sichtbar machen

Eine laufende Summe ist eine einfache imperative Berechnung:

total = 0
for n in [3, 8, 5]:
    total = total + n

Der Anfangszustand ist total = 0. Die Addition von 3 ändert den Wert auf 3. Die Addition von 8 ändert ihn auf 11. Die Addition von 5 ändert ihn auf 16. Jede Zuweisung nutzt den Zustand, den der vorherige Schritt hinterlassen hat, sodass die Reihenfolge Teil des Verfahrens ist.

Dieser Stil entspricht den schrittweisen Änderungen, die der Prozessor an Registern und Speicher vornimmt. Er passt auch zu Algorithmen, die eine Sammlung gezielt an Ort und Stelle aktualisieren, etwa einer Sortierroutine, die Elemente vertauscht.

Aufgaben Namen geben

Prozedurale Programmierung gliedert imperativen Code in Funktionen oder Prozeduren. Ein Berichtsprogramm könnte read_scores(), average(scores) und print_report(avg) aufrufen. Die Namen lassen Lesende die Gesamtaufgabe erkennen, ohne sofort jeder internen Zeile folgen zu müssen. Jede Prozedur kann getrennt verstanden und getestet werden.

C, Pascal, Fortran und COBOL sind klassische prozedurale Sprachen. Auch Python unterstützt diesen Stil: Ein Skript kann benannte Funktionen verwenden, ohne Klassen zu definieren.

Strukturierte Programmierung ordnet den Kontrollfluss mit Sequenz, Verzweigung, Schleifen und Prozeduraufrufen. Sie vermeidet beliebige Sprünge, die die nächste ausgeführte Anweisung schwer vorhersehbar machen. Edsger Dijkstras Brief „Go To Statement Considered Harmful“ von 1968 trug zur Verbreitung dieses Ansatzes bei. Kontrollierte Ausstiege wie break, continue und return bleiben nützlich: Sie verlassen einen bestimmten Schleifendurchlauf, eine Schleife oder eine Funktion.

Wirkungen können über einen Rückgabewert hinausgehen

Ein Seiteneffekt verändert etwas über das von einer Funktion zurückgegebene Ergebnis hinaus. Eine Ausgabe, das Speichern einer Datei, das Senden einer Netzwerknachricht und das Ändern gemeinsam genutzter Daten sind Seiteneffekte. Programme benötigen solche Aktionen, um mit der Außenwelt zu interagieren.

Probleme entstehen, wenn nicht zusammengehöriger Code denselben Zustand unbemerkt verändert. Angenommen, apply_discount() senkt einen globalen price um 10 %, und add_shipping() addiert 5. Ausgehend von 100 ergibt erst der Rabatt 90 und anschließend der Versand 95. Zuerst der Versand ergibt 105 und anschließend der Rabatt 94,5. Beide Prozeduren führen ihre eigenen Schritte korrekt aus, aber das gemeinsame Ergebnis hängt von ihrer Reihenfolge ab.

Die Übergabe von Werten und die Rückgabe neuer Ergebnisse können diese Reihenfolge sichtbar machen:

price = add_shipping(apply_discount(100))

Der innere Aufruf läuft zuerst: Rabatt, dann Versand. Eine andere Verschachtelung drückt eine andere Regel aus. Ein klarer Datenfluss hilft zu erkennen, ob auch auf den Versand der Rabatt angewendet werden soll.

Imperativer Code ist innerhalb moderner Objektmethoden und Ereignisbehandlungsroutinen weiterhin verbreitet. Eine übergeordnete objektorientierte oder funktionale Gestaltung verhindert nicht, dass ein kleiner Teil direkte Befehle verwendet, wenn diese Schritte den Algorithmus verständlich machen.

Objektorientierte Programmierung (OOP) modelliert ein Programm als zusammenarbeitende Objekte. Jedes Objekt verbindet Daten mit Operationen auf diesen Daten. Ein Konto kann seinen Inhaber und Kontostand speichern und gleichzeitig Ein- und Auszahlungsoperationen anbieten.

Den Bauplan von seinen Instanzen unterscheiden

Eine Klasse legt die Attribute und Methoden fest, die ihre Objekte bereitstellen. Ein Objekt oder eine Instanz ist ein einzelnes konkretes Exemplar dieser Klasse. BankAccount ist der Bauplan; das Konto von Ana mit 150 und das Konto von Ben mit 40 sind verschiedene Instanzen. Ihre Kontostände können sich unabhängig voneinander ändern.

Ein Attribut speichert Daten, die zu einem Objekt gehören. Eine Methode ist eine Operation, die über ein Objekt aufgerufen wird, etwa acct.deposit(50). self in einer Python-Instanzmethode verweist auf das Objekt, für das der Aufruf erfolgt.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance = self._balance + amount

Der Aufruf BankAccount("Ana", 100) erzeugt eine neue Instanz. Ihre Methode __init__ initialisiert die Daten der Instanz. Ein Konstruktor richtet ein neues Objekt ein; Python trennt die Erzeugung von diesem Initialisierungsschritt. Der Aufruf acct.deposit(50) für dieses Konto ändert seinen Kontostand von 100 auf 150.

Die Regel an der Stelle der Aktualisierung platzieren

Datenkapselung bringt Daten und die Operationen zusammen, die ihre Regeln einhalten. Angenommen, ein Konto darf nie einen negativen Kontostand haben. Die Auszahlungsmethode prüft die vorgeschlagene Änderung, bevor sie sie ausführt:

def withdraw(self, amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    if amount > self._balance:
        raise ValueError("insufficient funds")
    self._balance = self._balance - amount

Diese Methode gehört in BankAccount. Bei einem Kontostand von 150 löst withdraw(200) einen Fehler aus und lässt 150 übrig. withdraw(30) gelingt und lässt 120 übrig. Der fehlgeschlagene Aufruf zieht nicht zuerst ab und entdeckt dann das Problem; die Prüfung erfolgt vor der Aktualisierung.

Anderer Code sollte diese Methoden verwenden, statt einen ungeprüften Kontostand zuzuweisen. Java und C# können den direkten Zugriff mit private einschränken. Pythons vorangestellter Unterstrich in _balance signalisiert gemäß einer Konvention ein internes Detail; er erzwingt keinen privaten Zugriff.

Das Geheimnisprinzip geht weiter: Aufrufer hängen von den Operationen ab, die eine Klasse anbietet, ohne ihre interne Darstellung kennen zu müssen. Der Kontostand könnte später anders gespeichert werden, während die öffentlichen Ein- und Auszahlungsoperationen ihre Bedeutung behalten.

Das Problem als Hinweis auf Zuständigkeiten nutzen

Ein Bibliothekssystem hat Bücher, Mitglieder und Ausleihen. Diese Nomen legen mögliche Klassen oder Attribute nahe; Aktionen wie Ausleihen und Verlängern legen Methoden nahe. Wähle für jede Klasse eine klare Zuständigkeit. Eine Kontoklasse, die außerdem jede E-Mail versendet und jeden Bericht formatiert, lässt sich schwerer ändern, weil nicht zusammengehörige Aufgaben vermischt werden.

Klassen und Objekte erschienen 1967 in Simula 67; Smalltalk trug in den 1970er-Jahren zur Verbreitung des Ansatzes bei. Java, C#, C++ und Python unterstützen OOP, aber die Verwendung einer dieser Sprachen zwingt nicht jedes Programm in Klassen. Die hilfreiche Entwurfsfrage lautet, welche Daten und Regeln zusammengehören.

Objekte müssen oft gemeinsame Operationen anbieten und sich zugleich in Einzelheiten unterscheiden. Vererbung, Polymorphie und Komposition lösen unterschiedliche Teile dieses Entwurfsproblems.

Eine bestehende Art von Objekt spezialisieren

Vererbung definiert eine Unterklasse aus einer Oberklasse. In Python gibt class SavingsAccount(BankAccount): der spezialisierten Klasse Zugriff auf das geerbte Kontoverhalten. Sie kann add_interest(rate) hinzufügen: Ein Kontostand von 1.000 wird durch eine Zinsgutschrift von 2 % zu 1.020.

Die beabsichtigte Beziehung ist eine Ist-ein-Beziehung. Ein Sparkonto ist weiterhin ein Bankkonto und muss die für Bankkonten erwarteten Regeln einhalten. Die Wiederverwendung einiger Zeilen reicht nicht aus, um zu behaupten, eine Art von Objekt sei eine andere.

Eine Unterklasse kann eine Methode mit ihrer eigenen Implementierung überschreiben. Angenommen, ein Girokonto berechnet für jede erfolgreiche Abhebung eine Gebühr von 1. Bei einem Kontostand von 100 kostet die Abhebung von 30 insgesamt 31 und lässt 69 übrig. Um die Kontoregel einzuhalten, muss die Methode die Abhebung zuzüglich der Gebühr prüfen, bevor sie den Kontostand ändert. Übersteigen diese Gesamtkosten den Kontostand, verweigert sie den gesamten Vorgang.

Einen Aufruf für unterschiedliche Objekte nutzbar machen

Polymorphie ermöglicht, dass dieselbe Operation für unterschiedliche Objekttypen funktioniert. Ein Kreis und ein Rechteck können beide area() anbieten:

for shape in shapes:
    print(shape.area())

Die Schleife benötigt kein if für jede Formklasse. Jedes Objekt stellt seine eigene Implementierung bereit. Die Auswahl dieser Implementierung während der Ausführung heißt dynamische Methodenbindung.

Für Circle(2) beträgt die Fläche ungefähr 12,57 Quadrateinheiten. Für Rectangle(3, 4) beträgt sie 12 Quadrateinheiten. Ihre gemeinsame Fläche beträgt ungefähr 24,57 Quadrateinheiten. Ein späteres Triangle kann der Sammlung beitreten, indem es eine kompatible Operation area() bereitstellt; die Schleife selbst benötigt keinen weiteren Zweig.

Eine Schnittstelle legt die Operationen fest, die ein Typ anbieten muss. Javas interface Shape { double area(); } verlangt von implementierenden Klassen, die Flächenmethode bereitzustellen. Eine abstrakte Klasse kann einen Teil der gemeinsamen Implementierung vorgeben und andere Methoden den Unterklassen überlassen. Python verwendet oft Duck-Typing: Ein Objekt kann in der Schleife funktionieren, wenn es die benötigte Operation bereitstellt, auch ohne gemeinsame Oberklasse.

Einen Teil enthalten, statt zu ihm zu werden

Komposition speichert andere Objekte als Teile. Ein Auto hat einen Motor und Räder. Es kann die Methode start() seines Motors aufrufen, ohne von Engine zu erben.

Tiefe Vererbungsketten können die Auswirkungen einer Änderung der Oberklasse über viele Klassen verbreiten. Eine Unterklasse, die geerbtes Verhalten deaktivieren muss, kann auf eine ungeeignete Ist-ein-Beziehung hinweisen. Komposition hält solche Abhängigkeiten oft kleiner und übersichtlicher.

Die vier häufig genannten Säulen der OOP passen hier zusammen: Datenkapselung schützt Daten durch Operationen, Abstraktion verbirgt Implementierungsdetails, Vererbung spezialisiert einen Typ und Polymorphie ermöglicht einem Aufrufer, eine gemeinsame Operation für verschiedene Implementierungen zu nutzen.

Funktionale Programmierung erzeugt Ergebnisse durch die Kombination von Funktionen. Ein zentraler Grundsatz ist, aus Eingaben neue Werte zu erzeugen und dabei gemeinsame Veränderungen zu begrenzen. Lisp führte um 1958 weitverbreitete funktionale Ideen ein; Haskell, Erlang, Clojure, F# und OCaml entwickeln diese Ideen auf unterschiedliche Weise weiter.

Erkennen, was eine Funktion rein macht

Eine reine Funktion liefert für dieselben Argumente dasselbe Ergebnis und hat keine Seiteneffekte. def with_tax(price): return price * 1.2 veranschaulicht die Idee: with_tax(50) ergibt 60,0. Eine Funktion, die außerdem etwas an eine globale Liste anhängt oder eine Nachricht ausgibt, hat eine Wirkung über ihren Rückgabewert hinaus. Ein Ergebnis, das von der aktuellen Uhrzeit abhängt, hängt ebenfalls von mehr als den Argumenten ab.

Ein reiner Aufruf kann durch seinen Rückgabewert ersetzt werden, ohne das Programmverhalten zu ändern. Diese Eigenschaft heißt referenzielle Transparenz. Sie erleichtert isolierte Tests und erlaubt es, unabhängige Aufrufe parallel auszuführen, ohne dass sie um die Aktualisierung eines gemeinsamen Zustands konkurrieren.

Unveränderlichkeit hält einen bestehenden Wert unverändert. [n + 1 for n in nums] erzeugt eine neue Liste und lässt nums unberührt. Ein Programm kann veränderliche Informationen weiterhin darstellen, indem es neue Versionen erzeugt; es muss die alte Version nicht überschreiben.

Verhalten als Daten übergeben

Funktionen sind Funktionen erster Klasse, wenn sie Namen zugewiesen, als Argumente übergeben und als Werte zurückgegeben werden können. Eine Funktion höherer Ordnung nimmt eine Funktion entgegen oder gibt eine zurück. Ein Lambda-Ausdruck ist ein unbenannter Funktionsausdruck, etwa lambda n: n * n.

Drei verbreitete Operationen höherer Ordnung bilden eine Verarbeitungskette:

• filter behält Elemente, die einen Test erfüllen.
• map wandelt jedes verbleibende Element um.
• reduce fasst Elemente mithilfe eines Akkumulators zu einem Ergebnis zusammen.

Um die Quadrate der geraden Zahlen von 1 bis 6 zu summieren, bleiben nach dem Filtern 2, 4 und 6; das Quadrieren ergibt 4, 16 und 36; die Summe ist 56.

sum(map(lambda n: n * n,
        filter(lambda n: n % 2 == 0, range(1, 7))))

Hier prüft % 2 == 0, ob eine Zahl gerade ist, und range(1, 7) liefert 1 bis 6. Haskell drückt dieselbe Berechnung als sum (map (^2) (filter even [1..6])) aus.

Wird reduce aus Pythons functools importiert, kombiniert reduce(lambda acc, n: acc + n, [3, 8, 5], 0) zunächst 0 mit 3 zu 3, dann mit 8 zu 11 und schließlich mit 5 zu 16. Die Verarbeitungskette beschreibt Umwandlungen ohne eine umgebende Schleife, die eine gemeinsam genutzte Summe aktualisiert.

Eine Umgebung erhalten oder ein kleineres Problem aufrufen

def multiplier(k): return lambda x: k * x gibt eine Funktion zurück, die den Zugriff auf k behält. Daher gibt multiplier(3)(10) den Wert 30 zurück, auch nachdem der äußere Aufruf beendet ist. Die zurückgegebene Funktion und die erhaltene Umgebung bilden eine Closure.

Bei der Rekursion ruft sich eine Funktion für ein kleineres Problem selbst auf. Die Fakultät gibt bei n == 0 den Wert 1 zurück; andernfalls gibt sie n * factorial(n - 1) zurück. Für 5 ergeben die Produkte 120. Eine endliche Berechnung benötigt einen erreichbaren Basisfall. Nicht abgeschlossene verschachtelte Aufrufe lösen in Python schließlich einen RecursionError aus; Sprachen mit echter Endaufrufoptimierung können für Aufrufe an letzter Stelle Stapelspeicher wiederverwenden.

Die bloße Verwendung von Funktionen macht Code nicht funktional: Prozedurale Funktionen können den Zustand verändern. Tatsächliche funktionale Programme lesen weiterhin Eingaben und schreiben Ausgaben; häufig halten sie Effekte nahe an den Rändern des Programms und die zentralen Berechnungen rein.

Deklarative Programmierung beschreibt das gewünschte Ergebnis und überlässt die Ausführungsschritte einer Ausführungsumgebung der Sprache. Funktionaler Code wird gewöhnlich neben Abfragesprachen und logischer Programmierung unter diese allgemeine Idee gefasst.

Eine Abfrage als Anfrage lesen

Eine relationale Datenbank speichert Daten in Tabellen. Angenommen, students enthält die Zeilen mit Namen und Note Ana 92, Ben 75, Chen 80 und Dara 64:

SELECT name
FROM students
WHERE grade >= 80
ORDER BY name;

FROM nennt die Tabelle, WHERE gibt die Bedingung an, SELECT wählt das zurückgegebene Feld und ORDER BY verlangt alphabetische Reihenfolge. Ana und Chen erfüllen die Bedingung, einschließlich der Note von Chen, die genau 80 beträgt. Das Ergebnis sind ihre Namen in dieser Reihenfolge.

Ein imperatives Programm würde eine Ergebnisliste erstellen, Zeilen durchlaufen, jede Note prüfen, passende Namen anhängen und die Liste sortieren. SQL gibt der Datenbank das geforderte Ergebnis vor, ohne diese Schleife zu schreiben.

Ein Anfrageoptimierer wählt einen Ausführungsplan. Er könnte die Tabelle durchlaufen oder einen verfügbaren Index nutzen, eine Nachschlagestruktur, die geeignete Suchen beschleunigen kann. Viele Indizes verwenden sortierte Strukturen; andere nutzen andere Anordnungen. Das Hinzufügen eines Index kann den Plan ändern, ohne die Abfrage zu ändern. Mehr Daten bedeuten weiterhin Arbeit: Die Angabe des Ergebnisses garantiert nicht, dass jede Abfrage wenig Aufwand verursacht.

Fragen, was aus Fakten und Regeln folgt

Logische Programmierung beschreibt Fakten und Beziehungen und sucht dann nach Werten, die eine Frage erfüllen. In Prolog:

parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

Die Regel bedeutet, dass X ein Großelternteil von Z ist, wenn es ein Y gibt, für das beide Elternbeziehungen gelten. Die Abfrage ?- grandparent(tom, Who). findet Who = ann: Tom ist ein Elternteil von Bob und Bob ein Elternteil von Ann. Großgeschriebene Namen stehen für Variablen; die kleingeschriebenen Namen bezeichnen bestimmte Personen.

Deklarative Werkzeuge in deiner Umgebung erkennen

Eine Tabellenkalkulationsformel =SUM(B2:B5) gibt eine Abhängigkeit an. Die Tabellenkalkulation berechnet sie neu, wenn sich relevante Zellen ändern. Der reguläre Ausdruck [0-9]{3}-[0-9]{4} beschreibt drei Ziffern, einen Bindestrich und vier Ziffern, wie in „555-0199“. Eine Suchfunktion für Textmuster führt die Suche aus.

CSS legt das Aussehen mit einer Regel wie h1 { color: navy; } fest; HTML zeichnet die Seitenstruktur aus. Es sind deklarative Notationen, die gewöhnlich als Stylesheet- und Auszeichnungssprachen eingeordnet werden. Ihre Aufgabe unterscheidet sich von der einer Allzwecksprache, die ein breites Spektrum von Berechnungen ausdrücken kann.

Deklarativer Code kann nahe an einer Problemstellung bleiben und einer Ausführungsumgebung ermöglichen, ihr Verfahren zu verbessern. Er gibt dem Programmierer auch weniger direkte Kontrolle über einzelne Schritte, wodurch sich ein langsamer Plan schwerer untersuchen lässt. Darunter werden weiterhin konkrete Befehle ausgeführt: Deklarativ beschreibt, wie der Programmierer die Aufgabe ausdrückt, nicht einen Prozessor, der ohne Schritte arbeitet.

Ein Paradigma ändert, wie eine Lösung ausgedrückt wird, nicht welches numerische Ergebnis eine korrekte Lösung liefern soll. Betrachte Bestellungen mit den Beträgen [120, 45, 300, 80]: Gesucht ist die Summe der Beträge, die echt größer als 100 sind.

Zustandsänderungen verfolgen

Die imperative Version zeigt die Schleife und die Akkumulatorvariable:

total = 0
for amount in amounts:
    if amount > 100:
        total = total + amount

Der erste Betrag ändert total auf 120. Der zweite lässt den Wert unverändert. Der dritte ändert ihn auf 420, und der vierte lässt ihn dort. Das Programm macht die Reihenfolge von Prüfung und Aktualisierung sichtbar.

Eine Sammlung umwandeln

Ein kompakter Python-Ausdruck im funktionalen Stil ist sum(a for a in amounts if a > 100). Er wählt 120 und 300 aus und fasst sie zu 420 zusammen. Eine andere Version ist sum(filter(lambda a: a > 100, amounts)). Hier beschreibt das Prädikat die Zugehörigkeit, und sum kombiniert die ausgewählten Werte.

Ein Generatorausdruck oder filter-Aufruf nutzt Pythons Multiparadigmenfunktionen; sein Vorkommen macht nicht jeden umgebenden Teil der Anwendung rein.

Regeln bei Objekten unterbringen

In einem objektorientierten Entwurf speichert ein Order ein amount und bietet is_large() an, das self.amount > 100 zurückgibt. Ein OrderBook enthält Bestellobjekte und bietet large_total() an. Diese Methode kann Bestellungen durchlaufen, bei jeder prüfen, ob sie die Bedingung erfüllt, und passende Beträge addieren.

Die Summe bleibt 420. Der Unterschied liegt darin, wo die Zuständigkeiten liegen: Die Regel für eine große Bestellung gehört zu Order, und die Arbeit auf Ebene der Sammlung gehört zu OrderBook. Andere Funktionen können die Regel wiederverwenden, ohne ihre Schwellenwertprüfung zu kopieren.

Die Datenbank fragen

Liegen die Daten bereits in einer relationalen Datenbank, kann SQL die Summe anfordern:

SELECT SUM(amount)
FROM orders
WHERE amount > 100;

Die Datenbank wählt den Plan für Abruf und Aggregation. Die Abfrage weist keinen Aufrufer an, jede Zeile zu durchlaufen oder eine lokale Akkumulatorvariable zu führen.

Stile dort kombinieren, wo sie helfen

Python unterstützt prozedurale, objektorientierte und funktionale Techniken. JavaScript bietet Objekte, Funktionen erster Klasse und Closures. Auch C++, C#, Kotlin, Scala, Swift und Rust mischen Stile. Java wird stark mit OOP verbunden, unterstützt aber seit Java 8 im Jahr 2014 Lambda-Ausdrücke; Haskell ist rein funktional.

Eine Webanwendung kann Klassen für Benutzer und Bestellungen, funktionale Umwandlungen für Berichtsdaten, imperative Aktualisierungen innerhalb von Methoden und SQL für Datenbankabfragen verwenden. Diese Entscheidungen wirken auf verschiedenen Ebenen.

Ereignisgesteuerte Programmierung ergänzt eine weitere Organisationsidee: Registriere eine Behandlungsroutine, die läuft, wenn ein Ereignis eintrifft. In JavaScript übergibt button.addEventListener("click", showMenu) die Funktion showMenu als Funktionswert. Ein späterer Klick ruft sie auf. Die Behandlungsroutine kann selbst Objekte, reine Umwandlungen oder imperative Schritte verwenden. Ihre ereignisgesteuerte Rolle sagt aus, wann sie läuft, legt aber nicht den einzigen möglichen Stil für ihren Rumpf fest.

Keine Programmiersprache passt für jedes Projekt am besten. Allzwecksprachen sind gewöhnlich Turing-vollständig: Mit unbegrenzter Zeit und unbegrenztem Speicher können sie dieselbe Klasse von Berechnungen ausdrücken. Die tatsächliche Wahl hängt davon ab, ob eine Lösung zur jeweiligen Plattform, den Ressourcen, Werkzeugen und Menschen passt.

Mit dem beginnen, was funktionieren muss

Die Plattform ist oft eine feste Nebenbedingung. Browser führen JavaScript aus und können kompilierte Module über WebAssembly ausführen. TypeScript ergänzt statische Prüfungen und wird zu JavaScript kompiliert. Swift ist eine Standardwahl für Apps auf Apple-Plattformen; Kotlin wird für Android empfohlen. SQL ist die übliche Sprache für relationale Abfragen.

Betrachte als Nächstes das Anwendungsgebiet und das Ökosystem. Python hat weitverbreitete Bibliotheken für Datenverarbeitung und maschinelles Lernen wie NumPy und pandas. R konzentriert sich auf Statistik. C und C++ sind bei Betriebssystemen, Spiele-Engines und eingebettetem Code verbreitet. Java und C# kommen häufig in großen Geschäftssystemen vor; Bash ist nützlich, um Betriebssystemaufgaben zu automatisieren.

Dies sind praktische Zuordnungen, keine exklusiven Einsatzgebiete. Eine geeignete Bibliothek kann weit mehr Entwicklungsarbeit sparen als ein kleiner Unterschied in der Syntax der Sprache.

Ressourcen- und Sicherheitsanforderungen untersuchen

Ein Mikrocontroller mit nur einigen Kilobyte Arbeitsspeicher benötigt möglicherweise genaue Kontrolle über den Speicher und den zusätzlichen Laufzeitaufwand. C, C++ oder Rust können geeignet sein, wenn die Zielplattform sie unterstützt. Auch anspruchsvolle Komponenten von Spielen oder Datenbanken sprechen oft für diese Sprachen, aber Ausführungsumgebungen und Ressourcenbudgets unterscheiden sich: Unity verwendet C#, und einige Datenbanken verwenden Java oder Go.

Bevor du nach Geschwindigkeit auswählst, finde den Engpass: den Teil, der die Leistung begrenzt. Ein Programm, das hauptsächlich auf eine Netzwerkantwort wartet, wird nicht allein deshalb erheblich schneller, weil eine kleine lokale Schleife effizienter kompiliert wird. Miss repräsentative Arbeitslasten auf der Zielplattform.

Speichersicherheit verringert Fehler wie ungültige Speicherzugriffe. Sicheres Rust prüft Ownership-Regeln zur Übersetzungszeit; verwaltete Sprachen wie Java, C#, Go und Python bieten Speicherverwaltung zur Laufzeit. Statische Typisierung erkennt viele unverträgliche Operationen vor der Ausführung, was bei einer großen Codebasis helfen kann. Weder Speichersicherheit noch statische Typisierung beweist, dass die Logik des Programms korrekt ist.

Die Kosten für die Wartung des Ergebnisses einbeziehen

Das Wissen des Teams, verfügbare Entwickler, Programme zur Fehlerbehebung, Testwerkzeuge, Bibliotheken, Lizenzen und vorhandener Code beeinflussen die Entscheidung. Eine vertraute, unterstützte Sprache kann die Kosten für Bereitstellung und Wartung senken. Ein funktionierendes System neu zu schreiben verursacht Migrationsarbeit und Risiken, selbst wenn die neue Sprache attraktive Eigenschaften hat.

Bei einem städtischen Wetternetz haben verschiedene Komponenten unterschiedliche Anforderungen:

Eine nützliche Begründung verknüpft jede Wahl mit einer Anforderung: „Das Team wartet den Java-Dienst bereits, und seine Bibliotheken unterstützen die neue Funktion.“ Ein Beliebtheitsrang allein kann diese Begründung nicht liefern. Umfragen können auf eine große Gemeinschaft oder viele verfügbare Fachkräfte hinweisen; sie belegen nicht, welche Sprache für eine bestimmte Arbeitslast am besten ist.