De meeste moderne computerprogramma's zijn geschreven in talen van hoog niveau. Het is opmerkelijk dat velen van hen al in de jaren 60 en 70 zijn ontwikkeld, maar nog steeds relevant zijn. Welke andere feiten over talen op hoog niveau kunnen we opmerken? Wat zijn de meest voorkomende soorten relevante oplossingen?

De essentie van programmeertalen op hoog niveau

Een programmeertaal op hoog niveau is een hulpmiddel dat als machine-onafhankelijk wordt geclassificeerd. Wat betekent dit? Feit is dat programmeertalen in verschillende categorieën zijn onderverdeeld.

Er is machinecode: een reeks algoritmen die zijn ontworpen om de gebruiker rechtstreeks te besturen met de hardware-elementen van de computer. Hun essentie zal volledig machine-afhankelijk zijn: alleen bepaalde algoritmen zullen geschikt zijn voor specifieke typen pc's.

Er zijn assembleertalen. In feite zijn ze een aanvulling op de programma's die zijn ontworpen voor controle op laag niveau van pc-hardwarecomponenten via machinecode. Maar om vele redenen worden assembleertalen meestal ook geclassificeerd als machine-afhankelijk. In de regel zijn ze aangepast aan een specifiek type pc-hardwarecomponent. Hun belangrijkste taak is om het voor de gebruiker gemakkelijker te maken de computer te besturen via geschikte communicatie op laag niveau.

Een programmeertaal op hoog niveau stelt de gebruiker op zijn beurt in staat om met de pc te communiceren, ongeacht welke specifieke hardware op de computer is geïnstalleerd. Daarom moet het als machine-onafhankelijk worden geclassificeerd. Bij het schrijven van besturingssystemen wordt meestal een programmeertaal op hoog niveau gebruikt. Maar er zijn besturingssystemen die in assembleertaal zijn geschreven. Programmeertalen op laag en hoog niveau kunnen tegelijkertijd worden gebruikt. Een persoon die opdrachten op hoog niveau aan een pc geeft, moet deze op de een of andere manier overbrengen naar specifieke hardwarecomponenten, en deze functie kan worden geïmplementeerd door gelijktijdig assembleertalen te gebruiken met talen op hoog niveau die bij de structuur betrokken zijn. van het besturingssysteem.

Vertalers

De belangrijkste elementen die zijn opgenomen in programmeertalen op hoog niveau zijn vertalers. Hun functie kan variëren. Een van de belangrijkste toepassingsgebieden van vertalers is de ‘vertaling’ van opdrachten die in een programmeertaal op hoog niveau zijn gegenereerd, naar machinecode die begrijpelijk is voor een specifiek pc-hardwarecomponent, bijvoorbeeld een processor. Vertalers die deze functie uitvoeren, worden ook wel compilers genoemd. Er is een ander type overeenkomstige componenten: tolken. Ze zijn op hun beurt bedoeld om commando's op hoog niveau te 'vertalen' naar commando's die begrijpelijk zijn voor het besturingssysteem of welk programma dan ook.

Classificatie van talen op hoog niveau

Programmeertalen op hoog niveau kunnen op verschillende manieren worden geclassificeerd. Er is een gemeenschappelijk schema volgens welke ze zijn onderverdeeld in de volgende hoofdvariëteiten:

Procedureel georiënteerd (gebruikt als hulpmiddel bij het verwerken van informatie in elk stadium van berekeningen);

Probleemgericht (gebruikt als middel om industriële en toegepaste problemen op te lossen die ontstaan ​​naarmate de gebieden van pc-toepassingen zich uitbreiden);

Objectgeoriënteerd (het kunnen speciale gevallen zijn van talen van de eerste twee typen, maar ze zijn aangepast voor gebruik door een breed scala aan ontwikkelaars met verschillende trainingsniveaus, bijvoorbeeld in de vorm van een oplossing met een visuele interface ).

Laten we nu enkele historische en moderne programmeertalen op hoog niveau bekijken die met deze classificatie overeenkomen.

Procedureel georiënteerde talen

Deze omvatten Fortran. Het wordt beschouwd als de eerste programmeertaal op hoog niveau die voor wijdverbreid gebruik is gemaakt. Gekenmerkt door een eenvoudige structuur. BASIC is ook een procedureel georiënteerde taal. Het wordt beschouwd als een van de meest gebruikte bij het lesgeven in programmeren. Een voorbeeld van een andere procedureel georiënteerde taal is SI. Het is oorspronkelijk gemaakt voor het UNIX-besturingssysteem. Op basis daarvan ontstond vervolgens de taal C++, aangevuld met objectgeoriënteerde programmeertools. Een andere taal die tot deze categorie behoort, is Pascal. Vaak ook gebruikt bij het lesgeven in programmeren. Dankzij de mogelijkheden van deze taal kan deze worden gebruikt als een zeer krachtig hulpmiddel voor het ontwikkelen van professionele soorten software.

Probleemgeoriënteerde talen

Deze omvatten Lisp en Prolog. De eerste taal werd ontwikkeld in 1962, een paar jaar na de oprichting van Fortran. Daarom beschouwd als de tweede in de geschiedenis. Actief gebruikt als hulpmiddel voor programmeurs om met tekenreeksen te werken. In de praktijk werd Lisp gebruikt in systemen die waren geclassificeerd als expertsystemen, maar ook in systemen die bedoeld waren voor analytisch computergebruik. Prolog heeft wijdverbreid gebruik gevonden op het gebied van logisch programmeren. In de praktijk is het meestal betrokken bij het beheer van kunstmatige intelligentie-algoritmen in relevante systemen.

Objectgeoriënteerde talen

Laten we nu voorbeelden bestuderen van programmeertalen op hoog niveau die in de objectgeoriënteerde categorie vallen. Hiertoe behoren Visual Basic, Delphi, Visual Fortran, de bovengenoemde C++, evenals Prolog ++. In feite bevatten ze allemaal procedureel georiënteerde talen in hun kern. Er wordt echter verwacht dat ze aanzienlijk zullen worden aangevuld met visuele bedieningselementen met het oog op latere beheersing van de noodzakelijke algoritmen door ontwikkelaars die gewend zijn aan andere tools. Zo kan de eerste programmeertaal op hoog niveau, Fortran, snel worden geleerd door IT-specialisten met behulp van de mogelijkheden van Visual Fortran. Met behulp van een vergelijkbare methode kunt u BASIC of Prolog snel onder de knie krijgen.

Bij gebruik van Delphi wordt het programmeren op zijn beurt uitgevoerd in de taal op hoog niveau Object Pascal. Er is een groot aantal andere softwareontwikkelomgevingen geclassificeerd als objectgeoriënteerde talen. Dit gebied van ontwikkelt zich actief.

Fortran en Lisp zijn de eerste en tweede talen op hoog niveau

Laten we in meer detail bestuderen hoe de eerste programmeertaal op hoog niveau, Fortran, verscheen, evenals Lisp, die als de tweede wordt beschouwd. In 1954 creëerden ontwikkelaars van IBM, onder leiding van John Backus, een taal waarmee programmeurs de interactie met een pc enorm konden vergemakkelijken, die tot dan toe werd uitgevoerd via machineopdrachten of assembler. Het heette Fortran en werd al snel bekend in de USSR onder de gerussificeerde naam. Fortran werd een populair hulpmiddel voor wetenschappelijk computergebruik.

Het belangrijkste revolutionaire element dat door IBM-specialisten aan de gemeenschap werd voorgesteld, was in feite diezelfde compiler, ontworpen als alternatief voor assembler. In de eerste jaren dat ze programma's met Fortran schreven, beschouwden veel ontwikkelaars de compiler als een niet geheel succesvolle oplossing, vooral vanuit het oogpunt van arbeidskosten. Veel machinecodes zijn inderdaad eenvoudiger samengesteld dan met behulp van een vertaler. Toen de computerprestaties echter snel toenamen, begonnen programmeurs te beseffen dat het zonder gebruik van een compiler uiterst moeilijk was om effectieve software te maken die de rekenkracht van een pc volledig zou benutten. Zo werden de initiatieven van ontwikkelaars van IBM verder ontwikkeld. De fundamentele syntactische structuren van de hoogwaardige programmeertaal Fortran werden in veel gevallen gebruikt als basisstructuren bij het creëren van nieuwe oplossingen.

Een voorbeeld van het behalen van praktische resultaten bij de ontwikkeling van concepten ingebed in Fortran is de oprichting van Lisp. Deze taal werd in 1958 ontwikkeld, maar werd iets later algemeen bekend - in 1960. Lisp is ontwikkeld door John McCarthy en gepubliceerd in een van de populaire tijdschriften voor IT-specialisten. Het hoofddoel van de betreffende taal is lijstverwerking. Lisp is populair geworden onder ontwikkelaars van kunstmatige intelligentiesystemen. Op basis hiervan zijn talen als Planner, Scheme en Common Lisp gemaakt. Lisp heeft ook een aanzienlijke invloed gehad op veel moderne softwareontwikkelingstools. De structuur van programmeertalen op hoog niveau die tegenwoordig populair zijn, is grotendeels gebaseerd op Fortran- en Lisp-algoritmen.

Het zal echter interessant zijn om andere benaderingen te overwegen voor de classificatie van de software-ontwikkeltools die in beschouwing worden genomen.

Universele talen op hoog niveau

Moderne experts identificeren dus universele talen op hoog niveau. Deze omvatten met name die welke in de jaren 60 zijn ontwikkeld. Hun belangrijkste kenmerken:

Focus op een breed scala aan taken (voornamelijk taken die verband houden met computergebruik);

Een groot aantal taalconstructies en algoritmen;

Betekenis niet alleen voor die tijd, maar ook voor de moderne ontwikkelingsfase van computertechnologie;

Ondersteuning in relevante talen voor imperatieve methodologie.

Universele talen zijn van fundamenteel belang op het relevante gebied van IT-ontwikkeling. Opgemerkt kan worden dat ze tot nu toe geen directe analogen hebben in termen van interne structuur. Eigenlijk verklaart dit grotendeels de relevantie van het gebruik van de overeenkomstige talen in moderne objectgeoriënteerde interfaces. Ook gebruikelijk in de genoemde talen is het gegevenstype. Deze factor bepaalt grotendeels hun veelzijdigheid. Een van de meest opmerkelijke eigenschappen van talen die tot de categorie universele talen behoren, is continuïteit. Historisch gezien waren latere talen dus in de regel gebaseerd op de concepten van hun voorgangers.

Unieke talen

Sommige IT-experts classificeren ‘unieke talen’ als een aparte categorie. Deze omvatten: APL, Cobol, Forth, SETL en CLU. Wat zijn hun bijzonderheden?

Het belangrijkste aspect van APL is het gebruik van arrays (vectoren en matrices) als een belangrijk structureel type. Het specifieke van de Cobol-taal is de focus op de commerciële sfeer. Het is dus raadzaam om het te gebruiken bij het oplossen van problemen die verband houden met een gestandaardiseerd formaat voor de presentatie van resultaten. De Forth-taal wordt gekenmerkt door het gebruik van postfix-notatie van programma's, evenals het gebruik van stapelnotatie. SETL gebruikt waardenverzamelingen als een van de belangrijkste gegevenstypen. CLU is ook een programmeertaal op hoog niveau. Het belangrijkste kenmerk is het gebruik van het concept van het werken met abstracte gegevenstypen. Veel IT-specialisten zien de logische opkomst van nieuwe oplossingen op basis van unieke talen – zoals bijvoorbeeld Object-Oriented Cobol.

Parallelle programmeertools

Deze categorie kan een groot aantal oplossingen omvatten. Parallelle programmeertalen kunnen op hun beurt een groot aantal bases voor classificatie hebben. Bijvoorbeeld een methode om processen te organiseren. Deze basis omvat de classificatie van parallelle programmeertools op basis van de aanwezigheid daarin van:

Coroutine;

Takken;

Verenigingen;

Parallelle beugels;

Algoritmen voor het werken met processen.

Een andere basis voor het classificeren van talen van het type dat wordt overwogen, zijn methoden voor processynchronisatie. Passende oplossingen kunnen daarom zijn:

Semaforen;

Monitoren;

- “afspraak”;

Kritieke gebieden;

Procedureoproep op afstand;

Transacties geclassificeerd als atomair.

De talen van het betreffende type zijn onder meer Modula-2, BLISS, Concurrent Pascal, DP, Argus.

C-talenfamilie

Hierboven hebben we een oplossing als C bekeken als een voorbeeld van een programmeertaal op hoog niveau. In feite vormt het een hele familie. De talen die erbij horen zijn eigen constructies van C. De toevoeging van verschillende objectgeoriënteerde componenten leidde dus tot de ontwikkeling van C++. Na een aanzienlijke filtering van een aantal C-constructies ontstond de Java-taal. Opgemerkt kan worden dat Java grotendeels is ontstaan ​​onder invloed van de concepten van het Oberon-project, dat wordt geleid door Niklaus Wirth, de maker van de Pascal-taal. Is het JavaScript op hoog niveau? Natuurlijk wel, ondanks de beperkte toepassing ervan - als hulpmiddel voor het ontwikkelen van webpagina's. Maar programmeertalen op hoog niveau omvatten met name HTML, XML en SGML niet. Ze zijn geclassificeerd als hulpmiddelen voor hypertekstmarkering.

Pascal-talenfamilie

Ook de programmeertalen op hoog niveau van Pascal vormen een aparte familie. Op basis van Pascal is Oberon feitelijk gemaakt, geclassificeerd als een objectgeoriënteerde taal. Een belangrijk kenmerk van Oberon is het vermogen om typeveiligheid te bieden. Naast Oberon omvatten talen in de Pascal-familie Modula-2, evenals Component Pascal.

Ada-talenfamilie

Fundamenteel in de overeenkomstige categorie talen - Ada, besteld voor de behoeften van het Amerikaanse ministerie van Defensie. Het ontstond eind jaren zeventig, begin jaren tachtig. Het wordt gekenmerkt door een groot aantal functies, mogelijkheden en veelzijdigheid. De Ada-talenfamilie omvat oplossingen zoals Cedar, Modula 3.

Simula-talenfamilie

De Simula-taal is gebruikelijk in programmeerindustrieën die verband houden met simulatiemodellering. De specificiteit van de overeenkomstige oplossingen ligt in het gebruik van een specifieke kern. Het gebruik ervan maakt het gebruik van verschillende extensies mogelijk die zijn aangepast aan bepaalde toepassingsgebieden. Op basis van Simula is de objectgeoriënteerde taal Smalltalk ontstaan, evenals BETA, dat wordt gekenmerkt door het vermogen om algoritmen te combineren die het werken met data, procedures en management weerspiegelen binnen één enkele abstractie. BETA-objecten kunnen in verschillende contexten worden bekeken, zoals variabelen, functies of parallelle systemen.

Titel van het rapport

Moderne programmeertalen en hun gebruik

Auteur van het project

Projectstructuur

● Classificatieschema voor programmeertalen

● Classificatie van programmeertalen

● Overzicht van programmeertalen

● Nuttige bronnen

Classificatieschema voor programmeertalen

Classificatie van programmeertalen

Procedurele programmering- is een weerspiegeling van de computerarchitectuur van von Neumann. Een programma geschreven in een procedurele taal is een reeks opdrachten die een algoritme definiëren voor het oplossen van een probleem. Het belangrijkste idee van procedureel programmeren is het gebruik van geheugen om gegevens op te slaan. Het hoofdcommando is toewijzing, waarmee het geheugen van de computer wordt bepaald en gewijzigd. Het programma transformeert de inhoud van het geheugen en verandert deze van de begintoestand naar de resulterende toestand.

Er zijn de volgende procedurele programmeertalen:

 De Fortran-taal werd begin jaren vijftig van de 20e eeuw gecreëerd voor het programmeren van wetenschappelijke en technische problemen;

 COBOL - gemaakt eind jaren 60 van de 20e eeuw om problemen op te lossen bij het verwerken van grote hoeveelheden gegevens die zijn opgeslagen op verschillende gegevensopslagmedia;

 ALGOL (1960) is een multifunctionele geavanceerde programmeertaal. Het introduceerde voor het eerst de concepten van “blokstructuur van een programma” en “dynamische geheugentoewijzing”;

 Halverwege de jaren 60 van de 20e eeuw werd een gespecialiseerde programmeertaal voor beginners gecreëerd: BASIC. Het wordt gekenmerkt door leergemak en de aanwezigheid van universele hulpmiddelen voor het oplossen van wetenschappelijke, technische en economische problemen, maar ook voor problemen, bijvoorbeeld op het gebied van gaming.

Alle hierboven genoemde talen waren gericht op verschillende taakklassen, maar ze waren tot op zekere hoogte gebonden aan een specifieke computerarchitectuur.

 In 1963-1966 werd de multifunctionele universele taal PL-1 gecreëerd. Deze taal is zeer geschikt voor onderzoek en planning van computerprocessen, modellering, het oplossen van logische problemen en het ontwikkelen van softwaresystemen.

 Pascal-taal (PASCAL) (1968-1971) is de meest populaire procedurele programmeertaal voor pc's, die vandaag de dag nog steeds met succes wordt gebruikt. De Pascal-taal is gebaseerd op een benadering van algemene problemen naar specifieke problemen (eenvoudiger en kleiner van omvang). De basisprincipes van Pascal zijn onder meer: ​​a) Gestructureerd programmeren, dat gebaseerd is op het gebruik van subroutines en onafhankelijke datastructuren; b) Top-down programmeren, wanneer een probleem wordt opgedeeld in eenvoudige, onafhankelijk opgeloste problemen. Vervolgens wordt de oplossing voor het oorspronkelijke probleem volledig van boven naar beneden opgebouwd.

 Procedurele programmeertalen omvatten de ADA-taal (1979). Het onderscheidt zich door zijn modulaire ontwerp.

 De SI-taal (begin jaren 70) behoort ook tot de procedurele programmeertalen. De originele versie was gepland als een taal voor de implementatie van het Unix-besturingssysteem in plaats van de assembleertaal. Een van de kenmerken van de SI-taal is dat de verschillen tussen expressies en operators worden gladgestreken, waardoor deze dichter bij functionele programmeertalen komt. Bovendien heeft de SI-taal niet het concept van een procedure, en is het gebruik van subroutines gebaseerd op het concept van een functie, die de mogelijkheden van een procedure kan combineren. Aan de ene kant kan het, gebaseerd op de reeks besturingsconstructies en datastructuren, worden geclassificeerd als een taal op hoog niveau, en aan de andere kant beschikt het over een reeks middelen om rechtstreeks toegang te krijgen tot de functionele eenheden van een computer, die betekent dat het kan worden gebruikt als een operationele taal.

Objectgeoriënteerd programmeren (OOP) is een programmeermethode waarbij de belangrijkste elementen van programma's objecten zijn. In programmeertalen wordt het concept van een object geïmplementeerd als een reeks eigenschappen (datastructuren die kenmerkend zijn voor een bepaald object), methoden om deze te verwerken (routines voor het wijzigen van hun eigenschappen) en gebeurtenissen waarop een bepaald object kan reageren en die, als een regel, leiden tot veranderingen in de eigenschappen van het object. Het combineren van gegevens en hun inherente verwerkingsprocedures in één object wordt inkapseling genoemd en is een van de belangrijkste principes van OOP.

Een ander fundamenteel concept is klasse. Een klasse is een sjabloon op basis waarvan een specifiek softwareobject kan worden gemaakt; het beschrijft de eigenschappen en methoden die het gedrag van objecten van deze klasse bepalen. Elk concreet object met de structuur van deze klasse wordt een instantie van de klasse genoemd.

De volgende belangrijkste principes van OOP zijn overerving en polymorfisme. Overerving omvat het creëren van nieuwe klassen op basis van bestaande klassen en zorgt ervoor dat een afstammelingsklasse alle eigenschappen van de bovenliggende klasse kan hebben (erven).

Polymorfisme betekent dat geboren objecten informatie hebben over welke methoden ze moeten gebruiken, afhankelijk van waar ze zich in de keten bevinden.

Een ander belangrijk principe van OOP is modulariteit: objecten bevatten een volledige definitie van hun kenmerken, er mogen geen definities van methoden en eigenschappen daarbuiten worden geplaatst, dit maakt het mogelijk om het ene object vrijelijk in andere te kopiëren en te implementeren.

De modernste programmeertalen zijn C++ en Java. Sinds het midden van de jaren negentig zijn veel objectgeoriënteerde talen geïmplementeerd als visuele ontwerpsystemen, waarbij het interfacegedeelte van een softwareproduct interactief wordt gemaakt, zonder dat er programma-instructies worden geschreven. Objectgeoriënteerde visuele ontwerpsystemen omvatten Visual Basic, Delphi, C++ Builder, Visual C++. VBA-taal (Visual Basic for Application) is de taal van Microsoft Office-applicaties (Excel, Word, Power Point, enz.). VBA volgt de basissyntaxis van de taal en de programmeerregels van basistalen - dialecten, stelt u in staat macro's te maken om de uitvoering van bepaalde bewerkingen te automatiseren en een grafische gebruikersinterface, integratie tussen verschillende softwareproducten.

Declaratieve programmeertalen

Deze omvatten functionele en logische programmeertalen. Functioneel programmeren is een manier om programma's te schrijven waarbij de enige actie het aanroepen van een functie is. Functioneel programmeren maakt geen gebruik van geheugen als plaats om gegevens op te slaan, en maakt daarom geen gebruik van tussenvariabelen, toewijzingsinstructies of lussen. Het sleutelbegrip in functionele talen is expressie. Een programma geschreven in een functionele taal is een reeks beschrijvingen van functies en uitdrukkingen. De uitdrukking wordt berekend door het complexe terug te brengen tot het eenvoudige. Alle uitdrukkingen zijn geschreven in de vorm van lijsten. De eerste taal was de Lisp-taal (LISP, LIST Processing), gecreëerd in 1959. Met deze taal kunt u grote hoeveelheden tekstinformatie verwerken. Logisch programmeren is programmeren in termen van logica. In 1973 werd de kunstmatige intelligentietaal Prolog (PROLOG) (Programming in Logic) gecreëerd. Een Prolog-programma wordt opgebouwd uit een reeks feiten en regels, waarna een verklaring wordt geformuleerd, die Prolog probeert te bewijzen met behulp van de regels. De taal zoekt zelf naar een oplossing met behulp van de zoek- en matchingmethoden die erin zijn ingebed. Logische programma's worden niet gekenmerkt door hoge prestaties, omdat het proces van hun uitvoering neerkomt op het construeren van voorwaartse en achterwaartse redeneerketens met behulp van verschillende zoekmethoden.

Overzicht van programmeertalen

Assembler

Computerprogrammeertalen zijn onderverdeeld in 2 hoofdgroepen:

1) talen op laag niveau;

2) Talen op hoog niveau.

Talen op een laag niveau omvatten Assembleerttalen. Ze hebben hun naam gekregen van het Assembler-systeemprogramma, dat bronprogramma's die in dergelijke talen zijn geschreven, rechtstreeks omzet in machine-instructiecodes. De onderdelen hier zijn operators, en het resultaat van assemblage is een reeks machineopdrachten. Assemblagetaal combineert de voordelen van een machineopdrachttaal en enkele kenmerken van talen op hoog niveau. De assembler biedt de mogelijkheid om symbolische namen in het bronprogramma te gebruiken en bespaart de programmeur het vervelende werk (onvermijdelijk bij het programmeren in een machine-instructietaal) van het toewijzen van computergeheugen voor instructies, variabelen en constanten.

De assembler maakt ook flexibel en volledig gebruik van de technische mogelijkheden van de computer mogelijk, evenals de commandotaal van de machine. De assembler-bronprogrammavertaler is eenvoudiger dan de vertaler die nodig is voor een programmeertaal op hoog niveau. In assembler kun je een programma schrijven dat qua omvang en uitvoeringstijd net zo efficiënt is als een programma in machine-instructietaal. Dit voordeel ontbreekt in talen op hoog niveau. Deze taal wordt vaak gebruikt voor het programmeren van real-time systemen, technologische processen en apparatuur, waardoor de werking van informatie- en meetsystemen wordt gewaarborgd. Dergelijke systemen stellen doorgaans hoge eisen aan de hoeveelheid computergeheugen die ze in beslag nemen. Vaak wordt Assembleertaal aangevuld met tools voor het genereren van macro-instructies, die elk equivalent zijn aan een hele groep machine-instructies. Deze taal wordt macroassemblagetaal genoemd. Het gebruik van klaproos-bouwstenen brengt de assembleetaal dichter bij een taal op hoog niveau. Assembleertaal is een machine-afhankelijke taal, dat wil zeggen dat het de architectonische kenmerken van een bepaald type computer weerspiegelt

Pascal

De programmeertaal Pascal werd in 1968 ontwikkeld door Nicolas Wirth, een professor aan de afdeling Computerwetenschappen van het Zwitserse Federale Instituut voor Technologie, als alternatief voor bestaande en steeds complexer wordende programmeertalen zoals PL/1, Algol en Fortran. . De intensieve ontwikkeling van Pascal leidde tot het verschijnen van zijn standaard in de vorm van een herziene boodschap in 1973, en het aantal vertalers uit deze taal in 1979 overschreed de 80. Begin jaren tachtig versterkte Pascal zijn positie verder met de komst van de MS-Pascal- en Turbo-vertalers -Pascal voor pc. Sindsdien is Pascal een van de belangrijkste en meest gebruikte programmeertalen geworden. Het is veelbetekenend dat de taal al lang voorbij de academische en beperkte professionele interesse gaat en op de meeste universiteiten in hoogontwikkelde landen niet alleen als werkinstrument voor de gebruiker wordt gebruikt. Het belangrijkste kenmerk van Pascal is de belichaming van het idee van gestructureerd programmeren. Een ander belangrijk kenmerk is het concept van datastructuur als een van de fundamentele concepten.

De belangrijkste redenen voor de populariteit van Pascal zijn als volgt:

Door de eenvoud van de taal kunt u deze snel onder de knie krijgen en algoritmisch complexe programma's maken

Ontwikkelde manieren om datastructuren weer te geven zorgen ervoor dat u gemakkelijk kunt werken met zowel numerieke als symbolische en bitinformatie

De aanwezigheid van speciale technieken voor het maken van vertalers van Pascal vereenvoudigde hun ontwikkeling en droeg bij aan de brede verspreiding van de taal

Dankzij de optimaliserende eigenschappen van de vertalers van Pascal kunt u efficiënte programma's maken. Dit was een van de redenen om Pascal als systeemprogrammeertaal te gebruiken

De Pascal-taal implementeert de ideeën van gestructureerd programmeren, waardoor het programma visueel wordt en goede mogelijkheden biedt voor ontwikkeling en foutopsporing

Bell Labs-medewerker Denis Ritchie creëerde de C-taal in 1972 terwijl hij samenwerkte met Ken Thompson als hulpmiddel voor de implementatie van het Unix-besturingssysteem, maar de populariteit van deze taal groeide al snel uit boven de reikwijdte van een specifiek besturingssysteem en specifieke systeemprogrammeertaken. Momenteel kan geen enkel hulpmiddel en besturingssysteem als compleet worden beschouwd als het geen C-taalcompiler bevat. Ritchie vond C niet zomaar uit zijn hoofd uit; het prototype was de B-taal, ontwikkeld door Thompson. De programmeertaal C is ontworpen als hulpmiddel voor praktiserende programmeurs. In overeenstemming hiermee was het belangrijkste doel van de auteur het creëren van een taal die in alle opzichten handig en nuttig was.

C is een tool voor systeemprogrammeurs waarmee je diep in de meest subtiele mechanismen van informatieverwerking op een computer kunt duiken. Hoewel de taal een grote discipline van de programmeur vereist, zijn de formele vereisten niet streng en zijn korte formuleringen mogelijk.

C is een moderne taal. Het omvat de controlestructuren die worden aanbevolen door de programmeertheorie en -praktijk. De structuur ervan moedigt de programmeur aan om top-down ontwerp, gestructureerd programmeren en incrementele moduleontwikkeling in zijn werk te gebruiken.

C is een krachtige en flexibele taal. Het grootste deel van het Unix-besturingssysteem, compilers en tolken van de talen Fortran, Pascal, Lisp en BASIC zijn met zijn hulp geschreven.

C is een handige taal. Het is voldoende gestructureerd om een ​​goede programmeerstijl te ondersteunen zonder te beperkend te zijn. In zekere zin is de C-taal het meest universeel, omdat... Naast een reeks tools die inherent zijn aan moderne programmeertalen op hoog niveau (structuur, modulariteit, bepaalde gegevenstypen), bevat het tools voor programmeren bijna op assembler-niveau. Een groot aantal operators en tools vereisen dat de programmeur voorzichtig en nauwkeurig is en een goede kennis heeft van de taal met al zijn voor- en nadelen.

De taal C++ verscheen begin jaren 80. Gemaakt door Bjarne Stroustrup met het oorspronkelijke doel zichzelf en zijn vrienden te bevrijden van het programmeren in assembler, C of verschillende andere talen op hoog niveau.

Volgens de auteur van de taal is het verschil tussen de ideologie van C en C++ ongeveer het volgende: een C-programma weerspiegelt de ‘denkwijze’ van de processor, en C++ weerspiegelt de denkwijze van de programmeur. C++ voldoet aan de eisen van moderne programmering en legt de nadruk op het ontwikkelen van nieuwe gegevenstypen die het beste passen bij de concepten van het gekozen kennisgebied en de taken van de applicatie. Klasse is een sleutelconcept in C++. De klassebeschrijving bevat een beschrijving van de gegevens die nodig zijn om objecten van dit type weer te geven en een reeks bewerkingen voor het werken met soortgelijke objecten.

In tegenstelling tot traditionele C- en Pascal-structuren bestaan ​​de leden van een klasse niet alleen uit gegevens, maar ook uit functies. Lidfuncties van een klasse hebben bevoorrechte toegang tot gegevens binnen objecten van die klasse en bieden een interface tussen deze objecten en de rest van het programma. Tijdens verder werk is het helemaal niet nodig om de interne structuur van de klasse en het werkingsmechanisme van de ingebouwde functies te onthouden. In die zin is een klas als een elektrisch apparaat: weinig mensen kennen de structuur ervan, maar iedereen weet hoe hij het moet gebruiken.

C++ is een objectprogrammeertaal, een geavanceerde techniek voor programmaontwerp en -implementatie die waarschijnlijk het traditionele procedurele programmeren in het huidige decennium zal vervangen. Het belangrijkste doel van de maker van de taal, Dr. Björn Stroustrup, was om de C++-taal uit te rusten met constructies die de productiviteit van programmeurs zouden verhogen en het proces van het beheersen van grote softwareproducten zouden vergemakkelijken.

Abstractie, implementatie, overerving en polymorfisme zijn de noodzakelijke eigenschappen van de C++-taal, waardoor deze niet alleen universeel is, zoals de C-taal, maar ook een objecttaal. Fortran Fortran is een veelgebruikte taal, vooral onder gebruikers die aan numerieke modellering doen. Dit heeft verschillende redenen:

Het bestaan ​​van enorme hoeveelheden Fortran-applicatieprogramma's die in de loop der jaren zijn opgebouwd, evenals de aanwezigheid van een groot aantal programmeurs die deze taal effectief gebruiken;

De aanwezigheid van effectieve Fortran-vertalers op alle soorten computers, en de versies voor verschillende machines zijn behoorlijk gestandaardiseerd en het overbrengen van programma's van machine naar machine is meestal niet erg moeilijk;

De initiële focus van Fortran lag op fysieke, wiskundige en technische toepassingen; dit kwam met name tot uiting in het feit dat het lange tijd de enige taal bleef met een ingebouwd complex variabelentype en een groot aantal ingebouwde functies voor het werken met dergelijke variabelen.

De afgelopen periode heeft zich een nieuwe methodologie en filosofie van programmeren gevormd. Sinds het begin van de jaren zeventig heeft Fortran terechte kritiek gekregen. In 1977 werd een nieuwe taalstandaard, Fortran 77, aangenomen. Het kostte veel tijd om een ​​nieuwe standaard te creëren, maar nu kunnen we bedenken dat de ontwikkeling ervan is voltooid en dat de nieuwe Fortran-90-standaard de praktijk van Fortran-gebruikers begint te betreden. Alleen op machines zoals IBM PC zijn er verschillende vertalers, bijvoorbeeld Watfor, Lap-Fortran, enz. Maar de meest voorkomende op machines van dit type zijn verschillende versies van de Fortran-77-vertaler. De MS-Fortran 5.0-vertaler, uitgebracht in 1990, voldoet vrijwel volledig aan de Fortran-90-standaard. De meeste belangrijke wetenschappelijke en technische toepassingen zijn in Fortran geschreven omdat het draagbaar en robuust is, en omdat het ingebouwde wiskundige en trigonometrische functies heeft. Een aanvullend, integraal onderdeel van elk Fortran-applicatieprogramma is een uitgebreide grafische bibliotheek waarmee u verschillende grafische gegevens en afbeeldingen kunt gebruiken.

De taal werd voornamelijk tussen 1975 en 1980 gecreëerd als resultaat van een groots project van het Amerikaanse ministerie van Defensie met als doel een uniforme programmeertaal te ontwikkelen voor zogenaamde embedded systemen (d.w.z. besturingssystemen voor geautomatiseerde complexen die in realtime werken). . Dit betekende in de eerste plaats controlesystemen aan boord van militaire objecten (schepen, vliegtuigen, tanks, raketten, granaten, enz.). Daarom mogen de beslissingen van de auteurs van Ada niet als universeel worden beschouwd. Ze moeten worden gezien in de context van de kenmerken van het gekozen vakgebied. De taal van Ada ontstond als resultaat van een internationale competitie van taalprojecten die in 1978-1979 werd gehouden. Deelnemers moesten voldoen aan vrij strenge eisen die tot in detail waren ontwikkeld onder auspiciën van het Amerikaanse ministerie van Defensie. Interessant is dat alle talen die de laatste rondes van deze competitie bereikten, gebaseerd waren op Pascal. In dit opzicht kan Ada voorlopig worden gekarakteriseerd als Pascal, ontwikkeld met inachtneming van de vijf hierboven genoemde basisvereisten. Tegelijkertijd volgden de auteurs vooral het pad van het uitbreiden van Pascal met nieuwe elementen. Het resultaat was een aanzienlijk complexere taal.

COBOL

COBOL is een relatief oude taal die voornamelijk is ontwikkeld voor economisch onderzoek. De taal stelt u in staat effectief met een grote hoeveelheid gegevens te werken en is rijk aan verschillende zoek-, sorteer- en distributiemogelijkheden. Cobol-programma's, gebaseerd op het wijdverbreide gebruik van de Engelse taal, zouden zelfs begrijpelijk zijn voor degenen die Cobol niet spreken, aangezien teksten in deze programmeertaal geen speciaal commentaar behoeven. Dergelijke programma's worden meestal zelfdocumenterend genoemd. Andere voordelen van Cobol zijn meestal de structuur. Voor personal computers zijn behoorlijk krachtige compilers uit deze taal ontwikkeld. Sommige zijn zo effectief dat een programma waarvan fouten op een pc zijn opgelost, gemakkelijk naar mainframecomputers kan worden overgebracht.

Terwijl we de nadelen opsommen, kunnen we niet anders dan bedenken dat in Cobol alleen eenvoudige algebraïsche berekeningen kunnen worden geprogrammeerd. Deze taal is niet geschikt voor technische berekeningen. Een andere reden die de ontwikkeling van de taal tot op zekere hoogte tegenhoudt, is de aanwezigheid in de Verenigde Staten van een speciaal opgericht industriecomité dat normen ontwikkelt, waarvan de naleving wordt gecontroleerd door een overheidscommissie. Zoals altijd gebeurt in dergelijke gevallen, hebben bedrijven die zich bezighouden met softwareontwikkeling geen haast om hun werkstukken aan te passen aan de strenge eisen van de commissie, is er geen concurrentie tussen versies en als gevolg daarvan verliest de verspreiding van de taal

PL/1 werd tussen 1964 en 1965 door IBM ontwikkeld. PL/1 is een van de universele talen, d.w.z. het stelt je in staat problemen uit verschillende gebieden op te lossen: numerieke berekeningen, tekstverwerking, economische problemen, enz. Wat de mogelijkheden betreft, overlapt het talen zoals Fortran, ALGOL-60 (gemaakt voor numerieke berekeningen), Cobol (voor economische problemen), hoewel PL/1 deze talen om een ​​aantal redenen niet kon vervangen.

PL/1 bevat alle basisconstructies die kenmerkend zijn voor zogenaamde talen op hoog niveau, evenals een aantal specifieke hulpmiddelen die handig zijn voor praktisch programmeren. De taal lijkt op een bouwpakket met een groot aantal details: de gebruiker hoeft alleen die delen van de taal onder de knie te krijgen die voor hem praktisch noodzakelijk zijn. De operators zijn vrij beknopt, waardoor het programma vaak compacter kan worden geschreven dan in andere talen. Een programmeur die PL/1 kent, kan gemakkelijk elke andere taal van dezelfde of vergelijkbare klasse beheersen.

Tegelijkertijd heeft PL/1 ook een aantal nadelen die het leren en gebruiken van de taal lastig maken. De belangrijkste zijn als volgt. Ten eerste zijn er veel tools die elkaar dupliceren, ze zijn moeilijk te onthouden, het is niet duidelijk wat je moet gebruiken als dit bovendien zowel de vertaalsnelheid als de snelheid van de programma-uitvoering vermindert. Ten tweede zijn de programma's niet volledig machine-onafhankelijk.

Module

We kunnen bedenken dat de geschiedenis van de Modula-taal begint in 1980, toen Niklaus Wirth, een van de vooraanstaande informatietheoretici, bij de meeste computerwetenschappers vooral bekend als de schepper van de Pascal-taal, een beschrijving publiceerde van een nieuwe programmeertaal, die hij genaamd Modula. In tegenstelling tot Pascal, dat bedoeld was als taal voor programmeeronderwijs, was Modula vanaf het allereerste begin een taal voor professionele systeemprogrammeurs, die de beste tradities van zijn voorganger voortzette en deze verrijkte met nieuwe ideeën die voldoen aan de eisen voor programmeertalen zoals zoals structuur, modulariteit en uitbreidingsvermogen. Net als veel andere programmeertalen onderging Modula een evolutie, waarbij de oorspronkelijke naam werd omgevormd tot de naam Modula-2. Gelijktijdig met de ontwikkeling van de Modula-taal werden er nieuwe compilers voor gemaakt, maar geen van hen kon concurreren met de beste implementaties van de Pascal- en C-talen, bijvoorbeeld ontwikkeld door Borland. Tijdens deze overgangsperiode voor de Modula-taal werden de beste implementaties beschouwd als die van Logitech, waarvan de kenmerken inferieur waren aan die van Turbo Pascal en Turbo C. Pas in 1988, nadat het Top Speed-systeem op de Amerikaanse markt verscheen, nam Modula-2 zijn rechtmatige plaats in onder de proceduretalen bedoeld voor systeemprogrammering. Verschillende factoren hebben bijgedragen aan de groeiende populariteit van het Top Speed-systeem: een handige en bovendien gemakkelijk te wijzigen besturingsomgeving op verzoek van gebruikers, een snelle compiler en een selectieve link-editor. Maar het belangrijkste bleek te zijn dat de gemaakte programma's snel waren en niet veel geheugenruimte in beslag namen.

BASIS

BASIC (Basic - Symbolische instructiecode voor alle doeleinden voor beginners - "universele symbolische instructiecode voor beginners"). Een directe afstammeling van Fortran en nog steeds de meest populaire programmeertaal voor personal computers. BASIC verscheen in 1963 (het zou moeilijk zijn om de auteur te noemen, maar de belangrijkste eer voor zijn verschijning komt ongetwijfeld toe aan de Amerikanen John Kemeny en Thomas Kurtz). Zoals alle voordelen veranderde de eenvoud van BASIC in structurerende problemen, vooral in de vroege versies; Bovendien stond BASIC geen recursie toe - een interessante techniek waarmee je effectieve en tegelijkertijd korte programma's kunt schrijven.

Er zijn krachtige BASIC-compilers ontwikkeld, die niet alleen een rijke woordenschat en hoge prestaties bieden, maar ook de mogelijkheid tot gestructureerd programmeren. Volgens sommige programmeurs zijn de meest interessante versies GWBASIC, Turbo-Basic en Quick Basic.

Ooit markeerde de verschijning van Quick Basic de geboorte van de tweede generatie programmeersystemen in de BASIC-taal. Het bood de mogelijkheid tot modulair en procedureel programmeren, het creëren van bibliotheken, het samenstellen van kant-en-klare programma's, enz., waardoor het op het niveau kwam van klassieke programmeertalen als C, Pascal, Fortran, enz. Bovendien, vanwege het ontbreken van een officiële BASIC-taalstandaard, is de implementatie ervan in de vorm van Quick Basic de de facto standaard geworden. De onbetwiste leiders onder de verschillende versies van BASIC waren Quick Basic 4.5 en PDS 7.1 van Microsoft, die eind jaren 80 verschenen.

Lisp

De Lisp-taal werd in 1960 voorgesteld door J. McCarthy en is gericht op het ontwikkelen van programma's voor het oplossen van niet-numerieke problemen. De Engelse naam van deze taal, LISP, is een afkorting voor de uitdrukking LISt Processing (lijstverwerking) en benadrukt goed het belangrijkste toepassingsgebied ervan. Het concept van "lijst" bleek zeer ruim te zijn. Het is handig om algebraïsche uitdrukkingen, grafieken, elementen van eindige groepen, verzamelingen, gevolgtrekkingsregels en vele andere complexe objecten in de vorm van lijsten weer te geven. Lijsten zijn de meest flexibele vorm van weergave van informatie in het computergeheugen. Het is daarom niet verrassend dat een handige taal die speciaal is ontworpen voor het verwerken van lijsten snel aan populariteit heeft gewonnen.

Na de verschijning van Lisp hebben verschillende auteurs een aantal andere algoritmische talen voorgesteld die gericht zijn op het oplossen van problemen op het gebied van kunstmatige intelligentie, waaronder Planner, Snoball, Refal, Prolog. Dit belette echter niet dat Lisp de meest populaire taal bleef voor het oplossen van dergelijke problemen. In de bijna veertigjarige geschiedenis van haar bestaan ​​zijn er een aantal dialecten van deze taal verschenen: Common LISP, Mac LISP, Inter LISP, Standard LISP, enz. De verschillen daartussen zijn niet fundamenteel en komen vooral neer op een iets andere taal. reeks ingebouwde functies en enig verschil in de notatievormprogramma's. Daarom kan een programmeur die met een van deze heeft leren werken, gemakkelijk een andere onder de knie krijgen. Het grote voordeel van Lisp is de functionele oriëntatie, d.w.z. het programmeren gebeurt met behulp van functies. Bovendien wordt een functie opgevat als een regel die elementen van een bepaalde klasse matcht met de overeenkomstige elementen van een andere klasse. Het matchingproces zelf heeft geen enkel effect op de werking van het programma; alleen het resultaat ervan is belangrijk: de waarde van de functie. Dit maakt het relatief eenvoudig om grote softwaresystemen te schrijven en te debuggen. De duidelijkheid van programma's, een duidelijke afbakening van hun functies en de afwezigheid van lastige bijwerkingen tijdens de uitvoering ervan zijn verplichte vereisten voor het programmeren van zulke logisch complexe taken als die van kunstmatige intelligentie. Discipline bij het programmeren wordt vooral belangrijk als niet slechts één persoon, maar een hele groep programmeurs aan een programma werkt.

De programmeertaal Lisp is voornamelijk ontworpen voor het verwerken van symbolische informatie. Daarom is het logisch dat getallen in de wereld van Lisp verre van de hoofdrol spelen. De basisgegevenstypen in Lisp worden atoom- en puntpaar genoemd.

Proloog

Een logische programmeertaal is ontworpen om kennis over een bepaald vakgebied weer te geven en te gebruiken. Programma's in deze taal bestaan ​​uit een bepaalde reeks relaties, en de uitvoering ervan wordt gereduceerd tot het afleiden van een nieuwe relatie op basis van de gegeven relaties. Prolog implementeert een declaratieve benadering, waarbij het voldoende is om een ​​probleem te beschrijven met behulp van regels en uitspraken over bepaalde objecten. Als deze beschrijving voldoende nauwkeurig is, kan de computer zelfstandig de gewenste oplossing vinden.

Object PAL

Object PAL is een krachtige programmeertaal. Object PAL is een objectgeoriënteerde, gebeurtenisgestuurde, visuele programmeertaal. Op het initiële niveau van de Object PAL-functionaliteit kunt u gegevensbewerkingen uitvoeren, speciale menu's maken en een gegevensinvoersessie beheren. Gebeurtenissen in Object PAL genereren opdrachten die het effect van interactief gebruik van Paradox simuleren. Het is mogelijk om veel voorkomende taken te automatiseren, maar ook om acties uit te voeren op tabellen, formulieren en rapporten die tijdens interactief werken niet beschikbaar waren. Object PAL biedt ook alle functies van een volledig uitgeruste programmeertaal in de Windows-omgeving. U kunt Object PAL gebruiken om complete systemen te creëren die een speciaal menusysteem, een helpsysteem en verschillende gegevenscontroles implementeren. In Object PAL kunt u uw werk opslaan in een dynamisch gekoppelde bibliotheek, die via verschillende formulieren toegankelijk is. Bovendien kunt u koppelingen tot stand brengen met andere dynamische bibliotheken die programma's bevatten die zijn geschreven in talen als C, C++ of Pascal.

Object PAL kan worden gebruikt als hulpmiddel voor het maken van zelfstandige programma's. U kunt een volledige Windows-applicatie schrijven en deze uitvoeren onder Paradox.

Object PAL ondersteunt een dynamisch gegevensuitwisselingsmechanisme als zowel client als server. Bovendien ondersteunt Object PAL een mechanisme om als client met samengestelde documenten te werken. Naast bovenstaande is het mogelijk om multimedia in uw applicatie op te nemen door de draaiende applicatie te voorzien van geluids- en animatie-effecten.

Borlands implementatie van de dBase-taal is een succesvolle hybride van objectoriëntatie en traditionele programmeermethoden. Het maakte de creatie mogelijk van systemen met behulp van objectontwerp en het gebruik van conventionele technieken voor recordverwerking. De grote prestatie van het bedrijf Borland was dat het op zeer succesvolle wijze object- en procedurele programmeertechnieken combineerde. De eerste versie voor Windows gaf de gebruiker het krachtigste objectgebaseerde hulpmiddel op de markt voor databasesoftware. Hiermee kunt u nieuwe klassen objecten maken die de eigenschappen overerving, inkapseling en polymorfisme hebben. U kunt deze objecten ook programmeren met traditionele dBase-opdrachten, ideaal voor het beheren van eenvoudige tabellarische databases. Dit alles levert een onmiskenbaar voordeel op: het zonder veel moeite uitvoeren van de overgang naar objectprogrammeringstechnieken, een overgang die bijvoorbeeld zo moeilijk is als in het Paradox DBMS.

De Java-taal is ontstaan ​​als onderdeel van een project om geavanceerde software voor verschillende huishoudelijke apparaten te maken. Het project werd gestart in C++, maar er ontstonden al snel een aantal problemen. De beste manier om dit te bestrijden was door het gereedschap zelf te veranderen: de programmeertaal. Het werd duidelijk dat er een platformonafhankelijke programmeertaal nodig was, waardoor programma's konden worden gemaakt die niet voor elke architectuur afzonderlijk hoefden te worden gecompileerd en die op verschillende processors onder verschillende besturingssystemen konden worden gebruikt. De Java-taal was nodig om interactieve producten voor internet te maken. In feite werden de meeste architectonische beslissingen die bij het maken van Java werden genomen, ingegeven door de wens om een ​​syntaxis te bieden die vergelijkbaar is met C en C++. Java gebruikt vrijwel identieke conventies voor het declareren van variabelen, het doorgeven van parameters, het doorgeven van operators en voor het controleren van de stroom van code-uitvoering. Java voegt alle goede eigenschappen van C++ toe.

Drie sleutelelementen komen samen om de Java-taaltechnologie te vormen

Java biedt wijdverbreid gebruik van zijn applets: kleine, robuuste, dynamische, platformonafhankelijke actieve netwerkapplicaties die zijn ingebed in webpagina's. Java-applets kunnen net zo eenvoudig worden aangepast en gedistribueerd naar consumenten als elk ander HTML-document.

Java ontketent de kracht van objectgeoriënteerde applicatieontwikkeling door eenvoudige, vertrouwde syntaxis te combineren met een robuuste, gebruiksvriendelijke ontwikkelomgeving. Hierdoor kan een breed scala aan programmeurs snel nieuwe programma's en nieuwe applets maken.

Java biedt de programmeur een uitgebreide set objectklassen om veel van de systeemfuncties die worden gebruikt bij windowing, netwerken en I/O duidelijk te abstraheren. Het belangrijkste kenmerk van deze klassen is dat ze platformonafhankelijke abstracties bieden voor een breed scala aan systeeminterfaces.

Programmeertalen voor computernetwerken

Programmeertalen voor computernetwerken worden geïnterpreteerd. Tolken voor hen worden gratis verspreid en de programma's zelf zijn in de broncode. Dergelijke talen worden scripttalen genoemd.

Perl is een geïnterpreteerde taal gemaakt door programmeur Larry Wall voor het verwerken van grote teksten en bestanden en staat voor Practical Extraction and Report Language. Met Perl kunt u bijvoorbeeld een script maken dat een of meer bestanden opent, de informatie verwerkt en de resultaten schrijft.

Perl is een taal die is aangepast voor het verwerken van willekeurige tekstbestanden, het extraheren van de nodige informatie daaruit en het uitgeven van berichten. Perl is ook handig voor het schrijven van verschillende systeemprogramma's. Deze taal is gemakkelijk te gebruiken en efficiënt, maar het is moeilijk te zeggen dat hij elegant en compact is. De syntaxis van Perl-expressies ligt dicht bij de syntaxis van C. Recursie kan een willekeurige diepte hebben. Hoewel Perl is ontworpen om tekstbestanden te scannen, kan het ook binaire gegevens verwerken. Met Perl kunt u reguliere expressies gebruiken, objecten maken, stukjes Perl-code in een C- of C++-programma invoegen en heeft u ook toegang tot databases, waaronder Oracle.

Met de uitvinding van het World Wide Web bleek Perl een uitstekend hulpmiddel te zijn voor interactie met webservers via de Common Gateway Interface (CGI). Perl-opdrachten kunnen gemakkelijk gegevens uit een HTML-formulier of een andere bron halen en er een actie op uitvoeren.

Taal PHP(1995-1997) beschikt over tools voor databasetoegang en wordt gebruikt door makers van dynamische sites over de hele wereld.

Taal Tcl/Tk(eind jaren 80) bestaat uit krachtige opdrachten die zijn ontworpen om met abstracte, ongetypeerde objecten te werken en stelt u in staat programma's te maken met een grafische interface.

Taal VRML(1994) is gemaakt om virtuele driedimensionale interfaces op internet te organiseren.

Taal XML. Sinds 1996 wordt gewerkt aan het creëren van een universele documentstructuurtaal. Kan een vervanging worden voor HTML.

Conclusie

Nuttige bronnen

Review door Aizili

Waar is het rapport?

Recensie Ranifka

Re: Waar is het rapport?
Alles zal zijn :-D

Review door Shamagulova Elite

Recensie door Mishina Alexandra

Uitstekend rapport. Veel nieuwe dingen geleerd over programmeertalen.

Recensie door Alexandra Morozova

Natuurlijk zou ik graag een rapport zien, of in ieder geval een presentatie in welke vorm dan ook.

Voordat je een programmeertaal wilt leren, moet je iets weten over hun geschiedenis en waar ze worden gebruikt.

Ik presenteer u een kort overzicht van 25 bekende programmeertalen. Beginnend van de meest bekende tot de minst populaire. Het artikel is gemaakt voor beginners op het gebied van programmeren. Je kunt over elke taal lezen en degene kiezen die je het leukst vindt om te studeren.

Voordat je programmeertalen gaat leren, raad ik je aan een cursus .

1. JavaScript

Prototypegerichte scripting-programmeertaal. JavaScript is oorspronkelijk gemaakt om webpagina’s ‘levend’ te maken. In de browser maken ze rechtstreeks verbinding met de HTML en zodra de pagina wordt geladen, worden ze onmiddellijk uitgevoerd.

Toen JavaScript werd gemaakt, had het oorspronkelijk een andere naam: ‘LiveScript’. Maar toen was de Java-taal erg populair, en marketeers besloten dat een soortgelijke naam de nieuwe taal populairder zou maken.

Het was de bedoeling dat JavaScript een soort ‘klein broertje’ van Java zou worden. De geschiedenis heeft echter zijn eigen weg, JavaScript is enorm gegroeid en nu is het een volledig onafhankelijke taal, met zijn eigen specificatie en heeft niets met Java te maken.

2. Java

Een sterk getypeerde objectgeoriënteerde programmeertaal. Java-applicaties worden doorgaans vertaald naar aangepaste bytecode, zodat ze op elke computerarchitectuur kunnen worden uitgevoerd met behulp van de Java Virtual Machine.

Het voordeel van deze methode voor het uitvoeren van programma's is de volledige onafhankelijkheid van de bytecode van het besturingssysteem en de hardware, waardoor u Java-applicaties kunt uitvoeren op elk apparaat waarvoor een overeenkomstige virtuele machine bestaat. Een ander belangrijk kenmerk van de Java-technologie is het flexibele beveiligingssysteem, waarbij de programma-uitvoering volledig wordt gecontroleerd door de virtuele machine.

De taal heette oorspronkelijk Oak en werd ontwikkeld door James Gosling voor het programmeren van consumentenelektronica. Het werd later omgedoopt tot Java en werd gebruikt om clientapplicaties en serversoftware te schrijven.

3.PHP

Het is een veel voorkomende, open-source, geïnterpreteerde taal voor algemene doeleinden (scripttaal). PHP is speciaal gemaakt voor webontwikkeling en de code ervan kan rechtstreeks in HTML-code worden ingesloten. De syntaxis van de taal komt uit C, Java en Perl en is gemakkelijk te leren.

Het belangrijkste doel van PHP is om webontwikkelaars de mogelijkheid te bieden om snel dynamisch gegenereerde webpagina's te maken, maar de reikwijdte van PHP is hiertoe niet beperkt.

4. Python

Een hoogwaardige programmeertaal voor algemene doeleinden, gericht op het verhogen van de productiviteit van ontwikkelaars, de leesbaarheid van code en de ontwikkeling van webapplicaties. De kernsyntaxis van Python is minimalistisch. Code in Python is georganiseerd in functies en klassen, die kunnen worden gecombineerd tot modules.

5. C#

Objectgeoriënteerde programmeertaal. Ontwikkeld in 1998-2001 door een groep ingenieurs onder leiding van Anders Hejlsberg bij Microsoft als applicatie-ontwikkeltaal voor het Microsoft .NET Framework. C# behoort tot een taalfamilie met een C-achtige syntaxis, waarvan de syntaxis het meest lijkt op C++ en Java.

De taal heeft statisch typen, ondersteunt polymorfisme, overbelasting van operators, afgevaardigden, attributen, gebeurtenissen, eigenschappen, generieke typen en methoden, iterators, anonieme functies met ondersteuning voor sluitingen, LINQ, uitzonderingen, opmerkingen in XML-formaat.

6. C++

Een gecompileerde, statisch getypeerde programmeertaal voor algemene doeleinden. Het is een van de meest gesproken talen ter wereld. Google Chrome, Mozilla Firefox, Winamp en de Adobe-productlijn zijn ontwikkeld met behulp van C++. Bovendien zijn sommige moderne games en besturingssystemen in C++ ontwikkeld vanwege de snelle verwerking en compilatie.

7. Robijn

Een eenvoudige en leesbare programmeertaal gericht op het ontwikkelen van webapplicaties. Ontworpen door Yukihiro Matsumto in 1995. De taal heeft een besturingssysteemonafhankelijke implementatie van multithreading, strikt dynamisch typen en een garbage collector.

Het hoofddoel van Ruby is het creëren van eenvoudige en tegelijkertijd begrijpelijke programma's, waarbij niet de snelheid van het programma belangrijk is, maar de korte ontwikkeltijd, duidelijkheid en eenvoud van de syntaxis. De taal volgt het principe van "minste verrassing": het programma moet zich gedragen zoals de programmeur verwacht.

8.CSS

Cascading Style Sheets zijn een formele taal voor het beschrijven van het uiterlijk van een document dat is geschreven met behulp van een opmaaktaal.
Het wordt voornamelijk gebruikt als middel om het uiterlijk van webpagina's te beschrijven en te ontwerpen die zijn geschreven met HTML- en XHTML-opmaaktalen, maar kan ook worden toegepast op alle XML-documenten.

9.C

Een gecompileerde, statisch getypeerde programmeertaal voor algemene doeleinden. De C-taal werd in 1972 ontwikkeld door Dennis Ritchie bij Bell Labs. Het is de voorloper van programmeertalen als C++, Java, C#, JavaScript en Perl. Om deze reden leidt het leren van deze taal tot het begrijpen van andere talen. De C-taal wordt gebruikt voor het ontwikkelen van applicaties op laag niveau, omdat deze wordt beschouwd als het dichtst bij hardware.

10. Doelstelling-C

Een gecompileerde objectgeoriënteerde programmeertaal die wordt gebruikt door Apple Corporation, gebouwd op de C-taal en Smalltalk-paradigma's. De Objective-C-taal is een superset van de C-taal, dus C-code is volledig begrijpelijk voor de Objective-C-compiler. De taal wordt voornamelijk gebruikt voor Mac OS X (Cocoa) en GNUstep - implementaties van de objectgeoriënteerde OpenStep-interface. De taal wordt ook gebruikt voor iOS (Cocoa Touch).

11. Schelp

Het is niet zozeer een taal als wel een commandotolk (commandotaal). De scripts worden gebruikt om software-updates te automatiseren. Bevat standaardconstructies voor lussen, vertakkingen en functiedeclaraties. De UNIX-familie van besturingssystemen gebruikt SHELL als de standaard taakcontroletaal.

12. R

Een programmeertaal voor de verwerking van statistische gegevens en grafische afbeeldingen, en een gratis, open-source computeromgeving onder het GNU-project. R wordt veel gebruikt als statistische software voor data-analyse en is de de facto standaard geworden voor statistische programma's. R gebruikt een opdrachtregelinterface.

13. Perl

Een op hoog niveau geïnterpreteerde dynamische programmeertaal voor algemene doeleinden. De naam van de taal is een acroniem dat staat voor Practical Extraction and Report Language – “een praktische taal voor het extraheren van gegevens en het schrijven van rapporten.” Het belangrijkste kenmerk van de taal zijn de rijke mogelijkheden voor het werken met tekst, inclusief het werken met reguliere expressies die in de syntaxis zijn ingebouwd. Momenteel wordt het gebruikt voor een breed scala aan taken, waaronder systeembeheer, webontwikkeling, netwerkprogrammering, games, bio-informatica en de ontwikkeling van grafische gebruikersinterfaces.

14. Schaal

Een programmeertaal met meerdere paradigma's, ontworpen om beknopt en typeveilig te zijn voor het eenvoudig en snel creëren van op componenten gebaseerde software, waarbij de mogelijkheden van functioneel en objectgeoriënteerd programmeren worden gecombineerd. Scala-programma's lijken in veel opzichten op Java-programma's en kunnen vrijelijk communiceren met Java-code.

15.Ga

Een gecompileerde multi-threaded programmeertaal ontwikkeld door Google. De Go-taal is ontwikkeld als systeemprogrammeertaal voor het maken van zeer efficiënte programma's die draaien op moderne gedistribueerde systemen en multi-coreprocessors. Het kan worden gezien als een poging om een ​​vervanging voor de C-taal te creëren. Tijdens de ontwikkeling werd speciale aandacht besteed aan het garanderen van een zeer efficiënte compilatie. Go-programma's worden gecompileerd in objectcode en vereisen geen virtuele machine om uit te voeren.

16.SQL

Gestructureerde querytaal. een formele, niet-procedurele programmeertaal die wordt gebruikt om gegevens te creëren, wijzigen en manipuleren in een willekeurige relationele database die wordt beheerd door een geschikt databasebeheersysteem. SQL is in de eerste plaats een logische informatietaal die is ontworpen voor het beschrijven, wijzigen en ophalen van gegevens die zijn opgeslagen in relationele databases. Elke SQL-instructie is een verzoek om gegevens uit de database of een aanroep naar de database die ervoor zorgt dat gegevens in de database veranderen.

17. Haskell

Een gestandaardiseerde, pure, functionele programmeertaal voor algemene doeleinden. Het is een van de meest voorkomende programmeertalen met ondersteuning voor lazy computing. Een onderscheidend kenmerk van de taal is de serieuze houding ten opzichte van typen. Haskell is een uitstekende taal voor het leren en experimenteren met complexe functionele gegevenstypen.

18. Snel

Een open multi-paradigma gecompileerde programmeertaal voor algemene doeleinden. Swift is door Apple gemaakt, voornamelijk voor iOS- en OS X-ontwikkelaars, werkt met de Cocoa- en Cocoa Touch-frameworks en is compatibel met Apple's belangrijkste Objective-C-codebasis. Swift was bedoeld als een gemakkelijker leesbare en foutbestendigere taal dan zijn voorganger, Objective-C. Swift leent nogal wat van Objective-C, maar het wordt niet gedefinieerd door pointers, maar door de soorten variabelen die de compiler verwerkt. Veel scripttalen werken volgens een soortgelijk principe.

19. Matlab

Een op hoog niveau geïnterpreteerde programmeertaal die matrixgebaseerde datastructuren, een breed scala aan functies, een geïntegreerde ontwikkelomgeving, objectgeoriënteerde mogelijkheden en interfaces naar programma's die in andere programmeertalen zijn geschreven, omvat. Programma's geschreven in MATLAB zijn van twee typen: functies en scripts. Functies hebben invoer- en uitvoerargumenten, evenals een eigen werkruimte voor het opslaan van tussentijdse berekeningsresultaten en variabelen. Scripts gebruiken een gemeenschappelijke werkruimte. Zowel scripts als functies worden opgeslagen als tekstbestanden en dynamisch gecompileerd in machinecode.

20. Visuele basis

Een programmeertaal en geïntegreerde softwareontwikkelomgeving ontwikkeld door Microsoft Corporation. De Visual Basic-taal erfde de geest, stijl en syntaxis van zijn voorvader: de BASIC-taal, die veel dialecten kent. Tegelijkertijd combineert Visual Basic de procedures en elementen van objectgeoriënteerde en componentgeoriënteerde programmeertalen.

Visual Basic is ook een goed hulpmiddel voor het snel ontwikkelen van RAD-databasetoepassingen voor Microsoft Windows-besturingssystemen. Veel kant-en-klare componenten die bij de omgeving worden geleverd, zijn ontworpen om de programmeur te helpen onmiddellijk te beginnen met het ontwikkelen van de bedrijfslogica van de applicatie, zonder zijn aandacht af te leiden naar het schrijven van programma-lanceringscode.

21. Delphi

Een imperatieve, gestructureerde, objectgeoriënteerde programmeertaal met sterke statische variabele-typering. Het belangrijkste toepassingsgebied is het schrijven van applicatiesoftware.

Tegenwoordig is het, naast ondersteuning voor de ontwikkeling van 32- en 64-bit-programma's voor Windows, mogelijk om applicaties te maken voor Apple Mac OS X, maar ook voor Google Android (rechtstreeks uitgevoerd op een ARM-processor).

22. Hip

Een objectgeoriënteerde programmeertaal ontworpen voor het Java-platform als aanvulling op de Java-taal met Python-, Ruby- en Smalltalk-mogelijkheden. Groovy gebruikt een Java-achtige syntaxis met dynamische compilatie in JVM-bytecode en werkt rechtstreeks met andere Java-code en -bibliotheken. De taal kan in elk Java-project of als scripttaal worden gebruikt.

23. Visual Basic.NET

Een objectgeoriënteerde programmeertaal, die kan worden beschouwd als de volgende evolutieronde van Visual Basic, geïmplementeerd op het Microsoft .NET-platform. VB.NET is niet achterwaarts compatibel met een eerdere versie (Visual Basic 6.0). Ontwikkeling van projecten van oudere versies (*.vbp) is alleen mogelijk na hun voorlopige conversie naar het VB.NET-formaat door een speciale wizard (Migration Wizard); Na de conversie is echter een aanzienlijke handmatige wijziging van de teksten vereist.

24.D

Een multi-paradigma gecompileerde programmeertaal gemaakt door Walter Bright van Digital Mars. D is oorspronkelijk bedoeld als een re-engineering van de C++-taal, maar ondanks de aanzienlijke invloed van C++ is het er geen variant van. De taal werd ook beïnvloed door concepten uit de programmeertalen Python, Ruby, C#, Java en Eiffel.

25. Monteur

Een machinegeoriënteerde taal op laag niveau met opdrachten die niet altijd overeenkomen met machineopdrachten, die extra functies kan bieden, zoals macro's; autocode uitgebreid met programmeertaalconstructies op hoog niveau, zoals expressies, macro's en middelen om programmamodulariteit te garanderen.

Assembleertaal is een notatiesysteem dat wordt gebruikt om programma's die in machinecode zijn geschreven in voor mensen leesbare vorm weer te geven. Met assembleertaal kan de programmeur alfabetische geheugensteuncodes gebruiken, naar eigen goeddunken symbolische namen toewijzen aan computerregisters en geheugen, en ook adresseringsschema's instellen die voor hemzelf handig zijn. Bovendien maakt het het gebruik van verschillende nummersystemen mogelijk om numerieke constanten weer te geven en biedt het de mogelijkheid om programmaregels te labelen met symbolische namen, zodat er naar kan worden verwezen.

Ik heb niet alle talen gevolgd omdat... ze zijn niet zozeer in trek bij professionele programmeurs. Mijn taak is voltooid, nu hoef je alleen nog maar de juiste taal te kiezen en deze te overwinnen. Veel succes voor u bij uw inspanningen.

Naast het gebruik van commentaar om een ​​parallel programma te verkrijgen, breiden ze vaak bestaande programmeertalen uit. Er worden extra operators en nieuwe elementen voor het beschrijven van variabelen geïntroduceerd, waardoor de gebruiker expliciet de parallelle structuur van het programma kan definiëren en, in sommige gevallen, de uitvoering van het parallelle programma kan controleren. Zo bevat de High Performance Fortran (HPF)-taal, naast de traditionele Fortran-operators en het speciale commentaarsysteem, een nieuwe FORALL-operator, geïntroduceerd om parallelle programmalussen te beschrijven. Het meest interessante kenmerk van HPF is de mapping-array op meerdere niveaus - template-array - virtuele processor-array - fysieke processors, die maximale flexibiliteit mogelijk maakt bij het weergeven van gebruikersgegevens op een echte computer.

Een ander voorbeeld is de mpC-taal, ontwikkeld door het Institute of System Programming van de Russische Academie van Wetenschappen als een uitbreiding van ANSI C. Het belangrijkste doel van mpC is het creëren van efficiënte parallelle programma's voor heterogene computersystemen. De gebruiker kan de netwerktopologie, gegevens- en berekeningsdistributie en de vereiste gegevensoverdrachten specificeren. Het verzenden van berichten wordt georganiseerd met behulp van de MPI-interface.

Het DVM-systeem is ontworpen om draagbare en efficiënte computertoepassingen te creëren in de talen C-DVM en Fortran-DVM voor parallelle computers met verschillende architecturen. De afkorting DVM komt overeen met twee concepten: gedistribueerd virtueel geheugen en gedistribueerde virtuele machine. De eerste weerspiegelt de aanwezigheid van een enkele adresruimte. De tweede weerspiegelt het gebruik van virtuele machines voor een tweefasenschema voor het toewijzen van gegevens en berekeningen aan een echte parallelle machine. Het programmeermodel omvat het specificeren van DVM-instructies met behulp van speciale opmerkingen, wat betekent dat er één versie van het programma is voor sequentiële en parallelle uitvoering. Er worden drie groepen richtlijnen ondersteund: richtlijnen voor gegevensdistributie, richtlijnen voor berekeningsdistributie en specificaties voor externe gegevens. De compiler vertaalt het programma naar Fortran- of C-taal, waarbij gebruik wordt gemaakt van een van de bestaande parallelle programmeertechnologieën (MPI, PVM, Router) om de interactie tussen processors te organiseren. Het DVM-systeem omvat ook de LIB-DVM-ondersteuningsbibliotheek, een DVM-debugger, een DVM-programma-uitvoeringsvoorspeller en een DVM-programmaprestatieanalysator. Het systeem is ontwikkeld op het vernoemde Instituut voor Toegepaste Wiskunde. M.V.Keldysh RAS.

Speciale programmeertalen

Als het nodig is om de specifieke kenmerken van de architectuur van parallelle systemen of de eigenschappen van een bepaalde klasse van problemen in een bepaald vakgebied nauwkeuriger weer te geven, dan worden speciale parallelle programmeertalen gebruikt. De Occam-taal is gemaakt voor het programmeren van transputersystemen, en de taal met één toewijzing Sisal is ontworpen voor het programmeren van streammachines. Een zeer interessante en originele ontwikkeling is de declaratieve taal NORM, gecreëerd onder leiding van I.B. MVKeldysh RAS om de oplossing van rekenproblemen te beschrijven met behulp van rastermethoden. Dankzij het hoge abstractieniveau van de taal kun je problemen beschrijven in een notatie die dicht bij de oorspronkelijke formulering van het probleem door een wiskundige ligt, wat de auteurs van de taal gewoonlijk programmeren zonder programmeur noemen. Een taal met één toewijzing bevat geen traditionele programmeertaalconstructies die de volgorde van berekening vastleggen en daardoor de natuurlijke parallelliteit van het algoritme verbergen.

Bibliotheken en interfaces die de interactie tussen parallelle processen ondersteunen

Met de komst van massaal parallelle computers zijn bibliotheken en interfaces die de interactie van parallelle processen ondersteunen wijdverbreid geworden. Een typische vertegenwoordiger van deze richting is de Message Passing Interface (MPI), waarvan de implementatie beschikbaar is op vrijwel elk parallel platform, variërend van supercomputers met vectorpijplijnen tot clusters en netwerken van personal computers. De programmeur bepaalt zelf expliciet welke parallelle applicatieprocessen op welke plaats van het programma en waarmee processen gegevens moeten uitwisselen of hun werk moeten synchroniseren. Meestal zijn de adresruimten van parallelle processen verschillend. Met name MPI en PVM volgen deze ideologie. Andere technologieën, zoals Shmem, maken het gebruik van zowel lokale (privé) variabelen als gedeelde (gedeelde) variabelen mogelijk die toegankelijk zijn voor alle applicatieprocessen, en implementeren een schema voor het werken met gedeeld geheugen met behulp van Put/Get-bewerkingen.

Het Linda-systeem onderscheidt zich enigszins door het toevoegen van slechts vier extra functies in, uit, lezen en evalueren aan elke sequentiële taal, waardoor je parallelle programma's kunt maken. Helaas leidt de eenvoud van het onderliggende idee tot grote problemen bij de implementatie, waardoor deze prachtige technologie meer een object van academisch belang wordt dan een praktisch hulpmiddel.

Parallelle onderwerpbibliotheken

In de praktijk gebruiken applicatieprogrammeurs vaak helemaal geen expliciete parallelle constructies, maar wenden ze zich tot subroutines en functies van parallelle onderwerpbibliotheken in tijdkritische fragmenten. Alle parallelliteit en alle optimalisatie zijn verborgen in oproepen, en de gebruiker kan alleen het externe deel van zijn programma schrijven en standaardblokken vakkundig gebruiken. Voorbeelden van dergelijke bibliotheken zijn Lapack, ScaLapack, Cray Scientific Library, HP Mathematical Library, PETSc en vele anderen.

Enkele parallelle onderwerpbibliotheken

BLAS en LAPACK zijn bibliotheken die elementaire lineaire algebra-bewerkingen implementeren, zoals matrixvermenigvuldiging, matrix-vectorvermenigvuldiging, enz.

ScaLAPACK bevat een subset van LAPACK-procedures die opnieuw zijn ontworpen voor gebruik op MPP-computers, waaronder: het oplossen van systemen van lineaire vergelijkingen, matrixinversie, orthogonale transformaties, zoeken naar eigenwaarden, enz.

FFTW, DFFTPack - snelle Fourier-transformatie.

PETSc is een reeks procedures en datastructuren voor het parallel oplossen van wetenschappelijke problemen met modellen die worden beschreven in de vorm van partiële differentiaalvergelijkingen.

Gespecialiseerde pakketten en softwaresystemen

En tenslotte is het laatste gebied dat het vermelden waard is het gebruik van gespecialiseerde pakketten en softwaresystemen. Meestal hoeft de gebruiker in dit geval helemaal niet te programmeren. De hoofdtaak is om alle benodigde invoergegevens correct te specificeren en de functionaliteit van het pakket correct te gebruiken. Veel scheikundigen gebruiken het GAMESS-pakket dus om kwantumchemische berekeningen uit te voeren op parallelle computers, zonder na te denken over hoe parallelle gegevensverwerking in het pakket zelf wordt geïmplementeerd.

GPU's worden nu steeds vaker gebruikt om computerproblemen op te lossen, maar de vraag staat nog steeds open: hoe schrijf je effectieve programma's voor de juiste configuraties?

15/06/2011 Andrej Adinets

GPU's worden nu steeds vaker gebruikt om computerproblemen op te lossen, maar de vraag staat nog steeds open: hoe schrijf je effectieve programma's voor de juiste configuraties? Met de standaardoplossing - een combinatie van CUDA of OpenCL - kun je het algoritme relatief snel implementeren, maar het is lastig om er een versie mee te maken die is geoptimaliseerd voor een specifieke configuratie. Er zijn tools nodig voor het programmeren van GPU's op een hoger niveau, die bijvoorbeeld kunnen worden gemaakt met behulp van uitbreidbare talen.

Nog maar drie jaar geleden werden grafische verwerkingseenheden (Graphical Processing Units, GPU's) alleen beschouwd als videokaarten voor pc's, maar nu is de houding tegenover hen veranderd: er zijn speciale server-GPU-modellen verschenen, gericht op het oplossen van computerproblemen, de prestaties van dubbele -precisieberekeningen zijn toegenomen, systemen hebben recordprestaties geleverd en staan ​​bovenaan de Top500. Hoe schrijf je effectieve programma's voor dergelijke machines? Het standaardantwoord is een combinatie van CUDA of OpenCL voor het programmeren van GPU en MPI op clusterniveau. Deze tools zijn beschikbaar, actief ondersteund door fabrikanten van apparatuur, en er zijn al veel programma's voor geschreven, maar er zijn ook nadelen.

CUDA en OpenCL zijn uitbreidingen van de C-taal; ze zijn niet moeilijk te leren, ook al zijn het hulpmiddelen van vrij laag niveau. Met hun hulp kun je relatief snel een algoritme voor de GPU implementeren, maar het maken van een versie die is geoptimaliseerd voor een specifieke applicatie en configuratie blijkt veel moeilijker. Alle optimalisaties moeten handmatig worden uitgevoerd, waardoor de code groter wordt en de leesbaarheid afneemt. En hoewel programma's die met OpenCL zijn gemaakt overdraagbaar zijn over een breed scala aan architecturen, blijven de prestaties tijdens een dergelijke portering niet behouden. Vereist GPU-programmeertools van een hoger niveau.

Dergelijke tools kunnen op verschillende manieren worden gemaakt: het introduceren van een nieuwe programmeertaal; richtlijnen toevoegen aan een bestaande taal, zoals wordt gedaan in het PGI Accelerator- of CAPS HMPP-model; Profiteer van uitbreidbare talen. Uitbreidbare talen- programmeertalen waarvan de syntaxis en semantiek niet vastliggen, maar kunnen worden gewijzigd afhankelijk van de behoeften van de programmeur. Vergeleken met traditionele talen hebben uitbreidbare talen een aantal voordelen: het is gemakkelijker om er nieuwe functies aan toe te voegen; ze zijn open; het leren van nieuwe programmeermodellen op basis van dergelijke talen is gemakkelijker, omdat er slechts relatief kleine uitbreidingen hoeven te worden geleerd; Met behulp van dergelijke talen is het gemakkelijker om programma's te verfijnen en te optimaliseren.

Uitbreidbare talen

Om een ​​taal uitbreidbaar te maken, moet deze het volgende bevatten:

• een uitbreidingsmechanisme zonder de compiler te veranderen, dat in gelijke mate door alle compilers wordt ondersteund, wat in het bijzonder de aanwezigheid betekent van een standaardinterface voor interactie met compilers;
• constructies voor het uitbreiden en manipuleren van de codeboom, zoals macro's of quasi-quoting, om de taal uit te breiden;
• krachtige tools voor het schrijven van extensies, zoals de taal die wordt uitgebreid zelf, of een andere taal waarvan de kracht betekent dat de extensiecode hetzelfde kan doen als elk programma in die taal.

Het blijkt dat er relatief weinig talen zijn die aan deze eisen voldoen: Lisp, Nemerle, Seed7, xoc en Stratego. Tegelijkertijd gebruikt xoc, dat bedoeld is om de C-taal uit te breiden, een aparte taal Zeta voor het schrijven van extensies, en Stratego is een domeintaal voor het maken van broncodeconverters. Nemerle is een uitbreidbare taal die een raamwerk gebruikt. Netto.

Alle uitbreidbare talen ondersteunen mechanismen voor het werken met de programmaboom, en met name is dit de constructie van quasi-citatie: de specificatie van een object dat de programmaboom vertegenwoordigt met behulp van de broncode zelf.

De Nemerle-taal gebruikt hiervoor een constructie, bijvoorbeeld het maken van een boom die bestaat uit een variabeledeclaratie i met een beginwaarde van 0. Quasi-quoteren is vergelijkbaar met het maken van stringobjecten met stringconstanten. In afb. 1 toont een voorbeeld van quasi-citatie. Met de interpolatieconstructie kunnen variabele waarden worden vervangen door een vast patroon binnen een quasi-aanhalingsteken. In Nemerle worden hiervoor $(...) constructies gebruikt als je bijvoorbeeld een lijst moet vervangen. Uitbreidbare talen bevatten ook parseringsconstructies van programmabomen. In de Nemerle-taal wordt hiervoor de match(...) (...)-operator gebruikt, een analoog van switch uit de C-taal, waarvan de takken quasi-citerende constructies zijn. In dit geval wordt interpolatie geïnterpreteerd als de declaratie van nieuwe variabelen, die, als de vergelijking succesvol is, de waarden van de overeenkomstige subbomen ontvangen. Als e bijvoorbeeld voor de matching-operator match(e) (| => ... ) een boom bevat, gaat deze naar de variabele a en naar de variabele b .

Hulpmiddelen voor het werken met de programmaboom worden gebruikt in taaluitbreidingsconstructies. In de Nemerle-taal zijn dit macro's: speciale functies die worden uitgevoerd in de compilatiefase en die een fragment van de programmaboom retourneren, dat wordt vervangen in plaats van hun aanroep. In dit geval accepteert de macro programmafragmenten als parameters en kan deze transformeren. In principe kun je een macro op dezelfde manier aanroepen als een reguliere functie; maar een interessantere functie is om de macro-aanroep aan een speciale syntaxis te binden. Hiermee kunt u nieuwe syntactische structuren in de Nemerle-taal introduceren en zo de taal uitbreiden.

In afb. Figuur 2 toont een voorbeeld van een macro met een syntactische extensie waarmee je een multidimensionale lus kunt declareren met variabelen en het aantal iteraties voor elke dimensie, en in figuur 2 zie je Figuur 3 geeft een voorbeeld van de programmatransformatie die deze macro uitvoert. Houd er rekening mee dat de macro die deze extensie implementeert minder dan 30 regels broncode in beslag neemt en verschillende foutcontroles bevat. Met de traditionele aanpak zou het implementeren van een dergelijke uitbreiding aanzienlijk meer code vergen en bovendien het bestuderen van de interne werking van de compiler vereisen.

Historisch gezien was het macromechanisme het eerste dat in Lisp verscheen, waarin het programma wordt weergegeven als een gewone lijst en geen speciale constructies vereist om met de programmaboom te werken. Daarom is uitbreidbaar programmeren in deze taal het meest wijdverspreid. Macro's in Nemerle zijn vergelijkbaar met die in Lisp. In het xoc-systeem wordt het uitbreidingsmechanisme geïmplementeerd via grammatica-extensies en het ontleden van boomkenmerken. Elke extensie specificeert noodzakelijkerwijs twee attributen: het type syntactische structuur en de uitdrukking in de basistaal waarin deze wordt omgezet.

Uitbreidbare talen worden gekenmerkt door de implementatie van veel standaardconstructies via macro's. In de Nemerle-taal worden alle lussen en voorwaardelijke operatoren, behalve match, geïmplementeerd via macro's, en in Lisp zijn macro's standaard lusconstructies en functiedeclaraties.

Hoe talen gebruiken?

Voor een uitbreidbare programmeertaal kun je constructies schrijven waarmee je GPU's op de meest handige manier kunt programmeren, wat werd gedaan als onderdeel van het NUDA-project (Nemerle Unified Device Architecture), met als doel uitbreidingen van de Nemerle-taal te creëren. voor GPU-programmering. OpenCL wordt gebruikt als interface voor interactie met de GPU en de doeltaal voor de presentatie van het programma.

Eerst moeten we de uitvoering op de GPU van een subset code in de Nemerle-taal implementeren. Tegelijkertijd moeten bekende taaloperatoren worden ondersteund, zoals lussen en vertakkingen, evenals het werken met eenvoudige gegevenstypen, structuren en arrays. De code voor de GPU wordt in aparte functies of in NUDA-kernels geplaatst. Elke kernel is gemarkeerd met een nukernel-macro, die, gebaseerd op de kernelcode, OpenCL-code genereert en een stub-methode voor het aanroepen van de kernel aan de hostzijde. Voordat er code wordt gegenereerd, worden alle macro's uitgebreid, met uitzondering van macro's met looping en vertakkingen. Als een functie binnen de kernel moet worden aangeroepen, moet de functie worden gemarkeerd met een nucode-macro, die OpenCL-code voor de functie genereert. De kernel wordt aangeroepen met behulp van de nucall-macro; naast de kernelparameters krijgt het ook de configuratie van het threadraster waarmee het begint.

Meestal wordt de body van de lus gebruikt als kernel voor de GPU, dus ik zou de lus onmiddellijk naar de GPU willen overbrengen. Dit kan in Nemerle worden geïmplementeerd - de overeenkomstige macro in NUDA heet nuwork. Het neemt de threadblokgrootte als vereiste parameters en bepaalt, op basis van de huidige context en analyse van de lichaamscode van de lus, een reeks variabelen die als parameters aan de kernel moeten worden doorgegeven. Het lichaam van de kernel wordt gevormd uit het lichaam van de lus, de berekening van lusindexen via het globale threadnummer, evenals een voorwaarde waarmee de lus correct kan worden uitgevoerd, zelfs als de globale rastergrootte niet deelbaar is door de grootte van de draadgroep. De lus wordt vervangen door een aanroep van de nucall-macro, die de gegenereerde kernel aanroept.

In principe is het mogelijk om het gebruik van reguliere Nemerle-taalarrays in GPU-programma's toe te staan, maar dit leidt tot hoge overhead - de array moet elke keer dat de kernel wordt aangeroepen naar het GPU-geheugen worden gekopieerd en vervolgens terug worden gekopieerd. Daarom gebruiken GPU-programma's speciale arraytypen met luie synchronisatie tussen de GPU en CPU. Dit maakt het enerzijds mogelijk om de programmatekst niet te vervuilen met opdrachten voor het kopiëren van gegevens, en anderzijds om overheadkosten voor het kopiëren van gegevens te vermijden. Voor dergelijke arrays wordt, net als voor reguliere arrays in Nemerle, geheugenbeheer gebruikt met behulp van garbagecollection. Om geheugen voor dergelijke arrays toe te wijzen, is er een macro nunew, die moet worden toegepast op de gebruikelijke geheugentoewijzingsoperator.

In afb. 4 aan de linkerkant is een regulier programma voor het toevoegen van arrays, en aan de rechterkant is een soortgelijk programma, maar dan met berekeningen op de GPU. Het is vrij eenvoudig om GPU-programma's van reguliere programma's te verkrijgen - u hoeft alleen maar macro's toe te passen op lussen en geheugentoewijzingsbewerkingen, terwijl de hoeveelheid code vrijwel ongewijzigd blijft. Een programma geschreven met NUDA heeft minder dan 20 regels code nodig. Een soortgelijk programma, maar in pure C en OpenCL duurt meer dan 100 regels.

Naast macro's die het werken met de GPU eenvoudiger maken, bevat het NUDA-uitbreidingssysteem ook annotaties voor lusconversie. Annotaties zijn in wezen speciale macro's. De inline-annotatie wordt bijvoorbeeld toegepast op een lus met een vast aantal iteraties en rolt deze volledig uit. De dmine-annotatie voert het afrollen van diepe lus uit. “Diep uitrollen” betekent dat het maken van meerdere kopieën van de lusbody en het schudden niet alleen wordt uitgevoerd voor de lus zelf, maar ook voor geneste lussen als deze onafhankelijk zijn.

Effect

Waarom moet een programmeur een nieuwe taal leren en nieuwe bibliotheken met uitbreidbare talen beheersen? Het belangrijkste antwoord is productiviteit. Met een algoritme van parallelle lussen die met arrays werken en geschreven zijn in de Nemerle-taal, is het voldoende om een ​​paar annotaties toe te voegen om een ​​programma voor de GPU te krijgen. In dit geval werkt het programma op elk apparaat dat OpenCL ondersteunt, inclusief nVidia- en AMD GPU's, evenals x86-processors. Om hetzelfde te bereiken met alleen OpenCL- of CUDA-technologieën, zul je aanzienlijk meer middelen moeten besteden, die niet alleen zullen worden besteed aan het schrijven van de broncode, maar ook aan het debuggen van de interactie tussen de host en de GPU.

Een andere reden is de prestatie van de gegenereerde code. Op CUDA of OpenCL moeten lusconversies handmatig worden uitgevoerd, en afzonderlijk voor elke architectuur. Dit is een lang en foutgevoelig proces, en de resulterende code is moeilijk te lezen en niet te onderhouden. Met NUDA kan dit werk worden gedaan met behulp van annotaties. Voor verschillende kernels kunt u bijvoorbeeld de werking van beeldconvolutie of matrixvermenigvuldiging optimaliseren met behulp van inline- en dmine-annotaties. Zonder de omvang van de broncode te vergroten, kunt u twee tot vijf keer prestatiewinst behalen. Als dezelfde transformaties handmatig zouden worden uitgevoerd, zou dit bovendien leiden tot een toename van de code met meerdere malen, en soms met een orde van grootte, om nog maar te zwijgen van de tijd die wordt besteed aan het debuggen en het selecteren van optimale scanparameters. Een universeel geannoteerd programma van zeven regels in NUDA voor getransponeerde matrix-matrixvermenigvuldiging met dubbele precisie werkt op een nVidia Tesla C2050 slechts 40% langzamer dan de momenteel snelste implementatie (CUBLAS 3.2). Een soortgelijk programma dat met de hand wordt geschreven, zou 70 regels code nodig hebben. Voor standaardtaken kunt u de code uiteraard eenmalig handmatig schrijven om de productiviteit te verhogen, maar voor specifieke taken zal het verlagen van de arbeidskosten en het verhogen van de productiviteit zeer nuttig zijn. Ten slotte zijn productiviteitswinsten ook van toepassing op het maken van extensies zelf: het is gemakkelijker om ze te maken met uitbreidbare talen dan met traditionele tools. Het hele NUDA-systeem heeft, ondanks zijn functionaliteit, slechts 12.000 regels code nodig, de tests niet meegerekend. Dit is relatief weinig; de Nemerle-taalcompiler (build 9025) neemt bijvoorbeeld ongeveer 130.000 regels in beslag.

De uitbreidbare taal is een krachtig hulpmiddel en het gebruik ervan bij parallel computergebruik staat nog in de kinderschoenen. Er zijn veel interessante problemen bij de ontwikkeling van parallelle programmeertalen, en elk daarvan kan worden opgelost met behulp van een combinatie van extensies en bibliotheken. U kunt asynchrone codeblokken en parallelle lussen aan de taal toevoegen, en u kunt handige constructies maken voor het programmeren van clustersystemen, zoals gedistribueerde arrays. Tenslotte kun je met extensies een volwaardige parallelle programmeertaal bouwen, zoals Chapel of X10.

Andrej Adinets([e-mailadres beveiligd]) - junioronderzoeker Onderzoekscomputercentrum van de Staatsuniversiteit van Moskou (Moskou).