Lijst met programmeertalen. Programmeertalen op laag en hoog niveau

Een programmeertaal is een formele taal die is ontworpen om een ​​persoon met een computer te verbinden. Het informatie- en gegevensverwerkingsalgoritme is ingesteld in de programmeertaal. Een elektronische computer (ECM) neemt direct een programma waar dat wordt gepresenteerd in een machinetaal, programmeren waarin dat erg onhandig is voor mensen.

De ontwikkeling van computertechnologie leidde tot de opkomst van programmeertalen. Het doel van zo'n taal is om een ​​set rekenformules uit te rusten met aanvullende informatie die deze set in een algoritme verandert. In wat volgt, wordt een programmeertaal begrepen als een taal voor het samenstellen van programma's, d.w.z. de taal waarin het algoritme is geschreven om het probleem op een computer op te lossen.

De computerprogrammering van de eerste generatie gebeurde uitsluitend in machinetaal. Machinetaal is een set regels voor het coderen van bepaalde acties (in de meeste rekenkunde) in numerieke vorm. Voor alle machines is alleen het binaire getalsysteem begrijpelijk, dat echter, om de notatie door de programmeurs te verkorten, werd vervangen door de octale.

Een nummersysteem wordt meestal opgevat als een reeks technieken voor het benoemen en aanduiden van nummers. Het gebruikelijke systeem voor het noteren van getallen is een positioneel decimaal getalsysteem in overeenstemming met het feit dat de numerieke waarde ervan afhangt van de positie die wordt ingenomen door een van de cijfers die in dit systeem worden gebruikt. Het binaire getallenstelsel is het eenvoudigst, omdat het slechts twee cijfers gebruikt: 0 en 1, en het octale getalstelsel is handig omdat de basis, namelijk de numerieke waarde 8, de macht is van het grondtal van het binaire getallenstelsel 2. Voor bijvoorbeeld, het decimale getal 65 kan je voorstellen

In decimale notatie:

6 x 101 + 5 x 100 = 65;

In octaal systeem als

1 × 82 + 0 × 81 + 1 × 80 = 101;

En in het binaire getallenstelsel in de vorm

1 × 26 + 0 × 25 + 0 × 24 + 0 × 23 + 0 × 22 + 0 × 2l + 1 × 20 = 100 001.

Elke actie die door een computer moet worden uitgevoerd, wordt in machinetaal als een opdracht gespecificeerd. Een opdracht is informatie die wordt gepresenteerd in een vorm waarmee u deze in een machine kunt invoeren en die de acties van een computer voor een bepaalde periode bepaalt. Elke opdracht definieert dus in het algemeen een elementair onderdeel van het informatieverwerkingsproces, een machinebewerking genoemd. De initiële informatie voor verwerking wordt in de regel geleverd als een reeks specifieke waarden, gewoonlijk gegevens genoemd. De initiële gegevens voor het uitvoeren van een actie, inclusief een machinebewerking, worden operanden genoemd.

In een commando moet in het algemeen het type actie worden aangegeven, de opslaglocatie in de machine (adres) van de initiële informatie waarop de machinebewerking wordt uitgevoerd, het adres van het resultaat, evenals het volgende commando na deze worden uitgevoerd. Voor rekenkundige bewerkingen (of bewerkingen) wordt de initiële informatie in de regel in de vorm van twee getallen ingesteld, daarom moeten er twee adressen worden opgegeven in de opdracht ervoor. Een instructie moet dus een opcode bevatten die het type machinebewerking specificeert dat moet worden uitgevoerd, en vier adressen: twee adressen van operanden, het adres van het resultaat en het adres van de volgende instructie. Gewoonlijk is het vereiste aantal adressen in een opdracht minder dan vier.

In een computer met drie-adres-commando's wordt het adres van het volgende commando niet aangegeven, maar het commando van de volgende geheugencel automatisch uitgevoerd (met een nummer hoger door één, dat is het adres van het volgende commando). Als we bijvoorbeeld de code 01 accepteren voor de optelbewerking, dan ziet de opdracht er voor de optelling van twee getallen uit cellen 2051 en 2052 met het resultaat in cel 2345 in een machine met drie adressen er als volgt uit:

01 2051 2052 2345 26

De eerste verbetering in het programmeerproces was de introductie van symbolische adressen, die het mogelijk maakten om commando's samen te stellen en geheugen apart toe te wijzen. De essentie van deze techniek bestaat uit het verdelen van het RAM-geheugen van de machine in arrays, waarvan het aantal cellen niet van tevoren bekend is, en de nummers van de arraycellen worden gegeven door alfanumerieke aanduidingen zoals ai + 1, ai + 2,. ... ., symbolische adressen genoemd. Geheugentoewijzing wordt uitgevoerd door numerieke waarden toe te wijzen aan alle ai nadat het programma is gecompileerd. Dit laatste proces is puur mechanisch en kan worden geautomatiseerd, d.w.z. de toewijzing van de echte adressen kan aan de computer zelf worden toevertrouwd.

Deze verbetering in het programmeerproces leidde al snel tot de creatie van symbolische programmeertalen, of autocodes. Een dergelijke taal verschilt alleen van een machinetaal doordat symbolische (alfabetische) aanduidingen worden gebruikt in plaats van numerieke waarden die de opdrachtbewerkingscode en het adres ervan uitdrukken. Daarom was er in de eerste autocodes een één-op-één overeenkomst tussen de bewerkingen geschreven in de symbolische programmeertaal (of codering) en de instructies in de machinetaal, die werd aangegeven door het 1: 1-symbool, dat was geschreven achter de naam van de taal. Bijvoorbeeld AUTOCODE 1: 1 - AUTO Een op een coderen.

Verdere verbetering van autocodes kwam tot uiting in de opkomst van extra middelen die, volgens de gebruikelijke regels, de volgorde van acties in rekenkundige formules bepalen of, onder de noodzakelijke voorwaarden, de vertakking van het rekenproces, cyclische herhaling van programmasecties en andere operaties die voortkomen uit de toestand van het probleem. Dus geleidelijk verloren autocodes het 1: 1-voorvoegsel en hun invoertalen werden niet puur machine, maar machinegericht. Machine-oriëntatie betekende dat deze talen gebaseerd bleven op de instructieset van een bepaalde computer. De eerste machinegeoriënteerde talen waren over het algemeen onvolmaakt. In sommige talen was de beschrijving van de volgorde van berekeningen losgescheurd van de formules zelf, andere hadden complexe symbolen, weinig visueel of te gespecialiseerd, andere waren alleen aangepast voor het oplossen van een beperkt aantal problemen. Het belangrijkste nadeel was de gehechtheid van de taal aan deze machine.

Met de komst van machines van de tweede generatie ontstond de behoefte om talen te creëren die volledig gericht waren op de kenmerken van taken en niet afhankelijk waren van een specifieke machine. Deze eis werd verergerd door het feit dat computers van verschillende merken elkaar snel vervingen of door elkaar werden gebruikt. Probleemgerichte programmeertalen werden het symbool van de tweede generatie computers. Hun ontwikkeling werd steeds meer bepaald door de bijzonderheden van de taken, en niet door de kenmerken van de machines. Op de voorgrond kwam wat gebruikelijk was in verschillende problemen, en dit bracht verschillende talen samen die werden gecreëerd in het tijdperk van de dominantie van computerproblemen. Deze talen worden meestal formele algoritmische of gewoon algoritmische talen genoemd.

Er wordt veel gevraagd van een formele algoritmische taal. Ten eerste moet het visueel zijn, wat kan worden bereikt door bestaande wiskundige symbolen en andere gemakkelijk te begrijpen picturale middelen te gebruiken. Ten tweede flexibel, zodat elk algoritme kan worden beschreven zonder onnodige complicatie die gepaard gaat met het ontbreken van visuele middelen. Ten derde moet de taal ondubbelzinnig zijn - de registratie van een algoritme, gemaakt in overeenstemming met alle regels van de taal, mag geen verschillende interpretaties toestaan. Ten vierde, meertraps - een complex algoritme kan worden beschreven als een combinatie van eenvoudigere algoritmen. En ten slotte moet de taal uniform zijn - aan de ene kant moet het aantal picturale middelen niet te groot zijn, en aan de andere kant is het noodzakelijk dat dezelfde middelen kunnen worden gebruikt om dezelfde of verwante concepten uit te drukken in verschillende (volgens hun doel) delen van het algoritme. Zo'n taal dient:

Een manier van denken - de logische onvolkomenheid van de voorgestelde methode voor het oplossen van een probleem wordt vaak onthuld tijdens het schrijven van deze methode door middel van een algoritmische taal;

· Een communicatiemiddel tussen mensen - een beschrijving van het proces, uitgevoerd door een persoon, moet beschikbaar zijn voor een ander;

· Een tussenpersoon tussen een mens en een machine - in dit geval wordt de vertaling van de algoritmische taal in de taal van de machine uitgevoerd door de machine zelf met behulp van een speciaal programma - een vertaler.

Een van de eerste en meest succesvolle talen van deze soort was Fortran, ontwikkeld door IBM. In 1954 publiceerde een groep Amerikaanse programmeerspecialisten het eerste rapport over de Fortran-taal. De naam van de taal komt van de uitdrukking formules VERTALING - transformatie van formules. De Fortran-taal bestaat niet alleen tot op de dag van vandaag, maar staat ook vol vertrouwen op de eerste plaats ter wereld wat betreft prevalentie. Een van de redenen voor deze lange levensduur is de eenvoudige structuur van zowel Fortran zelf als de vertalers die ervoor bedoeld zijn. Een Fortran-programma is geschreven in de vorm van een reeks zinnen, of operators (een operator betekent een beschrijving van een bepaalde transformatie van informatie), en wordt opgesteld volgens bepaalde regels. Deze regels leggen met name beperkingen op aan de vorm van registratie en de rangschikking van onderdelen van de operator in de lijn van het formulier voor registrerende operators. Een Fortran-programma is een of meer segmenten (subroutines) van instructies. Het segment dat de werking van het hele programma als geheel regelt, wordt het hoofdprogramma genoemd.

Fortran is ontworpen voor gebruik in wetenschappelijke en technische informatica. Deze taal kan echter gemakkelijk taken beschrijven met vertakte logica (productieprocessen modelleren, spelsituaties oplossen, enz.), sommige economische problemen, en vooral bewerkingstaken (tabellen, samenvattingen, verklaringen, enz.).

Een wijziging van de Fortran-taal, die in 1958 verscheen, heette Fortran II en bevatte de concepten van een subroutine en gedeelde variabelen om communicatie tussen segmenten mogelijk te maken.

In 1962 hoort de opkomst van de taal die bekend staat als Fortran IV en die op dit moment de meest voorkomende is geworden. Tegelijkertijd begon het werk van de commissie bij de American Standards Association (ASA), die (tegen 1966) twee normen ontwikkelde: de Fortran-talen en de basis (hoofd) FORTRAN (Basic FORTRAN). Deze talen komen grofweg overeen met modificaties IV en II, maar basis Fortran is een subset van Fortran, terwijl Fortran II dat niet is voor Fortran IV.

De Fortran-taal blijft evolueren en verbeteren, en beïnvloedt de creatie en ontwikkeling van andere talen. Fortran is bijvoorbeeld de basis voor de BASIC-dialoogtaal en de BASIC-plus-extensie, veelgebruikte talen in alle timesharingsystemen, talen voor het aanleren van de vaardigheden van het gebruik van algoritmische talen in de programmeerpraktijk. Deze talen worden met name geïmplementeerd op personal computers. Momenteel is er een nieuwe standaard gecreëerd - Fortran 77.

Al snel na de oprichting van Fortran (1957), verscheen de ALGOritmic Language (ALGOritmic Language), gecreëerd op basis van brede internationale samenwerking. In 1960 werd een officieel bericht gepubliceerd over een algoritmische taal genaamd Algol-60, waarbij het getal 60 het jaar betekent dat de taal werd goedgekeurd.

Algol-60 is gemaakt na de ontwikkeling en praktische toepassing van Fortran en wordt daarom gekenmerkt door zowel de introductie van nieuwe ontwerpen als de veralgemening van de concepten die beschikbaar zijn in Fortran. Als in Fortran bijvoorbeeld operators functioneel zijn onderverdeeld in uitvoerbare en niet-uitvoerbare, dan is er in Algol geen dergelijke indeling en spelen constructies die beschrijvingen worden genoemd de rol van niet-uitvoerbare Fortran-operators.

Er zijn ook andere verschillen. Wat Fortran en Algol echter gemeen hebben, is het feit dat beide talen zijn gebaseerd op het concept van expressie, wat praktisch samenvalt met het concept van een wiskundige uitdrukking met alleen algebraïsche bewerkingen en elementaire functies. De eenvoudigste objecten waaruit uitdrukkingen zijn samengesteld, zijn gehele getallen en benaderende reële getallen en logische waarden.

Algol wordt algemeen erkend als een zeer nuttig hulpmiddel voor het publiceren van algoritmen en voor het aanleren van de basisprincipes van programmeren.

Tot voor kort verdienden zowel Fortran als Algol-60 terecht de naam universele talen, aangezien ze de programmering van het grootste deel van de wetenschappelijke en technische problemen (voornamelijk computationeel) verzorgden. Maar geen van deze talen maakte het natuurlijk mogelijk om alle opkomende problemen zonder uitzondering te beschrijven. Daarom verschenen ongeveer tegelijkertijd algoritmische talen met een andere oriëntatie, die voldeden aan de behoeften van die nieuwe gebieden van wetenschap en technologie, die zich in de daaropvolgende jaren intensief begonnen te ontwikkelen.

Een voorbeeld is economische taken - de taak om materiële activa, vervaardigde producten, personeel, financiën, enz. onderneming of industrie. Voor dergelijke taken zijn de belangrijkste acties invoer- en uitvoerbewerkingen met een relatief kleine hoeveelheid eenvoudige berekeningen, evenals sequentiële verwerking van gegevensarrays. De beschrijving van dit soort acties kan worden uitgevoerd in de COMmon Business Oriented Language, voorgesteld door IBM in 1959.

De taken van het verwerken van symbolische informatie ontstaan ​​vooral op het gebied van wetenschappelijk onderzoek. Dit zijn bijvoorbeeld transformatie van formules, oplossing van vergelijkingen (niet numeriek, maar in analytische vorm), analyse en synthese van teksten in kunstmatige of natuurlijke taal (met name automatische programmering en machinevertaling), enz.

Van de talen voor het verwerken van symbolische informatie is de Lisp-taal, gecreëerd door een groep onderzoekers in 1960 aan het Massachusetts Institute of Technology, erg populair, vooral onder vertegenwoordigers van de fysieke en wiskundige wetenschappen. In deze taal is alle informatie die wordt verwerkt, inclusief het programma zelf, georganiseerd in zogenaamde lijsten - opeenvolgingen van elementen. Een element kan primair zijn (letter of cijfer) of op zijn beurt een lijst. Op deze manier kunnen willekeurig complexe structuren ontstaan.

Een andere taal - Snobol - wordt voornamelijk gebruikt voor machinale analyse van teksten die in natuurlijke talen zijn geschreven. Daarin is het basisconcept een string - een willekeurige reeks letters, cijfers en andere tekens. De belangrijkste bewerking is het zoeken in een string naar een deel van een string die in een bepaalde afbeelding is gebouwd en dit deel te vervangen door een andere string. Zowel het beeld als de lijnen die het vervangen, zijn samengesteld uit afzonderlijke elementen van een eenvoudig type. Het zoekresultaat bepaalt de volgorde van verdere acties. De Snobol-taal is heel gemakkelijk te leren.

Het belangrijkste voordeel van probleemgeoriënteerde, machine-onafhankelijke algoritmische talen is dat ze zijn gebouwd met maximale aandacht voor menselijke ideeën, zo niet over het wezen, dan over de vorm van het probleem dat wordt opgelost, met de maximale benadering van de vorm waarin een persoon gewend is deze taken te beschrijven, en rekening houdend met de logische verbanden die hij leerde benadrukken in de bestudeerde verschijnselen.

Algol wordt bijvoorbeeld gekenmerkt door een benadering van de gebruikelijke wiskundige symboliek. Fortran staat, in tegenstelling tot Algol, dichter bij machinetaal dan bij mensentaal. Lisp wordt gekenmerkt door het gebruik van het apparaat van zogenaamde recursieve beschrijvingen, dat veel wordt gebruikt in de wiskundige logica, bij onderzoek naar de grondslagen van de wiskunde, enz.

De overvloed aan algoritmische talen die verscheen in de periode van de tweede generatie computers, is enerzijds grotendeels te wijten aan de mode, anderzijds de onmogelijkheid van een van de voorgestelde talen om alle problemen die zijn ontstaan. De derde generatie computers heeft de ontwikkeling van een nieuwe benadering voor het creëren van een werkelijk universele algoritmische taal op de agenda gezet.

Een van de pogingen van deze soort is de creatie door IBM van de algoritmische taal PL/1 (Programming Language/1 - een programmeertaal). Het is gebaseerd op de talen Fortran en Cobol, een aantal beeldmiddelen en concepten zijn ontleend aan Algol en andere talen, met name talen voor het verwerken van symbolische informatie. Vervolgens werden verschillende versies van de taal gepubliceerd, die erg van elkaar verschilden, maar geleidelijk aan stabiliseerde de taal zich, en nu verschillen nieuwe publicaties van de vorige alleen door redactionele wijzigingen, eliminatie van onnauwkeurigheden of verbetering van individuele elementen.

De belangrijkste elementen van een programma dat in de taal PL/1 is geschreven, zijn operators, met behulp waarvan zowel gegevens als hun verwerkingshandelingen worden beschreven. Naar analogie met Fortran is het originele programma een verzameling van het hoofdprogramma en subroutines in de vorm van een blok. Het concept van een blok in PL / l is gebaseerd op de concepten van een blok in de Algol-60-taal. Deze taal is dus in het algemeen gebouwd op basis van de concepten van bestaande algoritmische talen en in hun tradities.

Een andere poging houdt verband met de verdere ontwikkeling van Algol. In 1968 werd een document gepubliceerd waarin de basis werd geschetst van een nieuwe universele algoritmische taal genaamd Algol-68. In deze taal wordt het aantal basisconcepten tot een redelijk minimum teruggebracht om een ​​hoge visuele kracht van de taal te bereiken en de vrijheid van combinatie en interactie van deze concepten met elkaar te waarborgen.

De taal Algol-68 is traditioneel, omdat er een wens is om alle gebruikers kant-en-klare middelen te bieden om hun algoritmen te beschrijven. Tot nu toe kon deze benadering de opkomst van nieuwe gespecialiseerde talen niet voorkomen. Dus in 1971 werd de algoritmische taal Pascal gepubliceerd, genoemd naar de grote Franse wetenschapper van de 17e eeuw, die als eerste ter wereld een automatisch apparaat uitvond waarmee getallen kunnen worden toegevoegd. De Pascal-taal is de opvolger van Algol-60, het heeft constructies vergelijkbaar met die in PL/l en Algol-68, maar Pascal is laconieker. Pascal is bijna net zo eenvoudig als BASIC, maar Pascal promoot de introductie van moderne programmeertechnologie op basis van de geleidelijke opbouw van een programma dat bestaat uit kleine goed gedefinieerde procedures, d.w.z. de ideeën van gestructureerd programmeren worden consequent doorgevoerd. Een ander belangrijk kenmerk van Pascal is het concept van datastructuur als een van de fundamentele concepten die, samen met het concept van een algoritme, de kern vormen van programmeren.

Op basis van de Pascal-taal werd eind jaren 70 de Ada-taal gecreëerd, die een zeer breed toepassingsgebied heeft. De taal is vernoemd naar de eerste vrouwelijke programmeur, Ada Lovelays. De algoritmische taal van Ada heeft bepaalde veranderingen ondergaan in het evolutieproces en heeft nu alle kenmerken van een standaardtaal. Het is een zeer gestructureerde taal, vooral geschikt voor de ontwikkeling van real-time systemen. De Ada-taal is echter te omslachtig, uitgebreid en biedt de programmeur onvoldoende vrijheid.

In tegenstelling tot de vermelde talen op hoog niveau die in de vroege jaren 80 verschenen, is de programmeertaal C een taal op relatief laag niveau. Maar dit betekent niet dat deze taal niet krachtig genoeg is. De C-taal is een universele taal die nauw verwant is aan het populaire UNIX-besturingssysteem (zowel het UNIX-systeem als de software zijn geschreven in de C-taal). Algoritmische taal C weerspiegelt volledig de mogelijkheden van moderne computers, waardoor u zeer efficiënte programma's kunt schrijven zonder toevlucht te nemen tot assembleertalen, voornamelijk vanwege eenvoudige, opeenvolgende constructies van besturingsstromen. Controles, loops, groepering en subroutines worden aangeboden, maar geen multiprogrammering, parallelle bewerkingen, synchronisatie en coroutines - onmisbare attributen van krachtige talen (Ada, PL/1, Algol-68).

Onlangs is er een tendens geweest in de richting van de creatie van zogenaamde uitbreidbare universele talen. Het belangrijkste idee van deze trend is niet om gespecialiseerde dialecttalen te vermijden, maar om een ​​gemeenschappelijke basis te creëren voor het "programmeren van dialecten".

De uitbreidbare taal moet faciliteiten hebben voor het grammaticaal ontleden van de teksten van een van de extensies om erachter te komen welke teksten grammaticaal correct zijn voor een bepaald dialect en welke structuur ze hebben. Zo'n taal zou zijn toekomstige consumenten een aantal belangrijke mogelijkheden moeten bieden: bijvoorbeeld om semantische modellen te bouwen (dwz om nieuwe termen te introduceren om de concepten die door hen worden uitgedrukt te beschrijven, hun relatie met enkele basisconcepten en met de eerder geïntroduceerde concepten ), beschrijf de implementatie van extensies - manieren van hun meest geschikte weergave met behulp van de middelen die beschikbaar zijn voor moderne computers. Er zijn andere kenmerken van uitbreidbare talen die kunnen worden opgemerkt.

1. Ontwikkeling van programmeertalen

Generaties programmeertalen

Het is gebruikelijk om programmeertalen op te delen in vijf generaties.

^ In de eerste generatie omvat talen die zijn gemaakt in de vroege jaren 50, toen de eerste computers verschenen. Het was de eerste assembleertaal die gebaseerd was op het principe van één instructie, één regel.

bloeiend tweede generatie programmeertalen kwamen eind jaren 50 - begin jaren 60. Vervolgens werd een symbolische assembler ontwikkeld, waarin het concept van een variabele verscheen. Het werd de eerste volwaardige programmeertaal. Dankzij het uiterlijk zijn de ontwikkelsnelheid en de betrouwbaarheid van programma's merkbaar toegenomen.

De noodzaak derde generatie programmeertalen worden meestal toegeschreven aan de jaren 60. Op dit moment ontstonden universele talen op hoog niveau, met hun hulp is het mogelijk om problemen op elk gebied op te lossen. De kwaliteiten van nieuwe talen, zoals relatieve eenvoud, onafhankelijkheid van een bepaalde computer en het vermogen om krachtige syntactische constructies te gebruiken, hebben de productiviteit van programmeurs drastisch verhoogd. De structuur van deze talen, begrijpelijk voor de meeste gebruikers, trok hen aan tot het schrijven van kleine programma's (meestal van technische of economische aard). De overgrote meerderheid van de talen van deze generatie wordt tegenwoordig met succes gebruikt.

Vanaf het begin van de jaren 70 tot heden duurt de periode van talen vierde generatie... Deze talen zijn bedoeld voor de uitvoering van grote projecten, waardoor hun betrouwbaarheid en snelheid van creatie toenemen. Ze zijn gericht op gespecialiseerde toepassingsgebieden, waar goede resultaten kunnen worden behaald met behulp van niet universele, maar probleemgerichte talen die werken met specifieke concepten van een smal vakgebied.

Meestal hebben deze talen krachtige ingebouwde operators om functionaliteit in een enkele regel te beschrijven waarvoor duizenden regels broncode nodig zijn om te implementeren in talen van een lagere generatie.

De geboorte van talen vijfde generatie gebeurde midden jaren 90. Hiertoe behoren ook systemen voor het automatisch maken van applicatieprogramma's met behulp van visuele ontwikkelingstools, zonder programmeerkennis.

Het belangrijkste idee achter deze talen is de mogelijkheid om de resulterende tekst automatisch te genereren in universele programmeertalen (die vervolgens moet worden gecompileerd). Instructies worden in de meest visuele vorm in de computer ingevoerd met behulp van methoden die het handigst zijn voor iemand die niet bekend is met programmeren.

^ Een overzicht van programmeertalen op hoog niveau

fortran

Het is de eerste gecompileerde taal in de jaren vijftig.

Programmeurs die programma's uitsluitend in assembler ontwikkelden, hadden ernstige twijfels over de mogelijkheid van de opkomst van een hoogwaardige taal op hoog niveau, dus het belangrijkste criterium voor het ontwikkelen van Fortran-compilers was de efficiëntie van de uitvoerbare code. Hoewel Fortran pionierde met een aantal kritische programmeerconcepten, werd het gemak van het schrijven van programma's opgeofferd voor de mogelijkheid om efficiënte machinecode te genereren. Er zijn echter een groot aantal bibliotheken voor deze taal gemaakt, variërend van statistische complexen tot satellietbesturingspakketten. Fortran wordt nog steeds actief gebruikt in veel organisaties. Er is een standaardversie van Fortran HPF (High Performance Fortran) voor parallelle supercomputers met meerdere processors.

Cobol (Cobol).

Het is een gecompileerde taal voor gebruik in de economie en voor het oplossen van zakelijke problemen, ontwikkeld in de vroege jaren '60. Het is erg "uitgebreid" - de operators zien er soms uit als gewone Engelse uitdrukkingen. In Cobol zijn zeer krachtige tools geïmplementeerd om te werken met grote hoeveelheden data die op verschillende externe media zijn opgeslagen. Er zijn veel applicaties in deze taal gemaakt, die nog steeds in gebruik zijn.

Algol Gecompileerde taal gemaakt in 1960. Het was bedoeld om Fortran te vervangen, maar vanwege de complexere structuur werd het niet op grote schaal toegepast. In 1968. Er werd een versie van Algol 68 gemaakt, die nog steeds voorloopt op veel programmeertalen in zijn mogelijkheden, maar door het gebrek aan efficiënt genoeg computers ervoor, was het niet mogelijk om tijdig goede compilers te maken.

Pascal

De Pascal-taal, gemaakt in de late jaren 70, lijkt in veel opzichten op Algol, maar het stelt een aantal vereisten voor de structuur van het programma strenger en er zijn mogelijkheden waardoor het met succes kan worden gebruikt bij het maken van grote projecten.

Basis

Er zijn zowel compilers als tolken voor deze taal, en het staat op de eerste plaats in de wereld in populariteit. Het werd in de jaren 60 gecreëerd als onderwijstaal en is heel gemakkelijk te leren.

C (C)

Deze taal is gemaakt in het Bell-laboratorium en werd aanvankelijk niet als mainstream beschouwd. Het was bedoeld om assembler te vervangen, zodat het programma's kon maken die net zo efficiënt en compact zijn, zonder afhankelijk te zijn van een bepaald type processor. C lijkt in veel opzichten op Pascal en heeft extra faciliteiten voor directe geheugenmanipulatie (pointers). Veel applicatie- en systeemprogramma's en een aantal bekende besturingssystemen (Unix) zijn in de jaren '70 in deze taal geschreven.

C++ (C++)

C ++ is een objectgeoriënteerde uitbreiding van de C-taal, ontwikkeld in 1980. Het implementeert veel krachtige nieuwe functies die de productiviteit van programmeurs drastisch hebben verhoogd, maar het maken van complexe en betrouwbare programma's vereist een hoog niveau van professionele training van ontwikkelaars.

Java (Java)

Deze taal is begin jaren 90 door Sun gemaakt op basis van C++. Het is ontworpen om de ontwikkeling van applicaties op basis van C++ te vereenvoudigen door alle low-level features ervan uit te sluiten. Maar het belangrijkste kenmerk van deze taal is de compilatie, niet in machinecode, maar in platformonafhankelijke bytecode (elk commando neemt één byte in beslag). Deze bytecode kan worden uitgevoerd met behulp van een interpreter, waarvan vandaag een JVM-versie (Java Virtual Machine) voor alle platforms wordt gemaakt.

Bijzondere aandacht wordt besteed aan de ontwikkeling van deze taal in twee richtingen:

• 
  ondersteuning voor alle soorten mobiele apparaten en microcomputers die zijn ingebouwd in huishoudelijke apparaten (Jini-technologie);
• 
  creatie van platformonafhankelijke softwaremodules die kunnen draaien op servers in wereldwijde en lokale netwerken met verschillende besturingssystemen (Java Beans-technologie).

^ Database programmeertalen

Deze groep talen verschilt in de eerste plaats van algoritmische talen in de taken die worden opgelost. Een database is een bestand (of een groep bestanden) dat een geordende reeks records is met een uniforme structuur en is georganiseerd volgens een enkele sjabloon (meestal in tabelvorm). Een database kan uit meerdere tabellen bestaan. Het is handig om in databases verschillende informatie op te slaan uit naslagwerken, archiefkasten, boekhoudkundige tijdschriften, enz. Wanneer u met databases werkt, moet u meestal de volgende bewerkingen uitvoeren:

De eerste databases verschenen heel lang geleden, toen de behoefte ontstond om grote hoeveelheden informatie te verwerken en groepen records te selecteren op basis van bepaalde criteria. Hiervoor is de Structured Query Language (SQL) gemaakt. Het is gebaseerd op een krachtige wiskundige theorie en maakt een efficiënte databaseverwerking mogelijk door het manipuleren van groepen records in plaats van individuele records.

Voor het beheer van grote databases en hun efficiënte verwerking zijn DBMS (Database Management Systemen) ontwikkeld.

In feite heeft elk DBMS, naast het ondersteunen van de SQL-taal, zijn eigen unieke taal die is gericht op de kenmerken van dit DBMS en niet overdraagbaar is naar andere systemen.

Tegenwoordig zijn er vijf toonaangevende DBMS-fabrikanten in de wereld:

Microsoft (SQL Server), IBM (DB2), Oracle, Software AG (Adabas), Informix en Sybase. Hun producten zijn gericht op het ondersteunen van het gelijktijdige werk van duizenden gebruikers op het netwerk, en de databases kunnen in gedistribueerde vorm op meerdere servers worden opgeslagen.

Met de komst van personal computers werden de zogenaamde desktop DBMS gecreëerd. De DBMS dBase II, waarvan de taal werd geïnterpreteerd, wordt beschouwd als de voorloper van moderne databaseprogrammeertalen voor pc's. Toen werden er compilers voor gemaakt, de FoxPro en Clipper DBMS'en verschenen, die dialecten van deze taal ondersteunden. Tegenwoordig worden vergelijkbare maar incompatibele versies van de dBase-talenfamilie geïmplementeerd in Visual FoxPro van Microsoft en Visual dBase van Inprise.

^ Programmeertalen voor internet

Met de actieve ontwikkeling van het wereldwijde netwerk zijn er veel populaire programmeertalen gecreëerd, speciaal aangepast voor internet.

Ze verschillen allemaal in karakteristieke kenmerken: de talen worden geïnterpreteerd, de tolken voor hen worden gratis verspreid en de programma's zelf bevinden zich in de broncode. Dergelijke talen worden scripttalen genoemd.

HTML-code. Een bekende taal voor papierwerk. Het is heel eenvoudig en bevat basiscommando's voor het opmaken van tekst, het toevoegen van afbeeldingen, het instellen van lettertypen en kleuren, het organiseren van koppelingen en tabellen. Alle webpagina's zijn geschreven in HTML of gebruiken HTML-extensies.

Perl. In de jaren 80 ontwikkelde Larry Wall de Perl-taal. Het is ontworpen als een hulpmiddel voor het efficiënt verwerken van grote tekstbestanden, het genereren van tekstrapporten en het beheren van taken. Perl is veel krachtiger dan talen als C. Het introduceert veel veelgebruikte functies voor het werken met strings, arrays, allerlei tools voor gegevensconversie, procesbesturing, werken met systeeminformatie, enz.

VRML. In 1994. de taal VRML is gemaakt voor het organiseren van virtuele driedimensionale interfaces op internet. Hiermee kunt u in tekstvorm verschillende driedimensionale scènes, verlichting en schaduwen, texturen (objectcoatings), roteren in elke richting, schalen, verlichting aanpassen, enz.

^ Modelleertalen

Bij het maken van programma's en het vormen van databasestructuren worden vaak formele methoden voor hun presentatie gebruikt - formele notaties, met behulp waarvan u databasetabellen, velden, programma-objecten en de relatie daartussen visueel kunt weergeven in een systeem met een gespecialiseerde editor en een generator van programmabroncodes op basis van de gemaakte modellen. Dergelijke systemen worden CASE-systemen genoemd. Ze gebruiken actief IDEF-notaties en recentelijk wordt UML steeds meer verspreid.

1. ^

   Moderne programmeersystemen

Basisprincipes van het programmeren van visuele interfaces

Een van de doodlopende wegen, of crises bij het programmeren, is onlangs in verband gebracht met de ontwikkeling van een grafische gebruikersinterface. Het handmatig programmeren van alle vensters, knoppen, menu's die de gebruiker kent, het afhandelen van muis- en toetsenbordgebeurtenissen, inclusief afbeeldingen en geluid in programma's, vergde steeds meer tijd van de programmeur. In sommige gevallen begon deze hele service tot 80-90% van het volume aan programmacodes in beslag te nemen. Bovendien werd al dit werk vaak bijna tevergeefs verspild, omdat een jaar later de algemeen aanvaarde stijl van de grafische interface veranderde en alles opnieuw moest worden begonnen.

De uitweg uit deze situatie werd aangegeven door twee benaderingen.

De eerste is de standaardisatie van veel interfacefuncties, waardoor het mogelijk werd om bibliotheken te gebruiken die bijvoorbeeld beschikbaar zijn in Windows. Als gevolg hiervan konden applicaties zich bij het veranderen van de stijl van de grafische interface (bijvoorbeeld bij het overstappen van Windows 3.x naar Windows 95) automatisch aanpassen aan het nieuwe systeem zonder enige herprogrammering.

De tweede revolutionaire stap was de opkomst van visueel programmeren, dat zijn oorsprong vond in Visual Basic en op briljante wijze werd belichaamd in C++ Builder van Delphi en Borland.

Visuele programmering maakte het mogelijk om het ontwerp van de gebruikersinterface terug te brengen tot eenvoudige en intuïtieve procedures die het mogelijk maken om in minuten of uren te doen wat voorheen maanden werk kostte.

Voorbeeld. In Delphi ziet het er zo uit. Je werkt in de Delphi Integrated Development Environment, die je voorziet van formulieren (mogelijk meerdere in de applicatie) waarop de componenten passen. Dit is meestal een venstervorm, hoewel er ook onzichtbare vormen kunnen zijn. Met behulp van de muis worden de pictogrammen van de componenten die beschikbaar zijn in de Delphi-bibliotheken op het formulier overgebracht en geplaatst. Met eenvoudige manipulaties kunt u de grootte van de locatie van deze componenten wijzigen. Tegelijkertijd is tijdens het ontwerpproces voortdurend het resultaat zichtbaar - een afbeelding van de vorm en de componenten die erop staan. De ontwerpresultaten zijn zichtbaar zonder zelfs maar het programma te compileren.

Het grote voordeel is dat Delphi tijdens het ontwerpen van het formulier en het plaatsen van componenten erop automatisch programmacodes genereert, inclusief de bijbehorende fragmenten die dit onderdeel beschrijven. En dan kan de gebruiker in de bijbehorende dialoogvensters de standaardwaarden van de componenten wijzigen en, indien nodig, handlers voor sommige gebeurtenissen schrijven. In feite komt ontwerpen neer op het plaatsen van componenten op een formulier, het instellen van enkele van hun eigenschappen en het schrijven van event-handlers, indien nodig.

Componenten kunnen visueel zijn, zichtbaar wanneer de applicatie actief is, en niet-visueel, en bepaalde servicefuncties uitvoeren. Visuele componenten zijn tijdens het ontwerpproces direct zichtbaar op het scherm in dezelfde vorm waarin de gebruiker ze tijdens runtime zal zien.

Delphi's bibliotheken met visuele componenten bevatten vele soorten componenten en hun nomenclatuur breidt zich zeer snel uit van versie tot versie. Wat al beschikbaar is, is voldoende om bijna elk van de meest ingewikkelde applicaties te bouwen zonder toevlucht te nemen tot het maken van nieuwe componenten. Tegelijkertijd kan zelfs een onervaren programmeur applicaties maken die er professioneel uitzien.

^ Basis programmeersystemen

De meest populaire universele programmeertalen van vandaag zijn de volgende: Basic, Pascal, C ++ (C ++), Java.

Voor elk van deze programmeertalen zijn er tegenwoordig veel programmeersystemen geproduceerd door verschillende bedrijven en gericht op verschillende pc-modellen en besturingssystemen.

De volgende visuele omgevingen voor het snel ontwerpen van programma's voor Windows zijn het populairst:

• 
  Basis: Microsoft Visual Basic;
• 
  Pascal: Borland Delphi;
• 
  C++: Borland C++ Bulider;
• 
  Java: Symantec Café.

1. ^

   Architectuur van softwaresystemen

Terwijl de meeste op zichzelf staande applicaties - kantoorprogramma's, ontwikkelomgevingen, tekst- en beeldvoorbereidingssystemen - op één computer draaien, bestaan ​​grote informatiesystemen (bijvoorbeeld een bedrijfsautomatiseringssysteem) uit tientallen en honderden afzonderlijke programma's die via een netwerk met elkaar communiceren draaien op verschillende computers. In dergelijke gevallen zouden ze op een andere software-architectuur werken.

1. 
   Op zichzelf staande applicaties. Ze werken op één computer.
2. 
   Toepassingen in een bestandsserverarchitectuur. De computers van de gebruikers van het systeem zijn verenigd in een netwerk, terwijl kopieën van hetzelfde programma op elk van hen (op de plaats van de klant) worden gestart, die toegang hebben tot de server voor gegevens, die bestanden opslaat die tegelijkertijd beschikbaar zijn voor alle gebruikers (in de regel zijn dit databases). De server heeft een verhoogde betrouwbaarheid, hoge prestaties, grote geheugencapaciteit; er is een speciale serverversie van het besturingssysteem op geïnstalleerd. Wanneer verschillende programma's tegelijkertijd toegang hebben tot hetzelfde bestand, bijvoorbeeld om het bij te werken, kunnen er problemen optreden vanwege de dubbelzinnigheid van de definitie van de inhoud. Daarom wordt elke wijziging aan een openbaar bestand toegewezen aan een transactie (een elementaire gegevensverwerking met een vast begin, einde (succesvolle of niet-succesvolle afronding), en een aantal andere kenmerken). Het bijzondere van deze architectuur is dat alle berekeningen worden uitgevoerd op clientlocaties, waarvoor voldoende krachtige pc's nodig zijn (dit zijn de zogenaamde systemen met een dikke client - een programma dat alle verwerking van informatie die van de server wordt ontvangen, uitvoert).
3. 
   Client-server-applicaties . Deze architectuur is vergelijkbaar met de vorige, alleen is de server niet alleen in staat om gelijktijdige toegang tot gegevens te bieden, maar ook om programma's uit te voeren die een bepaalde hoeveelheid rekenwerk op zich nemen (in de bestandsserver architectuur, het wordt volledig geïmplementeerd op clientinstallaties). Hierdoor is het mogelijk om de algehele betrouwbaarheid van het systeem te vergroten, aangezien de server veel stabieler is dan de pc, en om onnodige belasting te verwijderen van de clientplaatsen waar deze kan worden gebruikt. Toepassingen die erop worden gelanceerd, voeren kleine hoeveelheden berekeningen uit en soms zijn ze alleen bezig met het weergeven van informatie die van de server is ontvangen, daarom worden ze thin clients genoemd.
4. 
   Toepassingen in multi-tier architectuur. Het nadeel van de vorige architectuur is dat de belasting van de server dramatisch toeneemt, en als het faalt, stopt het hele systeem met werken. Daarom wordt er een zogenaamde applicatieserver aan het systeem toegevoegd, waarop al het rekenwerk wordt gedaan. Een andere databaseserver verwerkt gebruikersverzoeken en een derde kan worden uitgerust met een speciaal programma - een TP-monitor, die de transactieverwerking optimaliseert en de belasting van de servers in evenwicht houdt. In de meeste praktische gevallen zijn alle servers in serie geschakeld, en het uitvallen van één link, zo niet het stoppen van al het werk, vermindert in ieder geval de prestatie van het systeem.
5. 
   Toepassingen in een gedistribueerde architectuur. Om de nadelen van de overwogen architecturen te vermijden, zijn speciale technologieën uitgevonden waarmee u een programma kunt maken in de vorm van een set componenten die kan worden uitgevoerd op alle servers die op het netwerk zijn aangesloten (de componenten zijn als het ware verdeeld over het netwerk). Het belangrijkste voordeel van deze aanpak is dat als een computer uitvalt, speciale monitorprogramma's die de juiste werking bewaken, het tijdelijk ontbrekende onderdeel op een andere computer onmiddellijk opnieuw opstarten. In dit geval wordt de algehele betrouwbaarheid van het hele systeem erg hoog en wordt de rekenbelasting op een optimale manier over de servers verdeeld. Toegang tot de mogelijkheden van elk onderdeel dat is ontworpen om met de gebruiker te communiceren, wordt uitgevoerd vanaf een willekeurige clientsite. Omdat alle berekeningen op servers plaatsvinden, wordt het mogelijk om ultradunne clients te maken - programma's die alleen informatie weergeven die van het netwerk is ontvangen en die minimale computerbronnen nodig hebben. Hierdoor is toegang tot het componentensysteem niet alleen mogelijk vanaf een pc, maar ook vanaf kleine mobiele apparaten. Een speciaal geval van de componentbenadering is toegang tot servertoepassingen vanuit browsers via internet.

Deze technologieën zullen de komende decennia vorm geven aan de ontwikkeling van de informatie-industrie.

Programmeertalen het is een formeel tekensysteem dat is ontworpen om algoritmen te beschrijven in een vorm die handig is voor de uitvoerder.

Classificatie van programmeertalen

Programma is een gedetailleerde en volledige beschrijving van het algoritme door middel van een programmeertaal. De uitvoerder van het programma is een computer. Om door een computer te worden uitgevoerd, moet een programma worden weergegeven in machinecode - een reeks getallen die door de processor wordt begrepen. Het is nogal moeilijk om met de hand een programma in machinecodes te schrijven. Daarom worden tegenwoordig bijna alle programma's gemaakt met behulp van programmeertalen, die qua syntaxis en semantiek dicht bij de natuurlijke menselijke taal liggen. Dit vermindert de complexiteit van het programmeren. De tekst van het programma dat met de programmeertaal is geschreven, moet echter worden omgezet in machinecode. Deze bewerking wordt automatisch uitgevoerd door een speciaal hulpprogramma genaamd vertaler. Tolk vertaalt in de taal van machinecodes, op zijn beurt controleert elke operator van het bronprogramma de juistheid van het schrijven van de operator en voert het onmiddellijk uit. In tegenstelling tot de tolk compiler vertaalt het volledige bronprogramma in machinetaal.

Voorbeelden van hulpprogramma's - tolken zijn GW Basic, Logo, algoritmische taal voor scholen, veel programmeertalen voor databases. De compilers zijn Turbo Pascal, C++, Delphi.

Er kunnen twee benaderingen worden onderscheiden door de methode van het ontwikkelen van programma's:

procedureel programmeren is programmeren waarbij de uitvoering van programma-instructies wordt bepaald door hun volgorde, spronginstructies, lus of oproepen naar procedures;

objectgeoriënteerd programmeren - programmeren waarbij programma-objecten worden gevormd die een set eigenschappen hebben, een set methoden hebben en kunnen reageren op gebeurtenissen die zowel in de externe omgeving als in het object zelf plaatsvinden (muisklikken, timer-triggering, overschrijding van een numerieke limiet, enz.) enz.). De uitvoering van een bepaald deel van het programma hangt dus af van gebeurtenissen in het softwaresysteem.

Objectgeoriënteerd programmeren (OOP) sluit niet uit, maar omvat procedurele programmeertechnologie.

Belangrijkste programmeertalen

De meest populaire universele programmeertalen zijn: Basic; Pascal; C++; Java.

Er zijn veel versies van de Basic-taal, geïmplementeerd als zowel tolken als compilers. In Rusland wordt Basic traditioneel gebruikt in een informaticacursus op de middelbare school. Visuele programmeeromgeving Microsoft Visual Basic wordt gebruikt als softwareondersteuning voor MS Office-toepassingen.

De Pascal-taal is samengesteld en wordt veel gebruikt als een omgeving voor het lesgeven in programmeren op universiteiten. De RAD-omgeving, die zijn basiseigenschappen erft, is de Borland Delphi-omgeving.

Voor de C++-taal is de RAD-omgeving Borland C++ Builder. Deze gecompileerde taal wordt vaak gebruikt om softwaretoepassingen te ontwikkelen waarbij het nodig is om de snelheid en zuinigheid van het programma te waarborgen.

Met de Java-taal - een geïnterpreteerde taal - kunt u platformonafhankelijke softwaremodules maken die in computernetwerken met verschillende besturingssystemen kunnen werken. De RAD-omgeving ervoor is Symantec Cafe.

Programmeersysteem is een systeem voor het ontwikkelen van nieuwe programma's in een specifieke programmeertaal.

Moderne programmeersystemen bieden gebruikers meestal krachtige en gebruiksvriendelijke programmeertools. . Ze bevatten:

compiler of tolk;

geïntegreerde ontwikkelomgeving;

hulpmiddelen voor het maken en bewerken van programmateksten;

uitgebreid bibliotheken van standaardprogramma's en functies;

debug programma's, d.w.z. programma's die helpen bij het vinden en oplossen van fouten in het programma;

"vriendelijk" voor de gebruikersdialoogomgeving;

bedrijfsmodus met meerdere vensters;

krachtige grafische bibliotheken; Gereedschap werken met

bibliotheken

ingebouwd assembler;

ingebouwde helpdesk;

andere bijzonderheden.

Populaire programmeersystemen - Turbo basis , Snelle basis , Turbo pascal , Turbo C ... Onlangs waren programmeersystemen gericht op het maken van Windows-toepassingen:

plastieken zak Borland Delphi (Delphi) is een briljante opvolger van de Borland Pascal-compilerfamilie en biedt hoogwaardige en zeer gebruiksvriendelijke visuele ontwikkelingstools. De extreem snelle compiler stelt u in staat om bijna elk applicatieprogrammeerprobleem efficiënt en snel op te lossen.

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

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

Talen en programmeersystemen

Het concept van machinetaal

Machinetaal is een systeem van commando's dat direct begrepen wordt door de hardware van een bepaald elektronisch computersysteem. Als gevolg hiervan wordt de machinetaal op unieke wijze bepaald door de processorinstructieset en de computerarchitectuur.

De instructieset van de processor bevat:

· Rekenkundig-logische commando's - commando's voor rekenkundige bewerkingen op binaire getallen en logische bewerkingen op binaire vectoren;

· Besturingscommando's - commando's voor overgang, vertakkingen, herhalingen en enkele andere commando's;

· Commando's voor gegevensoverdracht - commando's met behulp waarvan het RAM-geheugen en de CPU worden uitgewisseld;

· Gegevensinvoer-uitvoeropdrachten - opdrachten met behulp waarvan de CPU en externe apparaten gegevens uitwisselen.

Elke opdracht bevat de code van de bewerking die wordt uitgevoerd en informatie over de adressen van de gegevens waarop deze bewerking wordt uitgevoerd. Bovendien bevat het commando (direct - stuurcommando's en indirect - andere commando's) informatie over het adres van het commando dat daarna zal worden uitgevoerd. Dus elke reeks instructies die zich in het RAM bevinden, is in feite een algoritme dat is vastgelegd in het instructiesysteem van de processor - een machineprogramma.

De meest voorkomende is nu de architectuur van een computer met een gemeenschappelijke bus. De gemeenschappelijke bus is de centrale informatiesnelweg die externe apparaten verbindt met de centrale processor. Het bestaat uit een databus, een adresbus en een controlebus. De databus is bedoeld voor gegevensuitwisseling tussen RAM en externe apparaten. De adresbus draagt ​​dataadressen. Deze bus is eenrichtingsverkeer. De besturingsbus dient als kanaal voor de uitwisseling van besturingssignalen tussen externe apparaten en de centrale processor.

Machinetaal (processortaal) is dus een reeks instructies, die elk een elementaire actie beschrijven om informatie die in binaire code wordt weergegeven, te transformeren. Het universele gebruik van de binaire code voor het weergeven van informatie van een grote verscheidenheid aan vormen leidt ertoe dat het programma voor het oplossen van zelfs een vrij eenvoudig probleem honderden machine-instructies bevat. Het schrijven van een dergelijk programma met behulp van machine-instructies is zelfs voor een ervaren programmeur niet eenvoudig. Echte programma's bestaan ​​uit tien- en honderdduizenden machine-instructies. Daarom moet elke technologie voor het ontwerpen van een programma gebaseerd zijn op technieken die kenmerkend zijn voor het menselijk denken, werken met concepten die bekend zijn bij een persoon uit het vakgebied waartoe de taak behoort.

Met andere woorden, de programmeur (algoritmeontwerper) moet zijn algoritme kunnen formuleren in de taal van bekende concepten; dan moet een speciaal programma deze concepten uitdrukken met behulp van werktuigmachines, waarbij de tekst van het algoritme wordt vertaald (vertaald) in de taal van de machine.

Deze behoefte leidde tot de opkomst van programmeertalen op hoog niveau als talen voor het opnemen van algoritmen die bedoeld zijn voor uitvoering op een computer.

Machine georiënteerde talen

De voorlopers van talen op hoog niveau zijn de zogenaamde machinegeoriënteerde talen of autocodetalen. Een van de meest prominente vertegenwoordigers van machinegeoriënteerde talen is Assembler. Assembler staat heel dicht bij machinetaal, de meeste instructies zijn exacte symbolische representaties van machine-instructies. Het voordeel is dat het niet langer nodig is om de numerieke codes van de processorinstructies te onthouden, het is voldoende om hun symbolische representatie te kennen. Bovendien verschijnt voor het eerst in machinegeoriënteerde talen het concept van een variabele als een benoemd geheugengebied voor het opslaan van gegevens, en daarmee het concept van een gegevenstype. In programma's in een machinegerichte taal wordt het mogelijk om zowel numerieke als tekstuele informatie te gebruiken in een voor mensen bekende vorm.

Ondanks de duidelijke voordelen van machinegeoriënteerde talen ten opzichte van een puur machinetaal, is het schrijven van programma's in deze talen nog steeds beladen met aanzienlijke problemen. De programma's zijn erg omslachtig en moeilijk te lezen.

Programmeertalen op hoog niveau

Programmeertalen op hoog niveau spelen de rol van communicatiemiddel tussen de programmeur en de machine, maar ook tussen programmeurs. Deze omstandigheid legt veel verplichtingen op aan de taal:

De taal moet dicht bij die fragmenten van natuurlijke talen liggen die een specifiek onderwerp van menselijke activiteit bieden; (Een taal gericht op zakelijke toepassingen moet de concepten bevatten die bij dit soort activiteiten worden gebruikt: document, factuur, database, enz.).

Alle taalfaciliteiten moeten zodanig worden geformaliseerd dat ze als machineprogramma's kunnen worden geïmplementeerd.

Een programmeertaal is meer dan een middel om algoritmen te beschrijven: het bevat een systeem van concepten op basis waarvan iemand over zijn problemen kan nadenken, en een notatie waarmee hij zijn gedachten over het oplossen van een probleem kan uitdrukken.

Modellen van omroepprogramma's. Vertalers

Over het algemeen zijn computers niet ontworpen om programmeertalen op hoog niveau te begrijpen. De hardware herkent en voert alleen machinetaal uit, het programma waarin niets meer is dan een reeks binaire getallen.

De opkomst van programmeertalen ging gepaard met het besef dat de vertaling van een algoritme geschreven in een "bijna" natuurlijke (algoritmische) taal in een machinetaal kan worden geautomatiseerd en daarom op de schouders van een machine kan worden toevertrouwd. Het is hierbij belangrijk om onderscheid te maken tussen taal en de uitvoering ervan. De taal zelf is een notatiesysteem dat wordt beheerst door een reeks regels die de woordenschat en syntaxis bepalen. Een taalimplementatie is een programma dat deze notatie omzet in een reeks machine-instructies volgens de semantische regels die in de taal zijn gedefinieerd.

Er zijn twee manieren om een ​​taal te implementeren: compilers en interpreters. Compilers vertalen de volledige tekst van een in een programmeertaal geschreven programma in één doorlopend proces naar machinecode. Dit creëert een compleet machinecodeprogramma dat vervolgens kan worden uitgevoerd zonder dat een compiler nodig is.

De tolk herkent en voert op elk moment één zin (operator) van het programma uit en zet de verwerkte zin gaandeweg om in een machineprogramma. Het verschil tussen een compiler en een tolk is vergelijkbaar met het verschil tussen simultaanvertaling van mondelinge spraak en vertaling van een tekst.

In principe kan elke taal zowel worden gecompileerd als geïnterpreteerd, maar in de meeste gevallen heeft elke taal zijn eigen voorkeursmanier van implementatie. Blijkbaar is deze voorkeur meer dan een eerbetoon aan traditie. De keuze wordt bepaald door de taal zelf. Fortran, Pascal, Modula-2 zijn meestal gecompileerd. Talen als Logo, Fort worden bijna altijd geïnterpreteerd. BASIC en Lisp worden in beide vormen veel gebruikt.

Er zijn twee hoofdtypen compilers op basis van het type uitvoergegevens:

· Het samenstellen van de uiteindelijke uitvoerbare code;

· Compileren van geïnterpreteerde code, voor de uitvoering waarvan aanvullende software nodig is.

De uiteindelijke uitvoerbare code zijn toepassingen die zijn geïmplementeerd als EXE-bestanden, DLL-bibliotheken, COM-componenten. De geïnterpreteerde code omvat de bytecode van JAVA-programma's die worden uitgevoerd door de virtuele JVM-machine.

De objectcode die door de compiler wordt gegenereerd, is een gegevensgebied en een machine-instructiegebied met adressen die vervolgens worden "onderhandeld" door een linkeditor (soms een loader genoemd). De link-editor plaatst alle afzonderlijk gecompileerde objectmodules en statisch gekoppelde bibliotheken in één adresruimte.

In wat volgt, zullen we de uitvoerbare vorm van het programma de code noemen die is verkregen als resultaat van het compileren van het bronprogramma.

Vertaal (compilatie) proces

Een programma dat in een programmeertaal op hoog niveau is geschreven, wordt een bronprogramma genoemd en elke onafhankelijke programma-eenheid die een bepaald programma vormt, wordt een programmamodule genoemd. Om het bronprogramma om te zetten in zijn uitvoerbare vorm (uitvoerbaar bestand), voert de vertaler een bepaalde reeks acties uit. Deze volgorde hangt zowel af van de programmeertaal als van de specifieke implementatie van de vertaler zelf. Bij het vertalen is het niet alleen belangrijk om het programma te compileren, maar ook om een ​​voldoende efficiënte code te verkrijgen.

Tijdens het vertaalproces wordt de analyse van het originele programma uitgevoerd en vervolgens wordt de synthese van de uitvoerbare vorm van dit programma uitgevoerd. Afhankelijk van het aantal weergaven van het bronprogramma dat door de compiler wordt uitgevoerd, worden vertalers onderverdeeld in single-pass, two-pass en vertalers die meer dan twee passages gebruiken.

De voordelen van een one-pass compiler zijn onder meer een hoge compilatiesnelheid, en de nadelen zijn in de regel dat je niet de meest efficiënte code krijgt.

Two-pass compilers worden veel gebruikt. Ze zorgen voor de eerste doorgang om het programma te analyseren en om informatietabellen op te bouwen die in de tweede doorgang worden gebruikt om de objectcode te genereren.

De afbeelding toont de belangrijkste fasen die worden uitgevoerd in het proces van het vertalen van het bronprogramma.

De programmaanalysefase bestaat uit:

· Lexicale analyse;

· Syntactische analyse;

· Semantische analyse.

Bij het analyseren van het bronprogramma scant de vertaler achtereenvolgens de tekst van het programma dat wordt weergegeven als een reeks tekens, waarbij de programmastructuur wordt ontleden.

In het stadium van lexicale analyse worden de belangrijkste componenten van het programma - lexemen onderscheiden. Tokens zijn trefwoorden, identifiers, bedieningssymbolen, opmerkingen, spaties en scheidingstekens. De lexicale analysator extraheert niet alleen tokens, maar bepaalt ook het type van elk token. Tegelijkertijd wordt in het stadium van lexicale analyse een symbooltabel samengesteld, waarin elke identifier is gekoppeld aan zijn eigen adres. Dit maakt verdere analyse mogelijk om het adres in de symbooltabel te gebruiken in plaats van een specifieke waarde (tekenreeks).

Het markeren van tokens is vrij arbeidsintensief en vereist het gebruik van complexe contextgevoelige algoritmen.

In het stadium van het ontleden worden de ontvangen tokens geparseerd om semantisch begrijpelijke syntactische eenheden te verkrijgen, die vervolgens worden verwerkt door de semantische analysator. Syntactische eenheden zijn dus uitdrukkingen, declaratie, operator van een programmeertaal, functieaanroep.

In het stadium van semantische analyse worden syntactische eenheden verwerkt en wordt tussencode gegenereerd. Afhankelijk van de aan- of afwezigheid van de optimalisatiefase kan het resultaat van semantische analyse een verder geoptimaliseerde tussencode zijn of een kant-en-klare objectmodule.

De meest voorkomende taken die door de semantische analysator worden opgelost, zijn onder meer:

· Detectie van fouten tijdens het compileren;

· Het vullen van de symbooltabel, gemaakt in het stadium van lexicale analyse, met specifieke waarden die aanvullende informatie over elk element van de tabel bepalen;

· Macro's vervangen door hun definities;

· Uitvoering van compile-time richtlijnen.

Een macro is een vooraf gedefinieerde code die in de compilatiefase in het programma wordt ingevoegd op alle plaatsen waar de aanroep van deze macro wordt aangegeven.

In de synthesefase van het programma wordt het volgende uitgevoerd:

· Code generatie;

· Links bewerken.

Het codegeneratieproces bestaat uit het converteren van tussencode (of geoptimaliseerde code) naar objectcode. In dit geval kan, afhankelijk van de programmeertaal, de resulterende objectcode worden gepresenteerd in een uitvoerbare vorm of als een objectmodule om verder te worden verwerkt door de linker.

Het codegeneratieproces is dus een integraal onderdeel van de programmasynthesefase en de noodzaak om de linker uit te voeren hangt af van de specifieke programmeertaal. Opgemerkt moet worden dat in de praktijk de term "codegeneratie" vaak wordt toegepast op alle acties van de programmasynthesefase die leiden tot een uitvoerbare programmavorm.

De linker komt overeen met de adressen van codefragmenten die zich in afzonderlijke objectmodules bevinden: adressen van aangeroepen externe functies, adressen van externe variabelen, adressen van functies en methoden van elke module worden bepaald. Om adressen te bewerken, gebruikt de linkeditor speciale laadtabellen die in de vertaalfase zijn gemaakt. Nadat de objectmodules door de linker zijn verwerkt, wordt een uitvoerbaar programmaformulier gegenereerd.

4.1. Programmeer systemen.

Het hoofddoel van elk programma - een beschrijving van de volgorde van opdrachten voor de centrale processor, die deze moet uitvoeren. Deze commando's moeten worden uitgedrukt in machinecode, d.w.z. in een voor de centrale processor begrijpelijke taal. Het is daarom erg moeilijk voor een persoon om programma's in zo'n taal te schrijven de volgende benadering wordt gevolgd om programma's te maken:

De programmeur schrijft tekst in een taal die hij begrijpt en waar hij zich prettig bij voelt. Vervolgens vertaalt het het in machinetaal en verandert het in een vorm die handig is voor de CPU en het besturingssysteem.

Voor dit doel worden speciale talen ontwikkeld voor het beschrijven van algoritmen, die worden genoemd algoritmische talen of programmeertalen .

(05.12.2012)

Ze (algoritmische taal) hebben een aantal eigenschappen:

1. specialisatie - een hulpmiddel dat wordt geleverd door een taal die is gericht op de beschrijving van taken van vakgebieden van een bepaald type. Bijvoorbeeld: sommige talen zijn vooral bedoeld voor numerieke berekeningen (Pascal), andere voor het werken met tekstuele informatie (LISP), en andere voor het schrijven van systeemprogramma's (C). Kortom, met de meest voorkomende talen kunt u de oplossing van verschillende problemen beschrijven (daarom worden ze universeel genoemd), maar ze zijn het handigst voor het oplossen van de problemen waarvoor ze zijn ontworpen.

2. Het vermogen om gemakkelijk leesbare tekst te schrijven met een duidelijke structuur. Deze benadering in het programmeren heet modulair (structureel) ... Hij veronderstelt het schrijven van afzonderlijke softwaremodules met hun daaropvolgende geautomatiseerde assemblage in een enkel programma. In dit geval schrijft de programmeur een programmamodule genaamd het hoofd (hoofd)programma ... Daarin beschrijft hij de volgorde van uitvoering van de resterende modules, die worden genoemd programma's of functies .

Vanwege de eigenaardigheden van programmeertalen zijn er: vier belangrijke fasen bij het starten van een programma voor uitvoering :

1. Uitzending - vertaling van de tekst van programmamodules van een algoritmische taal naar een machinetaal.

2. Samenstellen van de na vertaling verkregen programmamodules in één programma.

3. Een programma debuggen - het proces van het vinden en elimineren van fouten in de programmatekst.

4. Uitvoering van het programma.

Om deze fasen te bieden, zijn de programmeersystemen bedoeld.

Ze bevatten de volgende componenten:

1. Gespecialiseerde tekstverwerker. Biedt hulp aan een persoon bij het schrijven van de tekst van programmamodules.

2. Vertalers. Vertaler Is een vertaler van de taal waarin de teksten van programmamodules zijn geschreven naar de interne machinetaal. Twee soorten vertalers:

• tolken. De tolk zorgt voor regel voor regel vertaling van de programmatekst in machinetaal en voor de gelijktijdige uitvoering van elk commando van dit programma. De interpreter automatiseert alle stadia van het starten van een programma voor uitvoering.
• Compilers. De compiler vertaalt de tekst van een programmamodule in machinetaal zonder deze uit te voeren. Tegelijkertijd worden door de programmeur gemaakte syntaxisfouten in de tekst aan het licht gebracht. Als resultaat van het werk van de compiler wordt een objectmodule gemaakt, die nog niet klaar is voor uitvoering.

3. Link-editor. De link-editor automatiseert het proces van het samenstellen van verwante, maar afzonderlijk geschreven en vertaalde softwaremodules. In de loop van hun werk hij onthult fouten van onjuist gespecificeerde koppelingen tussen modules ( bijvoorbeeld, de aanwezigheid in de tekst van een link naar een niet-bestaande module) of hun afwezigheid. Daarnaast, hij voegt toe service-informatie die het besturingssysteem nodig heeft voor latere controle over de uitvoering van dit programma. Het bestand dat door het programma is verkregen, kan worden uitgevoerd onder besturing van het besturingssysteem zonder een programmeersysteem, daarom wordt het genoemd uitvoerbaar (opstartbaar) bestand .

4. Debugger. Debugger rendert helpen bij het vinden van verschillende fouten in het programma tijdens de uitvoering ervan. Deze omvatten bijvoorbeeld:: logische fouten (een poging om te delen door nul), evenals fouten in verband met onjuiste invoergegevens.