Programmiersprache

2019-05-29T15:57:23Z

Programming-Bootcamp: /* Siehe auch */

{{Überarbeiten|grund=Inhaltliche Redundanz zu anderen Lemmas lt. Diskussion 'Einleitung / Redundanz'}}
[[Datei:Quellcodebeispiel C++.png|mini|250px|Quelltext eines Programms in der Programmiersprache [[C++]].]]
[[Datei:Scratch Screenshot, Running Script.png|mini|250px|Quelltext eines Programms in der Programmiersprache [[Scratch (Programmiersprache)|Scratch]].]]
Eine '''Programmiersprache''' ist eine [[formale Sprache]] zur Formulierung von Datenstrukturen und [[Algorithmus|Algorithmen]], d. h. von Rechenvorschriften, die von einem [[Computer]] ausgeführt werden können.<ref>Duden Informatik, ISBN 3-411-05232-5.</ref> Sie setzen sich aus Anweisungen nach einem vorgegebenen Muster zusammen, der sogenannten [[Syntax]].

Während die ersten Programmiersprachen noch unmittelbar an den Eigenschaften der jeweiligen Rechner orientiert waren, verwendet man heute meist problemorientierte Sprachen, sogenannte [[Höhere Programmiersprache|''höhere Programmiersprachen'']], die eine [[Abstraktion (Informatik)|abstraktere]] und für den Menschen leichter verständliche Ausdrucksweise erlauben. In diesen Sprachen geschriebene Programme können automatisiert in [[Maschinensprache]] übersetzt werden, die von einem [[Prozessor]] ausgeführt wird. Zunehmend kommen auch [[Visuelle Programmierung|visuelle Programmiersprachen]] zum Einsatz, die den Zugang zu Programmiersprachen erleichtern.

Bei deklarativen Programmiersprachen ist der Ausführungsalgorithmus schon vorab festgelegt und wird nicht im Quelltext ausformuliert/beschrieben, sondern es werden nur seine (Start-)Parameter, (Rand-)Bedingungen und Regeln festgelegt, die das Ergebnis erfüllen muss.

== Übersicht ==
[[Datei:Programmiersprache Umfeld.png|mini|Begriffszusammenhänge 'Programmiersprache']]
Die in einer bestimmten Programmiersprache häufig mittels einfacher [[Texteditor]]en erzeugten Anweisungen nennt man [[Quelltext]] (oder auch Quellcode). Um auf einem Computer ausgeführt zu werden, muss der Quelltext in die [[Maschinensprache]] dieses Computer(typ)s übersetzt werden. Diese ist im Gegensatz zu [[Höhere Programmiersprache|höheren Programmiersprachen]] und zur [[Assemblersprache]] ein für Menschen schwer lesbarer Binärcode. Wird von Programmierung in Maschinensprache gesprochen, so ist heute meist die Assemblersprache gemeint.

Die [[#Übersetzer|Übersetzung]] in Maschinensprache kann entweder vor der Ausführung durch einen [[Compiler]] oder – zur [[Laufzeit (Informatik)|Laufzeit]] – durch einen [[Interpreter]] oder [[JIT-Compiler]] geschehen. Oft wird eine Kombination aus beiden Varianten gewählt, bei der zuerst der Quelltext der angewendeten Programmiersprache in einen [[Zwischencode]] übersetzt wird, welcher dann zur Laufzeit innerhalb einer [[Laufzeitumgebung]] in Maschinencode überführt wird. Dieses Prinzip hat den Vorteil, dass derselbe Zwischencode auf verschiedenen Plattformen ausführbar ist. Beispiele für einen solchen Zwischencode sind der Java-[[Bytecode]] sowie die [[Common Intermediate Language]].

Programmiersprachen bieten meist mindestens
* [[Eingabe und Ausgabe|Ein-/Ausgabe-Befehle]], damit das Programm [[Information]]en (genauer: [[Daten]]) entgegennehmen und wieder ausgeben kann;
* [[Deklaration (Programmierung)|Deklaration]] von [[Variable (Programmierung)|Variablen]] und [[Feld (Datentyp)|Feldern]], um Informationen (zwischen-)speichern zu können;
* mathematische Grund- und Standardfunktionen;
* Grundfunktionen zur Zeichenkettenverarbeitung;
* Steueranweisungen für [[Bedingte Anweisung und Verzweigung|bedingte Ausführung]], [[Schleife (Programmierung)|Wiederholung]], Programmunterteilung (z. B. in [[Unterprogramm|Unterfunktionen]]) sowie Einbinden von [[Programmbibliothek|Bibliotheken]].
Meist ist es möglich, aus diesen Grundfunktionen höhere Funktionen zu erstellen und diese als Bibliothek wiederverwendbar zu kapseln. Von dort zu einer höheren oder problemorientierten Sprache zu gelangen, ist kein großer Schritt mehr. So gab es schon bald eine große Zahl an Spezialsprachen für die verschiedensten Anwendungsgebiete. Damit steigt die [[Wirtschaftlichkeit|Effizienz]] der Programmierer und die [[Portable Software|Portabilität]] der Programme, meist nimmt dafür die [[Rechenleistung|Verarbeitungsgeschwindigkeit]] der erzeugten Programme ab, und die Mächtigkeit der Sprache nimmt ab: Je höher und komfortabler die Sprache, desto mehr ist der Programmierer daran gebunden, die in ihr vorgesehenen Wege zu beschreiten.

Sprachen sind verschieden erfolgreich – manche „wachsen“ und finden zunehmend breitere Anwendung; immer wieder sind auch Sprachen mit dem Anspruch entworfen worden, Mehrzweck- und Breitbandsprachen zu sein, oft mit bescheidenem Erfolg ([[PL/1]], [[Ada (Programmiersprache)|Ada]], [[Algol 68]]).

=== Panorama ===
Die Bedeutung von Programmiersprachen für die Informatik drückt sich auch in der Vielfalt der Ausprägungen und der Breite der Anwendungen aus.

* Maschinensprache, [[Assemblersprache]]n oder [[C (Programmiersprache)|C]] erlauben eine hardwarenahe Programmierung.
* [[Höhere Programmiersprache]]n erlauben komfortableres, schnelleres Programmieren.
* [[Skriptsprache]]n dienen zur einfachen Steuerung von Rechnern, wie bei der [[Stapelverarbeitung]].
* [[Visuelle Programmierumgebung|Sprachen mit visuellen Programmierumgebungen]] erleichtern die graphische Gestaltung von [[Grafische Benutzeroberfläche|Benutzeroberflächen]].
* [[Esoterische Programmiersprache]]n sind experimentelle Sprachen mit unüblichen Programmierkonzepten und/oder Berücksichtigung themenfremder Aspekte, z. B. ästhetisches Aussehen des Quellcodes.
* [[Grafische Programmiersprache]]n sollen einen besonders leichten Zugang zum Programmieren bieten; statt Quelltext zu schreiben, kann das Programm aus Verarbeitungsblöcken zusammengeklickt werden.
* [[Minisprache]]n sollen Kinder früh ans Programmieren heranführen (nicht zu verwechseln mit ''minilanguages'', einem Synonym für ''domain-specific languages''.).

Umgangssprachlich wird auch in anderen Bereichen von Programmiersprachen gesprochen. Nachfolgende Sprachen sind jedoch ''nicht'' für die Beschreibung von Algorithmen und allgemeine Datenverarbeitung entworfen, also keine ''[[General Purpose Language]]s'':
* [[Datenbanksprache]]n sind für den Einsatz in und die Abfrage von [[Datenbank]]en gedacht.
* [[Seitenbeschreibungssprache]]n sowie sonstige Beschreibungssprachen (z. B. [[Very High Speed Integrated Circuit Hardware Description Language|VHDL]]) sind eine [[Imperative Programmierung|imperative]] Form eines [[Datenformat]]s.
* [[Computerized Numerical Control|CNC-Programmiersprachen]] dienen der Erzeugung von [[Steuerungstechnik|Steuerungsinformationen]] für Werkzeugmaschinen.
Derartige Sprachen fallen unter die ''[[domänenspezifische Sprache|domänenspezifischen Sprachen]].''

=== Anweisungskategorien ===
Die Anweisungen von Programmiersprachen (Beispiele siehe [[Anweisung (Programmierung)|hier]]) lassen sich nach folgenden Gruppen klassifizieren:
* [[Eingabe und Ausgabe|Eingabe- und Ausgabe]]-Befehle – lesen Daten von der Tastatur, von einer [[Datei]] oder aus anderen Quellen ein oder sie geben sie auf/über ein bestimmtes Ausgabegerät (Bildschirm, Datei, Drucker, ...) aus.
* [[Zuweisung]]en und Berechnungen – verändern oder erzeugen Dateninhalte.
* [[Kontrollstruktur]]en – entscheiden aufgrund der vorliegenden Daten, welche Befehle als Nächstes ausgeführt werden.
* [[Deklaration (Programmierung)|Deklarationen]] – reservieren Speicherplatz für [[Variable (Programmierung)|Variablen]] oder [[Datenstruktur]]en unter einem fast frei wählbaren Namen. Über diesen Namen können sie später angesprochen werden.
* Aufrufe 'programm-externer' Unterroutinen/Module wie Systemfunktionen (z. B. 'Read') oder funktionaler Module, auch aus anderen Programmiersprachen.

=== Übersetzer ===
{{Hauptartikel|Compiler}}
Um ein in einer bestimmten Programmiersprache erstelltes Programm ausführen zu können, muss dessen [[Quellcode]] in eine äquivalente Folge von Maschinenbefehlen übersetzt werden. Das ist notwendig, da der Quellcode aus Zeichenfolgen besteht (z. B. „A = B + 100 * C“), die der Prozessor nicht „versteht“.

Die in der Geschichte der Computertechnik und der [[Softwaretechnologie]] eingetretenen Entwicklungssprünge brachten auch unterschiedliche Werkzeuge zur Erzeugung von Maschinencode, ggf. über mehrere Stufen, mit sich. Diese werden beispielsweise als [[Compiler]], [[Interpreter]], [[Precompiler]], [[Linker (Computerprogramm)|Linker]] etc. bezeichnet.

In Bezug auf die Art und den Zeitpunkt der Übersetzung können zwei Ablaufprinzipien unterschieden werden:
* Wird ein ''Programmtext als Ganzes'' 'übersetzt', so spricht man in Bezug auf den Übersetzungsmechanismus von einem Compiler. Der Compiler selbst ist ein Programm, das als Dateneingabe den Programm-Quellcode liest und als Datenausgabe den Maschinencode (z. B. Objectcode, EXE-Datei, „executable“) oder einen Zwischencode liefert.
* Wenn der Programmtext ''während der Ausführung'' übersetzt wird, spricht man von einer interpretierten Sprache. Das Programm wird in einer [[Laufzeitumgebung]] (z. B. [[Java Virtual Machine|JVM]] oder [[Common Language Runtime|.NET CLR]]) interpretiert und von ihr in Maschinenbefehle umgewandelt. Dem Prozessor ([[CPU]]) werden sie Befehl für Befehl oder en-bloc zur Ausführung zugeleitet.
Daneben existieren verschiedene ''Mischvarianten'':
* Bei der „Just-in-Time-Kompilierung“ wird der Programmtext direkt vor jedem Programmlauf neu übersetzt.
* Zum Teil erzeugen Compiler einen noch nicht ausführbaren Programmcode, der von nachfolgenden [[Systemsoftware|Systemprogrammen]] zu ausführbarem Maschinencode umgeformt wird. Hier sind die Konzepte „plattformunabhängiger [[Zwischencode]]“ (z. B. im Rahmen der [[Distribution (Software)|Software-Verteilung]]) und „plattformgebundener [[Objektcode|Objectcode]]“ (wird zusammen mit weiteren Modulen zu ausführbarem Code, z. T. [[Lademodul]] genannt, zusammengebunden) zu unterscheiden.
* Mit [[Precompiler]]n können spezielle, in der Programmiersprache selbst nicht vorgesehene Syntax-Konstrukte (zum Beispiel [[Entscheidungstabelle]]n) bearbeitet und, vor-übersetzt in die gewählte Programmiersprache, im Quellcode eingefügt werden.

Zur Steuerung des Übersetzens kann der Quelltext neben den Anweisungen der Programmiersprache zusätzliche spezielle [[Compiler-Anweisung]]en enthalten. Komplexe Übersetzungsvorgänge werden bei Anwendung bestimmter Programmiersprachen / [[Integrierte Entwicklungsumgebung|Entwicklungsumgebungen]] durch einen [[Erstellungsprozess|Projekterstellungsprozess]] und die darin gesetzten [[Parameter (Informatik)|Parameter]] gesteuert.

== Geschichte ==
{{Hauptartikel|Geschichte der Programmiersprachen}}
{{siehe auch|Computerprogramm#Geschichte|Programmierung#Geschichte}}

[[Datei:Grace Hopper.jpg|mini|[[Grace Hopper]] entwickelte den ersten [[Compiler]] und gilt als „''Grandma [[COBOL]]''“]]

Zur Vorgeschichte der Programmiersprachen kann man von praktischer Seite die zahlreichen Notationen zählen, die sowohl in der [[Fernmeldetechnik]] ([[Morsezeichen]]) als auch zur Steuerung von Maschinen ([[Jacquardwebstuhl]]) entwickelt worden waren; dann die [[Assemblersprache]]n der ersten Rechner, die doch nur deren Weiterentwicklung waren. Von theoretischer Seite zählen dazu die vielen Präzisierungen des [[Algorithmus]]begriffs, von denen der [[Lambda-Kalkül|λ-Kalkül]] die bei Weitem bedeutendste ist. Auch [[Konrad Zuse|Zuses]] [[Plankalkül]] gehört hierhin, denn er ist dem ''minimalistischen'' Ansatz der Theoretiker verpflichtet ([[Bit]] als Grundbaustein).

In einer ersten Phase wurden ab Mitte der 1950er Jahre unzählige Sprachen<ref>Um 1965 zählte man 1700, vgl. [[ISWIM]].</ref> entwickelt, die praktisch an gegebenen Aufgaben und Mitteln orientiert waren. Seit der Entwicklung von [[Algol 60]] (1958–1963) ist die Aufgabe des [[Übersetzerbau]]s in der praktischen Informatik etabliert und wird zunächst mit Schwerpunkt Syntax (-erkennung, [[Parser]]) intensiv bearbeitet. Auf der praktischen Seite wurden erweiterte [[Datentyp]]en wie [[Verbund (Datentyp)|Verbunde]], [[Zeichenkette]]n und [[Zeiger (Informatik)|Zeiger]] eingeführt (konsequent z. B. in [[Algol 68]]).

In den 1950er Jahren wurden in den [[Vereinigte Staaten|USA]] die ersten drei weiter verbreiteten, praktisch eingesetzten [[Höhere Programmiersprache|höheren Programmiersprachen]] entwickelt. Dabei verfolgten diese sowohl [[Imperative Programmierung|imperative]] als auch [[Deklarative Programmierung|deklarativ]]-[[Funktionale Programmierung|funktionale]] Ansätze.

Die Entwicklung von [[Algol 60]] läutete eine fruchtbare Phase vieler neuer Konzepte, wie das der [[Prozedurale Programmierung|prozeduralen Programmierung]] ein. Der Bedarf an neuen Programmiersprachen wurde durch den schnellen Fortschritt der [[Computertechnik]] gesteigert. In dieser Phase entstanden die bis heute populärsten Programmiersprachen: [[BASIC]] und [[C (Programmiersprache)|C]].

In der Nachfolgezeit ab 1980 konnten sich die neu entwickelten [[Logische Programmierung|logischen Programmiersprachen]] nicht gegen die Weiterentwicklung traditioneller Konzepte in Form des [[Objektorientierte Programmierung|objektorientierten Programmierens]] durchsetzen. Das in den 1990er Jahren immer schneller wachsende [[Internet]] forderte seinen Tribut beispielsweise in Form von neuen [[Skriptsprache]]n für die Entwicklung von [[Webserver]]-Anwendungen.

Derzeit schreitet die Integration der Konzepte der letzten Jahrzehnte voran. Größere Beachtung findet so beispielsweise der Aspekt der [[Codesicherheit]] in Form von [[Virtuelle Maschine|virtuellen Maschinen]]. Neuere integrierte, visuelle Entwicklungsumgebungen erfordern deutlich weniger Aufwand an Zeit und Kosten. Bedienoberflächen lassen sich meist visuell gestalten, Codefragmente sind per Klick direkt erreichbar. Dokumentation zu anderen Programmteilen und Bibliotheken ist direkt einsehbar, meist gibt es sogar ''lookup''-Funktionalität, die noch während des Schreibens herausfindet, welche Symbole an dieser Stelle erlaubt sind und entsprechende Vorschläge macht ([[Autovervollständigen]]).

Neben der mittlerweile etablierten [[Objektorientierte Programmierung|objektorientierten Programmierung]] ist die [[modellgetriebene Architektur]] ein weiterer Ansatz zur Verbesserung der [[Software-Entwicklung]], in der Programme aus [[syntaktisch]] und [[semantisch]] formal spezifizierten Modellen generiert werden. Diese Techniken markieren gleichzeitig den Übergang von einer eher handwerklichen, individuellen Kunst zu einem industriell organisierten Prozess.

; Sprachgenerationen {{Anker|Sprachgenerationen}}

Man hat die Maschinen-, Assembler- und höheren Programmiersprachen auch als Sprachen der ''ersten bis dritten Generation'' bezeichnet; auch in Analogie zu den gleichzeitigen Hardwaregenerationen. Als ''[[4GL|vierte Generation]]'' wurden verschiedenste Systeme beworben, die mit Programmgeneratoren und Hilfsprogrammen z. B. zur Gestaltung von Bildschirmmasken (''screen painter'') ausgestattet waren. ''Die'' Sprache der fünften Generation schließlich sollte in den 1980er Jahren im Sinne des ''Fifth Generation Computing'' [[Prolog (Programmiersprache)|Concurrent Prolog]] sein.

== Programmierparadigmen ==
{{Hauptartikel|Programmierparadigma}}

{| cellpadding="1" style="float:right;border: 1px solid #8888aa; background: #f7f8ff; padding: 10px; font-size: 95%; margin: 0 15px 0 15px; text-align:center"
|+ '''Paradigmen in Programmiersprachen (Auswahl)'''
|- style="text-align:center; background-color:#CCCCCC;"
|'''Name''' || '''[[Funktionale Programmierung|funktional]]''' || '''[[Imperative Programmierung|imperativ]]''' || '''[[Objektorientierung|objektorientiert]]''' || '''[[Deklarative Programmierung|deklarativ]]''' || '''[[Logische Programmierung|logisch]]''' || '''[[Nebenläufigkeit|nebenläufig]]'''
|-
| [[Ada (Programmiersprache)|Ada]] || || X || X || || || X
|- style="background-color:#EFEFEF;"
| [[C (Programmiersprache)|C]] || || X || || || ||
|-
|[[Prolog (Programmiersprache)|Prolog]] || || || || X || X ||
|- style="background-color:#EFEFEF;"
|[[Scheme]] || X || X ||(X)|| X || ||(X)
|-
|[[Haskell (Programmiersprache)|Haskell]] || X ||(X)|| || X || ||(X)
|- style="background-color:#EFEFEF;"
|[[Scala (Programmiersprache)|Scala]] || X ||(X)|| X || (X) || || X
|}

Die Programmiersprachen lassen sich in Kategorien einteilen, die sich im evolutionären Verlauf der Programmiersprachen-Entwicklung als sog. [[Programmierparadigma|Programmierparadigmen]] gebildet haben. Grundlegend sind die Paradigmen der [[Strukturierte Programmierung|strukturierten]], der [[Imperative Programmierung|imperativen]] und der [[Deklarative Programmierung|deklarativen Programmierung]] – mit jeweils weiteren Unterteilungen. Eine Programmiersprache kann jedoch auch mehreren Paradigmen gehorchen, das heißt die begriffsbestimmenden Merkmale mehrerer Paradigmen unterstützen.

=== Strukturierte Programmiersprachen ===
{{Hauptartikel|Strukturierte Programmierung}}

Strukturierte Programmierung ist Anfang der 1970er Jahre auch aufgrund der [[Softwarekrise]] populär geworden. Es beinhaltet die Zerlegung eines Programms in [[Unterprogramm]]e ([[prozedurale Programmierung]]) und die Beschränkung auf die drei elementaren [[Kontrollstruktur]]en [[Anweisung (Programmierung)|Anweisungs]]-[[Reihenfolge]], [[Bedingte Anweisung und Verzweigung|Verzweigung]] und [[Schleife (Programmierung)|Wiederholung]].

=== Imperative Programmiersprachen ===
Ein in einer [[Imperative Programmierung|imperativen Programmiersprache]] geschriebenes Programm besteht aus Anweisungen (latein ''imperare'' = befehlen), die beschreiben, ''wie'' das Programm seine Ergebnisse erzeugt (zum Beispiel Wenn-dann-Folgen, Schleifen, Multiplikationen etc.).

=== Deklarative Programmiersprachen ===
Den genau umgekehrten Ansatz verfolgen die [[Deklarative Programmierung|deklarativen Programmiersprachen]]. Dabei beschreibt der Programmierer, welche Bedingungen die Ausgabe des Programms (das ''Was'') erfüllen muss. Wie die Ergebnisse konkret erzeugt werden, wird bei der [[#Übersetzung|Übersetzung]], zum Beispiel durch einen Interpreter festgelegt. Ein Beispiel ist die Datenbankabfragesprache [[SQL]].

Ein Programm muss nicht unbedingt eine Liste von Anweisungen enthalten. Stattdessen können [[Grafische Programmiersprache|grafische Programmieransätze]], zum Beispiel wie bei der in der Automatisierung verwendeten Plattform [[STEP 7]], benutzt werden.

Die Art der formulierten Bedingungen unterteilen die deklarativen Programmiersprachen in [[logische Programmiersprache]]n, die [[mathematische Logik]] benutzen, und [[funktionale Programmiersprache]]n, die dafür [[Funktion (Mathematik)|mathematische Funktionen]] einsetzen.

=== Objektorientierte Programmiersprachen ===
{{Hauptartikel|Objektorientierte Programmierung}}

Hier werden Daten und Befehle, die auf diese Daten angewendet werden können, in Objekten zusammengefasst. Objektorientierung wird im Rahmen der [[Objektorientierte Programmierung|Objektorientierten Programmierung]] verwendet, um die [[Komplexität]] der entstehenden Programme zu verringern.

Die Bausteine, aus denen ein objektorientiertes Programm besteht, werden als Objekte bezeichnet. Die Konzeption dieser Objekte erfolgt dabei in der Regel auf Basis der folgenden [[Paradigma|Paradigmen]]:<ref>{{Literatur|Autor=Peter A. Henning, Holger Vogelsang|Titel=Taschenbuch Programmiersprachen|Verlag=Fachbuchverlag im Carl Hanser Verlag|Ort=Leipzig|Jahr=2007|ISBN=978-3-446-40744-2}}</ref>
; [[Polymorphie (Programmierung)|Polymorphismus]]: Fähigkeit eines [[Bezeichner]]s, abhängig von seiner Verwendung unterschiedliche Datentypen anzunehmen.
; [[Datenkapselung (Programmierung)|Datenkapselung]]: Als Datenkapselung bezeichnet man in der Programmierung das Verbergen von Implementierungsdetails.
; [[Vererbung (Programmierung)|Vererbung]]: Vererbung heißt vereinfacht, dass eine abgeleitete Klasse die Methoden und Attribute der Basisklasse ebenfalls besitzt, also ''erbt''.

== Typsystem ==

{{Hauptartikel|Typisierung (Informatik)}}


[[Variable (Programmierung)|Variablen]] sind mit einem Namen versehene Orte im Speicher, die einen Wert aufnehmen können. Um die Art des abgelegten Wertes festzulegen, muss in vielen Programmiersprachen der Variablen ein [[Datentyp]] zugewiesen werden. Häufige Datentypen sind Ganz- und [[Gleitkommazahl]]en oder auch Zeichenketten.

Es wird zwischen typisierten und typenlosen Sprachen unterschieden. In typisierten Sprachen (zum Beispiel [[C++]] oder [[Java (Programmiersprache)|Java]]) wird der Inhalt der Variable durch einen Datentyp festgelegt. So gibt es für Ganz- und Gleitkommazahlen verschiedene Datentypen, die sich durch ihren Wertebereich unterscheiden. Sie können vorzeichenlos oder vorzeichenbehaftet sein. Nach aufsteigendem Wertebereich sind dies zum Beispiel: Short, [[Integer (Datentyp)|Integer]] oder Long. Datentypen für Gleitkommazahlen sind zum Beispiel Float oder Double. Einzelne Zeichen können im Datentyp [[Char (Datentyp)|Char]] gespeichert werden. Für [[Zeichenkette]]n steht der Datentyp String zur Verfügung.

Die typisierten Sprachen können anhand des Zeitpunkts der Typüberprüfung unterschieden werden. Findet die Typüberprüfung bereits bei der Übersetzung des Programms statt, spricht man von [[Statische Typisierung|statischer Typisierung]]. Findet die Typprüfung zur Laufzeit statt, spricht man von [[Dynamische Typisierung|dynamischer Typisierung]]. Erkennt eine Programmiersprache Typfehler spätestens zur Laufzeit, wird sie als [[Typsicherheit|typsicher]] bezeichnet.

Bei statischer Typprüfung ist der Programmierer versucht, diese zu umgehen, oder sie wird nicht vollständig durchgesetzt (zum jetzigen Stand der Technik muss es in jeder statischen Sprache eine Möglichkeit geben, typlose Daten zu erzeugen oder zwischen Typen zu wechseln – etwa wenn Daten vom [[Massenspeicher]] gelesen werden). In Sprachen mit dynamischer Typprüfung werden manche Typfehler erst gefunden, wenn es zu spät ist. Soll der Datentyp einer Variablen geändert werden, ist ein expliziter Befehl zur [[Typumwandlung|Umwandlung]] nötig.

Die typenlosen Sprachen (zum Beispiel [[JavaScript]] oder [[Prolog (Programmiersprache)|Prolog]]) verfügen, im Gegensatz zu den typisierten Sprachen, über keine differenzierten Datentypen. Der Datentyp einer Variablen wird erst zur Laufzeit festgelegt. Wird einer Variablen ein Wert eines anderen Typs zugewiesen, findet eine Umwandlung der Variablen in den neuen Typ statt. Die typenlosen Sprachen behandeln oftmals alle Einheiten als Zeichenketten und kennen für zusammengesetzte Daten eine allgemeine Liste.

Durch die Festlegung des Datentyps werden vor allem zwei Zwecke verfolgt:

* Deskriptive Typangaben erleichtern die Programmierung und entlasten die Notation. Beim Zugriff auf ein [[Feld (Datentyp)|Feld]] mit einem Index kann die Speicherstelle, an der sich der abgefragte Wert befindet, abhängig vom verwendeten Datentyp berechnet werden.
* Präskriptive Typangaben schließen bestimmte Operationen aus. Es kann zum Beispiel das Einhalten von Feldgrenzen geprüft werden, um einen Zugriff über die Feldgrenzen hinaus zu verhindern.

Das sichere Typsystem der Programmiersprache ML bildet die Grundlage für die Korrektheit der in ihr programmierten [[Theorembeweiser|Beweissysteme]] (LCF, HOL, [[Isabelle (Theorembeweiser)|Isabelle]]); in ähnlicher Weise versucht man jetzt auch die Sicherheit von [[Betriebssystem]]en zu gewährleisten.<ref>''Vgl.'' [[Sprachbasiertes System]] – z. B. [[Singularity]] basierend auf der Programmiersprache ''Sing#'', ''[[JX (Betriebssystem)|JX]]'' für [[Java (Programmiersprache)|Java]], [[Coyotos]] mit der Sprache ''[[BitC]]''.</ref> Schließlich ermöglichen erst unterschiedliche Typangaben das populäre [[Überladen]] von Bezeichnern. Nach [[Christopher Strachey|Strachey]] sollte das Typsystem im Mittelpunkt der Definition einer Programmiersprache stehen.

Die [[Definition]] von Daten erfolgt im Allgemeinen durch die Angabe einer konkreten [[Spezifikation]] zur Datenhaltung und der dazu nötigen Operationen. Diese konkrete Spezifikation legt das allgemeine Verhalten der Operationen fest und abstrahiert damit von der konkreten Implementierung der Datenstruktur (s. a. [[Deklaration (Programmierung)|Deklaration]]).

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 z. B. sind Objekte FCCs, in [[Lisp]] ist jedes Stück Programm FCCs, in [[Perl (Programmiersprache)|Perl]] sind es Zeichenketten, Arrays und Hashes. Auch der Aufbau der Daten folgt syntaktischen Regeln. Mit [[Variable (Programmierung)|Variablen]] kann man bequem auf die Daten zugreifen und den dualen Charakter von Referenz und Datum einer Variablen ausnutzen. Um die Zeichenketten der Daten mit ihrer (semantischen) Bedeutung nutzen zu können, muss man diese Bedeutung durch die Angabe eines [[Datentyp]]s angeben. Zumeist besteht im Rahmen des [[Typsystem]]s auch die Möglichkeit, neue Typen zu vereinbaren. LISP verwendet als konzeptionelle Hauptstruktur Listen. Auch das Programm ist eine Liste von Befehlen, die andere Listen verändern. [[Forth (Programmiersprache)|Forth]] verwendet als konzeptionelle Hauptstruktur [[Stapelspeicher|Stacks]] und Stack-Operationen sowie ein zur Laufzeit erweiterbares Wörterbuch von Definitionen und führt in den meisten Implementationen überhaupt keine Typprüfungen durch.

== Sonstiges ==

Ein beliebter Einstieg in eine Programmiersprache ist es, mit ihr den Text ''Hello World'' (oder deutsch „Hallo Welt“) auf den Bildschirm oder einem anderen Ausgabegerät auszugeben (siehe [[Hallo-Welt-Programm]]). Entsprechend gibt es [[Liste von Hallo-Welt-Programmen/Programmiersprachen|Listen von Hallo-Welt-Programmen]] und eigene Webseiten,<ref>[http://www2.latech.edu/~acm/helloworld Auflistung von Hello-World-Programmen nach Programmiersprachen]</ref> die Lösungen in verschiedenen Programmiersprachen gegenüberstellen.

== Siehe auch ==
* [[Liste von Programmiersprachen]]
*[https://programming-bootcamp.com/projekte.html Übungen für Programmiersprachen]
* [[Zeittafel der Programmiersprachen]]
* [[Bildungsorientierte Programmiersprachen]]

== Literatur ==
* {{Literatur|Autor=[[Friedrich L. Bauer]], Hans Wössner|Titel=Algorithmische Sprache und Programmentwicklung| Auflage= 2. verbesserte |Verlag=Springer |Ort=Berlin u. a. |Jahr=1984 |ISBN=3-540-12962-6}}
* {{Literatur|Autor=Peter A. Henning, Holger Vogelsang|Titel=Handbuch Programmiersprachen. Softwareentwicklung zum Lernen und Nachschlagen|Verlag=Hanser |Ort=München|Jahr=2007|ISBN=978-3-446-40558-5}}
* {{Literatur|Autor=Kenneth C. Louden|Titel=Programmiersprachen: Grundlagen, Konzepte, Entwurf|Verlag=Internat. Thomson Publ.|Ort=Bonn/ Albany u. a.|Jahr=1994|ISBN=3-929821-03-6}}
* {{Literatur|Autor=John C. Reynolds|Titel=Theories of Programming Languages|Verlag=Cambridge Univ. Press|Ort=Cambridge|Jahr=1998|ISBN=0-521-59414-6}}
* {{Literatur|Autor=Robert Harper|Titel=Practical Foundations for Programming Languages|Verlag=Cambridge Univ. Press|Ort=Cambridge|Jahr=2016|ISBN=978-1-107-15030-0}}
* {{Literatur|Autor=Peter van Roy, Seif Haridi|Titel=Concepts, Techniques, and Models of Computer Programming|Verlag= MIT Press|Ort=Cambridge|Jahr=2004|ISBN=0-262-22069-5}}
* {{Literatur|Autor=Michael L. Scott|Titel=Programming language pragmatics|Auflage=2.|Verlag=Elsevier, Morgan Kaufmann|Ort=Amsterdam|Jahr=2006|ISBN=0-12-633951-1}}

== Weblinks ==
{{Wiktionary}}
{{Wikibooks|Regal:Programmierung|Programmierung}}
{{Commonscat|Programming languages|Programmiersprachen}}
* [http://www.99-bottles-of-beer.net/ 99 ''Bottles of Beer'']: Ein Programm in hunderten von Programmiersprachen bzw. Dialekten (englisch)

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4047409-4|LCCN=|NDL=|VIAF=}}

[[Kategorie:Programmiersprache| ]]
[[Kategorie:Programmiersprache als Thema| ]]
[[Kategorie:Compilerbau]]

Wikipedia - Benutzerbeiträge [de]

Programmiersprache