Geschichte der Programmiersprachen

Mit der ständigen Evolution von Computern haben sich Programmiersprachen weiterentwickelt. Untersuchen erreicht, dass die erste Sprache vor über 100 Jahren geschaffen und von einer Frau entwickelt wurde. Mal sehen was die Geschichte der Programmiersprachen.

geschichte-der-programmiersprachen-1

Geschichte der Programmiersprachen: Hintergrund

Im Laufe der Zeit und der ständigen Entwicklung von Computern mussten Programmiersprachen gemäß den Anforderungen von Programmierern und Computern im Allgemeinen modifiziert und verbessert werden, wodurch eine große Anzahl von Sprachen und Codes erzeugt wurde, die bereits in Vergessenheit geraten sind.

Die ersten Programmiersprachen sind älter als der aktuelle Computer, zunächst waren die Programmiersprachen Codes. Die von Jacquard im Jahr 1801 entwickelte Webmaschine nutzte die Löcher in perforierten Karten, um die Bewegung des mechanischen Arms einer Webmaschine nachzubilden, um automatisch dekorative Muster zu erzeugen.

Zwischen den Jahren 1842 und 1843 gelang es Ada Lovelace, die Arbeit von Menabrea an einer von Charles Babbage vorgeschlagenen Maschine "The Analytical Engine" zu übersetzen. Ada Lovelace, fügte einige Beobachtungen zur Methodik hinzu, um die Berechnungen der Bernoulli-Zahlen mit dieser Maschine durchzuführen.

Herman Hollerith verschlüsselte alle Informationen auf den Lochkarten, als er feststellte, dass die Lokführer die Fahrgäste anhand des Lochs in der Fahrkarte identifizieren konnten. 1890 erstellte Hollertih dann einen Passagierdatencode auf diesen Karten.

Die anfänglichen Computercodes waren darauf spezialisiert, wofür sie verwendet werden sollten. In den ersten Jahrzehnten des XNUMX. Jahrhunderts basierten numerische Berechnungen auf Dezimalzahlen. Später erkannten sie, dass Logik mit Zahlen symbolisiert werden konnte.

Alonzo Church drückte die Lambda-Berechnung mit Formeln aus. Die Turing-Maschine legte den Grundstein für die Kompilierung von Programmen als Daten von einem Computer in der Von-Neumann-Architektur.

Der Turing-Code diente jedoch nicht erfolgreich als Grundlage für fortgeschrittene Sprachen, sondern wurde bei der gründlichen Analyse von Algorithmen verwendet.

Die erste Geschichte der Programmiersprachen, es ist schwierig, zeitlich genau zu lokalisieren. Von Anfang an definierten Hardwarebeschränkungen die Geschichte der Programmiersprachen.

Anfangs unterstützten die Lochkarten nur etwa 90 Spalten, wurden jedoch verwendet, um eine Klassifizierung jeder der Karten vorzunehmen. Durch die Verwendung der Magnettrommel als Speicher mussten die Programme mit den Schwingungen der Trommel durchsetzt werden. Die Programme waren also von der Hardware abhängig.

Für bestimmte Experten waren die Jacquard-Webmaschine sowie die Babbage-Maschine sehr einfache Sprachen und mit Einschränkungen, um die Aktionen dieser Maschinen zu beschreiben. Innen Geschichte der ProgrammiersprachenAuch Lochkarten gelten als Grundsprache, obwohl sie nicht für den menschlichen Verzehr geschaffen wurde.

geschichte-der-programmiersprachen-2

Wichtige Termine und Daten

In den 40er Jahren wurden die ersten Computer entwickelt, die mit elektrischem Strom betrieben wurden. Sie hatten Geschwindigkeits- und Speicherkapazitätsbeschränkungen und zwangen Programmierer, einfache Programme zu erstellen. Langfristig erkennen sie, dass das Programmieren als Sprache einen großen intellektuellen Schub braucht, da man Fehler essen kann, wenn man das Fach nicht kennt.

Im Jahr 1948 veröffentlichte Konrad Zuse einen Artikel über eine von ihm entwickelte Programmiersprache namens Plankalkul, forschte jedoch nicht weiter auf diesem Gebiet. Unter den Sprachen, die zu dieser Zeit erstellt wurden, können folgende hervorgehoben werden:

  • 1943: ENIAC-Code.

  • 1948 Plankalkul, dies wurde ein halbes Jahrhundert später umgesetzt.

  • 1949 bis 1954 - Es wurde eine Anleitung entwickelt, die für bestimmte Hersteller erstellt wurde.

50er und 60er XNUMX. Jahrhundert: Beginn der Geschichte der Programmiersprachen

Zu dieser Zeit wurden die drei noch gültigen Programmiersprachen entwickelt, die sind:

  1. 1955 - FORTRAN, entwickelt von John Backus.

  2. 1958: LISP, entwickelt von John McCarthy.

  3. 1959: COBOL, entwickelt vom Short Range Committee, und ihr Einfluss war Grace Hopper.

Ein weiterer wichtiger Moment war Ende der 50er Jahre, als von einem amerikanischen und europäischen Komitee der Computerexperten (Algol) eine aktualisierte "Sprache für Algorithmen" veröffentlicht wurde. Dieser Bericht fasste viele Ideen und Beobachtungen des Tages zusammen und lieferte zwei relevante Neuerungen für die Geschichte der Programmiersprachen:

  • Verschachtelte Blockstrukturen: Codesequenzen und zugehörige Deklarationen werden in Blöcke gepackt, ohne dass es sich explizit um einzelne Prozesse handeln muss.

  • Lexikalischer Geltungsbereich: Ein Block hat seine eigenen Variablen, Prozesse und Funktionen, die für den Code außerhalb dieses Blocks nicht sichtbar sind, ein Beispiel wäre das Verbergen von Daten oder Informationen.

Eine weitere Neuerung, die mit diesen Informationen verbunden ist, ist die folgende:

  • Ein präzises mathematisches Zeichen, Backus-Naur-Form oder besser bekannt als BNF, wurde verwendet, um den Aufbau der Sprache zu beschreiben. Alle folgenden Programmiersprachen haben eine Variation von BNF verwendet, um den kontextfreien Teil ihrer Konstruktion zu beschreiben.

Dieses amerikanische und europäische Komitee beeinflusste insbesondere die Entwicklung der nachfolgenden Sprachen. Burroughs' große Systeme wurden entwickelt, um in einen erweiterten Satz eines solchen Komitees programmiert zu werden, das als Algol bekannt wurde.

Algols Hauptideen verbreiteten sich und im Jahr 1968 wurde Algol 68 realisiert:

  • Der Aufbau und die Semantik waren orthogonaler, mit unbekannten Routinen, ein Typisierungssystem mit Funktionen höherer Ordnung.

  • Zu diesem Zweck wurde nicht nur der freie Teil des Kontextes formal definiert, sondern auch die Konstruktion und Semantik im Sinne von Van Wijngaardens Grammatik geschaffen.

Die umfangreichen, aber ungenutzten Funktionen von y Algol 68 und sein kompliziertes System automatischer Verknüpfungen und Einschränkungen führten zu Unbeliebtheit und schwieriger Anwendung.

So löste sich Niklaus Wirth aus dem Gremium und entwickelte die einfache Sprache namens "Pascal". Dies sind einige der damals entwickelten Sprachen:

  • Jahr 1951: Regionale Assemblersprache.

  • Jahr 1952: Autocoder.

  • Jahr 1954: IPL.

  • Jahr 1955: Flow Matic.

  • Jahr 1957: FORTRA N.

  • Jahr 1958: LISP.

  • Jahr 1959: FACT, COBOL und RPG.

  • Jahr 1962: APL, Simula und SNOBOL.

  • Jahr 1963: CPL.

  • Jahr 1964: BASIC und PL / I.

  • Jahr 1967: BCPL.

geschichte-der-programmiersprachen-3

Die 70er: Grundmodelle sind etabliert

Zwischen den 1960er und 1970er Jahren gab es einen großen Boom in der Geschichte der Programmiersprachen. Die meisten der relevantesten Programmiersprachenmodelle, die heute verwendet werden, wurden zu dieser Zeit erstellt:

  • SIMULA, wurde 1960 von Dahl und Nygaard als Algol 60 Superset erstellt, es war die erste Sprache der Geschichte der Programmiersprachen, entwickelt, um die Programmierung für Objekte zu stärken.

  • Die Programmiersprache C wurde ursprünglich als Systemprogrammiersprache entwickelt, die Entwickler waren in den Jahren 168 und 1972 Ken Thompson und Dennis Ritchie.

  • Smalltalk wurde in den 70er Jahren entwickelt und gab Objekten eine breite Gestaltung einer Sprache.

  • Prolog wurde 1972 von Roussel, Colmerauer und Kowalski entwickelt und gilt als die erste logische Programmiersprache.

  • ML baute ein polymorphes Typsystem, das 1973 von Robin Milner an der Spitze von Lisp entwickelt wurde, das als Vorläufer der funktionalen Programmiersprachen statischer Typen gilt.

Die beschriebenen Programmiersprachen waren die grundlegende Grundlage innerhalb der Geschichte der Programmiersprachen, alle aktuellen Sprachen haben mindestens eine davon in ihrer Registrierung.

Zu dieser Zeit gab es auch eine breite Ideendebatte über die Vorzüge der strukturierten Programmierung, die im Grunde genommen die Programmierung ohne die Verwendung von GOTO symbolisierte. Diese Flut von Ideen bezog sich auf das Design der Sprache, da einige Sprachen GOTO nicht in Betracht gezogen haben und der Programmierer daher gezwungen war, eine strukturierte Programmierung zu erstellen

geschichte-der-programmiersprachen-3

Einige der Programmiersprachen, die zwischen dieser Zeit entstanden sind, sind:

  • Jahr 1968: Logo.

  • Jahr 1969: B, Vorgänger von C.

  • Jahr 1970: Pascal und weiter.

  • Jahr 1972: C, Prolog und Smalltalk.

  • Jahr 1973: ML.

  • Jahr 1975: Schema.

  • Jahr 1978: SQL, das in seinen Anfängen eine Sprache für Abfragen war und später auf die Konstruktion von Programmierungen ausgedehnt wurde. Modula - 2 wurde auch dieses Jahr entwickelt.

geschichte-der-programmiersprachen-4

80er: Stärkung, Module und Leistung

Die 1980er Jahre gelten als Geschichte der Programmiersprachen, als die Zeit der Stärkung in den imperativen Sprachen. Die Arbeit an Sprachen, die bereits im letzten Jahrzehnt erstellt wurden, wurde fortgesetzt.

C ++, kam, um die Programmierung in Richtung Objekt- und Systemprogrammierung zu kombinieren. Die US-Regierung hat die Standardisierung von ADA erreicht, einer Systemprogrammiersprache, die von Kriegs- und Verteidigungsunternehmen verwendet wird.

In Japan wiederum wurde ein Großteil des Staatshaushalts in die Erforschung von „Programmiersprachen der fünften Generation“ investiert, die auch Gebäude der Logikprogrammierung umfasste. Die Society for Functional Languages ​​führte die ML- und Lisp-Normalisierung durch.

Der investigative Fortschritt der funktionalen Sprache namens Miranda, der sehr langsam voranschritt, begann zu dieser Zeit zu greifen.

Der Trend im Bereich des Sprachdesigns ging zu einer besseren Herangehensweise an die Programmierung von Systemen in größerem Maßstab durch den Einsatz von Modulen, einer groß angelegten Organisation von Code-Einheiten.

Sprachen wie Modula, Ada und Ml schufen in den 80er Jahren hervorragende Modulsysteme, die mit der Konstruktion von generischen Programmierungen verwandt waren, die bereits Module mit vorgegebenen Parametern waren.

Obwohl keine neuen Ideen zu Programmiersprachen entwickelt wurden, wurden die meisten Spezialisten erweiterten die Grundlagen früherer Sprachen und erreichten Anpassungen an neue Realitäten. Ein Beispiel dafür sind die Sprachen der Emerald- und Argus-Systeme, die die Anpassung der Programmierung an Objekte für verteilte Systeme vorgenommen haben.

In den 80er Jahren wurden Fortschritte bei der Implementierung von Programmiersprachen erzielt. Die an Computerarchitektur arbeitende RISC-Gruppe wies darauf hin, dass Hardware für Compiler und nicht für Programmierer geschaffen werden müsse.

Mit Verbesserungen der Prozessorgeschwindigkeit und effektiveren Erfassungsmethoden weckte die RISC-Gruppe also Interesse an einer High-Level-Spracherfassungstechnologie.

Die Technologien der Programmiersprachen arbeiteten Anfang der 90er Jahre weiter an dieser Arbeit.

Unter den bekanntesten Sprachen, die in diesem Jahrzehnt entstanden sind, können wir erwähnen:

  • Jahr 1980: C++, die Version von C, aber mit Klassen.

  • Jahr 1983: Ada.

  • Jahr 1984: MATLAB und Common Lisp.

  • Jahr 1985: Eiffel.

  • Jahr 1986: Erlang und Ziel - C.

  • Jahr 1987: Perl.

  • Jahr 1988: Mathematica und Tcl.

  • Jahr 1989: FL.

geschichte-der-programmiersprachen-5

90er: Internetzeit

Die rasante Entwicklung des Internets in den 9 Jahren war das große Ereignis der Geschichte von Programmiersprachen. Mit der Schaffung und Entwicklung einer völlig innovativen Plattform für Computersysteme bot das Internet die Möglichkeit zur Einführung neuer Sprachen.

Insbesondere ist die Programmiersprache JavaScript zu erwähnen, die aufgrund ihrer schnellen Kopplung mit dem Netscape Navigator-Browser schnell berühmt wurde, sowie andere Sprachen, die es geschafft haben, ihre Verwendung bei der Erstellung bestimmter Anwendungen für das Web zu erweitern Server.

Wir laden Sie ein, zu lesen, wenn Sie daran interessiert sind Drahtlose Technologien: Definition und Funktionen.

Die 90er Jahre waren die Zeit der Neukombination und Weiterentwicklung von Vorläufersprachen, außerdem begannen sich funktionale Sprachen zu verbreiten. Es wurden schnelle Entwicklungs- oder RAD-Anwendungssprachen generiert, die sich an Objekten orientieren, unter denen wir erwähnen können: Visual Basic, Java und Object Pascal.

Auch innovative und radikale Sprachen, sogenannte Skriptsprachen, wurden entwickelt. Sie sind Sprachen mit höherer Produktivität als RADs, ihre Produktivität ist jedoch oft darauf zurückzuführen, dass es komplizierter ist, lange Programme zu schreiben und zu speichern als einfache und kleine Programme.

Skriptprogramme wurden jedoch bei der Webkonnektivität am bekanntesten.

Unter den relevantesten Sprachen, die in diesem Jahrzehnt geschaffen wurden, haben wir:

  • Jahr 1990: Haskell.

  • Jahr 1991: HTML, Visual Basic und Python.

  • Jahr 1993: Lua und Ruby.

  • Jahr 1994: CLOS.

  • Jahr 1995: JavaScript, PHP, Delphi und Java.

  • Jahr 1996: WebDNA.

  • Jahr 1997: Rebol.

  • Jahr 1999: D

Jahr 2000: Gegenwart

Innerhalb der Geschichte von Programmiersprachen, seine natürliche Entwicklung ist auf Forschungs- und Industrieebene kontinuierlich. Aktuelle Arbeitsgebiete sind:

  • Verstärkte Unterstützung für funktionale Programmierung in Programmiersprachen.

  • Entwurf und Konstruktion von Sprachen zur Unterstützung der verteilten und gleichzeitigen Programmierung.

  • Methoden zur Erweiterung der Sprach-, Überprüfungs- und Verifizierungsprozesse in Bezug auf Zuverlässigkeit und Sicherheit: Thread-Sicherheit, Kontrolle der Informationsmigration, erweiterte syntaktische Überprüfung.

  • Alternative Modularitätsmethoden.

  • Erstellung und Entwicklung komponentenorientierter Software.

  • Metaprogrammierung und Zugriff auf den abstrakten Syntaxbaum.

  • Fokus auf Vertrieb und Mobilität.

  • Integration mit Datenbanken.

  • Unterstützung für Unicode im Quellcode.

  • XML für grafische Benutzeroberfläche.

  • Open Source für die Entwicklung von Programmiersprachen.

Unter den relevantesten Sprachen, die in diesem Jahrzehnt geschaffen wurden, haben wir:

  • Jahr 2000: ActionScript.

  • Jahr 2001: Visual Basic.NET und C#.

  • Jahr 2002: F#.

  • Jahr 2003: Factor, Scala und Groovy.

  • Jahr 2005: Kratzer.

  • Jahr 2007: Clojure.

  • Jahr 2009: Geh.

  • Jahr 2011: Dart.

  • Jahr 2014: Schnell.

Wenn Ihnen diese Informationen gefallen haben, laden wir Sie ein, diese anderen interessanten Links zu lesen:

Hybrid Cloud: Definition, Funktion, Vorteile und mehr.


Schreiben Sie den ersten Kommentar

Hinterlasse einen Kommentar

Ihre E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert mit *

*

*

  1. Verantwortlich für die Daten: Actualidad Blog
  2. Zweck der Daten: Kontrolle von SPAM, Kommentarverwaltung.
  3. Legitimation: Ihre Zustimmung
  4. Übermittlung der Daten: Die Daten werden nur durch gesetzliche Verpflichtung an Dritte weitergegeben.
  5. Datenspeicherung: Von Occentus Networks (EU) gehostete Datenbank
  6. Rechte: Sie können Ihre Informationen jederzeit einschränken, wiederherstellen und löschen.