Geschiedenis van programmeertalen - VidaBytes

Met de permanente evolutie van computers zijn programmeertalen geëvolueerd. Onderzoeken behaalt dat de eerste taal meer dan 100 jaar geleden werd gecreëerd en ontwikkeld door een vrouw. Laten we eens kijken wat de geschiedenis van programmeertalen.

Geschiedenis van programmeertalen: achtergrond

In de loop van de tijd en de permanente evolutie van computers, moesten programmeertalen worden aangepast en verbeterd volgens de vereisten van programmeurs en computers in het algemeen, waardoor een groot aantal talen en codes werd gegenereerd die al in de vergetelheid zijn geraakt.

De oorspronkelijke programmeertalen dateren van vóór de huidige computer, in eerste instantie waren de programmeertalen codes. De weefgetouwmachine die in het jaar 1801 door Jacquard werd gemaakt, gebruikte de gaten in kaarten met perforaties om de beweging van de mechanische arm van een weefmachine na te bootsen, om automatisch decoratieve patronen te creëren.

Tussen de jaren 1842 en 1843 slaagde Ada Lovelace erin om het werk van Menabrea's werk te vertalen op een machine die Charles Babbage voorstelde, "The Analytical Engine". Ada Lovelace, voegde enkele opmerkingen toe over de methodologie om de berekeningen van de Bernoulli-getallen met deze machine te maken.

Herman Hollerith codeerde alle informatie op de ponskaarten, toen hij zich realiseerde dat de machinisten de passagiers konden identificeren aan de hand van het gat dat ze in het ticket hadden gemaakt. In 1890 maakte Hollertih een gegevenscode voor passagiersgegevens op deze kaarten.

De oorspronkelijke computercodes waren gespecialiseerd in overeenstemming met waarvoor ze zouden worden gebruikt. In de eerste decennia van de XNUMXe eeuw waren numerieke berekeningen gebaseerd op decimale getallen. Later realiseerden ze zich dat logica kon worden gesymboliseerd met getallen.

Alonzo Church drukte de Lambda-berekening uit met formules. De Turing-machine legde de basis voor het compileren van programma's als gegevens vanaf een computer in de Von Neumann-architectuur.

De Turing-code diende echter niet met succes als basis voor meer geavanceerde talen, maar werd gebruikt bij een grondige analyse van algoritmen.

Het eerste geschiedenis van programmeertalen, het is moeilijk om nauwkeurig in de tijd te lokaliseren. Vanaf het begin bepaalden hardwarebeperkingen de geschiedenis van programmeertalen.

Aanvankelijk ondersteunden de ponskaarten slechts ongeveer 90 kolommen, maar ze zouden worden gebruikt om een classificatie van elk van de kaarten te maken. Het gebruik van de magnetische trommel voor het geheugen betekende dat de programma's moesten worden afgewisseld met de trillingen van de trommel. De programma's waren dus afhankelijk van de hardware.

Voor bepaalde experts waren de Jacquard-weefmachine, evenals de Babbage Machine, zeer eenvoudige talen en met beperkingen om acties te beschrijven die deze machines deden. Binnenkant van geschiedenis van programmeertalenZelfs ponskaarten worden als een basistaal beschouwd, hoewel deze niet is gemaakt voor menselijke consumptie.

Belangrijke data en data

In de jaren 40 werden de eerste computers ontwikkeld, aangedreven door elektrische stroom. Ze hadden beperkingen op het gebied van snelheid en geheugencapaciteit, waardoor programmeurs gedwongen werden om eenvoudige programma's te maken. Op de lange termijn realiseren ze zich dat programmeren als taal een grote intellectuele boost nodig had, omdat je fouten kon eten als je het onderwerp niet kende.

In het jaar 1948 publiceerde Konrad Zuse een artikel over een door hem ontwikkelde programmeertaal Plankalkul, maar hij deed geen verder onderzoek op dit gebied. Onder de talen die op dat moment zijn gemaakt, kan het volgende worden benadrukt:

1943: ENIAC-code.
1948 Plankalkul, dit werd een halve eeuw later geïmplementeerd.
1949 tot 1954 - Er is een reeks instructies ontwikkeld die voor specifieke fabrikanten zijn gemaakt.

Jaren '50 en '60 XNUMXe eeuw: begin van de geschiedenis van programmeertalen

Op dit moment werden de drie nog steeds geldende programmeertalen ontwikkeld, namelijk:

1955 - FORTRAN, ontwikkeld door John Backus.
1958: LISP, ontwikkeld door John McCarthy.
1959: COBOL, ontwikkeld door het Short Range Committee, en haar invloed was Grace Hopper.

Een ander belangrijk moment was aan het einde van de jaren 50, toen het door een Amerikaanse en Europese commissie van computerexperts (Algol) werd gepubliceerd over een bijgewerkte "Taal voor algoritmen". Dit rapport bracht veel ideeën en observaties van de dag samen en leverde twee relevante innovaties voor de geschiedenis van programmeertalen:

Geneste blokstructuren: codereeksen en gerelateerde declaraties worden in blokken verpakt zonder dat ze expliciet naar afzonderlijke processen hoeven te gaan.
Lexicale reikwijdte: een blok heeft zijn eigen variabelen, processen en functies, die niet zichtbaar zijn voor de code buiten dit blok, bijvoorbeeld het verbergen van gegevens of informatie.

Een andere innovatie in verband met deze informatie is de volgende:

Een nauwkeurig wiskundig teken, Backus - Naur Form of beter bekend als BNF, werd gebruikt om de constructie van de taal te beschrijven. Alle volgende programmeertalen hebben een variant van BNF gebruikt om het contextvrije deel van hun constructie te beschrijven.

Deze Amerikaanse en Europese commissie heeft vooral invloed gehad op de ontwikkeling van latere talen. De grote systemen van Burroughs werden ontwikkeld om te worden geprogrammeerd in een uitgebreide set van zo'n commissie die bekend werd als Algol.

De belangrijkste ideeën van Algol verspreidden zich en tegen het jaar 1968 werd Algol 68 gerealiseerd:

De constructie en semantiek waren meer orthogonaal, met onbekende routines, een typesysteem met functies van hogere orde.
Niet alleen het vrije deel van de context werd formeel gedefinieerd, maar ook de constructie en semantiek, in termen van Van Wijngaardens grammatica, werden hiervoor gecreëerd.

De uitgebreide maar ongebruikte functies van y Algol 68 en het gecompliceerde systeem van automatische snelkoppelingen en beperkingen leidden tot impopulariteit en moeilijke toepassing.

Dus maakte Niklaus Wirth zich los van de commissie en ontwikkelde de eenvoudige taal die bekend staat als 'Pascal'. Dit zijn enkele van de talen die in die tijd zijn ontwikkeld:

Jaar 1951: Regionale assembler.
Jaar 1952: Autocoder.
Jaar 1954: IPL.
Jaar 1955: FlowMatic.
Jaar 1957: FORTRA N.
Jaar 1958: LISP.
Jaar 1959: FACT, COBOL en RPG.
Jaar 1962: APL, Simula en SNOBOL.
Jaar 1963: CPL.
Jaar 1964: BASIC en PL/I.
Jaar 1967: BCPL.

De jaren 70: fundamentele modellen worden vastgesteld

Tussen de jaren zestig en zeventig was er een grote hausse in de geschiedenis van programmeertalen. De meeste van de meest relevante programmeertaalmodellen die tegenwoordig worden gebruikt, zijn op dit moment gemaakt:

SIMULA, werd in 1960 gecreëerd door Dahl en Nygaard als een Algol 60-superset, het was de eerste taal van de geschiedenis van programmeertalen, ontwikkeld om de programmering voor objecten te versterken.
De programmeertaal C is oorspronkelijk gemaakt als een systeemprogrammeertaal, de ontwikkelaars waren Ken Thompson en Dennis Ritchie in de jaren 168 en 1972.
Smalltalk, gecreëerd in de jaren zeventig, zorgde voor een breed ontwerp van een taal voor objecten.
Prolog, gemaakt door Roussel, Colmerauer en Kowalski in 1972, beschouwde de eerste logische programmeertaal.
ML bouwde een polymorf typesysteem, gecreëerd door Robin Milner in 1973, aan de vooravond van Lisp, beschouwd als een voorloper in functionele programmeertalen van het statische type.

De beschreven programmeertalen vormden de fundamentele basis binnen de geschiedenis van programmeertalen, hebben alle huidige talen er minstens één in hun register.

Rond deze tijd was er ook een breed debat over ideeën over de verdiensten van gestructureerd programmeren, dat in feite het programmeren zonder het gebruik van GOTO symboliseerde. Deze stortvloed van ideeën was gerelateerd aan het ontwerp van de taal, omdat sommige talen GOTO niet overwogen, en dus werd de programmeur gedwongen om gestructureerde programmering te maken

Enkele van de programmeertalen die tussen deze tijd zijn gemaakt, zijn:

Jaar 1968: Logo.
Jaar 1969: B, voorloper van C.
Jaar 1970: Pascal en Forth.
Jaar 1972: C, Prolog en Smalltalk.
Jaar 1973: ML.
Jaar 1975: Regeling.
Jaar 1978: SQL, in het begin een taal voor query's en later uitgebreid tot de constructie van programmering. Modula - 2 is dit jaar ook ontwikkeld.

Jaren 80: versterking, modules en prestaties

De jaren 1980 worden beschouwd binnen de geschiedenis van programmeertalen, als de tijd van versterking in imperatieve talen. Er werd verder gewerkt aan talen die al in het vorige decennium waren gemaakt.

C ++, kwam om programmering naar objecten en systeemprogrammering te combineren. De Amerikaanse regering heeft de standaardisatie van ADA bereikt, een systeemprogrammeertaal die door oorlogs- en defensiebedrijven moet worden gebruikt.

In Japan werd op zijn beurt een groot deel van de nationale begroting geïnvesteerd in onderzoek naar "vijfde generatie programmeertalen", waaronder gebouwen voor logische programmering. De Society for Functional Languages voerde ML- en Lisp-normalisatie uit.

De onderzoeksopmars van de functionele taal genaamd Miranda, die heel langzaam ging, begon op dit moment aan te slaan.

De trend op het gebied van taalontwerp was een betere benadering van programmeersystemen op grotere schaal door het gebruik van modules, een grootschalige organisatie van code-eenheden.

Talen zoals Modula, Ada en Ml creëerden uitstekende modulesystemen in de jaren 80, en ze waren gerelateerd aan de constructie van generieke programmering, die modules zouden zijn die al vooraf bepaalde parameters hadden.

Hoewel er geen nieuwe ideeën over programmeertalen zijn ontwikkeld, zijn de meeste specialisten breidden de fundamenten van eerdere talen uit en bereikten aanpassingen aan nieuwe realiteiten. Een voorbeeld hiervan zijn de talen van de Emerald- en Argus-systemen, die de aanpassing van de programmering aan objecten voor gedistribueerde systemen maakten.

In de jaren tachtig werd vooruitgang geboekt bij de implementatie van programmeertalen. De RISC-groep die werkte aan Computer Architecture wees erop dat hardware gemaakt moest worden voor compilers en niet voor programmeurs.

Dus met verbeteringen in processorsnelheid en effectievere verzamelmethodologieën, trok de RISC-groep interesse in hoogwaardige taalverzameltechnologie.

De technologieën van programmeertalen bleven aan dit werk werken, in het begin van de jaren 90.

Een van de meest prominente talen die in dit decennium zijn gemaakt, kunnen we noemen:

Jaar 1980: C++, dat is de versie van C maar met klassen.
Jaar 1983: Ada.
Jaar 1984: MATLAB en Common Lisp.
Jaar 1985: Eiffel.
Jaar 1986: Erlang en Objective - C.
Jaar 1987: Perl.
Jaar 1988: Mathematica en Tcl.
Jaar 1989: FL.

jaren 90: internettijd

De snelle evolutie van het internet gedurende de 9 jaar, was de grote gebeurtenis van de Geschiedenis van programmeertalen. Met de creatie en ontwikkeling van een volledig innovatief platform voor computersystemen, bood het internet een kans voor de adoptie van nieuwe talen.

In het bijzonder moet worden vermeld de JavaScript-programmeertaal, die snel bekendheid verwierf vanwege zijn snelle koppeling met de Netscape Navigator-browser, evenals andere talen die erin slaagden het gebruik ervan uit te breiden bij het maken van bepaalde applicaties voor webservers.

We nodigen u uit om te lezen, als u meer wilt weten over: Draadloze technologieën: definitie en functies.

De jaren 90 waren de tijd van de nieuwe combinatie en vooruitgang van voorlopertalen, daarnaast begonnen functionele talen zich te verspreiden. Er werden snelle ontwikkelings- of RAD-toepassingstalen gegenereerd, gericht op objecten, waaronder we kunnen noemen: Visual Basic, Java en Object Pascal.

Er werden ook innovatieve en radicale talen ontwikkeld, ook wel scripttalen genoemd. Het zijn talen met een hogere productiviteit dan RAD's, maar hun productiviteit is vaak te wijten aan het feit dat het schrijven en bewaren van lange programma's ingewikkelder is dan eenvoudige en kleine programma's.

Scriptprogramma's werden echter de meest prominente in webconnectiviteit.

Een van de meest relevante talen die in dit decennium zijn gemaakt, hebben we:

Jaar 1990: Haskell.
Jaar 1991: HTML, Visual Basic en Python.
Jaar 1993: Lua en Ruby.
Jaar 1994: GESLOTEN.
Jaar 1995: JavaScript, PHP, Delphi en Java.
Jaar 1996: WebDNA.
Jaar 1997: Rebol.
Jaar 1999: D

Jaar 2000: huidige tijd

Binnen Geschiedenis van programmeertalen, zijn natuurlijke evolutie is continu, op onderzoeks- en industrieel niveau. Tot de huidige werkgebieden behoren:

Verhoogde ondersteuning voor functioneel programmeren in programmeertalen.
Ontwerp en constructie van talen om gedistribueerde en gelijktijdige programmering te ondersteunen.
Methoden om toe te voegen aan de taal-, beoordelings- en verificatieprocessen op het gebied van betrouwbaarheid en beveiliging: threadbeveiliging, controle op informatiemigratie, uitgebreide syntactische beoordeling.
Alternatieve modulariteitsmethoden.
Creatie en ontwikkeling van componentgerichte software.
Metaprogrammering en toegang tot de abstracte syntaxisboom.
Focus op distributie en mobiliteit.
Integratie met databanken.
Ondersteuning voor Unicode in de broncode.
XML voor grafische interface.
Open source voor de ontwikkeling van programmeertalen.