Készítette: Hudasi Luca Flóra
Régi programozási nyelvek
A programvezérlésű számítógépek a 2. világháború után indultak fejlődésnek. A számítógépeknek ebben az időben megnőtt a számítási sebességük, pontosabban számoltak, és lehetőség volt az információ tárolására is. A műveleteket emberi beavatkozás nélkül is el tudták végezni. A számítógépes programnyelvek - főleg az első időben - matematikai problémák megoldására koncentrálódtak. A mérnökök/matematikusok/programozók úgy vélték, hogy amennyiben a számítógéppel meg tudnak oldatni egy összetettebb matematikai problémát, akkor utána a matematika segítségével bármilyen hétköznapi problémát is le lehet írni. A programtervezés során először a probléma matematikai modelljét készítették el, majd ezt a modellt átültették egy algoritmusba, és csak ezután került az algoritmus a mai értelemben vett leprogramozásra.1 A korai nyelvek (Fortran, A, B) az előbb kifejtettek miatt rendelkeztek zömmel csak matematikai utasításkészlettel és színtaktikával. A programozáshoz kezdetben alaposan ismerni kellett a számítógép felépítését. Később az algoritmikus programozási nyelvek kifejlesztésével leegyszerűsödött a programozás. A teljesen gépi nyelvű programozás (0-ák és 1-esek) nagyon körülményes volt, és hamar rájöttek, hogy bizonyos ismétlődő tevékenységeket (utasításokat) a számítógéppel is el lehet végeztetni, mindössze egy mintafelismerő ’fordító’ programot kell hozzá írni, mely átalakítja a kulcsszavakat gépi utasításokra. Ilyen nyelvek voltak kezdetben az assembler típusú nyelvek, melyek géporientáltak voltak. A mai napig használt és ismert alacsony szintű nyelv az Assembly. Az Assembly tulajdonképpen gépi utasítások sorozata, melyhez egyrészt ismerni kell a 16-os és 8-as számrendszereket, valamint a gép felépítését és a regiszterek állapotát. A mai modern programok is mind assembly kódra fordulnak le, mert a gép ezt érti meg. Ha ma megírnánk egy programot assemblyben és ugyan azt megírnánk C#-ban, majd lefuttatnánk a kettőt, az assembly lényegesen gyorsabban futna. Ennek az az oka, hogy hiába fordul le a C#-os program is assemblyre, az lényegesen több utasítást tartalmaz, mint az assemblyben megírt program. Nyilvánvalóan az ember jobban ki tudja szűrni, hogy milyen utasításokra van szüksége és jobban optimalizálja a kódot, mint a beépített C# fordító. Ettől függetlenül, a mai gyors számítógépeknek hála a programozók megengedhetik maguknak ezt a „pazarlást” és egyre kevesebb olyan programozó van, aki még tud assemblyben komolyan programozni. Vegyük az alábbi egyszerű példát az assembly nyelv logikájának bemutatására. A példaprogram2 kiszámol egy tetszőleges indexű Fibonacci számot, amely jelen esetben 5:
1
Artiaga – Davis: Algoritmusok és FORTRAN programjaik, 1977, Műszaki Könyvkiadó (Budapest) Erdélyi Zoltán: FORTRAN programozási nyelv, 1979, Tankönyvkiadó (Budapest) 2 Saját program
global _main section .text _main: mov ecx,5 mov eax,1 mov ebx,1 mov edx,0 luca: xor edx,edx add edx,ebx add edx,eax mov ebx,eax mov eax,edx loop luca A példából látszik, hogy ebben az esetben a memóriakezelést teljes mértékben a programozó végzi olyan mélységig, hogy még azt is meg kell adni melyik adat melyik regiszterbe kerüljön. Néhány minimális eszköz áll csak a programozó rendelkezésére, mint például a ciklus használata (loop) vagy a függvény deklaráció (_main). Ma már lehetőség van a rendszer C függvényeinek használatára is, így tulajdonképpen ki lehet bővíteni a lehetőségeket a C nyelv képességeivel, de régebben ilyen nem létezett. Az assembler típusú nyelvek után elég gyors fejlődésnek indultak és megjelentek a különböző magasabb szintű (algoritmikus) programozási nyelvek is fordítóval együtt. Ezekben a nyelvekben az utasításkészlet közelebb áll a matematikában használatos jelölésekhez, és kevés gépi ismeret szükséges hozzájuk. Kezdetben úgynevezett ’autokódok’ léteztek, melyek ugyan már nem gépi kódok voltak, hanem fordítóval és szimbolikus utasításkészlettel rendelkező nyelvek, de mégis különböző változatban fordultak elő a különböző számítógépekhez. Például az NME Matematikai Intézetben működő ODRA 1204es gépnek az ’EMA’ volt az autokódja (programozási nyelve). Tehát egy másik motiváció is előremozdította a programozási nyelvek fejlődését, mégpedig, hogy minél univerzálisabb legyen, mert annál hordozhatóbb lesz a program számítógépek között. Az 1950-60 években két magasszintű univerzális programozási nyelvet dolgoztak ki, a FORTRAN-t és az ALGOL-t. A FORTRAN eredetileg az IBM számítógépeinek az autokódja volt, de az IBM számítógépekkel együtt annyira elterjedt, hogy univerzális kód lett belőle. Az ALGOL egy európai programozási nyelv, és kifejlesztésekor törekedtek arra, hogy minél általánosabban lehessen vele leírni minden matematikai algoritmust. A számítógépeket kezdetben nem univerzális használatra gyártották, hanem különböző szakterületeken előforduló problémák megoldására specializálták a példányokat. A programozási nyelvek is követték a mintát, és szükség volt ’szak-nyelvekre’.
Ilyen problémaorientált univerzális nyelv a COBOL, mely az adatfeldolgozásban játszott fontos szerepet. Egy másik példa a SIMSCRIPT, melyet rendszerszimulációs problémák megoldására használtak. A FORTRAN programozási nyelv az 1970-es években élte fénykorát. A szó a formula és translation szavakból jött. Ez egy algoritmikus nyelv, fejlettebb, mint az assembly. A FORTRAN nyelv több változata volt használatban, melyek utasításaikban kicsit eltértek egymástól annak függvényében, hogy melyik számítógép családra használták. 1962-ben „az Amerikai Szabványügyi Hivatal (ASA) egy külön munkacsoportot hozott létre, amelynek az volt a feladata, hogy a FORTRAN-t számítógéptől független, szabályos programozási nyelvként definiálja”3. Amellett, hogy ez nem egy feladatspecifikált nyelv, mint például a SIMSCRIPT, azért is aratott nagy sikert, mert könnyen érthető volt a logikája, és a korabeli beviteli eszközöket, mint a lyukkártyát és lyukszalagot könnyű volt ezen a nyelven programozni. Bemutatunk egy nagyon egyszerű példaprogram FORTRAN nyelven 4 mely meghatározza legfeljebb 100 valós szám számtani átlagát:
55 3
66
MASTER ATLAG DIMENSION X (100) READ (6, 55) N, (X(I), I=1, N) FORMAT (I3/(8F10.3)) S=0 I=1 S = S + X (I) I=I+1 IF (I.LE.N) GO TO 3 S = S/FLOAT(N) WRITE (7,66) S FORMAT (1 H1, F10.3) STOP END
A FORTRAN nyelvben használatosak voltak a ma is ismert program logikai tagolások, mint a függvény, eljárás, main metódus, adatdeklaráció, stb. Az utasításkészletből látható, hogy az assemblyvel ellentétben itt nem kell a regiszterekkel törődni és a nyelv felépítése valóban általános. Az 1970-es években megjelent egy másik nyelv, a B nyelv, melyet Ken Thompson fejlesztett ki a Bell Labs-ban. A nyelv logikája, szintaxisa különbözött a többi korabelitől. Multics rendszerek programozására használták, és ez a nyelv volt az alapja a későbbi C nyelvnek. A következő példakódból5 látható mennyit fejlődött a programozás és hogyan kezdett közeledni a mai úgynevezett C alapú nyelvekhez:
3
Erdélyi Zoltán: FORTRAN programozási nyelv, 1979, Tankönyvkiadó (Budapest) 19. oldal Erdélyi Zoltán: FORTRAN programozási nyelv, 1979, Tankönyvkiadó (Budapest) 24. oldal 5 Ken Thompson : Users' Reference to B 1972, (scannelt változat: http://cm.belllabs.com/cm/cs/who/dmr/kbman.html) 4
main() { extrn putchar, n, v; auto i, c, col, a; i = col = 0; while(i
A program kiszámolja az e-2 értékét (azaz ∑ −2). ! A B nyelvben továbbá megjelent az argv[] mint előre definiált vektor. Ezzel a legtöbb mai modern nyelv rendelkezik, és arra szolgál, hogy a programot indulásakor fel lehessen paraméterezni. A B nyelv ezen kívül már beépített fájlműveleteket is tartalmazott. A B nyelvre erősen ráépült a mai napig is használatos és legelterjedtebb C nyelv. A számítógép programozásra igen nagy hatást gyakorolt ez a nyelv. Szintaktikailag nagyon hasonló a B nyelvhez, néhány változtatás, újítás került bele, hogy még hatékonyabb legyen. Például megjelent a ’void’ típusú metódus, mely lehetővé tette, hogy olyan függvényt írjunk, amelynek nincs visszatérési értéke. Ma ezeket nem függvényeknek, hanem eljárásoknak nevezzük. Kezdetben ezt is Unix alapú operációs rendszerekre írták, mint a B nyelvet, de aztán olyan nagy sikert aratott, hogy megjelentek más operációs rendszerekkel is kompatibilis fordítók. A következő C program stringeket vizsgál, és összeadja a bennük fellelhető természetes számokat6:
6
Juhász – Kósa – Pánovics – Édelkraut: C példatár (http://www.inf.unideb.hu/kmitt/konvkmitt/c_peldatar/book.xml.html#id451490)
unsigned long termszam( char *s ) { unsigned long osszeg = 0; int i; for ( i = 0; s[ i ]; ++i ) if ( !isdigit( s[ i ] ) ) s[ i ] = ' '; while ( 1 ) { char *p; osszeg += strtoul( s, &p, 10 ); if ( s == p ) break; s = p; } return osszeg; }
A C nyelvet ma főképpen hardver programozására, illetve rendszer kernel programozására használják. Az assembly helyettesítője lett, habár az assembly is még használatban van. Érdekességként érdemes megemlíteni az ABC nyelvet, melynek a neve szándékosan került ki az A, B és C programnyelvek neveinek összevonásából. Ugyan a C nyelv sokkal kezelhetőbb volt, mint a megelőző nyelvek, mégis sokan nehezen érthetőnek találták. Egy jó C programozónak továbbra is megalapozott matematikai és gépi ismeretekkel kellett rendelkeznie, ezért néhány szakemberben megfogalmazódott az a gondolat, hogy kéne egy olyan nyelvet készíteni, amely sokkal gyorsabban megtanulható, azaz „sokkal beszédesebb” mint az A, B és C nyelvek. Így fejlesztették ki az „ABC” programozási nyelvet. Ennek hatására két táborra oszlottak a programozók, és különféle publikációk jelentek meg arról, hogy miért lenne érdemes megkönnyíteni a programozók dolgát, illetve, a másik csoport nézete szerint miért nem kéne ledegradálni a programozást csupán a kényelem kedvéért. Végül a C nyelv győzött de csak az ABC-vel szemben, mivel az ABC elvesztette a népszerűségét, és „tanulónyelvnek” bélyegezték. Az irányzat viszont, miszerint alkossunk olyan nyelveket, amelyeknél a programozás megkönnyítésére helyezzük a hangsúlyt, tovább élt, és a későbbi „menedzser nyelvek” mind ebből nőttek ki (például C#). Az alábbi program részlet7 egy nagyobb program része, de illusztrálja az ABC nyelv „beszédességét”:
7
Geurts – Meertens – Pemberton: ABC programmer’s handbook, 70. oldal (Bosko Books, 2005, Bristol)
HOW TO GENERATE IMITATION FROM followers: PUT choise keys followers IN group WHILE group in keys followers: GENERATE ONE CHARACTER WRITE / GENERATE ONE CHARACTER: PUT choise followers[group] IN character WRITE character UPDATE group WITH character Ugyan sokan vitatják, hogy programozási nyelv lenne-e, de meg kell említeni az SQL-t, amely szintén az 1970-es években látta meg a napvilágot. Az SQL-t (structured-querylanguage) az IBM fejlesztette ki. Azáltal, hogy szélesebb körben is elterjedtek a számítógépek, és egyre több cég és szervezet tárolta gépeken az adatokat, igény volt arra, hogy ehhez a tárolt, nyilvántartott adatmennyiséghez gyorsan és hatékonyan hozzá lehessen férni. Az adatbázis kitalálása magával hozta az adatbázis-nyelv kialakulását is. Egy olyan nyelvre volt szükség, amellyel könnyedén és egyszerűen meg lehet valósítani halmazműveleteket és halmazok közötti adatmozgató/módosító utasításokat. Az SQL egy célnyelv, amelyet kifejezetten adatbázis műveletekre írtak. A személyes véleményem az, hogy ez is épp olyan programnyelv mint a többi, mivel az alap funkciók mind megvannak benne: függvény deklaráció, változó deklaráció, ciklusok, stb. Általában azt szokták programozási nyelvnek nevezni, ami Turing-teljes. Arról, hogy az SQL Turing-teljes-e, megoszlanak a vélemények. Vannak bizonyos újabb SQL nyelvek, melyek már biztosan azok, de a hagyományos SQL-nél ez nem bizonyított. Bemutatunk egy példaprogramot az összetettebb SQL műveletre8:
8
saját program
declare @HumanName VARCHAR(50) declare @Email VARCHAR(256) declare @GROUP INT declare @Priority INT declare @HumanID INT declare @GroupId VARCHAR(50) SET @ GROUP = 1 declare HumanCursor CURSOR FOR SELECT HumanName, Email, GroupId FROM MyDB.IMPORT WITH(NOLOCK) WHERE GROUP= @ GROUP declare PriorityCursor CURSOR FOR SELECT CASE WHEN ISNUMERIC(Priority) = 1 THEN CAST(Priority AS INT) ELSE 0 END FROM MyDB. IMPORT WITH(NOLOCK) WHERE GROUP= @ GROUP OPEN HumanCursor OPEN PriorityCursor FETCH NEXT FROM HumanCursor INTO @HumanName, @Email, @GroupId FETCH NEXT FROM PriorityCursor INTO @Priority WHILE @@FETCH_STATUS = 0 BEGIN EXEC @ HumanID = MyDB.FUNCTION1 @HumanName,@Email,@ GROUP,@Priority,0 UPDATE MyDB.IMPORT SET HumanID=@HumanID WHERE GroupId=@GroupId FETCH NEXT FROM HumanCursor INTO @HumanName, @Email, @GroupId FETCH NEXT FROM PriorityCursor INTO @Priority END CLOSE HumanCursor CLOSE PriorityCursor DEALLOCATE HumanCursor DEALLOCATE PriorityCursor; A példában szereplő ciklus, változó, függvényhívás a megszokott programozási elemek csak más szintaxissal. Az 1970-80-as évektől kezdve rohamos fejlődésnek indultak a magasabb szintű programozási nyelvek. Sokféle ma is használatos nyelv alakult ki, mint például a C++, Basic, Pascal, Matlab, stb. Azáltal, hogy a számítógépeket már sorozatban kezdték gyártani, megnyílt a piac a hordozható, gépfüggetlen nyelvek előtt. A programnyelvekhez immáron compiler is tartozott. Megjelentek a fejlesztőkörnyezetek (IDE-k). A computerek megnövekedett kapacitásával, memóriájával az elvégzendő feladatok is bonyolultabbak lettek, a korábbi nyelvek pedig már korlátoltnak bizonyultak ezekhez a feladatokhoz.
Kezdett két éles csoport kialakulni a programnyelvek között: a ma is használatos régi nyelveket is magába foglaló csoport a hardver programozására szakosodott, a másik csoport pedig a „hardver független” felső, szoftveres rétegre. Az első csoport igényeinek továbbra is megfelelt az assembly és C nyelv, melyek időközben egyéb funkciókkal egészültek ki. Viszont a másik új csoport térhódításával teljesen új igények jelentek meg. Ilyen volt a szép felület, dinamikus, grafikus interfész, és a felhasználói élmény fokozása. Ha egy mai grafikus szoftvert szeretnénk megírni assemblyben vagy akár C-ben, ahhoz, hogy ugyanazt a hatást érjük el, mint mondjuk Java-val, igen sokat és körülményesen kellene programozni. Ahhoz, hogy ésszerű időn belül le lehessen fejleszteni egy szoftvert, szükség volt újabb, modernebb programozási technikákra. A szoftverfejlesztésben igen nagy mérföldkőnek számító objektumorientált programnyelv volt a megoldás erre a problémára. A C továbbfejlesztett, objektum orientált változata lett a C++, a Pascal-é pedig az Object Pascal. Az objektumorientáltság igazából egy elv, amellyel gyorsabban tudjuk leprogramozni, és később átlátni és változtatni a megoldandó problémát. Objektumorientáltan akár C nyelven is lehetne programozni, hiszen ez egy elv nem pedig technika, de mivel az új, objektumorientált nyelvek eleve erre épülnek szintaktikailag is, így azokban ez sokkal könnyebb és gyorsabb. A modern programnyelvek lényege, hogy nem a programozó dolga a memória és egyéb hardverek kezelése, mivel ezt megoldja a háttérben a fordító. A kód fordításkor gépi kódra fordul át. Nyilvánvaló, hogy ezáltal memória és erőforrás pazarlás történik, de a technika fejlődésével ez egyre jobban megengedhető volt, nem úgy, mint a régi időkben, amikor minden bit számított. A ’90-es években még tovább fejlődtek az objektumorientált nyelvek, és új, még korszerűbbek jelentek meg, mint például a Java és a Python. A Microsoft, látva a Java sikerét és térhódítását, kifejlesztette a saját nyelvét, a C#-ot. Köztudottan ez a nyelv a C++ és a Java képességeiből lett összegyúrva. Talán mondhatjuk, hogy az egyik legkönnyebben programozható nyelv. Szintaktikailag nagyon közel áll a Javahoz, viszont továbbra is lehetőség van benne a memória kezelésére és pointerek használatára, mint C++-ban. A következő példakód9 egy Java program egyik osztályából való, és bemutatja a tipikus objektumorientált szemléletmódot:
9
Saját program
package WebService; import exceptions.IdGeneratingFailureException; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; /** * * @author luca */ public class ClientRegister { final private static Object mutex = new Object(); final private static Object instanceMutex = new Object(); private static ClientRegister _singleton = null; private static ConcurrentMap<String,Client> _clients = null; public static ClientRegister getInstance() { synchronized(instanceMutex) { if (_singleton == null) { _singleton = new ClientRegister(); } return _singleton; } } private ClientRegister() { _clients = new ConcurrentHashMap<String, Client>(); } protected String put(String id, String password) throws IdGeneratingFailureException { if ((id == null) || (password == null)) return null; if ((id.length() == 0) || password == null) return null; if (ClientVerifier.getInstance().verify(id, password) == false) return null; synchronized(mutex) { if (_clients.containsKey(id)) { return _clients.get(id).getGeneratedId(); } String generatedId = IdGenerator.getInstance().generate(); if(generatedId == null || generatedId.length()==0) { throw new IdGeneratingFailureException("Generating id failed. Try again later."); } Client client = new Client(id, generatedId); _clients.put(id,client); return generatedId; } } }
A példa egy webproxy program egyik osztálya. A bejelentkezett klienseknek generál egy azonosítót (generatedId), eltárolja a bejelentkezett klienst majd visszatéríti a generált egyedi azonosítót. Még a szinkronizációt is az objektumok kihasználásával oldja meg. Ugyanezt az osztályt egy tízszer hosszabb kódban lehetett volna megvalósítani mondjuk a régi Pascal nyelven, amit ráadásul utólag módosítani megint csak többszörös munka. Az említett programnyelveken kívül rengeteg példát lehetne még hozni különböző irányzatokra, melyek hozzájárultak a programozás fejlődéséhez, de mindegyik alapvető elvben a régi programozási nyelvekből nőtte ki magát, és a régi időben lefektetett elvek még a mai napig is tartják magukat. Ennek nyilvánvalóan egyik oka a technikai korlátozottság, valamint olyan alapvetően adott körülmények, mint a kettes számrendszer használata gépi szinten. A programozás tulajdonképpen a matematika egyik speciális ága, a program felfogható úgy, mint egy bonyolult matematikai függvény. A gépek és a programnyelvek fejlődésével ez a módszer egyre több lehetőséget teremt, és nagymértékben hozzájárul világunk technikai előrehaladásához.
Felhasznált irodalom
Erdélyi Zoltán: FORTRAN programozási nyelv, 1979, Tankönyvkiadó (Budapest) Artiaga – Davis: Algoritmusok és FORTRAN programjaik, 1977, Műszaki Könyvkiadó (Budapest) Geurts – Meertens – Pemberton: ABC programmer’s handbook, 2005, Bosko Books (Bristol) Ken Thompson : Users' Reference to B, 1972 (scannelt változat: http://cm.belllabs.com/cm/cs/who/dmr/kbman.html) Juhász – Kósa – Pánovics – Édelkraut: C példatár (http://www.inf.unideb.hu/kmitt/konvkmitt/c_peldatar/book.xml.html#id451490) http://en.wikipedia.org/wiki/Timeline_of_programming_languages dr. Mersich Istvánné: Alkalmazott számítástechnika, 1992, Műszaki Könyvkiadó (Budapest)
