„Geschichte der Programmiersprachen“ – Versionsunterschied
Zur Navigation springen
Zur Suche springen
| [gesichtete Version] | [ungesichtete Version] |
Inhalt gelöscht Inhalt hinzugefügt
Diba (Diskussion | Beiträge) K Änderungen von 79.215.67.206 (Diskussion) auf die letzte Version von Diba zurückgesetzt (HG) |
AZ: Der Seiteninhalt wurde durch einen anderen Text ersetzt. |
||
| Zeile 1: | Zeile 1: | ||
/ |
|||
Die '''Geschichte der Programmiersprachen''' beginnt bereits im 19. Jahrhundert und ist in ihren Anfängen stark durch die [[Mathematik]] und durch [[Ingenieurswissenschaft]]en geprägt. Ab wann eine [[Programmiersprache]] vorliegt, ist tatsächlich nicht eindeutig zu bewerten. |
|||
== Anfänge == |
|||
[[Bild:Jacquard01.jpg|thumb|left|Die Lochkartensteuerung der Jacquard-Maschine]] |
|||
Mit dem Einsetzen der [[Industrielle Revolution|industriellen Revolution]] wurden viele vormals handwerkliche Tätigkeiten immer stärker in die Kontrolle von Maschinen gegeben. Diese waren durch ihre zyklischen Funktionsweisen besonders für sich wiederholende Aufgaben ausgelegt. Andererseits wurde es immer wichtiger, den maschinell ausgeführten Prozessen auch Alternativen vorzugeben, zumal diese Prozesse auch immer schneller ausgeführt werden konnten. |
|||
Exemplarisch für diese Notwendigkeit steht die Einführung des programmierbaren Webstuhls von [[Joseph-Marie Jacquard]] am Anfang des 19. Jahrhunderts. Der Webstuhl erhielt durch [[diskret]]e Auslassungen in den Lochstreifen die Informationen über das zu webende Muster. Das Kunsthandwerk des Webens konnte nun als „Programmierkunst“ auf einem dem Stoffmuster analogen Medium fortgeführt werden. |
|||
Als erste Arbeit im Bereich der mathematisch-logischen Programmierung gilt eine Vorschrift für die Berechnung von [[Bernoulli-Zahl]]en, die [[Ada Lovelace]] in den Jahren 1842/1843 für die mechanische [[Analytical Engine]] von [[Charles Babbage]] erstellte. Dieses Programm konnte zu ihrer Zeit nur von Hand ausgeführt werden, denn wegen Fertigungsproblemen gab es im 19. Jahrhundert keine funktionsfähige Maschine. |
|||
== Die 1930er und 1940er Jahre: Logische Kalküle == |
|||
Der [[Lambda-Kalkül]] wurde von [[Alonzo Church]] und [[Stephen Kleene]] in den 1930er Jahren entwickelt. Es wurde schon früh nachgewiesen, dass der Lambda-Kalkül eine [[Turing-Vollständigkeit|universelle Programmiersprache]] ist. Damit hätten sich schon damals theoretisch ebenso mächtige Programme schreiben lassen, wie heute in jeder modernen Programmiersprache. |
|||
Mit Fertigstellung der ersten elektronischen Rechenmaschinen und der Verwendung der [[Boolesche Algebra|booleschen Algebra]] ging es spürbar mit der Entwicklung von Programmiersprachen weiter. Hervorzuheben sind diesbezüglich etwa [[1937]] die Patente von [[Konrad Zuse]], welche eine Computerarchitektur beschreiben, die später als [[Von-Neumann-Architektur|Von-Neumann-Maschine]] bekannt wird. In den 1940er Jahren stellte Zuse dafür seine Programmiersprache [[Plankalkül]] fertig, in die Ideen aus dem Lambda-Kalkül einflossen. |
|||
== Die 1950er Jahre: Erste moderne Programmiersprachen == |
|||
[[Datei:Grace Hopper.jpg|mini|[[Grace Hopper]] entwickelte den ersten [[Compiler]] und gilt als „''Grandma COBOL''“]] |
|||
In den 50er Jahren des letzten Jahrhunderts wurden in den [[USA]] die ersten drei weiter verbreiteten, praktisch eingesetzten [[Höhere Programmiersprache|höheren Programmiersprachen]] entwickelt: |
|||
Die Älteste noch in weitem Gebrauch befindliche Sprache [[FORTRAN]] ('''FOR'''mula '''TRAN'''slator) wurde 1954 von [[John W. Backus]] et al. entworfen, |
|||
1959 kam [[LISP]] ('''LIS'''t '''P'''rocessor) von [[John McCarthy]] et al. hinzu, das einen auf einer Seite in sich selbst beschreibbaren Kern aufweist und |
|||
1959 brachten [[Grace Hopper]] et al. [[COBOL]] ('''CO'''mmon '''B'''usiness '''O'''riented '''L'''anguage) für kommerzielle Anwendungen zur Welt. |
|||
Die vorgenannten Sprachen existieren mit ihren Nachfolgern bis heute. Vor allem LISP beeinflusste die später an amerikanischen Universitäten entwickelten Programmiersprachen stark. |
|||
Der nächste größere Meilenstein wurde zwischen 1958 und 1960 gesetzt, als ein internationales Komitee während einer Tagungsreihe eine „neue Sprache für Algorithmen“ mit dem späteren Namen Algol 58 entwarf. Das Komitee beendete seine Entwicklung mit dem ''Revised Report on [[Algol 60]]'' ('''ALGO'''rithmic '''L'''anguage). In den Bericht zur Tagung wurden viele Ideen aufgenommen, die zu dieser Zeit in der Fachgemeinschaft kursierten, und ebenso zwei Neuerungen: Zum einen die [[Backus-Naur-Form]] (BNF) zur kontextfreien Beschreibung der Syntax der Programmiersprache. Nahezu alle folgenden Programmiersprachen benutzen die BNF, um die Syntax als [[kontextfreie Grammatik]] darzustellen. Zum anderen wurden [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|Gültigkeitsbereiche]] erstmals definiert. |
|||
Obwohl Algol 60 sich aus politischen Gründen in Nordamerika nicht durchsetzte, hauptsächlich weil [[IBM]] eine Gegenentwicklung in Form von [[PL/I]] anbot, teilweise aber auch wegen der Entscheidung, die Ein- und Ausgabe nicht in die Sprachdefinition zu integrieren, wurde Algol in der Folgezeit zum Standard in der (west)europäischen Welt. Sie beeinflusste die Ausbildung einer ganzen Generation von Informatikern und das Design späterer Sprachen, insbesondere von [[Simula|Simula 67]], [[Pascal (Programmiersprache)|Pascal]] und [[Scheme]]. |
|||
== Die 1960er und 1970er Jahre: Entwicklung neuer Paradigmen == |
|||
[[Datei:Ken n dennis.jpg|mini|links|[[Ken Thompson]] und [[Dennis Ritchie]] sind die Entwickler der noch heute viel benutzten Programmiersprache [[C (Programmiersprache)|C]]]] |
|||
In der Folgezeit wurde eine große Zahl von Programmiersprachen entwickelt, da die Möglichkeit und der Bedarf durch den schnellen Fortschritt der [[Computertechnik]] ''(siehe auch: [[Digitaltechnik]], [[Mikroelektronik]])'' gegeben war. Den größten Erfolg hatten dabei Weiterentwicklungen der bereits vorhandenen Programmiersprachen, also in erster Linie [[Imperative Programmierung|„zustandswechselorientierte“]] Konzepte. Beispielsweise wurde um 1964 [[BASIC]] ('''B'''eginner's '''A'''ll-purpose '''S'''ymbolic '''I'''nstruction '''C'''ode) entwickelt, um Studierenden den Einstieg in die Programmierung mit Algol und FORTRAN zu erleichtern. |
|||
Mitte der 1960er-Jahre tauchte in der sogenannten [[Softwarekrise]] erstmals das Phänomen auf, dass die Kosten für die Software die Kosten für die Hardware überstiegen. In der Folge kam es zu den ersten großen gescheiterten Software-Projekten. |
|||
BASIC wurde schließlich auch in den Ende der 1970er Jahre gebauten, erschwinglicheren [[Heimcomputer]]n populär. Auch die Programmiersprache [[C (Programmiersprache)|C]], 1972 für das neu entwickelte Betriebssystem [[Unix]] entworfen, hat ihre Wurzeln in Algol. Sie setzte sich gegenüber BASIC für allgemeine [[Anwendungsprogramm]]e durch; die grundlegenden funktionalen Teile ([[Kernel (Betriebssystem)|Kernel]]) vieler [[Betriebssystem]]e sind in C programmiert. Beide Programmiersprachen haben bis heute viele Varianten nach sich gezogen. |
|||
Es entstanden in dieser Zeit jedoch auch neue Konzepte. Große Bedeutung erlangte das [[Objektorientierte Programmierung|objektorientierte Programmieren]], das Daten-, Prozedur- und Referenzaspekte in dem einzigen Konzept des Objekts vereinigt. Denkweise und Begriffe der [[Objektorientierung]] zeigten sich zuerst in [[Simula|Simula 67]], einer Sprache für Simulationszwecke, die als erste Sprache (damals noch nicht so genannte) objektorientierte Verfahren einführte. Erzählt wird, dass ihre Entwickler [[Ole-Johan Dahl]] und [[Kristen Nygaard]] an Schiffssimulationen gearbeitet hatten. Dabei ergab sich durch die unüberschaubar vielen Parameterbeziehungen eine verwirrende Vielfalt an Möglichkeiten, wie sich die verschiedensten [[Attribut (Objekt)|Attribut]]e der unterschiedlichen Schiffe gegenseitig beeinflussen konnten. So kam bei ihnen die Idee auf, die unterschiedlichen Schiffstypen jeweils als eigenständige [[Objekt (Programmierung)|Objekte]] zu behandeln, wobei jede [[Klasse (objektorientierte Programmierung)|Klasse]] von Objekten für die ''eigenen'' Daten und das ''eigene'' Verhalten selbst zuständig war. 1962 trafen sie sich am [[Norwegian Computing Center]] in Oslo und erstellten eine erste formale Beschreibung der Sprache, die in München vorgestellt wurde. Ein erster Prototyp eines Simula [[Compiler]]s lief bereits 1964. In den 1970er Jahren wurde Simula in der Praxis vielfach eingesetzt. Die objektorientierten Konzepte der Sprache hatten großen Einfluss auf die weitere Entwicklung von Programmiersprachen. |
|||
Während in Simula die neuen Konzepte noch von ihrer Implementierung nicht deutlich abgehoben wurden, wurde in der Folgezeit die Konzepte weiterentwickelt. Deren Begriffe und Verfahren wurden bereits seit den frühen 1970er Jahren im [[Xerox Palo Alto Research Center]] mit der Sprache [[Smalltalk (Programmiersprache)|Smalltalk]] verfeinert und konsequenter als in Simula umgesetzt. Smalltalk wurde schließlich in den 1980ern der Öffentlichkeit allgemein freigegeben. Smalltalk war als voll dynamisches System angelegt, bei dem man Objekte interaktiv erzeugen und ändern konnte – im Gegensatz zum vorher verwendeten System statischer Programme. Bemerkenswert auch gegenüber ihren Nachfolgern ist die Integration der Sprache in einer innovativen graphischen [[Benutzeroberfläche]], die erstmals eine echte Interaktion ermöglichte. |
|||
Nachdem [[Niklaus Wirth]] bei seiner Mitarbeit an Algol enttäuscht war, entwickelte er [[Pascal (Programmiersprache)|Pascal]] zusammen mit [[Kathleen Jensen]] und setzte Pascal ab 1971 konsequent für die Lehre von Sprachkonzepten ein. Nachdem er festgestellt hatte, wie schwierig die Softwareentwicklung größerer Projekte mit mehreren Entwicklern umzusetzen war, veröffentlichte er 1978 die mit einem strengen [[Modul (Software)|Modul]]- und [[Interface#Softwareschnittstellen|Schnittstellenkonzept]] versehene Weiterentwicklung [[Modula-2]]. |
|||
[[Prolog (Programmiersprache)|Prolog]] von [[Alain Colmerauer]], [[Phillipe Roussel]], und [[Robert Kowalski]] begründete ab 1972 die [[logische Programmierung]] und wurde bis 1975 festgeschrieben. |
|||
== Die 1980er Jahre: Konsolidierung und Objektorientierung == |
|||
In den 1970ern zeigte sich das [[Verteidigungsministerium der Vereinigten Staaten]] besorgt über die Anzahl von über 450 Programmiersprachen, die in seinen Projekten verwendet wurden. Viele der Programmiersprachen waren zudem nicht [[standard]]isiert, sondern vom Anbieter abhängig. Eine Arbeitsgruppe sollte diesen Dschungel lichten und eine Sprache finden, welche die militärischen Bedingungen des Ministeriums erfüllt. Viele existierende Sprachen wurden überprüft, doch 1977 kam die Arbeitsgruppe zum Entschluss, dass keine der vorhandenen Sprachen geeignet war. Nach Ausschreiben von vier Sprachentwürfen entschied man sich 1980 für die aus den besten Ideen der Entwürfe komponierte Sprache [[Ada (Programmiersprache)|Ada]]. Dieser Entwurf wurde unter der Bezeichnung MIL-STD 1815 standardisiert, da 1815 die Namensgeberin [[Ada Lovelace]] geboren wurde. Das Verteidigungsministerium der USA schrieb zeitweilig vor, dass jedes Softwareprojekt mit einem Anteil von mehr als 30 % neuem Code in Ada geschrieben werden musste. Um die Verbreitung des Standards zu unterstützen, finanzierte die [[United States Air Force|US Air Force]] die Entwicklung des kostenfreien [[GNAT]]-[[Compiler]]s. Die Anzahl verschiedener Programmiersprachen im Ministerium reduzierte sich schließlich auf 36. |
|||
[[Bild:Historie.svg|thumb|Die [[Objektorientierte Programmiersprache|objektorientierten Programmiersprachen]] wurden über die Zeit immer stärker.]] |
|||
Die [[objektorientierte Programmierung]] begann Mitte der 1980er Jahre populärer zu werden, hauptsächlich durch den Einfluss von [[C++]], das als syntaktische Erweiterung der Sprache C konzipiert war. [[Bjarne Stroustrup]] hatte 1983 C++ vorgestellt. Viele existierende Programmiersprachen erhielten seit dieser Zeit objektorientierte Erweiterungen, wie Pascal oder LISP (siehe dazu die Abbildung). |
|||
1988 veröffentlichte [[Niklaus Wirth]], der bereits die [[Strukturierte Programmierung|strukturierte Programmiersprache]] Pascal und die modulare Programmiersprache Modula-2 entworfen hatte, die objektorientierte Programmiersprache [[Oberon (Programmiersprache)|Oberon]]. Bei dieser wurden alle nicht unbedingt notwendigen Elemente der relativ mächtigen Programmiersprache Modula-2 weggelassen und die Objektorientierung durch das einfache Konzept der Erweiterung der (mit ''RECORD'' deklarierten) [[Datentyp]]en implementiert. Zusammen mit [[Jürg Gutknecht]] konnte er mit dieser Programmiersprache in kurzer Zeit einen Oberon-[[Compiler]] und das [[Betriebssystem|Betriebs-]] und [[Laufzeitsystem]] ''Oberon System'' programmieren, das wie bei der vollständigen Objektorientierung notwendig, mit einer [[Automatische Speicherbereinigung|automatischen Speicherbereinigung]] ausgestattet ist. |
|||
1995 wurde die Objektorientierung als Erweiterung auch in die neue Version [[Ada 95]] aufgenommen. Weiter gefestigt wurde die Stellung der objektorientierten Programmierung durch die schnell wachsende Beliebtheit der grafischen Bedienoberflächen, die sich objektorientiert sehr einfach programmieren ließen. |
|||
Das Hinzufügen objektorientierter Erweiterungen zu Sprachen, die ursprünglich nicht dafür entworfen wurden, führte oft zu Problemen mit der [[Kompatibilität (Technik)|Kompatibilität]] und [[Wartbarkeit]] von bereits geschriebenen [[Quelltext]]. Vielen rein objektorientierte Sprachen fehlten wiederum [[Prozedurale Programmierung|prozedurale Programmiermöglichkeiten]], an die sich viele [[Programmierer]] gewöhnt hatten. Um diese Lücke zu schließen, wurden zunehmend Versuche unternommen, neue objektorientierte Sprachen zu schaffen, die gleichzeitig eine prozedurale Programmierung erlauben. Die Programmiersprache [[Eiffel (Programmiersprache)|Eiffel]] war 1985 ein früher Versuch in diese Richtung. Inzwischen wurde Eiffel aber praktisch vollständig von [[Java (Programmiersprache)|Java]] (1995) verdrängt. Die an Java und C++ angelehnte Programmiersprache [[C-Sharp|C#]] (2001) verfolgt ähnliche Ziele wie Java. |
|||
== Die 1990er Jahre bis heute: Das Internetzeitalter == |
|||
[[Bild:James Gosling 2005.jpg|thumb|[[James Gosling]] gilt als Erfinder von [[Java (Programmiersprache)|Java]]]] |
|||
Das schnelle Wachstum des [[Internet]]s war eine neue Herausforderung. Allen voran die [[Hypertext Markup Language]] (HTML) ermöglichte dabei als [[Auszeichnungssprache]] das Aussehen des Internets zu gestalten. Das Internet bildete eine völlig neue Grundlage für die Erstellung von [[Softwaresystem]]en und damit auch für die Entwicklung neuartiger Programmiersprachen. Dass sie sich schon früh in [[Webbrowser]]n integrierte, zeichnet die Programmiersprache [[Java (Programmiersprache)|Java]] aus und begründete ihre Popularität. Auch setzten sich verschiedenste [[Skriptsprache]]n für die Entwicklung von [[Webserver]]-Anwendungen durch. Obwohl keine der Sprachen fundamentale Neuerungen im Sprachdesign mit sich brachte, wurden nun Aspekte wie [[automatische Speicherbereinigung]] oder [[Starke Typisierung|starke]] und [[statische Typisierung]] stärker berücksichtigt. Immer größere Beachtung fand auch die [[Codesicherheit]] und die [[Portabilität (Informatik)|Portabilität]] des Programmcodes, dies führte zur Entwicklung von [[Virtuelle Maschine|virtuellen Maschinen]] als [[Laufzeitumgebung]]en. |
|||
Der Siegeszug der [[Objektorientierte Programmierung|objektorientierten Programmierung]] setzte sich weiter fort. In diesem Zusammenhang ist die für das objektorientierte Programmieren entworfene graphische Notationsformen der [[Unified Modeling Language]] (UML) zu nennen. Durch die meist visuellen [[Modell]]ierung wird in UML die [[Softwareentwicklung]] zu einem geordneten Prozess. Dabei kann man feststellen, dass bisher lediglich der [[Abstraktion]]sgrad erhöht wurde. UML wird jedoch mit ihrer zunehmenden Spezifizierung immer mehr zu einer eigenen Programmiersprache. |
|||
[[Bild:Kdevelop.png|thumb|left|Modernes Programmieren mit [[Integrierte Entwicklungsumgebung|Entwicklungsumgebung]]]] |
|||
Neuere [[Integrierte Entwicklungsumgebung|integrierte, visuelle Entwicklungsumgebungen]] haben im Zeit- und Kostenaufwand deutliche Fortschritte gebracht. [[Grafische Benutzeroberfläche|Bedienoberflächen]] lassen sich nun visuell gestalten, Codefragmente sind per Klick direkt erreichbar. Dokumentationen zu anderen Programmteilen und [[Programmbibliothek|Bibliotheken]] sind direkt einsehbar. Meist gibt es sogar eine so bezeichnete „Look-Up“-Funktionalität, die noch während des Schreibens herausfindet, welche Symbole an einer bestimmten Stelle erlaubt sind und entsprechende Auswahlen vorschlägt. |
|||
== Siehe auch == |
|||
* [[Zeittafel der Programmiersprachen]] |
|||
== Weblinks == |
|||
* [http://www.horst-zuse.homepage.t-online.de/HNF-PNN.pdf Geschichte der Programmiersprachen] von [[Horst Zuse]] |
|||
* [http://museums.wikia.com/wiki/VMoC Virtual Museum of Computing] (Linksammlung) |
|||
* [http://www.levenez.com/lang/ Éric Lévénez: Computer Languages History], mit Zeittafel und Linkverzeichnis (englisch) |
|||
* [http://www.aisee.com/graph_of_the_month/lang.htm Geschichte der Programmiersprachen als Graph] |
|||
* [http://www.inf.ethz.ch/personal/wirth/Miscellaneous/IEEE-Annals.pdf A Brief History of Software Engineering] von [[Niklaus Wirth]] (englisch, PDF, 45 kB) |
|||
[[Kategorie:Programmiersprache|!Geschichte]] |
|||
[[Kategorie:Geschichte der Informatik|!Programmiersprache]] |
|||
Version vom 19. Februar 2014, 10:10 Uhr
/