Information Technology | Studies, essays, thesises » A programozási nyelvek története, fejlődése

A programozási nyelvek története, fejlődése Időszámításunk előtt 1500-ra tehető az első számolást segítő eszközök megjelenése (abakusz). Már ezeknek az egyszerű eszközöknek a használata is algoritmikus módszer szerint történt, itt is egy meghatározott műveletsorozatot, tevékenységsorozatot kellett végrehajtani az eredmény számításának érdekében. 1642-ben készült el Blaise Pascal összeadó gépe, amely mechanikus elvek alapján képes volt az összeadások elvégzésére. A lyukkártyás és lyukszalagos gépeknek is kódolt formában adták át a bemeneti információkat, a gép pedig hasonló formában közölte a kimeneti információkat. Ez volt a legelső és legegyszerűbb kódolás Már ebben a kezdeti időszakban is jellemző volt a számolást segítő eszközök algoritmikus működése, a kódolt információtárolás. Igazi forradalmat jelentett 1948-ban a Neumann János által kidolgozott elvek megjelenése, amelyek a számítógép

felépítésére és működésére vonatkozóan egyaránt újszerű gondolatokat tartalmaztak. A magyar származású tudós a következő követelményeket fogalmazta meg a számítógéppel kapcsolatban: • Az utasításokat az adatokkal azonos módon kell tárolni, numerikus formában. • A számítógép használjon kettes számrendszert. • A számítógép teljes egészében elektronikus felépítésű legyen, mellőzni kell a mechanikus részegységeket. • A vezérlőegység teljesen automatikus legyen, emberi beavatkozás nélkül hajtsa végre az utasításokat. • A számítógép tartalmazzon egy számolóművet, amely képes elvégezni miden számítási feladatot. A fenti elvek alapján nyilvánvaló, hogy szükség volt egy egyértelmű kódolási rendszerre, amelynek segítségével meg lehetett fogalmazni a probléma (a számítási művelet) lépéseinek leírását. Ezt a kódolt leírást a belső memória tartalmazta, és a számolómű hajtotta

végre az egyes műveleteket egymás után. Tehát a számítógép soros működésűvé vált A problémák megfogalmazása, leírása során különös figyelmet kellett fordítani arra, hogy a műveletek milyen sorrendben követik egymást, mivel az automatikus működésű számítógép (számolómű) sorban hajtotta végre az utasításokat, tehát mindig tudni kellett, mi a következő lépés. 1952-ben készült el Neumann János tervei alapján az EDVAC nevet viselő számítógép, amely az első Neumann-elvek alapján épített gép volt. Innen kezdődött a programozási nyelvek története Az EDVAC volt az első számítógép, amelyen “programot lehetett végrehajtani”. Ezek a programok még nagyon kezdetlegesek, egyszerűek voltak, elsősorban matematikai problémák megoldására specializálva. A programozás kezdeti időszakára jellemző volt, hogy a programok általában csak azon a gépen futottak le, amely gépeken elkészítették őket, egyszóval a

programok gépfüggőek voltak. Az évek folyamán bővült a számítógép által megoldandó problémák köre, egyre több területen kezdtek el számítógépet használni, és az újabb alkalmazási területek újabb problémákat vetettek fel. Az igényekhez igazodva az évek folyamán a programozási munka könnyítése, gyorsítása érdekében a programozási technikák és eszközök (programozási nyelvek) is fejlődni kezdtek. Kezdetben a programozási nyelvek nagyon közel álltak a gépi problémamegoldás logikájához, a programozás tulajdonképpen nem volt más, mint a gépnek adott utasítások sorozatának leírása, amely a gép nyelvén történt. Mivel a gépi logika az emberi gondolkodástól igen messze esik, az első programok megírása igen sok időt vett igénybe, nem beszélve arról, amikor a programon módosítani kellett. A ’60-as években egyre több számítógép került a nagyvállalatokhoz, ahol már nemcsak a számítások elvégzése volt

az igény, szerettek volna számítógépen ennél összetettebb feladatokat is megoldani. A nehézkes programozási módszerek és a gazdasági élet – amely a vállalatok döntéseit alapvetően befolyásolja – dinamikus változásai nem igazán voltak összhangban egymással. A hosszú, nehéz munkával készített programok igen gyorsan elavultak, és máris lehetett hozzákezdeni a következő írásához. Tehát új, gyorsabb, egyszerűbb programfejlesztési módszerekre volt szükség. Ebben az időben jelentek meg az első magas szintű programozási nyelvek, amelyek már nem a számítógép, hanem az emberi gondolkodás logikája alapján próbálták a problémákat megközelíteni. A fejlesztések, kutatások eredményeképpen új programozási módszerek, technikák, filozófiák jelentek meg. Mostmár nemcsak a problémamegoldás egyszerűsítése volt a cél, a programok szerkezeti felépítése, az emberi logika minél hatékonyabb kihasználása lett az újabb

fejlesztések irányvonala. Megjelentek az általános célú és a specializált programozási nyelvek, a ’70-es évek elején új módszerként jelentkezett a struktúrált programozás. A ’90-es évekre komoly teret nyertek a számítógépek az élet valamennyi területén. Komoly igény volt arra, hogy a szoftverpiac követni tudja az egyre szélesebb körű igényeket, tehát új eszközökre volt szükség, amelyek segítségével a programozók gyorsan tudnak hatékony és megbízható alkalmazásokat írni. A gyors programfejlesztés céljait egy az emberi gondolkodáshoz közel álló módszer teszi lehetővé, ugyanakkor a programnak nem szabad hatékonyságát elveszítenie, tehát minél elemibb egységekből kell felépíteni. Mindkét igényt kielégítette az objektum-orientált programozási technika, amely a valódi tárgyakhoz hasonlóan képes kezelni a rendszer absztrakt elemeit. Azaz a programozónak rendelkezésére állnak az előre definiált programelemek,

amelyekből összeállíthatja a működőképes programot. Annak érdekében, hogy a problémának leginkább megfelelő alkalmazást lehessen előállítani, az egyes elemek tulajdonságait a programozó tetszése szerint módosíthatja. A ’90-es évek második felére jellemző a legújabb programozási technikák kialakulása, amelyek esetében már nemcsak egy probléma megoldására nyílik lehetőség, komplex információs rendszereket kezelhetünk általuk. Ezen a szinten a programozónak már nem arra kell koncentrálnia, hogy hogyan oldja meg a problémát, sokkal fontosabbá válik a mivel kérdése. A legfejlettebb programozási rendszerek már automatikusan generálják a kódot, ezzel a programozónak már nem kell foglalkoznia. Ezek a rendszerek sok esetben nemcsak a program helyességét ellenőrzik, hanem a problémamegoldás hatékonyságát is. Ezáltal a programozónak kizárólag a megoldandó probléma lényegére kell figyelnie, megkeresheti a kritikus

pontokat a programban, és minden korábbi lehetőségnél hatékonyabban optimalizálhatja annak működését. Az évek során igen sok programozási nyelv alakult ki, amelyeket szemléletük, fontosabb jellemzőik alapján négy generációba soroltak. 1 GL (első generációs programozási nyelvek): Az első programozási nyelv a gépi kód volt. Ennek a nyelvnek az utasításait a számítógép képes volt közvetlenül, minden átalakítás nélkül végrehajtani, értelmezni. A problémákat nagyon precízen kellett megfogalmazni, lépésekre bontani. Emellett a nyelv erősen gépfüggő volt, hiszen minden gépen más és más utasításokat használt, az adott problémát minden géptípus esetén másképpen kellett leírni, megfogalmazni, alkalmazkodva a számolóegység sajátosságaihoz. (A gépi kód mai napig sem egységes a különböző processzorok esetében.) A gépi nyelv olyan utasításokból állt, amelyek a gép számára közvetlenül értelmezhetőek

voltak, az emberi nyelvektől azonban igen messze állt a gépi logika. Hátrányai mellett néhány előnyt is meg kell említenünk: A leggyorsabb programot eredményezi, mivel nem tartalmaz felesleges utasításokat. Az egyes utasítások egységes (egy vagy kétcímes) formában vannak leírva. Példa egy gép kódú utasításra: 0B0A 0C0E 0D00 Az első négy számjegy az utasítás, a második négy számjegy az első memóriacím, a második négy számjegy a második memóriacím. A gépi kódú lehetőségekhez képest komoly előrelépést jelentett az Assembly nyelvek megjelenése, amelyek tulajdonképpen segédeszközt jelentettek a gépi kódú utasítások egyszerűbb megfogalmazásában. Az egyes gépi kódú utasításokhoz egy-egy mneomnikus kódot rendeltek hozzá, a tárcímeket pedig a memória kezdetéhez viszonyított relatív címekkel számították. Szintén újdonságnak számított, hogy az egyes memóriacímeket egy-egy szimbolikus névvel lehetett

helyettesíteni. Egy összeadás Assembly nyelven: ADD X, Y Az ADD szócska az összeadásra (addition) utal, az X és Y pedig memóriacímeket szimbolizálnak. Tehát az Assembly egy olyan alacsony szintű programozási nyelv, amelynél a művelet és a tárcím szimbolikusan megadható, de a programozás logikája továbbra is követni a gépi logikát. Természetesen, ha egy Assembly programot szeretnénk futtatni, azt mindig meg kell előznie egy átalakítási, fordítási műveletnek, amikor az Assembly utasításokat gépi utasításokká alakítjuk át. Az Assembly virágkorában az operációs rendszerek tartalmazták az Assembly fordítót. A fordítóprogramok compiler típusúak voltak. Az Assembly legtöbb utasítása egyetlen gépi utasítást reprezentált, azaz az Assembly 1:1 tipusú nyelv. Volt néhány utasítás, amely több gépi kódú utasítást jelentett, ezeket makróknak nevezték. Az Assembly nyelv a gépi kódú programozás után igen nagy előrelépést

jelentett, általa sokkal kényelmesebbé vált a programfejlesztési munka. Napjainkra az alacsony szintű programozási nyelvek háttérbe szorultak. Az Assembly-t ma már csak olyan feladatok esetén használják, ahol hardver szintű vezérlést kell megvalósítani. A visszaszorulásuknak sok oka mellett két fontosabbat szeretnék mindössze kiemelni: • A processzorok utasításkészlete ma is különböző, ezért a gépi kódban írt program nem hordozható. • Az alacsony szintű programozási nyelvek aprólékos, átgondolt munkát feltételeznek egyszerű problémák esetén is. A mai kor követelménye pedig a gyors, látványos, rövid idő alatt elkészülő programok felé mutat. 2 GL (második generációs programozási nyelvek): A számítógépek alkalmazási területének bővülése szükségessé tette a programok fejlesztési idejének csökkentését, azaz felmerült az igény, hogy a programokat minél gyorsabban írják meg a programozók. A gépi

kód és az assembly nehézkessége, géphez igazodása miatt nem volt erre alkalmas. A 60-as évek elején jelentek meg az első magas szintű programozási nyelvek. Az új nyelvek struktúrája már nem a számítógép sajátosságaihoz, hanem a problémához igazodott, a programozóknak itt már nem kellett a gépi végrehajtással foglalkoznia. Minél függetlenebb egy programozási nyelv a gépi logikától, annál magasabb szintű, annál magasabb minőségi követelményeknek tud eleget tenni. A magas szintű programozási nyelvek 1:N típusú nyelvek, azaz egyetlen magas szintű programnyelvi utasítás több gépi kódú utasítást reprezentál. Természetesen a magas szintű nyelven írt programokat is le kell fordítani - az assembly-hez hasonlóan - de komoly előny, hogy ezeknél a nyelveknél már sokkal kisebb a hibalehetőség, a forrásprogram sokkal áttekinthetőbb lett. A magas szintű programozási nyelvek már sokkal közelebb állnak az emberi logikához, mint

elődük, jóval egyszerűbben, világosabban le lehet írni segítségükkel a problémát. Egy összeadási művelet assembly-ben, illetve magas szintű programozási nyelvben: mov x,10 X=10 mov y,12 Y=12 add x,y SUM=X+Y mov sum,x FORTRAN: Az első magas szintű programozási nyelv az IBM cég által kidolgozott FORTRAN volt. 1957ben jelent meg, elsősorban a műszaki-tudományos számítások legősibb nyelve Nevét a Formula Translation szavak összevonásából kapta. Elsősorban matematikai formulákat tartalmazó elágazások kezelésére volt alkalmas, a numerikus algoritmusok széles körét támogatta, viszont az I/O műveletek, és a karakteres adathalmazok kezelése szempontjából nem bizonyult hatékony nyelvnek. Az I/O műveleteket mindössze alapvető függvények által valósította meg, a nyelv elsődleges célja a matematikai problémák megoldása volt, ehhez a speciális területhez azonban nagyon hatékony eszköznek bizonyult. A nyelv szerkezetét

vizsgálva azt tapasztaljuk, hogy a programok két részből állnak: • főprogramból, amely a PROGRAM és END utasítások között helyezkedik el. • egymásba nem ágyazható alprogramokból, szubrutinokból, amelyek FUNCTION.END, illetve a SUBROUTINEND utasítások között helyezkednek el a A fordítóprogram az egyes szerkezeti elemeket külön fordítja, a különböző tárgyprogramokat kell összeszerkeszteni, hogy futtatható programot kapjunk. A FORTRAN képességeinek növelésén a fejlesztők igen sokat fáradoztak. A nyelvnek igen sok szabványosított változata jelent meg. 1966-ban a FORTRAN 66, 1977-ben a FORTRAN 77 ANSI, és ezek mellett készültek el a FORTRAN II., IV és V változatok Az utolsó szabványosított változat a FORTRAN 90 volt, melyek ma is használnak a tudományos számítások programozására. Bár napjaink igényei az univerzális nyelvek felé mutatnak, a FORTRAN mégis megmaradt a műszaki és tudományos számítások nyelvének.

Jelenleg folyamatban van - vagy már elkészült - a legújabb verzió, a FORTRAN 2000. ALGOL: A FORTRAN-hoz hasonlóan, úttörő nyelv volt a magas szintű nyelvek sorában. 1955-ben fejlesztették ki, a matematikai, műszaki számítások célnyelveként. Az első véglegesnek tekintett változatot 1960-ban fogadták el egy párizsi konferencián, neve ALGOL 60 volt. Később, több lépcsőben történő fejlesztés után megjelent a nyelv egy újabb változata, az ALGOL 68. Mindkét változat támogatta a moduláris programozást és a dinamikus tárolóelhelyezést (hasonló a mai mutatókhoz). Új lehetősége volt a rekurzív alprogramok írása Az ALGOL viszonylag kis utasításkészlettel rendelkezett, azonban szintaktikája nagyon hasonlított az emberi beszédre (Bacus-Naur Forma). A nyelv szimbólumrendszere azonos volt a matematikában alkalmazott szimbólumrendszerrel, ami az ilyen jellegű problémák programozását nagyon megkönnyítette. A programban lévő blokkok

önálló egységeket képviseltek, az alprogramokat egymásba lehetett ágyazni. Az ALGOL szabad formátumú nyelv, az utasítások tetszőleges helyre írhatók. Minden utasítást ;-vel kell lezárni. A főprogram kezdetét a PROCEDURE szó jelzi, a program végét az END Mindkettő után meg kell adni a program nevét. A programban használt változókat deklarálni kell, a deklarációk a blokkok elején helyezkednek el. Az ALGOL nyelv elsősorban a kutatómunkában és az oktatás területén terjedt el. Első számú alkalmazási területe az informatikai kutatás volt. Jelentősége azonban vitathatatlan, mivel számos később kialakult programozási nyelv alapjaként szolgált. Pld: PASCAL COBOL: Az eddigiekben tárgyalt programozási nyelvek elsősorban a matematikai, műszaki számítások területét támogatták sikeresen. Szükség lett volna egy olyan nyelvre is, amely az adatfeldolgozást, az információs rendszerek kezelését segíti, támogatja. Az Amerikai

Védelmi Minisztérium finanszírozásával 1959-ben létrejött a CODASYL (Conference on Data Systems Language) bizottság, és lefektette az alapokat egy új, a gazdasági, kereskedelmi életben jól használható adatfeldolgozás-orientált programozási nyelv kifejlesztéséhez. 1963-ban született meg a COBOL (Common Business Oriented Language), amely alkalmasnak látszott a gazdasági életben való alkalmazásra is. Az Amerikai Szabványügyi Hivatal (ANSI) 1968-ban elfogadta, majd újabb fejlesztések után 1974-ben szabványossá nyilvánította a nyelvet. A COBOL megjelenése után hamar népszerűvé vált, mert minden számítógéptípuson alkalmazható nyelv volt. Kiterjedt lehetőségeket biztosított az adatállományok létrehozására, karbantartására és lekérdezésére. A COBOL kötött szerkezetű programozási nyelv volt, 4 szerkezeti blokkból épült fel: • Identification Division: Azonosító rész. Olyan információkat tartalmaz, mint a program és

a programozó neve, készítési időpontja stb. • Environment Division: Környezethívó rész. A futási környezet meghatározását, az alkalmazandó perifériák hivatkozásait tartalmazza. • Data Division: Adatleíró rész. Az alkalmazandó állományok és adatstruktúrák leírását tartalmazza • Procedure Division: Az eljáráshívó rész. A feldolgozandó adatokkal végzett műveletek, utasítások leírása A COBOL nyelvet ma is használják az adatfeldolgozás területén. Az első változathoz képest a nyelv igen nagy változásokon ment keresztül, nagyon sokat fejlesztették az évek során. 1989-ben jelent meg a strukturált, néhány évvel később az objektumorientált változata. A COBOL nyelv előnyeként meg kell említeni a kiváló dokumentálási lehetőségeket, a komplex adathalmazok kezelésének jelentős könnyítését. Hátránya viszont, hogy a programok mérete igen nagy lesz, és az alapvető matematikai műveleteken túl nem

támogatja a bonyolultabb számítási feladatokat. BASIC: A BASIC nyelv kialakulása a programozási nyelvek fejlődésének bölcsőjéhez vezet vissza, amikor a magyar származású Kemény János és munkatársa, Thomas Kurtz elhatározták, hogy kidolgoznak egy olyan programozási nyelvet, amelynek segítségével a programozás könnyen oktatható és tanulható. A köztudatban a BASIC nyelv a kezdő programozók nyelveként vált ismertté. Az ötlet a 60-as évek elején született, amikor megjelentek az első Time-sharing (időbeosztásos) rendszerek, és a központi számítógépen tárolt adatokhoz egyre több felhasználó férhetett hozzá. A felhasználóknak szükségük volt egy olyan programozási nyelvre, amelynek segítségével megvalósíthatták a központi adatokhoz való interaktív hozzáférést. A FORTRAN és COBOL nyelvek batch üzemmódban készültek, ezért nem voltak alkalmasak az adatok dialogikus feldolgozására, igény volt egy általános célú,

interaktív, eljárás-orientált programozási nyelv létrehozására. Az első ilyen interpreter típusú nyelv a BASIC volt, amely nagymértékben egyszerűsítette a programok írását és tesztelését. A BASIC (Beginners All-Purpose Symbolic Instruction Code) nyelv első működő változata 1963-ban jelent meg. A nyelv valójában a FORTRAN egyszerűsített változata volt, korlátozott utasításkészlettel és egyszerű szimbólumrendszerrel. A FORTRAN-nél lényegesen hatékonyabb támogatást nyújtott a karakteres adatok és az I/O műveletek kezeléséhez, szintaktikája közel állt az emberi gondolkodáshoz. Az első változatok utasításkészlete még nem tette lehetővé a struktúrált programozást, gyakran kellett alkalmazni az ugró utasításokat (GOTO). A BASIC-ben a programok végrehajtása utasításonként történt (INTERPRETER módban), ami gyakorlatilag nagyon megkönnyítette a programok tesztelését. Az első változattól kezdve a nyelv nagyon sok

változtatáson ment keresztül, nagyon sok változata jelent meg, újabb és újabb lehetőségekkel bővítve a nyelvet. A fontosabb változatok a QUICK BASIC, GFA BASIC, MS-BASIC, és a Pascal elemet is tartalmazó VISUAL BASIC. A változatok közül egyedül a VISUAL BASIC-et tekintjük strukturált programozási nyelvnek, a programblokkok és eljárások, függvények kezelése miatt. RPG: A 60-as évek végén jelent meg egy új, az IBM cég által kidolgozott programozási nyelv, amely a COBOL-hoz hasonlóan az adatfeldolgozás támogatását tűzte ki célként, de a megvalósítás során teljesen eltérő filozófiát alkalmazott. Ez a nyelv volt az RPG (Report Program Generator) Ellentétben az eddig tárgyalt procedurális nyelvekkel, az RPG a nyelvbe épített, előre definiált standard elemekkel dolgozott. A technikát arra alapozták, hogy minden üzleti típusú jelentés, kimutatás gyakorlatilag azonos felépítésű. Az RPG volt az első listageneráló

programozási nyelv. Lehetővé tette a bonyolult adatok gyors és egyszerű feldolgozását, és emellett viszonylag kis memóriát igényelt. Hátránya volt, hogy nem támogatta a bonyolultabb számításokat, ezek elvégzéséhez Assembly rutinokat kellett beszúrni. A nyelvnek sokféle változata született, sokáig próbálták fejleszteni, piacon tartani. Ennek ellenére korlátozott felhasználási területe miatt háttérbe szorult. 3 GL (harmadik generációs programozási nyelvek): A második generáció programozási nyelvei már lényegesen függetlenebbek voltak a gépi logikától, mint az első generációs nyelvek, az elkészített programokat többféle gépen is használni lehetett. Azonban a 2 GL nyelvek többsége egy-egy problémacsoport megoldására specializálódott, ami a programok fejlesztése, javítása során igen komoly akadályokat jelentett. A 60-as évek derekán kíséreltek meg először olyan programozási nyelvet fejleszteni, amely rendelkezik a 2

GL nyelvek jó tulajdonságaival is, emellett többféle problémacsoport megoldására alkalmas, univerzális. Az új korszakot a procedurális programozási szemlélet és az adatok struktúrájának hangsúlyozása jellemezte. Megszülettek az első 3 GL nyelvek, amelyeket még ma is használnak. Ezek a programnyelvek már igen sokféle probléma megoldására alkalmasak, de minden problémára optimális programozási lehetőséget biztosító programozási nyelv nem létezik. A 3 GL nyelveket három csoportra oszthatjuk: • általános célú, magas szintű nyelvek • objektum-orientált nyelvek • specializált nyelvek Az általános célú programozási nyelvek családjába tartozó nyelvek széleskörűen alkalmazhatók a gazdasági számításoktól a rendszerprogramozási fejlesztésekig, széles a lehetőségek skálája. Néhány ismertebb, szélesebb körben elterjedt 3 GL programozási nyelv: PL/1, APL, PASCAL, Modula-2, ADA, C. PL/1 (Programming Language

I.): A PL/1 programozási nyelvet az IBM cég fejlesztette ki, az első változata 1964-ben jelent meg. Ez a nyelv még nem igazán sorolható a harmadik generációs programozási nyelvek közé, de mivel igen sokféle feladat megoldására alkalmas, megérdemli a 3 GL elnevezést. A PL/1 szabad formátumú nyelv, amely a FORTRAN, az ALGOL és a COBOL nyelvek előnyeit egyesíti magában. Egyaránt alkalmas az adat-feldolgozási és a számítási problémák megoldására, emellett a program szerkezete egyszerű és követhető, formai előírásai nem túl szigorúak. A programok blokk-szerkezetű felépítése már a strukturáltság koncepcióját vetíti előre. A program tartalmaz egy főprogram részt, amely külön blokkokban több alprogramot foglalhat magába, az alprogramok egymásba ágyazhatók. A fordító a deklarációkat utólag helyezi el a program elején. A PL/1 előnyei: • mindenféle alkalmazáshoz jól használható • könnyen tanulható, egyszerű nyelv

• bonyolult feladatok megoldására is alkalmas • szabad formátumú programozást tesz lehetővé • blokkszerkezete jól illeszkedik a struktúrált programozási szemlélethez, az eljárások, függvények jól elválaszthatók egymástól Az első verziót újabb és újabb változatok követték, 1976-ban jelent meg az oktatáshoz is jól alkalmazható változata a PL/C. Bár a PL/1 univerzális programozási nyelv, mégis csak az IBM gépek alkalmazói körében terjedt el, aminek oka a megjelenés időpontjában keresendő. Ekkorra már a programozók többsége megismerte a FORTRAN és a COBOL használatát, és nem kívántak egy újabb nyelvre áttérni, főleg mivel ez a nyelv az előző kettő integrációjának tekinthető, igaz tartalmaz néhány újdonságot. APL (A Programming Language): Az APL egy a matematikai problémák megoldására orientálódott, többcélú (de nem általános) programozási nyelv volt. A nyelvet Kenneth Iverson, amerikai

matematikus dolgozta ki, elsősorban műszaki, tudományos alkalmazások fejlesztése céljából. Az APL programok egyik sajátossága, hogy kezelik a görög betűket, beépített (implicit) lehetőségei közé tartoznak az egy- és többdimenziós tömbökkel végzett műveletek. A nyelv szimbólumrendszere és szerkezete szabad formátumú. Az APL programok írásához speciális billentyűzetre van szükség (a görög betűk és a speciális operátorok miatt). Az APL nyelv nem támogatja a struktúrált programozást, így nagyobb feladatok megoldását nehézkessé teszi, de a nagy számban rendelkezésre álló beépített operandussal kiválóan alkalmas prototípusok gyors készítésére. A 70-es, 80-as években műszaki, tudományos és gazdasági problémák megoldásra egyaránt hatékonyan használták. Az újabb változatok (APLG) támogatják a grafikus feldolgozást is, manapság a numerikus számítógépek működésének leírásához használják. PASCAL: A

PASCAL nyelv volt az első igazi és legteljesebb körű megvalósítása a struktúrált szemléletű programozás elveinek. Niklaus Wirth professzor, a zürichi Műszaki Főiskola oktatója dolgozta ki a nyelvet a 70-es években, és Blaise Pascal francia matematikus-filozófusról nevezte el. Wirth professzor az ALGOL programozási nyelv alapján definiálta a PASCAL szabályait, a cél egy az ALGOL-hoz hasonló, de általános célú programozási nyelv elkészítése volt. A PASCAL általános célú programozási nyelv, amelyet elsősorban az oktatásban, a műszakitudományos számítások területén és a komplex programrendszerek fejlesztése során alkalmaznak elterjedten. Szabad formátumú nyelv, mely viszonylag kevés utasítást tartalmaz. A programok szerkezete kötött, szigorú előírások vonatkoznak rá. A PASCAL programok blokkokból épülnek fel, a blokkok a begin foglalt szóval kezdődnek és az end foglalt szóval érnek véget. Minden utasítás végére 

-t kell tenni. A PASCAL nyelv támogatja a moduláris programozást, függvények és eljárások definiálhatók a function és a procedure foglalt szavak segítségével. A függvények, eljárások egymásba ágyazhatók, sőt a nyelv támogatja a rekurziót is. A PASCAL erősen típusos nyelv. A programban használni kívánt változókat a főprogram előtt elhelyezkedő deklarációs részben fel kell tüntetni. A PASCAL fordítók compiler típusú fordítók. A programok szabályos, szigorú, egyértelmű felépítése miatt a nyelv az oktatás kedvelt programozási nyelve. A PASCAL nagyon jó alapot biztosít más programozási nyelvek tanulásához, a struktúrált programozás alapelveinek megértéséhez. MODULA-2: Amint a nevéből is lehet következtetni, olyan programozási nyelvről van szó, amely igen magas szinten támogatja a moduláris programozás módszerét, azaz a feladatok részfeladatokra bonthatók és az egyes részeket külön lehet programozni,

fejleszteni. Az egyes modulok az utasítások mellett tartalmazzák a modul során felhasznált adatokat, változókat, konstansokat is. A modulok hierarchikus felépítésűek, tehát egymásba ágyazhatók. Célszerű élni ezzel a lehetőséggel, annak érdekében, hogy az egyes alprogramok egymással megfelelően tudjanak kommunikálni. A nyelv támogatja a rekurzív alprogramok mellett, a párhuzamos vezérlőszerkezetek készítését is. Ez utóbbi lehetőség a versenyhelyzetben álló folyamatok programozásánál lehet hasznos (multitasking). A nyelv egyik nagy előnye, hogy a moduláris felépítésű programok könnyen áttekinthetők, értelmezhetők egy esetleges módosításkor. Manapság is népszerű nyelv, majdnem minden operációs rendszerhez beszerezhető a fordítóprogramja. ADA: A ’70-es évek közepén fejlesztették ki ezt a Pascal-hoz hasonló nyelvet, amely nagyon hatékonyan alkalmazható mind a rendszerszintű programok írása során, mind a komplex

gazdasági számítások megoldásakor. A nyelv Augusta Ada Byron-ról kapta a nevét, akit Charles Babbage munkatársaként az első női programozóként említ az informatika története. Az ADA nyelv fejlesztésének célja egy hatékony, teljes gépfüggetlenséget biztosító programozási nyelv létrehozása volt. Éppen ezen törekvések miatt az ADA nyelv nagyon sok lehetőséget biztosít, a fontosabbak: multitasking, kommunikáció, megszakítás-kezelés. Az ADA programok moduláris felépítésűek, az egyes modulokat Package-nek nevezzük. Ezek az egységek gyakorlatilag egymástól függetlenül elkészíthetők és lefordíthatók. A modulok hivatkozhatnak egymásra a USE kulcsszó segítségével. A nyelv sajátossága, hogy az egymástól csak néhány ponton eltérő modulokat a GENERIC és NEW kulcsszavak segítségével egymásból származtathatjuk. Ez a tulajdonság már az objektumorinentált nyelvek irányába mutat előre A nyelv előnye, hogy támogatja a

multitaskos működést, amely ma már alapvető követelménynek számít. A megírt program áttekinthető, könnyen módosítható, a moduláris felépítés miatt. A nyelv szerteágazó lehetőségei szinte minden területen használhatóvá teszik, ugyanakkor ebben a komplexitásban kereshető a nyelv hibája is. Az ADA egyik gyenge pontja, hogy bonyolult és sajátságos szemantikával rendelkezik, amely más nyelvek esetén nem jellemző, ezért tanulása elég nehéz feladat. C nyelv: A rendszerprogramozás fejlődése során mérföldkőnek tekinthetjük az 1972-ben megjelent C nyelvet. Megalkotója Dennis Ritchie, aki eredetileg a UNIX rendszerek fejlesztőeszközének szánta. Később különleges hatékonyságát és sokoldalú felhasználási lehetőségét látva más operációs rendszerekhez kidolgozták a C nyelvű fordítóprogramokat. A nyelv különlegessége, hogy egyesíti magában a hardverközeli programozás és a magasszintű nyelvek előnyeit, ilyen módon

jól kihasználhatjuk a hardver adta lehetőségeket – javul a futási idő – mégis gyorsan tudunk új programokat írni, mivel logikájában a magas szintű nyelvek formáját követi a C is. A Pascal-hoz hasonlóan viszonylag kevés utasítást tartalmaz, a legtöbb műveletet előre definiált függvények segítségével oldja meg. A C nyelv támogatja az alprogramok készítését, de csak a függvény típusú modulokat ismeri. Az eljárásokat visszatérési érték nélküli függvényként definiálhatjuk. Lehetőség van rekurzív alprogramok készítésére is A C nyelv nagyon erősen támaszkodik a mutatókra. Előnyös a C programok írása során kihasználni a mutatók adta lehetőségeket, mert programunk ezáltal gyorsabb, hatékonyabb lehet. Típuselőírásai sokkal engedékenyebbek, mint azt a Pascal nyelv esetén tapasztaltuk, bár az automatikus típusdeklarációt nem támogatja, a konverziók terén igen nagy szabadságot biztosít a programozónak. A C

nyelv utasításai mindössze a struktúrált programok készítéséhez szükséges utasításokra korlátozódnak: • Összetartozó utasítások (utasításblokk {}) • Kétirányú elágazási szerkezet (if else) • Esetszétválasztás (switch case ) • Ciklusszervező utasítások A C nyelvet 1989-ben fogadta el az Amerikai Szabványügyi Hivatal. Ekkor jelent meg az ANSIC, az első szabványos C fordító A későbbi változatok ennek lehetőségeire építkeztek A C nyelvet ma is széles körben használják, első számú alkalmazási területe a rendszerprogramozás. A mai követelményeknek megfelelő C változatok a C++, az objektum-orientált lehetőségekkel bővített C nyelv, és a Concurent C, a párhuzamos folyamatok programozását segítő eszköz. Objektum-orientált programozási nyelvek: Az utóbbi években kezdett széleskörűen elterjedni egy új szemléletű programozási technika, az objektum-orientált programozás, amely az elődeinél

egyszerűbbé, hatékonyabbá, biztonságosabbá teszi a programkészítési munkát. Az objektum-orientált programozási nyelvek absztrakt adattípusokkal és a hozzájuk tartozó előre definiált algoritmusokkal segítik a programozó munkáját. Az objektum-orientált nyelvek az adatokat és az őket kezelő eljárásokat, függvényeket egységbe foglaltan ún. objektumként kezelik. Az objektum-orientált programozás lényege, hogy a programozás során felhasznált elemeket a nyelv előre definiálja, és különböző tulajdonságokkal ruházza fel. Amikor a programozó használni szeretné az egyik elemet, csak a tulajdonságait kell egyéni ízlése – illetve a feladatnak megfelelő elvárások szerint – megváltoztatnia. Egy egyszerű példán szemléltetve: A nyelvben előre definiált objektum a Kor, amely egy kör rajzolását teszi lehetővé. A Kor objektum: Type Kor=object Szin: Integer; Sugar: Integer; X: Integer; Y: Integer; Procedure Rajzol; End; A Kor

objektum felhasználása: Kor.Szin:= Green; Kor.Sugar:= 120; Kor.X:= 200; Kor.Y:= 300; Kor.Rajzol; Ez a proramozási technika sokkal közelebb áll az emberi gondolkodáshoz, mint a procedurális programozás. Az objektum-orientált programozás elterjedésével sok új nyelv jött létre, amelyek tiszta objektum-orientált nyelvek, más technikát egyáltalán nem támogatnak. Sok nyelvet kibővítettek az objektum-orientált technika alkalmazásának lehetőségével, ezek az ún. vegyes nyelvek Tiszta objektum-orientált nyelvek: SmallTalk A ’70-es évek elején fejlesztette ki Adele Coldberg és munkatársa Alan Kay azzal a céllal, hogy egy rugalmas, felhasználóbarát programozási környezetet biztosítson a fejlesztők számára. Manapság is széles körben használt programozási nyelv. Eiffel 1988-ban dolgozta ki a nyelvet Bertold Meyer. Objektum-orientált, erősen típusos nyelv A hordozhatóság érdekében a megírt programot C nyelvre is le lehet fordítani. A

szakemberek szerint az egyik legjobb objektum-orientált programozási nyelv. Vegyes nyelvek: Turbo Pascal A Turbo Pascal 5.5 verziójától kezdve támogatja az objektumok létrehozásának és kezelésének lehetőségét. A 60 verzióba már került egy előre definiált objektumrendszer – TVISION – is, amely a szöveges felületű programok készítése során használható fel hatékony segédeszközként. Borland C++ A C++ elnevezés a hagyományos C nyelv objektum-orientált lehetőségekkel bővített változatát jelenti. A Borland C++ 31 verzió már támogatja az objektum-orientált technika alkalmazását Hasonló környezetet és objektumrendszert biztosít, mint a Turbo Pascal 6.0 Specializált programozási nyelvek: Ma már a számítógépet a tudományos és kutatómunka igen sok területén is felhasználják. Ezek a területek olyan speciális igényeket támasztanak a számítógépekkel szemben, amelyek megoldásához hasonlóan speciális eszközökre van

szükség. Ezen problémák támogatása érdekében fejlesztették ki a specializált programozási nyelveket, amelyek sokszor csak igen szűk problémacsoportok megoldására alkalmasak. Ez mégsem említhető hátrányként, hiszen éppen ezért alkották őket: egy-egy probléma megoldásához hatékony segítséget biztosítanak. Nézzünk meg néhány ilyen speciális területet: Rendszer- és fordítóprogramok fejlesztése: A programfordítók fejlesztéséhez olyan magasszintű programozási nyelvre van szükség, amely hatékonyan támogatja az alacsony szintű programozás és az operatív tár közvetlen kezelését egyaránt, lehetővé teszi a bitenkénti műveletek végzését, mégis rendelkezik a magasszintű nyelvek előnyeivel. Ilyen nyelvek: B, C, BCPL, Pascal. Formulakezelő nyelvek: Nagy pontosságot igénylő, bonyolult matematikai, műszaki számítások számítógép által történő elvégzéséhez biztosítanak hatékony segítséget ezek a nyelvek.

Például: FORMAC, REDUCE, MACSYMA. Szimbólum-feldolgozó nyelvek: Nagy mennyiségű szöveges információk, hosszú listaadatok értékelésére, elemzésére kidolgozott célnyelvek. Felhasználási területük az információkutatás, a matematikai kutatások Például: PROLOG, CONVERT, LISP, SNOBOL, COGENT. Szimulációs nyelvek: Nagyon sok területen használatos nyelvek, kísérletek, folyamatok eredményeinek előrejelzését segítő eszközök. Például: SIMSCRIPT, SIMULA, GPSS. Adatbázis-kezelő nyelvek: Adatbázisokban tárolt adatok kezelését segítő programozási nyelvek. lekérdezhetjük, módosíthatjuk, karbantarthatjuk az adatbázisban tárolt adatokat. Segítségükkel Kiterjeszthető programnyelvek: A harmadik generációs programozási nyelvek legfejlettebb változatai. A programozási feladat megoldásához a nyelv csak egy minimális bázist definiál előre. A hiányzó eszközöket azonban a programozó maga állíthatja elő a már létező elemek

segítségével. Például: LOGO, FORTH. 4 GL (negyedik generációs programozási nyelvek): A XX. század második felében a számítástechnika forradalmi változáson ment keresztül A Neumann elvek megjelenése és az első memóriában tárolt gépi nyelvű program lefuttatása után alig ötven évvel már információs rendszerek, központilag vezérelt számítógép hálózatok programozása, döntéshozást támogató rendszerek fejlesztése a célunk. Nyilvánvaló, hogy ilyen jellegű munkák elvégzésére a hagyományos programozási nyelvek által biztosított eszközök nem megfelelőek. A hardver eszközök rohamos fejlődésére támaszkodva kezdett kialakulni a programozás során egy új szemlélet, mely az eddigi alapelvekkel szöges ellentétben állt. A 4 GL nyelvek előnyösen egyesítik a procedurális és a non-procedurális nyelvek elemeit, lehetőségeit, kihasználva mindkét nyelv előnyeit, és kiküszöbölve a hátrányok jelentős részét. A

programok (programrendszerek) tervezése során a programozónak már nem a hogyan kérdésre kell válaszolnia, csak azzal kell törődnie, hogy mit szeretne megvalósítani. A legújabb programozási nyelvek esetében már nem az algoritmust, hanem az elérendő célt kell megfogalmazni, a kód generálását legtöbb esetben a fejlesztő rendszer automatikusan végzi el. Fontos jellemzője a nyelveknek, hogy nemcsak a program szintaktikai helyességét ellenőrzik, hanem megvizsgálják a program hatékonyságát, rendszerbe illeszthetőségét is. Meg kell említenünk a 4 GL nyelvek nyilvánvaló előnyei mellett néhány rossz tulajdonságot is. A program hatékonyságának növekedésével egyenes arányban nő a program hardverigénye – elsősorban memória – igénye is, a lefordított program méretéről nem is beszélve. A gyakorlati alkalmazások kb. 25%-a fejleszthető optimálisan a 4 GL programozási nyelvek valamelyikével, a maradék 75% esetében továbbra is

hatékonyabb eszköznek bizonyulnak a 3 GL nyelvek. A 4 GL nyelvek osztályozása: Lekérdező nyelvek: Biztosítják az adatbázisok adataihoz történő hozzáférést, akár egyszerű lekérdezésről, akár az adatok módosításáról, rendezéséről, vagy az adatbázis bővítéséről van szó. Programgenerátorok: Lehetővé teszik, hogy a felhasználó egy előre definiált minta alapján egyszerűen és hibátlanul hozzon létre egy harmadik generációs programnyelvi alkalmazást. Egyéb 4 GL nyelvek: Ebbe a csoportba sorolhatjuk a döntéstámogató rendszerek fejlesztésére használatos nyelveket, a prototípus nyelveket (modellezést, tervezést segítő nyelvek), és a formális specifikáció nyelveit. Mellékletek: 1. Melléklet: Gépi kódú és Assembly programrészlet 2. Melléklet: Fortran programrészlet 3. Melléklet: Algol és PL/I programrészlet 4. Melléklet: Basic programrészlet 5. Melléklet: Pascal programrészlet 6. Melléklet: Modula-2

programrészlet 7. Melléklet: ADA programrészlet 8. Melléklet: C programrészlet 9. Melléklet: A programozási nyelvek generációi