De programmeertaal Fortran wordt voornamelijk gebruikt voor wetenschappelijk computergebruik. Uitgevonden in 1954, het oudste taal programmeren op hoog niveau, gevolgd door Lisp (1958), Algol (1958) en COBOL (1959). Het aantal wetenschappelijke bibliotheken geschreven in Fortran en de creatie van speciale vertaler-compilers zorgen ervoor dat de taal vandaag de dag kan worden gebruikt. Bovendien zijn er meerdere rekenmachines gemaakt voor vectorisatie, coprocessors en parallellisme, die deze taal doorkruisen voor gebruik in industriële productie moderne wereld.

John Backus, een IBM-radio-ingenieur, publiceerde in 1954 artikelen met de titel "Preliminary Report", "Specifications for the IBM Matmal Transmula TRANslating System", waaruit de term FORTRAN voortkwam. Daarna kostte het nog eens twee jaar inspanning van het hele team, dat hij leidde, om de eerste compiler voor de programmeertaal Fortran te schrijven (25.000 regels voor de IBM 704).

De naam van de taal werd oorspronkelijk geschreven in hoofdletters FORTRAN en werd gebruikt om te verwijzen naar taalversies tot Fortran 77, in tegenstelling tot gratis versies syntaxis vanaf Fortran 90. In de Fortran 77-standaard kleine letters maken geen deel uit van de taal, maar de meeste compilers ondersteunen ze naast de standaard.

Tegenwoordig is de programmeertaal Fortran de dominante programmeertaal die wordt gebruikt technische toepassingen. Daarom is het belangrijk dat afgestudeerde ingenieurs Fortran-code kunnen lezen en wijzigen. Van tijd tot tijd voorspellen zogenaamde experts dat de taal zijn populariteit zal verliezen en binnenkort helemaal niet meer zal worden gebruikt.

Deze voorspellingen faalden altijd. Fortran is het meest stabiel computer taal programmeren in de geschiedenis. Een van de belangrijkste redenen waarom de programmeertaal Fortran heeft overleefd en zal overleven, is traagheid software. Nadat het bedrijf veel middelen en mogelijk miljoenen dollars heeft uitgegeven software, is het onwaarschijnlijk dat ze de software in een andere taal zal vertalen.

Het grote voordeel van Fortran is dat het gestandaardiseerd is door de internationale instanties ANSI en ISO. Als een programma in ANSI is geschreven, kan het daarom op elke computer met een Fortran 77-compiler worden uitgevoerd belangrijke gegevens. Programma's van de objectgeoriënteerde programmeertaal Fortran bestaan ​​dus in verschillende software-apparaten.

Stadia van het creëren van een taalplatform:

1. In 1954-1957 werd de eerste compiler helemaal opnieuw ontwikkeld. In die tijd waren er meestal geen "talen op hoog niveau" (=HLL). besturingssystemen waren eenvoudig en het geheugen was klein, ongeveer 16 Kb. De eerste compiler draaide op de IBM 704. Deze HLL-taal was veel efficiënter dan assembleren en erg populair in zijn tijd.
2. FORTRAN II verscheen in 1958. Datzelfde jaar werd FORTRAN III ontwikkeld, maar nooit op grote schaal geproduceerd.
3. In 1961 werd FORTRAN IV opgericht. Het bevatte verbeteringen zoals de implementatie van de COMMON- en EQUIVALENCE-verklaringen.
4. In 1962 begon een ASA-commissie met de ontwikkeling van een standaard voor de objectgeoriënteerde programmeertaal Fortran. Hierdoor kon de verkoper het op elke nieuwe computer gebruiken. En dit feit maakte het nog populairder. HLL, de taal werd beschikbaar in Apple-systemen en TRS80.
5. In 1967 werd FORTRAN 66, 's werelds eerste HLL-standaard, uitgebracht. Door de publicatie van de standaard werd de taal op grotere schaal geïmplementeerd dan welke andere taal dan ook. Halverwege de jaren zeventig was vrijwel elke computer, mini of mainframe hiermee uitgerust standaard taal FORTRAN 66. De gebruikte taal if-statements, goto-statements en spagethi-programma's. Dit soort gestructureerde programmering werd populair in de jaren 60 en 70.
6. "Fortran" bestond vooral op ponskaarten, waarbij het FMS-systeem de lay-out van de bronnen optimaliseerde totdat Fortran 90 een "vrije" syntaxis introduceerde. Daarin begint de Fortran-arraycode vanaf de 7e kolom en mag niet langer zijn dan 72 duizend tekens.

Er moet ook worden opgemerkt dat vóór Fortran 90 spaties geen betekenis hadden tussen de 7e en 72e kolom. Zo kan de cyclus "DO I = 1,5" ook geschreven worden als "DOI = 1,5". Aan de andere kant is "DO I = 1,5" gelijk aan "DOI = 1,5".

Er zijn talloze industriële codes geschreven in Nastran, NAG en de IMSL-Fortran-bibliotheek. Compatibiliteit van nieuwe versies met eerdere versies is belangrijk. Om deze reden is Fortran 90 volledig compatibel met Fortran 77. Volgende versies van de standaard hebben echter al incompatibiliteiten geïntroduceerd.

Al snel volgden de meer geavanceerde talen Fortran 90 en Fortran 95, bijgewerkt naar de huidige Fortran-2003-standaard. Gezien het feit dat moderne compilers onbeperkt werken in alle huidige Windows-versies en ondersteunen zelfs 64-bits processors. Fabrikanten hebben inmiddels de trend van de tijd onderkend en bieden compilers voor Linux aan in de vorm van de objectgeoriënteerde programmeertaal Actor Fortran.

Vereisten voor het gebruik van een programmeertaal

Het moet duidelijk zijn dat Fortran nog steeds een veelgebruikte programmeertaal is en vooral wordt gebruikt op het gebied van ontdekking. Klassieke toepassingen, bijvoorbeeld in de natuurkunde of techniek, zijn omvangrijk en complex wiskundige berekeningen. Ze zijn erg handig vanwege de uitgebreide wiskundige bibliotheken die voor verschillende compilers bestaan. Samenvattend kunnen we dat vandaag de dag zeggen Fortran-taal wordt nog steeds gebruikt om een ​​aantal redenen:

• De beschikbaarheid van talrijke functionele bibliotheken is gedurende vele jaren ontwikkeld.
• Beschikbaarheid van software in Fortran, waarvoor zeer belangrijke ontwikkelingsbronnen nodig zijn, wanneer het overstappen naar een andere taal als te duur wordt beschouwd.
• Beschikbaarheid van krachtige compilers met ingebouwde Fortran-functies, die zeer snel produceren uitvoerbare bestanden.
• De taal is toegankelijker voor een uitvinder die geen gespecialiseerde computercursus heeft gevolgd.

Veel wetenschappelijke programma's zijn nu geschreven in C en C++, waarvoor op de meeste machines compilers beschikbaar zijn. Andere gecompileerde talen worden soms gebruikt voor wetenschappelijk computergebruik, en vooral voor programma's zoals Scilab of Matlab. Deze laatste omvatten ook de BLAS- en LAPACK-bibliotheken, ontwikkeld in Fortran-programmering. Matlab was oorspronkelijk een Fortran-programma dat werd verspreid onder universiteiten en onderzoekscentra.

Hoewel Tom Lahey nu de "enige" algemene compiler is, wordt Lahey Computer Systems nog steeds door veel programmeurs gebruikt. Lahey werkt al een aantal jaren samen met Fujitsu, waarbij Lahey zich concentreert op de Fortran-parser en Fujitsu op de codegenerator. De huidige Compiler Suite voor Windows heet Lahey Fujitsu Fortran 95 (LF95) en is beschikbaar in verschillende versies, waarvan sommige ook integreren met Visuele studio.NET 2003.

Er is ook een goedkope versie van LF95 Express zonder eigen IDE. De huidige versie is 7.1. op Linux wordt aangeroepen door de Lahey/Fujitsu Fortran 95 v6.2-compiler voor Linux en is beschikbaar in twee verschillende versies. Bijvoorbeeld, Pro-versie omvat OpenMP v2.0-compatibiliteit, eenvoudige grafische engine Winteracter Starter Kit, wiskunde bibliotheek En wetenschappelijke bibliotheek Fujitsu 2-routines.

Een andere fabrikant is Absoft. Compilers en C++ bestaan ​​niet alleen voor Windows en Linux, maar ook voor OS X op de Macintosh. Deze compilers zijn interessant voor ontwikkelaars die alle drie de platforms nodig hebben of willen ondersteunen. Helaas maakt Absoft onderscheid tussen 32-bits en 64-bits versies voor Linux, waarbij momenteel versie 10.0 van Fortran 95 voor 64-bits Linux wordt gebruikt.

Relatief nieuw op de markt is de EKOPath Compiler Suite. Deze bestaat uit C++-compilers en een Fortran-ontwikkelomgeving voor Linux, die ook afzonderlijk verkrijgbaar zijn en vooral gericht zijn op 64-bit AMD-gebruikers. Het draait ook op Intel EM64T. Microsoft probeerde ook ooit een "goedkope markt" voor Fortran te vinden en introduceerde de Microsoft Powerstation op de markt.

De markt was misschien te klein voor de softwaregigant, maar Digital nam in 1997 een deel van de code over en gebruikte zijn ervaring met de Digital Unix- en OpenVMS-compilers. Dit was de geboorte van het nog steeds zeer succesvolle Digital Visual Fortran. Op een gegeven moment verhuisde Digital naar Compaq, waar de compiler voor was ontwikkeld huidige versie Compaq Visual Fortran (CVF) v6.6.

Naast de "normale" 32-bit platforms zijn er verschillende 64-bit compilers, bijvoorbeeld voor Intel Itanium en Intel EM64T. Hoewel ze niet "dringend" zijn vanwege de omvang van het aanbod, zijn ze wel beschikbaar gratis download via websysteem Intel-ondersteuning Premier.

Na een eenmalige, wat omslachtige registratie, kun je er een jaar lang gebruik van maken, met elke paar weken nieuwe updates. Zelfs oudere versies blijven beschikbaar.

Een Fortran-programma is een reeks tekstregels. De tekst moet een specifieke syntaxis volgen. Bijvoorbeeld: een cirkel met straal r, oppervlakte c.

Dit programma leest de werkelijke straal en bepaalt de oppervlakte van een cirkel met straal r:

"Straal r:"lees (*), *) r;

oppervlakte = 3,14159 * r * r;

schrijf (*) (*, *) "Gebied =";

Regels die beginnen met "C" zijn commentaar en hebben geen ander doel dan het programma leesbaarder te maken voor mensen. Aanvankelijk waren alle Fortran-programma's geschreven hoofdletters. De meeste programmeurs schrijven nu kleine letters omdat dit beter leesbaar is.

Een Fortran-programma bestaat doorgaans uit een hoofdprogramma of stuurprogramma en verschillende routines, procedures of routines. Hoofdprogrammastructuur:

• de naam van het programma;
• verklaringen;
• verklaringen;
• stop;
• einde.

Cursief moet niet als letterlijke tekst worden opgevat, maar eerder als algemene beschrijving. De stop-instructie is optioneel en lijkt misschien overbodig, omdat het programma toch stopt als het het einde bereikt, maar het wordt aanbevolen om een ​​programma altijd te beëindigen met een stop-instructie om te benadrukken dat de uitvoeringsstroom wordt beëindigd.

Regels voor kolompositie

Fortran 77 is geen vrije opmaaktaal, maar heeft een zeer strikte set regels voor opmaak broncode. Meest belangrijke regels zijn de regels voor de rangschikking van kolommen:

• Kol. 1: Blanco of “c” of “*” voor opmerkingen.
• Kol. 2-5: operatorteken.
• Kol. 6: voortzetting van de vorige regel.
• Kol. 7-72: verklaring.
• Kol. 73- 80: Volgnummer.

Een Fortran-regel die begint met de letter "c" of een asterisk in de eerste kolom is commentaar. Opmerkingen kunnen overal in een programma verschijnen. Goed geschreven zijn ze van cruciaal belang voor de leesbaarheid van een programma. Commerciële Fortran-codes bevatten vaak ongeveer 50% commentaar. U kunt ook programma's tegenkomen die Uitroepteken(!). Dit is zeer afwijkend in Fortran 77, maar is toegestaan ​​in Fortran 90.

Het uitroepteken kan overal op een regel verschijnen. Soms past een uitspraak niet op één regel, dan kun je de uitspraak opdelen in twee of meer regels en op de juiste plek een vervolgteken gebruiken.

1. C23456789 - Dit demonstreert de positie van de kolom.
2. "C" - de volgende verklaring gaat door twee gebieden fysieke lijnen.
3. Oppervlakte = 3,14159265358979+ * r * r.

Lege spaties worden genegeerd vanaf Fortran 77. Als u dus alle spaties in Fortran 77 verwijdert, is het programma syntactisch nog steeds correct, hoewel het bijna onleesbaar is voor de operators.

Variabelenamen in Fortran bestaan ​​uit 1-6 tekens, waaruit u kunt kiezen letters a-z en nummers 0-9. Het eerste teken moet een letter zijn. Fortran 90 staat variabelenamen van willekeurige lengte toe. Fortran 77 maakt geen onderscheid tussen top- en kleine letters, in feite wordt ervan uitgegaan dat alle invoer dat is hoofdletters. Bijna alle F 77-compilers accepteren echter kleine letters. Elke variabele moet in een declaratie worden gedefinieerd. Hiermee wordt het type van de variabele ingesteld. De meest voorkomende variabelenlijsten zijn:

• geheel getal;
• echt;
• dubbele precisie;
• complex;
• logisch;
• karakter.

De lijst met variabelen moet bestaan ​​uit namen, gescheiden door komma's. Elke variabele moet precies één keer worden gedeclareerd. Als een variabele niet wordt gedeclareerd, gebruikt F 77 een reeks impliciete regels om het type vast te stellen. Dit betekent dat alle variabelen die beginnen met de letters "in" gehele getallen zijn, en alle andere reële getallen. Veel oudere F 77-programma's gebruiken deze impliciete regels, maar programmeurs zouden dit niet moeten doen omdat de kans op programmafouten dramatisch toeneemt als ze variabelen inconsistent declareren.

Fortran 77 heeft slechts één type voor integer-variabelen. Gehele getallen worden doorgaans opgeslagen als variabelen van 32 bits (4 bytes). Daarom moeten alle integer-variabelen waarden aannemen in het bereik [-m, m], waarbij m ongeveer 2 * 10 9 is.

F 77 heeft er twee verschillende soorten voor drijvende-kommavariabelen, echte dubbele precisie genoemd. Sommige numerieke berekeningen vereisen zeer veel hoge precisie en er moet dubbele precisie worden gebruikt. Normaal gesproken is real een variabele van 4 bytes en de dubbele precisie is 8 bytes, maar dit hangt af van de machine.

Niet-standaardversies van Fortran gebruiken de syntaxis real*8 om te verwijzen naar drijvende-kommavariabelen van 8 bytes. Sommige constanten komen vele malen voor in een programma. Daarom is het raadzaam om ze slechts één keer te definiëren, aan het begin van het programma. Hiervoor wordt de parameteroperator gebruikt. Het maakt programma's ook beter leesbaar. Een programma voor de oppervlakte van een cirkel moet bijvoorbeeld zo worden geschreven.

Syntaxis van parameteroperator (naam = constante, ..., naam = constante). Regels voor de parameteroperator:

1. Een "variabele" die in een parameterinstructie wordt gedefinieerd, is geen variabele, maar een constante waarvan de waarde nooit kan veranderen.
2. "Variabele" kan maximaal één parameterinstructie weergeven.
3. De operatorparameter moet vóór de eerste uitvoerbare operator komen

Enkele goede redenen om een ​​parameter te gebruiken - helpt typefouten te verminderen, eenvoudig een constante te wijzigen die vaak in een programma voorkomt.

Booleaanse expressies kan alleen de waarde.TRUE hebben. of fout. en kan worden gevormd door vergelijking met behulp van relationele operatoren.

U kunt geen tekens gebruiken zoals '<» или «=» для сравнения в F 77, но можно использовать правильную двухбуквенную аббревиатуру, заключенную точками. Однако такие символы разрешены в Fortran 90.

Logische expressies kunnen worden gecombineerd met de logische operatoren "AND", "OR", "NOT", die een duidelijke betekenis hebben. Waarheidswaarden kunnen worden opgeslagen in Booleaanse variabelen. De opdracht is vergelijkbaar met de rekenkundige opdracht.

Voorbeeld: logisch a, ba = .TRUE.b = a .AND. 3.LT. 5/2

De volgorde van prioriteit is erg belangrijk. De regel is dat rekenkundige expressies eerst worden geëvalueerd, daarna relationele operatoren en ten slotte logische operatoren. Daarom krijgt b de waarde .FALSE. In het bovenstaande voorbeeld worden Booleaanse variabelen zelden gebruikt in Fortran, maar ze worden vaak gebruikt in voorwaardelijke instructies zoals de "if" -instructie.

Constant en doel

De eenvoudigste vorm van een uitdrukking is een constante. Er zijn 6 soorten constanten die overeenkomen met 6 gegevenstypen. Hier zijn enkele geheeltallige constanten: 10-10032767+15

Echte constanten: 1,0-0,252.0E63.333E-1.

E-notatie betekent het vermenigvuldigen van de constante met 10, verheven tot de macht volgend op de "E". Daarom is 2,0E6 twee miljoen, en 3,333E-1 ongeveer een derde. Voor constanten die groter zijn dan de grootste die feitelijk is toegestaan, of die een hoge nauwkeurigheid vereisen, moet dubbele precisie worden gebruikt. De notatie is hetzelfde als voor reële constanten, behalve dat "E" wordt vervangen door "D".

Voorbeeld:2.0D-11D99.

Hier is 2.0D-1 dubbele precisie met één vijfde, terwijl 1D99 één is, gevolgd door 99 nullen.

Het volgende type zijn complexe constanten. Ze worden aangegeven met een paar constanten (geheel getal of reëel), gescheiden door een komma en tussen haakjes.

Voorbeelden zijn: (2, -3)(1,9,9E-1). Het eerste getal geeft het reële deel aan, het tweede het denkbeeldige deel.

Het vijfde type zijn logische constanten. Ze kunnen slechts één van twee betekenissen hebben:

Houd er rekening mee dat er punten met letters moeten worden geschreven.

Het laatste type zijn karakterconstanten. Ze worden meestal gebruikt als een reeks tekens, een zogenaamde string. Ze bestaan ​​uit een willekeurige reeks tekens tussen apostrofs (enkele aanhalingstekens):

"Alles gaat!"

"Het is een mooie dag"

Tekenreeks- en tekenconstanten zijn hoofdlettergevoelig. Het probleem doet zich voor als u een echte apostrof in de regel zelf wilt hebben. In dit geval moet je de apostrof verdubbelen: "Het" "het is een mooie dag", wat betekent "Wat een prachtige dag"

Voorwaardelijke instructies zijn belangrijke componenten van elke programmeertaal. De meest voorkomende van deze uitspraken in Fortran is de 'if'-instructie, die feitelijk verschillende vormen heeft.

De eenvoudigste is de logische uitdrukking “if” in de Fortran-beschrijving: if (logische uitdrukking) uitvoerbare instructie.

Dit moet op één regel worden geschreven, bijvoorbeeld bij het bepalen van de absolute waarde van x:

als (x .LT. 0) x = -x

Als er meer dan één instructie moet worden uitgevoerd in een "if", moet de volgende syntaxis worden gebruikt: if (logische uitdrukking) thenstatementsendif.

Uitvoeringsstroom van boven naar beneden. Voorwaardelijke expressies worden opeenvolgend geëvalueerd totdat een echte waarde wordt gevonden. De juiste code wordt vervolgens uitgevoerd en de besturing gaat naar de volgende instructie na het einde "if".

If-instructies kunnen op meerdere niveaus worden genest. Om de leesbaarheid te garanderen, is het belangrijk om de juiste inspringing te gebruiken. Hier is een voorbeeld:

if (x .GT. 0) thenif (x .GE. y) thenwrite(*,*) "x is positief en x >= y"elsewrite(*,*) "x is positief maar x< y"endifelseif (x .LT. 0) thenwrite(*,*) "x is negative"elsewrite(*,*) "x is zero"endif

Programmeurs moeten vermijden dat er veel niveaus van "if"-instructies worden genest, omdat dit moeilijk te volgen zal zijn.

Je kunt elk Unix-werkstation met een F 77-compiler gebruiken. Ervaren programmeurs raden aan om Sun of Dec.

Een Fortran-programma bestaat uit platte tekst die bepaalde syntaxisregels volgt. Dit heet broncode. Programmeurs gebruiken een editor om broncode te schrijven. De meest voorkomende editors op Unix zijn emacs en vi, maar ze kunnen een beetje ingewikkeld zijn voor beginnende gebruikers. U kunt een eenvoudiger editor gebruiken, zoals xedit, die onder X-windows draait.

Zodra een Fortran-programma is geschreven, wordt het opgeslagen in een bestand met de extensie “.f” of “.for” en wordt het programma omgezet in een machinaal leesbare vorm. Dit gebeurt met behulp van een speciaal programma, een compiler. De Fortran 77-compiler wordt gewoonlijk f77 genoemd. De compilatie-uitvoer krijgt standaard de enigszins cryptische naam "a.out", maar u kunt indien nodig een andere naam kiezen. Om het programma uit te voeren, voert u eenvoudig de naam van het uitvoerbare bestand in, bijvoorbeeld "a.out". De compiler vertaalt de broncode naar objectcode en de linker of loader vertaalt deze naar een uitvoerbaar bestand. Zoals u kunt zien, is deze procedure helemaal niet ingewikkeld en voor elke gebruiker toegankelijk.

Simulatie is een van de meest gebruikte productiemethoden en andere systemen in moderne fabrieken. De meeste simulatiemodellen worden gebouwd met behulp van de objectgeoriënteerde programmeertaal Actor Fortran, of een simulatiesoftwarepakket geschreven in een traditionele taal. Deze hulpmiddelen hebben hun beperkingen. Objectgeoriënteerde technologie wordt op veel gebieden steeds vaker toegepast en belooft een flexibelere en efficiëntere benadering van het modelleren van bedrijfssystemen.

Simula Fortran-programmering wordt vergeleken met een conventionele wetenschappelijke programmeertaal genaamd FORTRAN. Een typisch militair simulatiemodel is geprogrammeerd in zowel SIMULA als FORTRAN. Het SIMULA-programma was 24% korter dan de FORTRAN-versie.

De SIMULA-versie is ook eenvoudiger en geeft een beter beeld van het model dat wordt gesimuleerd. Aan de andere kant is de uitvoeringstijd voor productieruns 64% sneller met de objectgeoriënteerde programmeertaal Simula Fortran. Uit een afweging van de voor- en nadelen blijkt dat SIMULA steeds winstgevender software zal worden, met hogere personeelskosten en lagere computerkosten.

CUDA laat zien hoe krachtige applicatieontwikkelaars de kracht van GPU's kunnen benutten met behulp van Fortran, een gemeenschappelijke taal voor wetenschappelijk computergebruik en het testen van supercomputerprestaties. De auteurs gaan niet uit van enige eerdere ervaring met parallel computergebruik en behandelen alleen de basisprincipes en best practices. De rekenefficiëntie van GPU's die CUDA Fortran gebruiken, wordt mogelijk gemaakt door de doel-GPU-architectuur.

CUDA Fortran for Scientists and Engineers zal rekenintensieve delen van de code identificeren en de code aanpassen voor gegevensbeheer, parallellisme en prestatie-optimalisatie. Dit alles gebeurt in Fortran, zonder dat het programma in een andere taal hoeft te worden herschreven. Elk concept wordt geïllustreerd met concrete voorbeelden, zodat u de prestaties van de code onmiddellijk kunt evalueren.

Misschien zal de mondiale onderneming op een dag ‘eindelijk globaliseren’ en besluiten dat Fortran niet langer nodig is, maar niet nu. Dankzij de huidige mogelijkheden van het moderne Fortran zien veel programmeurs en wetenschappers het als de toekomst. Bovendien zijn er genoeg fabrikanten in de wereld die leven van het ontwikkelen van moderne compilers en goed geld verdienen aan dit proces.

Geschiedenis van de creatie van de programmeertaal Fortran. Bestaande normen. Versie van de programmeertaal Fortran.

Programmeurs schreven programma's voor de eerste computers in machinecommandotalen. Dit is een zeer arbeidsintensief en langdurig proces. Er verstreek een aanzienlijke hoeveelheid tijd tussen het begin van het compileren van het programma en het begin van het gebruik ervan. Dit probleem kon alleen worden opgelost door geautomatiseerde programmeertools te creëren.
De eerste ‘tools’ die programmeurs de arbeid bespaarden, waren subroutines. In augustus 1944 werd de eerste subroutine voor het berekenen van sinx geschreven voor de Mark I-relaismachine onder leiding van Grace Hopper (een vrouwelijke programmeur en marineofficier bij de Amerikaanse marine).
Grace Hopper was niet de enige die zich zorgen maakte over het probleem van het gemakkelijker maken van het werk van programmeurs. In 1949 ontwikkelde John Mauchly (een van de makers van de ENIAC-computer) het SHORT Code-systeem, dat kan worden beschouwd als de voorloper van programmeertalen op hoog niveau. De programmeur schreef het op te lossen probleem op in de vorm van wiskundige formules en zette de formules om in tweelettercodes. Vervolgens vertaalde een speciaal programma deze codes naar binaire machinecode. Zo ontwikkelde J. Mauchly een van de eerste primitieve tolken. En in 1951 creëerde G. Hopper de eerste compiler A-0. Zij was de eerste die deze term introduceerde.

Eerste talen op hoog niveau: Cobol en Fortran
In de jaren vijftig van de vorige eeuw begon een groep onder leiding van G. Hopper met de ontwikkeling van een nieuwe taal en compiler B-0. Nieuw taal zou programmeren mogelijk maken in een taal die dicht bij het reguliere Engels ligt. De taalontwikkelaars selecteerden ongeveer 30 Engelse woorden, voor de herkenning daarvan bedacht G. Hopper een methode die bewaard bleef in de operators van toekomstige programmeertalen: elk woord bevat een unieke combinatie van de eerste en derde letter. Hierdoor kan de compiler alle andere letters in een woord negeren bij het genereren van machinecode voor een programma.
G. Hopper associeerde de noodzaak van de opkomst van een dergelijk systeem, waarvan de taal dicht bij gesproken taal ligt, met het feit dat de reikwijdte van computertoepassingen zal toenemen, en daarom ook het aantal gebruikers zal groeien. Volgens G. Hopper moeten pogingen worden gestaakt om ‘ze allemaal om te zetten in wiskundigen".
In 1958 heette het B-0-systeem FLOW-MATIC en was het gericht op het verwerken van commerciële gegevens. In 1959 werd de machine-onafhankelijke COBOL-taal (Common Business Oriented Language) ontwikkeld programmeertaal hoog niveau voor de corresponderende vertaler uit deze taal. G. Hopper trad opnieuw op als adviseur bij het creëren van de COBOL-taal.
In 1954 werd een bericht gepubliceerd over de creatie van de FORTRAN-taal (FORmula TRANslation) (Fortran). De geboorteplaats van de taal was het hoofdkantoor van IBM in New York. Een van de belangrijkste ontwikkelaars is

Johannes Backus. Hij werd ook de auteur van NFB (Backus Normal Form), dat wordt gebruikt om de syntaxis van veel programmeertalen te beschrijven. In dezelfde periode werd de ALGOL-taal populair in Europese landen en de USSR. Net als FORTRAN was het gericht op wiskundige problemen. Het implementeerde de geavanceerde programmeertechnologie van die tijd, gestructureerd programmeren.

Fortran in de Sovjet-Unie.

Fortran verscheen later in de USSR dan in het Westen, omdat Algol aanvankelijk als een veelbelovender taal werd beschouwd. Communicatie tussen Sovjet-natuurkundigen en hun collega's bij CERN speelde een belangrijke rol bij de introductie van Fortran, waar in de jaren zestig vrijwel alle berekeningen werden uitgevoerd met behulp van Fortran-programma's.

De eerste Sovjet-Fortran-compiler werd in 1967 gemaakt voor de Minsk-2-machine, maar kreeg niet veel populariteit. De wijdverbreide introductie van Fortran begon na de creatie in 1968 van de FORTRAN-DUBNA-compiler voor de BESM-6-machine. EC-computers, die in 1972 verschenen, hadden aanvankelijk al een Fortran-vertaler (“geleend” van IBM/360 samen met andere software).

Normen

De taal is gestandaardiseerd binnen ANSI en ISO

Er zijn normen ontwikkeld: Fortran 66, Fortran 77, Fortran 90, Fortran 95, Fortran 2003 en Fortran 2008.

Standaardisatie van programmeertalen schept de voorwaarden voor het vergroten van de draagbaarheid van software voor computers van welke architectuur dan ook. De standaardisatie van Fortran is een van de redenen voor de lange levensduur van de taal, omdat het dankzij standaardisatie is verzekerd dat de mogelijkheid is gewaarborgd om een ​​enorm fonds aan applicatieprogramma's te gebruiken die in de afgelopen decennia van het bestaan ​​van de taal zijn gecreëerd.

Fortran is een sterk gestandaardiseerde taal en daarom gemakkelijk overdraagbaar naar verschillende platforms. Er zijn verschillende internationale taalstandaarden:

FORTRAN IV(later gebruikt als basis FORTRAN 66 (1966);

FORTRAN 77(1978) veel verbeteringen: stringgegevenstype en functies voor de verwerking ervan, blokinstructies IF, ELSE IF, ELSE, END IF, INCLUDE-instructie, enz.

Fortran 90(1991) hebben de taalstandaard aanzienlijk herzien. Er is een gratis formaat voor het schrijven van code geïntroduceerd. Er zijn aanvullende beschrijvingen verschenen: IMPLICIT NONE, TYPE, ALLOCATABLE, POINTER, TARGET, NAMELIST; controlestructuren DO ... END DO, DO WHILE,CYCLE, SELECT CASE, WHERE; werken met dynamisch geheugen (ALLOCATE, DEALLOCATE, NULLIFY); softwarecomponenten MODULE, PRIVÉ, PUBLIEK, BEVAT, INTERFACE, GEBRUIK, INTENTIE. Er zijn nieuwe ingebouwde functies verschenen, allereerst zijn er OOP-elementen verschenen in de taal voor het werken met arrays

Fortran 95(1997) - correctie van de vorige standaard Fortran 2003(2004) Verdere ontwikkeling van OOP-ondersteuning in de taal. Interactie met het besturingssysteem De FORALL-operator en -constructie zijn geïntroduceerd, waardoor meer flexibiliteit mogelijk is dan de WHERE-operator en -constructie om arrays toe te wijzen en omslachtige lussen te vervangen. Met FORALL kunt u elke sectietoewijzing of WHERE-clausule vervangen, in het bijzonder biedt het toegang tot de diagonaal van een matrix. Deze operator wordt als veelbelovend beschouwd bij parallelle computergebruik, waardoor parallellisatie efficiënter wordt vergemakkelijkt dan lussen.

Fortran 2003(2004) Verdere ontwikkeling van OOP-ondersteuning in de taal. Interactie met het besturingssysteem. De volgende functies zijn ook toegevoegd: 1. Asynchrone gegevensinvoer/uitvoer 2. Middelen voor interactie met de taal. 3. Verbetering van de dynamische plaatsing van gegevens. Fortran 2008(2010) De standaard gaat uit van ondersteuning door middel van de parallelle computertaal (Co-Arrays Fortran). Het is ook de bedoeling om de maximale afmeting van arrays te vergroten tot 15, ingebouwde speciale wiskundige functies toe te voegen, enz.

Fortran programmeertaalversie

Programmeurs die programma's uitsluitend in assembleertaal ontwikkelden, uitten ernstige twijfels over de mogelijkheid van een krachtige taal op hoog niveau, dus het belangrijkste criterium bij het ontwikkelen van Fortran-compilers was de efficiëntie van de uitvoerbare code. Er zijn voor deze taal een groot aantal bibliotheken gemaakt, variërend van statistische complexen tot satellietcontrolepakketten, dus Fortran wordt nog steeds actief gebruikt. Er is een standaardversie van Fortran, WF (High Performance Fortran), voor parallelle supercomputers met meerdere processors.

Cobol (Kobol). Het is een gecompileerde taal voor gebruik bij economische en zakelijke problemen, ontwikkeld in het begin van de jaren zestig. Het wordt gekenmerkt door een grote "breedsprakigheid" - de uitspraken zien er soms uit als gewone Engelse uitdrukkingen. Cobol leverde zeer krachtige tools voor het werken met grote hoeveelheden gegevens die op verschillende externe media zijn opgeslagen. In deze taal zijn veel applicaties gemaakt, die nog steeds actief worden gebruikt.

Algol (Algol). Een gecompileerde taal gemaakt in 1960. Het was bedoeld om Fortran te vervangen, maar vanwege de complexere structuur werd het niet veel gebruikt. In 1968 werd een versie van Algol 68 gemaakt, die qua mogelijkheden vandaag de dag nog steeds voorloopt op veel programmeertalen, maar vanwege het gebrek aan voldoende efficiënte computers ervoor was het niet mogelijk om er goede compilers voor te maken in een tijdige wijze.

Pascal. De Pascal-taal, eind jaren zeventig gecreëerd door de grondlegger van veel moderne programmeerideeën, Niklaus Wirth, doet in veel opzichten denken aan Algol, maar heeft een aantal eisen aan de programmastructuur aangescherpt en beschikt over mogelijkheden die het mogelijk maken om succesvol te zijn. gebruikt bij het maken van grote projecten.

Basis. Er zijn zowel compilers als tolken voor deze taal, en deze staat qua populariteit op de eerste plaats ter wereld. Het werd in de jaren 60 ontwikkeld als onderwijstaal en is heel gemakkelijk te leren. Dit is een van de veelbelovende programmeertalen.

C (Si). Deze taal is gemaakt in het Bell Laboratory en werd aanvankelijk niet als een massataal beschouwd. Het was de bedoeling om de assembler-taal te vervangen om even efficiënte en compacte programma's te kunnen maken en tegelijkertijd niet afhankelijk te zijn van een bepaald type processor. In de jaren '70 zijn veel applicatie- en systeemprogramma's en een aantal bekende besturingssystemen (Unix) in deze taal geschreven.

Java (Java, Java). Deze taal is begin jaren 90 door Sun gemaakt op basis van C++. Het is ontworpen om de ontwikkeling van op C++ gebaseerde applicaties te vereenvoudigen door alle functies op laag niveau eruit te verwijderen. Maar het belangrijkste kenmerk van deze taal is dat het niet in machinecode wordt gecompileerd, maar in platformonafhankelijke bytecode (elk commando neemt één byte in beslag). Deze bytecode kan worden uitgevoerd met behulp van een tolk: de Java Virtual Machine, waarvan vandaag de dag versies voor alle platforms worden gemaakt. Dankzij de beschikbaarheid van veel Java-machines kunnen Java-programma's niet alleen overdraagbaar zijn op het niveau van de brontekst, maar ook op het niveau van de binaire bytecode. Daarom staat de Java-taal tegenwoordig op de tweede plaats in populariteit in de wereld, na BASIC.

Onlangs richtten programmeersystemen zich op creëren Windows-applicaties:

· plastieken zak Borland Delphi (Delphi) is een briljante opvolger van de Borland Pascal-familie van compilers en biedt hoogwaardige en zeer handige visuele ontwikkelingstools. Dankzij de uitzonderlijk snelle compiler kunt u vrijwel elk efficiënt en snel oplossen.

· plastieken zak Microsoft Visual Basic - een handig en populair hulpmiddel voor het maken van Windows-programma's met behulp van visuele hulpmiddelen. Bevat hulpmiddelen voor het maken diagrammen En presentaties.

· plastieken zak Borland C++ - een van de meest gebruikte tools voor het ontwikkelen van DOS- en Windows-applicaties.

In 2017 wordt de Fortran-taal 60 jaar oud. Gedurende deze tijd werd de taal verschillende keren verfijnd. Fortran 90, 95, 2003 en 2008 worden als "moderne" versies beschouwd. Als het aanvankelijk een programmeertaal op hoog niveau was met een puur structureel paradigma, verscheen in latere versies ondersteuning voor OOP en parallelle programmering. Tegenwoordig is Fortran op de meeste platforms geïmplementeerd.

Vóór de komst van Fortran programmeerden ontwikkelaars met behulp van machinecode en assembleertaal. De taal op hoog niveau werd snel populair omdat deze gemakkelijk te leren was en efficiënte uitvoerbare code genereerde. Dit maakte het leven voor programmeurs een stuk eenvoudiger.

In 1950, toen John Backus 25 jaar oud was, behaalde hij een masterdiploma in wiskunde aan de Columbia University en kreeg hij een baan als programmeur bij IBM. Al snel leidde hij een team dat een tolk ontwikkelde genaamd "Fast Encoder" voor de IBM-701-computer. Vervolgens werkte hij als onderdeel van een team aan het creëren van een krachtigere opvolger van de 701, de IBM-704.

In 1953 kwam Backus met een rationalisatie-initiatief. Hij stelde voor om er een taal en een compiler voor te maken, die het programmeren van het IBM-704-model zou moeten vereenvoudigen. Het systeem maakte het mogelijk programma's in algebraïsche vorm te schrijven, en de compiler moest deze automatisch in machinecodes vertalen.

Met dit voorstel was John Backus, zoals ze zeggen, op het juiste moment op de juiste plaats. Omdat IBM laat op de markt kwam, had het moeite de verkoop van zijn computers te vergroten. Om deze reden ondersteunde ze computerwetenschappelijk onderzoek aan Columbia, Harvard en verschillende andere universiteiten. Bovendien was IBM zelf op zoek naar manieren om de programmeerkosten te verlagen en probeerde het ook het werk met computers te vereenvoudigen om ze aantrekkelijker en 'vriendelijker' te maken voor gebruikers.

Feit is dat het destijds vooral wetenschappers, ingenieurs en docenten waren die met computers werkten. Voor wetenschappelijke berekeningen werden computers gebruikt. Deze mensen ondervonden echter grote moeilijkheden, omdat ze machinecodes en assembleertaal moesten gebruiken. En dit vereiste een vrij diepgaande kennis van de structuur en werking van de computer zelf.

Daarom zouden ze er waarschijnlijk mee instemmen een taal op hoog niveau te leren, vooral als deze lijkt op de algebraïsche formules waarmee ze vertrouwd zijn. Dergelijke overwegingen waren voor IBM aanleiding om Fortran te ontwikkelen.

IBM-704

De IBM-onderzoekers die Fortran creëerden, hadden geen idee hoe belangrijk deze taal zou worden. Toen ze begin 1954 met hun werk begonnen, ontwikkelde de informatica zich spontaan, en iedereen werkte in een opwelling. Dit leidde tot de opkomst van professionele programmeurs en computerwetenschappers.

Een van de managers van IBM besloot dat schakers goede programmeurs zijn, dus begon hij tijdens schaakpartijen met een van de IBM-medewerkers (die overigens Amerikaans schaakkampioen was) gesprekken met mogelijke kandidaten voor programmeurs.

Slechts weinigen van de acht mensen die betrokken waren bij de ontwikkeling van Fortran hadden enige serieuze kennis van computers. Ze kwamen van universiteiten en luchtvaartmaatschappijen, maar ook van IBM's eigen programmeergroepen.

Zelfs het hoofd van het Fortran-ontwikkelingsteam, John Backus, had slechts een paar jaar computerervaring toen hij begon met het creëren van een nieuwe programmeertaal.

Vóór de universiteit was Backus een middelmatige student ("Ik ging naar meer scholen dan ik me kan herinneren"). Nadat hij tijdens de Tweede Wereldoorlog in het leger had gediend, belandde hij in New York City, waar hij naar de radiotechniekschool ging. "De grens van mijn ambities was het maken van een apparaat voor geluidsweergave van hoge kwaliteit", gaf Beckus later toe.

Een televisie- en radioreparatieleraar wekte echter Backus 'interesse in wiskunde en overtuigde hem ervan zijn studie aan Columbia University voort te zetten. Dit was het bescheiden begin van een van de meest lonende carrières in de geschiedenis van de computer.

Dus vestigden de ontwikkelaars, onder leiding van Backus, zich op het IBM-hoofdkantoor aan Madison Avenue in New York.

Ze identificeerden de basisconcepten van de nieuwe taal, in het bijzonder de toewijzingsoperator (bijvoorbeeld N = 100), die variabelen op specifieke waarden instelde, introduceerden geïndexeerde variabelen die de computer vertelden welk element uit de lijst met variabelen nodig was (bijvoorbeeld , X(3) betekent het derde element van de lijst, genaamd X), stelde een zeer belangrijke DO-operator voor, waarmee je de gewenste reeks operators een bepaald aantal keren kon herhalen.

Zoals Backus opmerkte, geloofden de meeste mensen dat de belangrijkste bijdrage van Fortran het vermogen was om programma's als algebraïsche formules te schrijven in plaats van in machinetaal. Maar eigenlijk is dat niet zo. Volgens hem heeft Fortran vooral de organisatie van loops geautomatiseerd. Het belang van deze taak bij het ontwikkelen van wetenschappelijke toepassingen kan moeilijk worden overschat. Het werk aan de taal ging snel.

Het ontwikkelen van een compiler is echter een heel andere zaak. Backus begreep dat het niet eenvoudig was om twijfels over de mogelijkheden van 'automatisch' programmeren, dat wil zeggen het schrijven van programma's in talen op hoog niveau, weg te nemen. Dit zal gebeuren wanneer programma's die met Fortran worden geproduceerd net zo snel en betrouwbaar zijn als programma's die in machinecode of assembleertaal zijn geschreven, dacht hij.

Volgens het plan werd zes maanden uitgetrokken voor de ontwikkeling van de compiler, maar het werk eraan duurde meer dan twee jaar.

Eind 1956 en in 1957 nam de intensiteit van het werk aan het verfijnen en debuggen van de compiler sterk toe. In deze periode huurden groepsleden vaak een kamer in een nabijgelegen hotel, waar ze overdag sliepen terwijl ze 's nachts aan de machine werkten, om zoveel mogelijk ononderbroken machinetijd te hebben. De fouten werden één voor één geëlimineerd en in april 1957 was de compiler klaar voor gebruik door eigenaren van de IBM-704-machine.

"Grote schaamte"

Door een fout die Backus ‘een grote schande’ noemde, werd de samensteller naar het Westinghouse-Bettis-laboratorium gestuurd in de vorm van een pak ponskaarten en zonder enige instructies; waardoor Herb Bright van het Westinghouse-Bettis-laboratorium Fortran blindelings kon runnen. Andere gebruikers ontvingen het systeem op magneetband, samen met een bedieningshandleiding.

Op een vrijdag in april 1957 bezorgde een postbode een mysterieus pakketje bij het computercentrum van het atoomlaboratorium Westinghouse-Bettis nabij Pittsburgh. Programmeur Herb Bright en twee van zijn collega's openden een ongemarkeerde doos en vonden een stapel van ongeveer 2.000 ponskaarten, zonder enige instructie.

Kijkend naar de ponskaarten herinnerde Bright zich dat IBM bezig was met het finaliseren van een taal op hoog niveau voor gebruik op de IBM-704. Misschien heeft de postbode precies deze langverwachte compiler gebracht? Bright en zijn vrienden besloten de mysterieuze kaarten in de computer te laden en te kijken wat er gebeurt.

Bright plaatste een in Fortran geschreven testprogramma in de lezer van de computer en drukte op de startknop. De nieuwe compiler stuurde een bericht naar de printer: "er is een fout gedetecteerd in de operator op kaart nr. 25 - er ontbreekt een komma."

Programmeurs die gewend waren aan verwarrende berichten in de vorm van numerieke codes waren verbaasd over de duidelijkheid van deze informatie. De foutieve operator werd gecorrigeerd en de startknop werd opnieuw ingedrukt. De banden begonnen te draaien en de computer spuwde een stapel geperforeerde programmakaarten uit. Nadat de kaarten in de lezer waren geladen, begon de printer te werken en werden er 28 pagina's afgedrukt zonder te stoppen. De computer maakte slechts een kleine fout in het uitvoerformaat. “Maar de cijfers klopten! De cijfers klopten!” - riep Bright later uit.

In feite verschenen er rond dezelfde tijd als Fortran nog twee talen op hoog niveau: Cobol en Algol. Sinds eind jaren vijftig zijn ze lange tijd leiders in de computerwereld die vertegenwoordigen zijn afstammelingen van deze drie talen.

Distributie en aanpassing

Maar aanvankelijk werd Fortran niet met veel warmte ontvangen. De programmeurs, zo herinnerde Backus zich, “waren zeer sceptisch over al onze applicaties.” Vergeleken met zijn voorgangers was Fortran echter relatief eenvoudig te leren en te gebruiken.

Bovendien leverde IBM alle 704-modellen gratis met Fortran. Als gevolg hiervan werd in 1958 meer dan de helft van alle machineopdrachten op de 60 computers van het bedrijf niet handmatig, maar 'automatisch' verkregen, met behulp van een nieuwe taal op hoog niveau.

Backus begreep dat concurrerende fabrikanten ook talen op hoog niveau voor hun computers zouden ontwikkelen. Fortran werd echter al snel de norm en werd aangepast voor verschillende computermodellen. De eerste aanpassing werd door IBM zelf uitgevoerd. Vijf jaar later werd Fortran gebruikt op zes verschillende modellen IBM-computers, evenals op computers van Sperry Rand, Philco en anderen.

Een klein team, waaronder David Hemmis, paste Fortran snel aan aan de IBM-650, een kleinere machine dan de IBM-704. Khemmis en zijn collega's ontwikkelden het FORTRANSIT-systeem (FOR TRANSIT - voor transitie); later versmolten deze twee woorden tot één. Zo werd het FORTRANSIT-systeem de eerste vertaler van het origineel, die op computers van verschillende modellen werkte.

David Hemmis, een vroege computertaalontwikkelaar, bestuurt zijn auto uit 1928. Foto genomen in Westhampton, New York tijdens de autorace van 1957.

Afronding

Het werk aan de nieuwe taal moest echter nog een hele tijd doorgaan: dit werd begin 1957 duidelijk, toen het debug-proces werd voortgezet. Backus en andere ontwikkelaars realiseerden zich dat de taal een nauwkeuriger systeem nodig had voor het diagnosticeren van softwarefouten. Bovendien was het noodzakelijk om de mogelijkheid van afzonderlijk en onafhankelijk schrijven van subroutines en programmamodules te implementeren. Dit zou de taal nog een voordeel opleveren: hergebruik van code.

Dankzij de inspanningen van de ontwikkelaars verscheen Fortran II slechts een jaar na de creatie van het origineel. Een van de voordelen van de nieuwe taal was dat fragmenten van assemblercode in programma's konden worden ingevoegd. Een latere versie, Fortran III, werd gemaakt in 1958. Fortran IV, dat de mogelijkheden van de taal verder uitbreidde, werd in 1962 bekend.

De kern van de taal, de basisoperatoren en uitdrukkingen, is door de jaren heen vrijwel onveranderd gebleven. Maar omdat Fortran herhaaldelijk werd aangepast aan nieuwe machinesystemen waarvoor het niet bedoeld was, stapelden de verschillen zich geleidelijk op. Sommige kansen gingen verloren, er ontstonden nieuwe. Dit leidde onvermijdelijk tot verwarring.

Niet alle compilers interpreteerden bijvoorbeeld de allerbelangrijkste DO-instructie op dezelfde manier: sommigen voerden de lus altijd minstens één keer uit zonder te controleren of deze überhaupt moest worden uitgevoerd, terwijl anderen dat wel deden. Om orde in dergelijke kwesties te brengen, kwamen computerfabrikanten en gebruikers overeen de taal te standaardiseren.

In 1966 heette de eerste standaard Fortran 66. In 1977 werd dienovereenkomstig de Fortran 77-standaard uitgebracht. In 1991 verscheen Fortran 95.

Fortran in de Sovjet-Unie

In de Sovjet-Unie was Algol-60 populairder. Daarom verscheen Fortran later in dit land. Het kwam echter geleidelijk aan bovenaan in populariteit. Er zijn compilers (vertalers) ontwikkeld voor de meeste huishoudelijke computers - "Minsk-32", BESM-4, BESM-6, AS-6, ES Computer, SM Computer, MVK "Elbrus" enzovoort.

In IPM im. Keldysh werden er op verschillende tijdstippen verschillende vertalers ontwikkeld. Twee ervan - Fortran-Almo en Forshag (Fortran stapsgewijs) zijn geschreven in de Almo-taal en de code is in dezelfde taal gegenereerd. Dit maakte het mogelijk om vertalers op verschillende soorten computers te installeren. Beide vertalers implementeren de Fortran 66-standaard.

Foreshag bevatte ook een conversatietaal waarmee code interactief kon worden gemaakt, bewerkt en vertaald. Daarnaast werd een reeks grafische programma's voor Fortran ontwikkeld - Graphor, die actief op verschillende computers werd gebruikt.

Fortran blijft tot op de dag van vandaag populair onder wetenschappers. Dit is de eerste programmeertaal op hoog niveau met een vertaler, die praktische toepassing en verdere ontwikkeling heeft gekregen. Zoals vermeld in de IBM-handleiding uit 1957, "biedt Fortran een efficiënte manier om 704-programma's te schrijven die gemakkelijk te leren zijn en geen uitgebreide computerkennis vereisen."

Sindsdien kunnen wetenschappers, ingenieurs en studenten met een computer communiceren zonder de hulp van professionele programmeurs die in assembleertaal schrijven.

De volgende generatie programmeurs begon Fortran echter als een ‘fossiel’ te behandelen. Edsger Dijkstra grapte dat het onderwijzen van deze taal aan studenten als een ernstige misdaad moest worden beschouwd.

Midden jaren vijftig gekenmerkt door snelle vooruitgang op het gebied van programmeren. De rol van programmeren in machinecodes begon af te nemen en er begonnen nieuwe soorten programmeertalen te verschijnen, die fungeerden als tussenpersoon tussen machines en programmeurs. Het is tijd voor de tweede en derde generatie programmeertalen

Sinds midden jaren vijftig. XX eeuw begon de eerste programmeertalen op hoog niveau te creëren. Deze talen waren Machine-onafhankelijk (niet gebonden aan een specifiek type computer).

Maar elke taal heeft zijn eigen compilers ontwikkeld: een programma dat de compilatie uitvoert.

Compilatie is de vertaling van een programma geschreven in een brontaal op hoog niveau naar een gelijkwaardig programma in een taal op laag niveau die dicht bij machinecode ligt (absolute code, objectmodule, soms assembleertaal)

FORTRAN-programmeertaal

De eerste taal op hoog niveau werd tussen 1954 en 1957 gemaakt door een groep programmeurs onder leiding van John Backus van IBM Corporation en dit werd de volgende fase in de ontwikkeling van programmeertalen. Het was de programmeertaal FORTRAN. Het was bedoeld voor wetenschappelijke en technische berekeningen. De naam Fortran is een afkorting van FORmulaTRANslator (formulevertaler).

Geschiedenis van de taal

Eind 1953 stelde John Backus voor om te beginnen met het ontwikkelen van een effectief alternatief voor assembler voor programmeren op de IBM 704 PC. Halverwege 1954 was de conceptspecificatie van de Fortran-taal voltooid. De eerste handleiding voor Fortran verscheen in oktober 1956, samen met de eerste compiler, die in april 1957 werd verzonden. De compiler was een optimaliserende compiler omdat klanten terughoudend waren in het gebruik van een programmeertaal op hoog niveau die geen code kon genereren met prestaties die lager waren dan die van assemblage. taal.

Destijds was de gemeenschap sceptisch over de nieuwe manier van programmeren en geloofde niet dat Fortran sneller en efficiënter programmeren mogelijk zou maken. Volgens John Backus zelf was het grootste deel van zijn werk gericht op ‘lui zijn’. Hij hield er echt niet van om programma's voor de IBM 701 in assembler te schrijven.

De taal is door wetenschappers algemeen aanvaard voor het schrijven van rekenintensieve programma's. De opname van een complex datatype maakte het bijzonder geschikt voor technische toepassingen.

In 1960 waren er versies van Fortran voor de IBM 709, 650, 1620, 7090 computers. De grote populariteit ervan moedigde concurrerende computerfabrikanten aan om Fortran-compilers voor hun computers te maken. Zo waren er in 1963 meer dan 40 compilers voor verschillende platforms. Dit is de reden waarom Fortran wordt beschouwd als de eerste veelgebruikte programmeertaal.

Fortran in de Sovjet-Unie

Fortran verscheen later in de USSR dan in het Westen, omdat Algol aanvankelijk als een veelbelovender taal werd beschouwd. Communicatie tussen Sovjet-natuurkundigen en hun collega's bij CERN speelde een belangrijke rol bij de introductie van Fortran, waar in de jaren zestig vrijwel alle berekeningen werden uitgevoerd met behulp van Fortran-programma's.

De eerste Sovjet-Fortran-compiler werd in 1967 gemaakt voor de Minsk-2-machine, maar kreeg niet veel populariteit. De wijdverbreide introductie van Fortran begon na de oprichting in 1968 van de FORTRAN-DUBNA-compiler voor de BESM-6-machine. ES-computers, die in 1972 verschenen, hadden aanvankelijk al een Fortran-vertaler (“geleend” van IBM/360 samen met andere software)

Moderne Fortran. Deugden van taal

Fortran werd op grote schaal gebruikt, voornamelijk voor wetenschappelijk en technisch computergebruik. Het is perfect voor het oplossen van numerieke problemen, aangezien veel bibliotheken in de loop van meer dan 50 jaar zijn geschreven, dus de taal wordt nu gebruikt en loopt niet het gevaar in de nabije toekomst vergeten te worden. Het wordt echter tot op de dag van vandaag nog steeds gebruikt, niet zozeer vanwege het succesvolle ontwerp, maar vanwege het grote aantal programma's dat erop is geschreven en die geen zin hebben om te veranderen en vooral te herschrijven.

Als je snel iets wilt berekenen, is Fortran waarschijnlijk een van de beste opties. Dit is precies waarom de taal is uitgevonden.

Dankzij de structuur kan de compiler berekeningen zeer goed optimaliseren.

Onder wetenschappers is er bijvoorbeeld een gezegde dat elk wiskundig probleem al een oplossing heeft in Fortran, en inderdaad, je kunt tussen de duizenden Fortran-pakketten een pakket vinden voor het vermenigvuldigen van matrices, een pakket voor het oplossen van complexe integraalvergelijkingen, en nog veel meer, vele anderen.