CSOMAG. Az Ada csomag két részből áll: csomag specifikáció csomag törzs. -- specifikációs rész: PACKAGE név IS. -- a csomag kívülről nem látható része

Átírás

1 ABSZTRAKCIÓ 93 ABSZTRAKCIÓ Az informatika arra való, hogy a valós világról ismereteket szerezzünk, és ezeket automatikusan fel tudjuk dolgozni. A valós világot azonban nem tudjuk egy az egyben leírni, alkalmazzuk az absztrakciót: a közös jellemzőket kiemeljük, a különbözőket elhanyagoljuk, és innentől kezdve a közös jellemzőkkel írjuk le. Az absztrakció megjelenik a programozásban is: Procedurális absztrakció: Az alprogram paraméterezhető, de típus nem adható át paraméterként. A specifikáció és az implementáció elválik. Adatabsztrakció: Első lépés a típus megjelenése az adatabsztrakció terén. A típussal rendelkező objektum egy csomó konzisztencia ellenőrzésen megy keresztül. Következő lépésben megjelenik a saját típus definiálási lehetőség. Kérdés, hogy ténylegesen új típust hozunk-e létre. A harmadik lépés: az absztrakt adattípus - Abstract Data Type (ADT) megjelenése. Vannak nyelvek, amelyek lehetővé teszik, hogy ne csak saját típust definiálhassunk, hanem a típusokhoz saját műveleteket is megadhassunk. Úgy tudunk saját típust megadni, hogy a típushoz megadom a típushoz tartozó elemek reprezentációját és típust kezelő műveleteket. Mindezt úgy, hogy az adott típus elemeihez csak irányított módon, a megadott műveleteken keresztül lehet hozzáférni. Az absztrakt adattípus elemeinek a reprezentációja nem látható, elválik a specifikáció és az implementáció. A viszonylag késői nyelvekben jelenik meg ez az eszközrendszer. Az absztrakt adattípus defíniálása során három szempontot kell figyelembe venni: Reprezentáció: Az új típus értékeit reprezentálni kell. Ez a reprezentáció egy valamilyen korábbi típus reprezentációján nyugszik. A beépített típusokon alapszik, és azoktól teljesen független. Ld. minden adatszerkezet reprezentálható egydimenziós tömb segítségével. Kívülről nem látható, hogy ez tömb. Míg például a Pascalban egy byte típusnak ismerem a reprezentációját, el tudom érni a bitjeit. Absztrakt adattípusról akkor beszélünk, ha a reprezentáció nem látható. Műveleteket is definiálnunk kell: a beépített műveletekre építjük fel a saját műveleteinket. Absztrakt adattípus esetén a műveletek ( függvények) implementációja nem látszik. Viselkedés: Úgy kell viselkednie az absztrakt adatszerkezetnek ahogy elvárjuk tőle: ld. verem LIFO. Tükröznie kell az adott adattípus viselkedését. Tehát az absztrakt adatszerkezetet csak a megadott műveletei segítségével használhatom, másként nem (bezárás). Kérdés, hogy vannak-e eszközök az adott programnyelvben, amivel az irányított hozzáférés megoldható. A mai programozásban alapvető szerepet játszik az absztrakt adattípus.

2 94 CSOMAG CSOMAG A csomag az Ada környékén jelenik meg, és egyre több nyelv veszi át. Szokásos elnevezés még: unit, modul. Programegység fajta, amely olyan programelemeket, szolgáltatásokat tartalmaz, melyeket a program más pontjain felhasználhatunk. Programelem (programozási eszköz) gyűjtemény. Ezek a programelemek lehetnek: típus változó nevesített konstans alprogram újabb csomag. Elsősorban az újrafelhasználhatóságot szolgálja, másrészt az adatabsztrakció eszköze. Segítségével absztrakt adattípus implementálható a nyelvben. Mellette ott van a procedurális absztrakció. AZ ADA CSOMAGJA Az Ada csomag két részből áll: csomag specifikáció csomag törzs -- specifikációs rész: PACKAGE név IS deklarációs rész [PRIVATE deklarációs rész [reprezentáció_előírás]] END [név]; -- a csomag kívülről látható része -- a csomag kívülről nem látható része A specifikációs részben szereplő deklarációs rész a csomag látható része. Itt vannak deklarálva a felsorolt programozási eszközök. Tehát itt változó, nevesített konstans, típus, alprogram deklaráció vagy újabb csomag deklaráció állhat. Minden itt deklarált eszközre hivatkozhatunk. A hivatkozás minősítéssel történik. A private rész kívülről nem elérhető.

3 CSOMAG 95 Ezután lehet megadni a csomag törzsét. Ha szerepel a specifikációs rész deklarációs részében alprogram, akkor ott az alprogramnak csak a specifikációja szerepelhet. Ekkor kötelező a törzs, és a csomag törzsében kötelezően szerepelnie kell az adott alprogram implementációjának. Az implementáció el van rejtve. -- törzs: [PACKAGE BODY név IS deklarációs rész -- kívülről nem látszik [BEGIN végrehajtható utasítások [kivételkezelő] ] END [név] ]; Kivételkezelő a törzs végén helyezhető el, ez a csomag kivételkezelője. A csomag kívülről nem látható privát deklarációs részében lehetővé teszi a nyelv, hogy reprezentációelőírás szerepeljen. (Értékek tárolásánál a bitkombináció megjelenése.) Az Adában csomag lehet önállóan fordítható programegység, vagy szerepelhet egy másik programegység deklarációs részében. Az utóbbi esetben statikus a hatáskör kezelés. E hatáskörön belül bárhonnan hivatkozhatok a látható részben deklarált objektumokra. A csomagok egymásba skatulyázása megengedett. Ha önállóan fordítom a csomagot, akkor a program más részei számára láthatóvá kell tenni explicit módon. A csomag más nyelvekben is megjelenik: Turbo Pascalban neve: UNIT. A UNIT szerepköre jóval szűkebb, mint az Ada csomagjának szerepköre. A Standard Pascalban nincs csomag. Más nyelvek modulnak hívják. PRIVATE TÍPUS Az Ada típusrendszerének felsorolásánál beszéltünk egy PRIVATE típusról, ugyanis a csomag specifikációs részének deklarációs részében, a látható részben szerepelhet a PRIVATE típusmegjelölés. Így az adott típusú objektum reprezentációját elrejtem, és a PRIVATE részben adom meg, hogy új reprezentációelőírást szerepeltetek. A PRIVATE típus szolgál az absztrakt adattípus megvalósítására az Adában, bizonyos objektumokhoz való hozzáférést korlátozza. A PRIVATE típusúnak deklarált objektumokra a nyelvbe beépített műveletek közül csak az egyenlőségvizsgálat (=) relációs művelet, és az értékadás (:=) alkalmazható. Tehát az így deklarált objektumok kezelő műveleteit a programozónak kell implementálnia. Ha van a látható részben privát típussal deklarált objektum, akkor kötelező a nem látható részben olyan eljárás

4 96 CSOMAG deklaráció, amely kezeli a típust. Műveleteket elsősorban függvénnyel (esetleg eljárással) adunk meg. Így a csomagba be van építve a viselkedésmód. A műveletek implementációja nem látható. Úgy kell megírni a műveleteket, hogy a viselkedésmódot tükrözze. Ha azt akarjuk, hogy az egyenlőségvizsgálat és az értékadás se legyen megengedett, akkor alkalmazhatjuk a LIMITED PRIVATE korlátozott privát típust. Ekkor csak a specifikált műveletek működnek, az egyenlőségvizsgálat és az értékadás már nem. Információrejtés (Information Hiding): a specifikációt megmutatom, az implementációt nem. Az információrejtéshez hasonló a bezárás: bizonyos információkat bezárunk a külvilág elől, hogy mi lesz látható, azt a csomag írója dönti el. A csomag alapvető eszköze az Adának. Az Adában kilenc db. beépített csomag van. A csomag látható részében deklarált eszközeire, objektumaira hatáskörükön belül minősítéssel hivatkozunk. Alakja: csomagnév.objektum_név; A minősítés szükségessége feloldható a USE utasítással. Alakja: USE csomag_név; Ha egy csomagban a látható részben változókat deklaráltunk, akkor azok a változók (amennyiben felhasználjuk őket a csomagban deklarált alprogramban) OWN típusú változók lesznek, amelyeknek tulajdonságuk, hogy két alprogramhívás közt megtartják értéküket. (A változó értékét felhasználhatom a következő alprogramhíváskor.) Ezzel további kommunikációs lehetőséget biztosít az Ada az alprogramok között.

5 CSOMAG 97 Példa: package RACIONALIS_SZAM is type RACIONALIS is record SZAMLALO : integer; NEVEZO : integer range 1..MAX_INTEGER; end record; - látható - látható - látható function = ( x,y : RACIONALIS) return boolean; -- látható function + ( x,y : RACIONALIS) return RACIONALIS; -- látható function * ( x,y : RACIONALIS) return RACIONALIS; -- látható end; package body RACIONALIS_SZAM is -- nem látható procedure KOZOS_NEVEZO (x,y: in out RACIONALIS) is function = function + function * end RACIONALIS_SZAM; A racionális aritmetikát valósítja meg ez a csomag. E csomag specifikációjának csak látható része van: Van benne típus definició: RACIONALIS. A racionális számok reprezentációja egy rekord segítségével történik, látszik kívülről, tehát nem absztrakt adattípus (bármikor büntetlenül hozzáférhetek a SZAMLALOhoz és a NEVEZO-hoz, nem zárja be). Van három függvényspecifikáció. Lennie kell törzsnek, ahol implementáljuk ezeket. Az Ada lehetővé teszi, hogy a függvény neve ne csak azonosító legyen. A műveleti jelek túlterheltek (pl. Pascalban a + műveleti jellel jelöljük az összeadást, a konkatenációt, uniót), a fordítóprogram dolga, hogy a megfelelő gépi kódú utasítást generálja. Az Adában ez még bővíthető, ugyanis az idézőjelek közé tett speciális karaktereket is használhatunk függvénynév megadásához, így még túlterheltebbek lesznek a műveleti jelek.

6 98 CSOMAG A fenti példa megmutatja a reprezentációt ezért nem absztrakt típus. A RACIONALIS reprezentációja látszik. A SZAMLALO-t össze tudom adni egy másik számmal (a sztenderd összeadási művelet segítségével). Mit kell tenni, hogy ebből absztrakt adatszerkezet legyen? Módosítani kell a specifikációt a következő módon: package RACIONALIS_SZAM is type RACIONALIS private; function = ( x,y:racionalis) return boolean ; function + ( x,y:racionalis) return RACIONALIS ; function * ( x,y:racionalis) return RACIONALIS ; private type RACIONALIS is record end record; end; A reprezentáció átkerül a nem látható részbe. Most már nem férek hozzá a SZAMLALO-hoz és a NEVEZO-höz bárhonnan szabadon. Privát típusnál az = egyenlőség vizsgálatot felülírtuk ebben az esetben. Formálisan prefix alakú kifejezésre adunk lehetőséget. Az értékadást nem írtuk felül. Ha ezt is le akarjuk tiltani : package RACIONALIS_SZAM is type RACIONALIS limited private; function :=... function =... end;

7 AZ ADA FORDÍTÁSI FILOZÓFIÁJA 99 AZ ADA FORDÍTÁSI FILOZÓFIÁJA, A FORDÍTÓPROGRAM MŰKÖDÉSE PRAGMÁK A program szövegében elhelyezhetők olyan utasítások, amelyek a fordító működését (üzemmódját) befolyásolják. A fordítóprogramnak szólnak, nem áll mögöttük közvetlen kód, de befolyásolhatják a kódot. Ezek a pragmák: Egy részük a program szövegének bármely pontján elhelyezhető. Másik része csak kötött helyen használható. A Turbo Pascalban is van pragma fogalom, ld.: fordítási direktívák..a C++ ban és a Javaban van-e pragma?- A pragma szerkezete a következő: PRAGMA név [(argumentum_lista)]; Az argumentum_lista szerkezete: [név =>] azonosító kifejezés ; A pragmák azon eszközrendszerek közé tartoznak, amelyeket az Ada hivatkozási nyelv szinten nem szabályoz. Az implementációk eltérnek egymástól. Az Ada rendszerekben általában mintegy 50 féle pragma van. Lássunk közülük néhányat: SUPPRESS : a kivétel figyelés letiltása. Bárhol elhelyezhető. Az adott programegységre vonatkozik. Lásd: kivételkezelés. INTERFACE: az adott alprogram deklarációjánál kell megadni ezt pragmát a specifikáció után, és azt jelzi, hogy az adott alprogram az adott nyelven van megírva. Alakja: INTERFACE (programnyelv_neve, alprogram_név);

8 100 AZ ADA FORDÍTÁSI FILOZÓFIÁJA LIST: fordítás közben a programszövegről forrásnyelvű lista készül. Előírja, hogy a program mely részéből készüljön lista. Alapértelmezés szerint listáz. Bárhol elhelyezhető. Alakja: LIST ON OFF FORDÍTÁSI EGYSÉGEK Az Ada program nem más, mint fordítási egységek együttese, így egy program fordítható egyben, vagy széttagolható önállóan fordítható egységekre. Fordítási egység az a szövegrész, amely a program többi részétől függetlenül fordítható. A Pascalban a program a fordítási egység. A fordítási egységek időben és térben egymástól függetlenül lefordíthatóak. A szerkesztő kapcsolja össze őket, és hozza létre ezekből a programot. A hamis hivatkozások sok nyelvben csak szerkesztésnél derülnek ki. Az Adában a kereszthivatkozások fordítási idejűek, fordítás közben végez az Ada konzisztenciaellenőrzést. A konzisztenciaellenőrzés tehát feljön fordítási szintre. Fordítási egység lehet: alprogram specifikáció alprogram törzs csomag specifikáció csomag törzs fordítási alegység valamint ezek tetszőleges kombinációja KÖNYVTÁRI EGYSÉGEK Azokat a fordítási egységeket, amelyek nem függnek más fordítási egységtől (nem alegységei más fordítási egységnek), könyvtári egységnek hívja az Ada. Ilyen könyvtári egységet a programozó tetszőleges számban hozhat létre. A könyvtári egységeknek külön egyedi nevük van. Egy könyvtári egységben lehetnek olyan alprogram hívások, amelyek nem az adott könyvtári egységben vannak megírva: kereszthivatkozás. Ha valamely fordítási egységben használni akarok egy olyan elemet, amely egy másik fordítási egységben van benne, akkor az adott elem specifikációjának lefordítva kell lennie, tehát előbb kell lefordítani, mint azt, amiben hivatkozunk rá. Itt a konzisztencia-ellenőrzés! Tehát a főprogramot kell utoljára megírni. Függvény esetén is elég, ha csak a specifikációja van lefordítva. Ez további lépés a procedurális absztrakció felé.

9 AZ ADA FORDÍTÁSI FILOZÓFIÁJA 101 Ha a specifikáció módosul (pl. mert plusz egy paramétert hozzáteszek), újra kell fordítani azt a fordítási egységet, amelyben a specifikáció van, és azokat, amelyek hivatkoznak erre a módosult specifikációra, és csak azokat. Ha csak az implementáció változik, csak azt kell újrafordítanunk. Ennek segítségével nagy programok fejlesztése mehet párhuzamosan. Minden fordítási egység kezdete előtt meg kell adni egy ún. környezetelőírást. Ennek megadása a WITH utasítással történik, és ezután azon könyvtári egységeket soroljuk fel vesszővel elválasztva, amelyekre az adott fordítási egységben hivatkozunk, amelynek eszközeit felhasználom a fordítási egységben. (Hasonlóan, mint a Pascalban a USES unitnév.) A saját könyvtári egységeket is fel kell sorolni. Alakja: WITH könyvtári_egység[,könyvtári_egység]...; Ezen könyvtári egységek alkotják az adott fordítási egység környezetét. Ez a fordítási egység ezen könyvtári egységek elemeit látja, ha nincsenek bezárva. Az Adában 9 db. szabvány könyvtári egység van. A könyvtári egységek jó része csomag. Az Adában is van olyan könyvtári egység, amelyet nem kell szerepeltetni a felsorolásban. Ez a STANDARD nevű könyvtári egység, amelyet a fordítóprogram minden fordítási egységhez automatikusan hozzáfordít, ezt nem kell külön megadni, alapértelmezés. Innen veszi a szemléletet a Turbo Pascal. Ez a sztenderd csomag tartalmazza a karakterkészletet, beépített típusokat, műveleteket és a beépített kivételeket. FORDÍTÁSI ALEGYSÉGEK Azokat a fordítási egységeket hívjuk fordítási alegységnek, amelyek önállóan nem léteznek, hanem egy másik fordítási egységhez kapcsolódnak. A program fordítási egységekből áll. Egy fordítási egységnek tetszőlegesen mély struktúrája van. A fordítási egység akármelyik szintjén megtehetem, hogy az implementációt nem adom meg, hanem jelzem, hogy a törzs (implementáció) máshol, külön lesz megadva. Egy fordítási alegység környezetét a csonk adja meg. Egy másik fordítási egységben megadom a törzset, ami a csonkhoz tartozik. A csonkot tartalmazó fordítási egységet kell előbb lefordítani. Tetszőleges csonksorozatot lehet létrehozni.

10 102 AZ ADA FORDÍTÁSI FILOZÓFIÁJA Példa: procedure FELDOLGOZO is // package D is HATAR : constant:=1000; TABLA : array (1..HATAR) of integer; procedure RESTART; end; // package body D is // procedure RESTART is begin for N in 1..HATAR loop TABLA(N):=N; end loop; end; // begin RESTART; procedure Q(x:integer) is begin D.TABLA(x):= D.TABLA(x)+1; end Q; end D; // begin //feldolgozo... D.RESTART;... end FELDOLGOZO; Itt egy eljárást látunk, ezen belül van egy csomag és egy másik eljárás. Fordítás után egy Feldolgozo nevű könyvtári egységet képez. Ez a programszöveg önállóan alkot egy fordítási egységet, de feldarabolható három külön fordítható egységre a következőképpen: első rész a csomag-specifikáció, második rész a csomag törzse és

11 AZ ADA FORDÍTÁSI FILOZÓFIÁJA 103 a harmadik rész egy eljárás: procedure FELDOLGOZO is package D is HATAR : constant:=1000; TABLA : array (1..HATAR) of integer; procedure RESTART; end; begin... D.RESTART;... end FELDOLGOZO; package body D is procedure RESTART is begin for N in 1..HATAR loop TABLA(N):=N; end loop; end; begin RESTART; End D; With D; procedure Q(x:integer) is begin D.TABLA(x):= D.TABLA(x)+1; end Q; Ha valamelyik fordítási egységben hivatkozunk a másikban lévő objektumra, annak a specifikációját mindenképp előbb kell lefordítani, tehát tudni kell mire hivatkozunk. Ezért először fordítandó az első rész, majd a második- és harmadik tetszőleges sorrendben. A lényeg, hogy az első rész fordítása megelőzze a másik kettőét. Hogyan néz ki egy fordítási alegység?

12 104 AZ ADA FORDÍTÁSI FILOZÓFIÁJA Példa: procedure T is R, S : real:=1.0; package D is pi.constant:=3.186; function F(X : real) return real; procedure G(X, Z : real); end; package body D is separate; -- csonkképzés procedure Q(u : in out real) is separate; -- csonkképzés begin Q(R);... D.G(R,S);... end T; separate(t) --fordítási alegység procedure Q (u : in out real) is begin end Q; separate(t) package body D is function F(x:real) return real is separate; --csokképzés procedure G(X, Z : real) is separate; end D; separate (T.D) --fordítási alegység function F(x:real) return real is end F; procedure G(X, Z : real) is end G;

13 AZ ADA FORDÍTÁSI FILOZÓFIÁJA 105 Fordítási alegységeket mutat ez a kódrészlet. A programegységek egymásba skatulyázhatók. Csonkokat képezek azon a helyen, ahonnan a fordítási alegységet kiemeltem. Csonkképzés SEPARATE-val: jelezzük, hogy itt nem található meg a törzs, hanem valahol máshol. Fordítási alegység separate-val kezdődik, és ( )-ben megadjuk azt a programegységet, amelyen belül a csonk van, megadjuk, hogy hová kapcsolódik. Ha kell, minősítünk. Időben elválhat a csonk és az alegység fordítása, de fontos a sorrend: előbb a csonkot tertalmazó fordítási egységet kell lefordítani, utána az alegységet. Az implementáció változhat, és csak azt kell újrafordítani. Előnye: nagy rendszer fejlesztésénél a specifikációt elkészítjük, az implementáció később következik. A procedurális absztrakció útján továbblépve: Az alprogram attól procedurális eszköz, hogy paraméterezzük. A specifikáció és az implementáció elválik. De típus nem adható meg paraméterként. Következő procedurális eszköz a csomag. Összegyűjtök programegységeket, szolgáltatásként használható. Következő procedurális eszköz, a generikus továbblép az újrafelhasználhatóság szintjén. Az általános megnevezése: makró. Az Ada generikus forrásszövegmintát ad alprogramok és csomagok generálásához. A generikus egy forrásszövegrész, amely szöveg paraméterezhető. Ezt a szöveget a fordító kezeli. Fordítási időben a fordító a megadott aktuális paraméterek segítségével a forrásszöveg mitából előállít egy konkrét alprogram vagy csomag szöveget, amit a fordító lefordít. Ott a procedurális absztrakció, hogy tetszőleges számú alprogramszöveg generálható a szövegből. Egy szöveggel különböző forrásszöveget tudok generáltatni. Fordítási időben történik a generálás.

14 106 GENERIKUS GENERIKUS Amit egyszer megírtunk, azt ne kelljen mégegyszer megírni. Ezen elv alapján eljárás- és csomag forrásszöveg generálható. Az újrafelhasználhatóság eszköze. A generikus egy minta forrásszöveg, amelyet paraméterezünk. A generikust meg lehet hívni. A hívást a fordítóprogram végzi el. A meghívás eredményeként a fordító előállít egy konkrét forrásszövegetaz aktuális paraméterek segítségével, amelyet azután lefordít. Az Ada generikus tehát egy olyan eszköz, amellyel eljárás, illetve csomag szövegmintát tudunk előállítani, fordítóval konkrét szöveget generáltatni, és majd azt fogja a fordító lefordítani. Csomag és alprogram generálható. Típus lehet paramétere a generikusnak! Alprogramnak viszont nem, egyetlen programnyelvben sem. Nézzük meg, hogyan néz ki az Ada generikus: GENERIC [formális_paraméter_lista] és ez után egy teljes alprogram vagy csomag, ami a generikus törzsét jelenti. A formális_paraméter_listán szerepelhet: változó deklaráció típus deklaráció a következő módon: TYPE név IS (< >) RANGE < > DELTA < > DIGITS < > tömb mutató private -- felsorolásos -- egész -- fixpontos -- lebegőpontos -- A csomag specifikációs részén kívül a generikus formális paramétereként szerepelhet a privát típus. szerepelhet alprogram specifikáció a következő módon: WITH alprogram_specifikáció [IS név]; WITH alprogram_specifikáció IS < >;

15 GENERIKUS 107 Akárhány fajta paraméter és egy fajtából tetszőleges számú szerepelhet a formális paraméterlistán, a felsorolás sorrendje tetszőleges. Ez a minta. (Csomag vagy alprogram minta.) Konkrét alprogramot vagy csomagot ebből a mintából a következő utasítás segítségével lehet generáltatni attól függően, hogy mi volt a generikus: PROCEDURE FUNCTION PACKAGE név IS NEW generikus_név [(aktuális_paraméter_lista)]; "A generikust így hívom meg." Ennek során lejátszódik egy paraméterkiértékelés és paraméterátadás. A generikus fix paraméterszámú. Paraméterkiértékelés: Sorrendi kötés az alapértelmezés. De alkalmazható név szerinti kötés is. Számbeli egyeztetésnél az alprogram formális paraméterekhez nem kötelező aktuális paramétert megadni akkor, ha az opcionális rész (az IS név vagy az IS < >) szerepel. Típusegyeztetés helyett fajtaegyeztetés van: változóhoz kifejezés: változó típusa a kifejezés típusával egyezik meg típushoz konkrét (már ismert) típusnév privát esetén teszőleges típusnevet megadhatunk Ha van alprogram specifikáció, megfelelő eljárás- vagy függvénynevet adhatok meg aktuális paraméternek. Az aktuális_paraméter_lista: Ha kifejezés az aktuális paraméter, a deklarált változó kezdőértéket kap. Ha a változó értékét nem módosítom a törzsben, akkor ez megfelel egy nevesített konstansnak. A típusnév átadása névszerint történik (fölülírja). Ha alprogramnév az aktuális paraméter, akkor nem kötelező megadni paramétert: Ha megadunk alprogram nevet, a generált szövegben ez a név jelenik meg. Ha nem adunk meg alprogram nevet, akkor a generált név: Vagy a WITH alprogram_specifikáció IS név -ben megadott név lesz. Vagy, ha WITH alprogram_specifikáció IS < > van, akkor nem történik helyettesítés, az eredeti név marad.

16 108 GENERIKUS Példa: generic type ELEM IS private; -- generikus rész with function F(U, V : ELEM) return ELEM is < >; procedure MUVELET(U, V : in out ELEM); -- eljárás deklaráció begin end; procedure SZOROZ is new MUVELET(integer); -- sorrendi kötés procedure OSSZEAD is new MUVELET(F=> +, ELEM=>integer); -- név szerinti kötés

17 GENERIKUS 109 Példa: Az Adára vonatkozó majdnem minden ismereteinket összegző példa: csomag, amely vermet (absztrakt adattípust) implementál, némi kivételkezeléssel szinesítve. generic MERET : integer; type ELEM is private; package VERMEK is type VEREM is limited private; procedure PUSH(S:in out VEREM; E:in ELEM); procedure POP(S:in out VEREM; E:out ELEM); OVERFLOW, UNDERFLOW:exception; private type VEREM is record HELY:array(1..MERET) of ELEM; INDEX:integer range 0..MERET:=0; end record; end; package body VERMEK is procedure PUSH(S:in out VEREM; E:in ELEM) is begin if S.INDEX=MERET then raise OVERFLOW; endif; S.INDEX:= S.INDEX+1; S.HELY(S.INDEX):=E; end PUSH; procedure POP(S:inout VEREM; E:out ELEM) is begin if S.INDEX=0 then raise UNDERFLOW; endif; E:=S.HELY(S.INDEX); S.INDEX:= S.INDEX-1; end POP; end VERMEK; package EGESZ_VEREM is new VERMEK(ELEM=>integer;MERET=>1024); --n.sz.k. package LOGIKAI_VEREM is new VERMEK(100, boolean); --sorrendi kötés

18 110 GENERIKUS Itt egy generikus csomag látható, melynek két paramétere van: elemek típusa kezelt elemek száma Tetszőleges típusú elemeket tartalmazó, tetszőleges méretű verem kezelését megvalósító csomag. Absztrakt adattípust valósít meg (bezárja az implementációt) private típussal (csak a leírtak megengedettek). Kívülről nem látszik, hogy hogyan van reprezentálva. A vermet egydimenziós tömbbel ábrázoljuk a szokásos módon. Az absztrakt adattípus viselkedését tükröznie kell: LIFO veremként működik. Két alapművelet van implementálva: a PUSH és a POP. Kivételkezelés: a csomagban nem kezelem azokat a szituációkat, hogy: a verem üres nem tudok olvasni a verem tele van nem tudok beleírni hanem abban a programegységben, amely használni akarja a csomagot. Nincs kivételkezelő, így a kivétel átadódik a hívás helyére.

19 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE 111 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE, KONKURRENS PROGRAMOZÁS ILLETVE EZEK MAGASSZINTŰ PROGRAMOZÁSI ESZKÖZEI A Neumann architektúrán felépülő gépek szekvenciálisak: a processzor a programnak megfelelő utasítási sorrendben hajtja végre az utasításokat elemi lépésenként. De itt is megjelenik a párhuzamosság. FOLYAMAT (processz) ÉS SZÁL (thread) Megírok egy programot valamilyen programozási nyelven, ezt a fordító lefordítja gépi kódra. Ha a gépi kódú program működik, akkor folyamatról, vagy szálról beszélünk. Ha ezek a működő kódok az erőforrásokat kizárólagosan birtokolják, akkor folyamatról beszélünk, ha bizonyos erőforrásokat közösen birtokolhatnak, akkor szálakról beszélünk. Az 50-es évek végén 60-as évek elején megjelennek a multiprogramozott operációs rendszerek. Így a programok szintjére jön fel a párhuzamos programozás. Szűk keresztmetszet: a CPU ideje. Egy processzor segítségével több feladatot lát el a számítógép aszinkron módon, de mégiscsak párhuzamosan. A másik irány: nagyon hamar megjelenik a szinkron párhuzamos működés. Az I/O eszközöket nem közvetlenül a processzor vezérli, hanem segédprocesszorok vannak beépítve. Később megjelennek a többprocesszoros rendszerek. Egy időben annyi folyamat működhet, ahány processzor van. Kérdés, hogy hol vannak azok a magasszintű programozási eszközök, amelyek kihasználják a többprocesszoros rendszer párhuzamosságát? A párhuzamos programozási filozófián felépülő nyelvek: Occam, Paralel C, Concurrent Pascal, Ada. A folyamatok illetve a szálak maguk szekvenciálisan működnek, a folyamatok viszont párhuzamosak. A folyamat önmagában szekvenciális, de egymáshoz viszonyítva párhuzamosan működnek. KOMMUNIKÁCIÓ A folyamatok kommunikálnak egymással, adatcserét folytatnak. (Az Adában folyamatok vannak.) Van két folyamat, ezek egymástól függetlenül önmagukban szekvenciálisan futnak. (ld. Programozáselmélet) SZINKRONIZÁCIÓ A párhuzamosan futó folyamatoknak bizonyos időpillanatokban találkozniuk kell. Előfordul, hogy a szinkronizációs ponton keresztül történik adatcsere, a szinkronizációs ponton keresztül zajlik a kommunikáció. Például olyan információt vár az egyik a másiktól, ami nélkül nem tud továbbhaladni.

20 112 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE KONKURENCIA A folyamatok vetélkednek az erőforrásokért. Kérdés, hogy hogyan oldható meg az erőforrások felosztása. KÖLCSÖNÖS KIZÁRÁS Mivel a folyamatok kizárólagosan birtokolják az erőforrásokat: például ha egy adatot több folyamat is használ, biztosítani kell, hogy amíg az egyik folyamat módosítja az adatot, addig a másik folyamat ne használhassa fel. HOLTPONT FOGALMA Két folyamat párhuzamos működése esetén ha a két folyamat úgy foglal le erőforrásolat, hogy mindkettőnek szüksége lenne a másik által lefoglalt erőforrásra, és egyik sem engedi el azt az erőforrást, amit ő lefoglalt, akkor nem tudnak továbbmenni, holtpont alakul ki. (Megoldása: ld. Programozáselmélet) Párhuzamos programozási eszközrendszer először a PL/1-ben jelent meg. Létezik a Pascalnak és a C-nek is olyan változata, amely ebben az irányban bővíti tovább a nyelvet. Azok az algoritmusok, amelyeket ismerünk, mind szekvenciális algoritmusok, de léteznek párhuzamos algoritmusok a problémák megoldására. Az algoritmusokon belül az egyszerre elvégezhető műveleteket egyszerre végezzük el. Az ember kultúrája olyan, hogy szekvenciálisan látja a világot, holott az agy párhuzamosan dolgozik, tehát a hardverünk tökéletesen alkalmas lenne a párhuzamos látásmódra. A programozási nyelvekben szükséges olyan eszközrendszer, amelyekkel biztosítani tudjuk a kommunikációt, a szinkronoizációt, a kölcsönös kizárást, a konkurenciát, azaz kezelni tudja a folyamatokat, amelyekkel megvalósíthatjuk a párhuzamos programozást. TASZK Az Adában a taszk, mint programozási eszköz szolgál a párhuzamos programozás megvalósítására. Általában a nyelvek taszkoknak hívják azokat az eszközöket, amelyekkel párhuzamos programozás valósítható meg. A taszk olyan nyelvi eszköz, amely mögött folyamat áll. A taszk olyan programegység, amely önállóan nem létezik, csak egy másik programegységbe beágyazva. SZÜLŐEGYSÉG A taszkot tartalmazó programegységet szülőegységnek hívjuk. TESTVÉRTASZK Egy szülőegységen belül akárhány testvértaszk elhelyezhető. Ezek azonos szinten deklarált taszkok.

21 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE 113 A taszkok tetszőleges mélységben egymásba ágyazhatók. A szülőegység és a testvértaszkok törzse mögötti folyamatok működnek egymással párhuzamosan. Többprocesszoros rendszerek esetén egy processzornak egy taszk felel meg. Egyprocesszoros rendszerek is programozhatók párhuzamos módon, a rendszer szimulálja a processzoron a párhuzamos programozást. A PC-s Ada verziók általában nem tudják szimulálni a párhuzamos programozást. Egy taszk akkor kezdi el a működését, amikor elindul a szülőegysége. Nem lehet külön aktivizálni, ez egy szinkronizációs pont, minden benne lévő folyamat ekkor indul. Egy taszk befejezi a működését: ha elérte a végét (vagyis elfogytak az utasításai) vagy ha a szülőegysége vagy a testvértaszk kivülről befejezteti a működését a következő utasítással: abort név; de a saját működését is befejezheti A szülőegység (akkor is, ha taszk) akkor fejeződik be, ha Ő, mint programegység befejeződött. És ha az összes általa tartalmazott testvértaszkja befejeződött. Ez megint egyfajta szinkronizációs pont a szülőegység számára. Képzeljük el, hogy a taszk egy blokk, amely a végére ért, de a testvértaszkjai még működnek. A blokk várakozik, elért egy szinkronizációs pontra, nem dolgozik, de még nem inaktív. A taszk két részből áll: specifikációs rész törzs

22 114 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE Alakja: -- specifikáció: TASK [TYPE] név IS [entry_deklaráció(k) END [név]]; -- törzs: TASK BODY név IS [deklarációk] BEGIN végrehajtható_utasítások; [kivételkezelő] END [név]; A specifikációs rész második sora olyan, mint egy eljárás specifikáció, csak az alapszó entry, nem procedure. Ezek a szinkronizáció eszközei az Adában. Létrehozható taszk típus, ez egy korlátozott privát típusnak tekinthető. Deklarálható tehát taszk típusú (taszkokat tartalmazó) tömb. Ezzel nem foglalkozunk részletesen. AKTÍV- ÉS PASSZÍV TASZKOK Passzív taszkok azok a taszkok, amelyek valamilyen szolgáltatást nyújtanak. Formálisan a deklarációs részében az entry deklaráció, amely a szolgáltatás leírását szolgálja. Aktív taszkok azok a taszkok, amelyek igénybeveszik ezeket a szolgáltatásokat. A passzív taszk tálcán kínálja a szolgáltatásokat, nem tudja, ki fogja igénybevenni. (Az aktív taszk viszont tudja, mit akar.) Az entry a szolgáltatás. A passzív taszkon belül (amely tartalmazza az entry_deklarációt) szinkronizációs pontot a következőképpen tudunk létrehozni: ACCEPT entry_név[(formális_paraméter_lista)] [DO utasítás(ok) END [név]]; -- ezek az utasítások a szolgáltatások Ahány entry deklaráció van a passzív taszkban, a törzsben legalább annyi elfogadó utasítás szükséges. Egy entry deklarációhoz a törzsben akárhány ACCEPT utasítás tartozhat. Ez egy szinkronizációs pont. Az aktív taszk oldaláról az ennek megfelelő szinkronizációs pontot egy entry hívás jelenti. Az entry hívás egy szabályos eljáráshívás: név (aktuális_paraméter_lista);

23 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE 115 SZINKRONIZÁCIÓ - RANDEVÚ A szinkronizációt az Ada úgy hívja, hogy randevú. Az aktív taszk egy entry hívással képez egy randevú pontot. Elindul a két taszk, szekvenciálisan hajtja végre az utasításokat, amíg egy randevú ponthoz nem ér az egyik taszk. Amelyik odaér a randevú ponthoz, megvárja a másikat. A randevú elsősorban a szinkronizáció eszköze az Adában, de van lehetőség a randevúban történő adatcserére is, erre szolgálnak az entry opcionális formális paraméterei. Lehetséges, hogy a kommunikáción túl csinálni is akarnak valamit a randevún: [DO utasítások END név;] Sem a kommunikáció, sem a tevékenység nem szükséges. Ha van megadva paraméter, akkor a randevú kezdetén in és in out paraméterek esetén információ áramlik az aktív taszktól a passzív felé; a randevú végén pedig out és inoutnál a passzív taszk felől halad az információ az aktív taszk felé. Van egy másik kommunikációs lehetőség is: minden taszknak van szülőegysége. A taszkok kommunikálhatnak globális változókkal is. Az összes taszk láthatja ugyanazt a változót. Biztosítandó a kölcsönös kizárás! Külön nyelvi eszköz van arra, hogy a közösen használt változóknak a rendszer biztosítsa a kölcsönös kizárást. Ez pragma segítségével történik. Alakja: SHARED VÁLTOZÓ_NÉV; A szülőegység deklarációjában kell megadni (a testvértaszkok használják). Ha valamely passzív taszknak nagyon népszerű a szolgáltatása, sokan akarnak vele randevúzni. Az aktív taszkok sorban állnak (időbeli sorrend), hogy igénybevehessék a szolgáltatását. (Ciklus használata.) A sorbanállás befolyásolható, taszkhoz prioritás rendelhető egy pragma segítségével (ezt a taszk specifikációjánál kell elhelyezni): PRIORITY(kifejezés); Vannak prioritással rendelkező és prioritás nélküli taszkok. Ezek a randevúra várakozás időbeliségét határozzák meg. Alacsonyabb, vagy prioritás nélküli taszk nem akadályozhatja egy magasabb prioritású taszk munkáját. Beszélünk relatív- és abszolút prioritásról: relatív prioritás: az éppen folyó randevú befejezéséig vár. abszolút prioritás: az éppen folyó randevút félbeszakítja. Van egy úgynevezett késleltető utasítás: delay kifejezés; A kifejezés nemnegatív, egész értékű, decimális számrendszerben értendő szám, amely a késleltetést adja meg másodpercben.

24 116 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE AZ AKTÍV TASZK RÉSZÉRŐL A RANDEVÚ BEFOLYÁSOLÁSA A KÖVETKEZŐ MÓDON TÖRTÉNIK FELTÉTELES RANDEVÚ Csak taszkban alkalmazható. A randevú végbemenetele szabályozható a select utasítással, ami csak taszkban fordulhat elő. SELECT entry_hívás [utasítás(ok)] ELSE utasítás(ok); END SELECT; Az entry_hívás a randevúpont. Az aktív taszk megnézi, hogy létrejöhet-e azonnal a randevú. Ha igen, akkor létrejön a randevú, az esetleges utasítások végrehajtódnak. Ha nem tud randevúzni, akkor nem vár, hanem póttevékenységet végez: az ELSE ágban lévő utasításokat hajtja végre. IDŐZÍTETT RANDEVÚ SELECT entry_hívás [utasítás(ok)] ELSE delay kifejezés; utasítás(ok); END SELECT; Ha azonnal megtörténhet a randevú, akkor randevúznak, majd annak befejezése után az entry_hívás utáni utasítás(ok) hajtódik, illetve hajtódnak végre. Ha nem (de nagyon fontos a randevú, képesek vagyunk várni is rá), akkor a késleltetési időn belül meghatározott ideig próbálkozik. Ha ezidő alatt végrehajtható a randevú, akkor végrehajtja, különben pótcselekvés. A PASSZÍV TASZK OLDALÁRÓL BONYOLULTABB SELECT [WHEN feltétel =>] alternatíva [OR [WHEN feltétel =>] alternatíva]... [ELSE utasítás(ok)] END SELECT;

25 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE 117 Egy alternatíva az alábbi három szerkezet valamelyike: accept_utasítás [utasítás(ok)]: elfogadó alternatíva delay_utasítás [utasítás(ok)] : késleltető alternatíva terminate_utasítás Korlátozások: Legalább egy egy WHEN ág szükséges, és lehet egy ELSE ág. Legalább egy elfogadó alternatíva szükséges, de akármennyi lehet. A delay_utasításból bármennyi lehet. A terminate_utasításból maximum egy. A delay_utasítás és a terminate_utasítás kizárja egymást. Ugyanarra az entry_utasításra akárhány elfogadó utasítás vonatkozhat. NYÍLT ÉS ZÁRT ALTERNATÍVÁK Egy alternatívát nyíltnak nevzünk, ha: vagy nem szerepel előtte WHEN feltétel vagy szerepel, de a feltétel igaz. Egyébként az alternatíva zárt. Szemantikája a következő: amikor egy ilyen select utasításhoz ér a passzív taszk: Kiértékelődnek a feltételek. Eldől, hogy mely alternatívák nyíltak, és mely alternatívák zártak. Azon nyílt alternatívákban, melyekben delay utasítás van, kiértékelődik a delayben megadott kifejezés is. Egy nyílt accept alternatíva kiválasztható, ha létezik olyan aktív taszk, amely ezzel a ponttal randevúzni akar (meghívta ezt az entryt). Ekkor a randevú végbemegy, és kilép a selectből. Ha egyszerre több kiválasztható nyílt alternatíva van, bármelyik végrehajtódhat. Nem determinisztikus, hogy melyik randevú hajtódik végre, de mindig csak egyetlen randevú mehet végbe. Egy nyílt késleltető alternatíva kiválasztható, ha nincs kiválasztható nyílt accept alternatíva. Ha több kiválasztható delay utasítás van, akkor a legkisebb várakozási idejűt választja ki. Ekkor a passzív taszk a megadott ideig várakozik, és nézi, hogy nem futott-e be valamely nyílt elfogadó alternatívához randevú kérés. Ha igen végrehajtja, ha nem akkor várakozott egy jót, és kilép a select-ből. Nyílt terminate alternatíva akkor választható ki, ha a testvér taszkok és a szülő egység befejezte a működését, vagy a szülő egység legalábbis várakozó állapotban van. Ha a szülőegység taszk, akkor kükönösen érdekes ez a szituáció. (Ezért nincs PC-s környezetben Ada fordító. Ehhez operációsrendszer kell!) Ekkor a taszk befejezi a működését.

26 118 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE Ha nincs kiválasztható nyílt alternatíva, és van ELSE rész, akkor végrehajtódnak az ELSE ágban lévő utasítások, és kilép a SELECT-ből. Ha nincsen ELSE rész, akkor a SELECT belefut egy végtelen várakozásbsa, amelyben nézi, hogy egy nyílt alternatíva kiválaszthatóvá, vagy egy zárt nyílttá és kiválaszthatóvá válik. Ha minden alternatíva zárt, és van ELSE ág, akkor végrehajtódnak az ELSE utáni utasítás(ok), és kilépünk a SELECT-ből. Ha nincs ELSE ág, akkor bekövetkezik a SELECT_ERROR kivétel. Ez a kivétel csak taszkokban következhet be. Aktív taszk csak olyan passzív taszkkal tud randevúzni, amelyik még működik. Ha egy olyan taszkra történik hivatkozás amely már inaktív, akkor kiváltódik a TASKING_ERROR kivétel. Ez a kivétel is csak taszkokban következik be. KIVÉTELKEZELÉS A TASZKOK VONATKOZÁSÁBAN - Ha a kivétel egy randevúban következik be, akkor a randevúban résztvevő mindkét taszkban bekövetkezik a kivétel. - A kivételkezelés szabályai a szokásosak, azzal a specialitással, hogy vannak olyan kivételek amelyek csak taszkban következhetnek be. - A taszknak, mint programegységnek a végén helyezhatő el kivételkezelő, de ha a kivételt egy taszkban nem kezeljük, vagy explicit továbbadjuk, akkor az továbbadódik a hívó programegységnek, azaz a szülőegységben váltódik ki a kivétel, vagy ha ott nincs lekezelve, akkor továbbadódik, de legfeljebb addig adódik tovább, amíg a szülőegység taszk. Ha a legkülsőbb taszkban sincs kivételkezelő, akkor a kivétel elhal, nem megy tovább abba a programegységbe, ami a taszkot tartalmazza (hiszen egy blokk, ami nem taszk, nem tud mit kezdeni a csak taszkban bekövetkezhető kivételekkel). Ezért a taszkokban kezelni kell a kivételeket. Ha az Ada programokat többprocesszoros rendszerekben futtatjuk, akkor valódi párhuzamos programozást valósítottunk meg. Egyprocesszoros rendszeren is működik olyan Ada program, amely taszkokat tartalmaz. Az operációs rendszer feladata, hogy a párhuzamosságot szimulálja. A párhuzamos programozás nem determinisztikus programozás, így van olyan szituáció, amiről a nyelv nem rendelkezik. Ada fordítók megítélése: determinisztikusan valósítja meg a taszkokat, vagy nem determinisztikusan valósítja meg a taszkokat.

27 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE 119 Klasszikus példa: A következő szituációt valósítja meg: Van egy taszk, ami adatokat állít elő a saját ütemének megfelelően. Van egy másik taszk, ami felhasználja a termelt adatokat szintén a saját ütemének megfelelően. Nincsenek szinkronban, párhuzamosan dolgoznak. Produkáljunk egy passzív taszkot, amely fogadja illetve adja az adatokat, például egy sor segítségével: puffer. Kell egy szülőegység, bele kell foglalni a taszkokat egy szülőegységbe, mivel taszkok nem szerepelhetnek önállóan. A szülőegységen belül tehát van három taszk. A szülőegység törzse üres. Feladata: figyelni a testvértaszkokat P. begin null; end; Az első taszk törzsében legyen egy végtelen ciklus: loop BUFFER.WRITE(CHAR); exit when CHAR=END_OF_CHAR; end loop; A második taszk felépítése: loop BUFFER.READ(CHAR); feldolgozás; exit when CHAR=END_OF_CHAR; end loop;

28 120 A PÁRHUZAMOS PROGRAMOZÁS KÉRDÉSE A PASSZÍV TASZK FELÉPTÉSE: task BUFFER is entry READ (C : out CHARACTER); entry WRITE (C : in CHARACTER); end; TASK BODY BUFFER IS POOL_SIZE : constant INTEGER:=100; POOL : array (1..POOL_SIZE) of CHARACTER; COUNT : INTEGER RANGE 0..POOL_SIZE:=0; IN_INDEX, OUT_INDEX : INTEGER RANGE 1..POOL_SIZE:=1; begin loop select when COUNT < POOL_SIZE => accept -- kezdetben nyílt, van hely WRITE (C : in CHARACTER) do POOL(IN_INDEX:=C); END; IN_INDEX:=IN_INDEX mod POOL_SIZE+1; COUNT:=COUNT+1; or when COUNT > 0 => accept --kezdetben zárt, nincs elem READ(C : out CHARACTER) do C:=POOL(OUT_INDEX); end; OUT_INDEX:= OUT_INDEX mod POOL_SIZE-1; COUNT:=COUNT-1; or terminate; --nyílt end select; end loop; end BUFFER; A törzs egy végtelenciklus, amelyen belül egy SELECT utasítás van. A SELECT feladata a szinkronizáció. Három ág van. A terminate mindig nyílt. Elindul a programrész, a három taszk belefut a végtelenciklusba. Az első randevút az első aktív taszk hajtja végre. Majd kilép a SELECT-ből. Mivel végtelenciklusról van szó, újból a SELECT-re kerül a vezérlés. A két aktív taszk előbb-utóbb kilép a végtelenciklusból, és elér a törzsének a végére. A szülőegység várakozik. A passzív taszk a terminate-nál fejezi be a működését.

29 MÓDSZERTANOK ÉS TECHNOLÓGIÁK 121 MÓDSZERTANOK ÉS TECHNOLÓGIÁK A 60-as években a számítástechnika kilépett a művészetek világából, és átment az iparba a szoftverek terén is (sorozatgyártás). Felvetődött a kérdés, hogy hogyan lehet sorozatban gyártani szoftvereket. Ez volt a szoftverkrízis időszaka. A következő kérdés vetődött fel: Hogyan lehet a probléma ismeretében bármilyen programnyelven jó programot írni? Mi az, hogy jó program? A jónak van egy helyes értelmezése. Ha van egy program, akkor tudjam, hogy mit csinál. Olyan programot írjak, ami azt csinálja, amit akarok: programhelyesség-bizonyítás. Mitől nem jó egy program? A szoftverkrízis környékén a programozás jellemzői: Monolitikus programozás: a programot egy ember készíti, fejleszti, tervezi, stb. A programnak nincs belső struktúrája, így a program módosítása vagy nehéz, vagy lehetetlen. A programok sosincsenek készen, csak 90%-ban. A program megbízhatatlan: Az input nem minden elemére működik, így nem algoritmust realizál. A szélsőséges esteket általában nem kezeli. Pl. a rendezési algoritmusnak egy elemre is működnie kell. A program nem mindig áll le. A program lefagy, a rendszer is elszáll. A program működik, de nem lehet tudni, hogy milyen eredményt ad. Hibás adatokat produkál. A program nem védi a saját adatait. Alkalmazkodóképesség hiánya az egyik legnagyobb probléma: Nem gépfüggetlen. Nem operációsrendszerfüggetlen. Növekvő terhelés mellett a teljesítmény, a hatékonyság rohamosan (exponenciálisan) csökken. (Programot írni sokan tudnak, jó programot is elegen, de jól működőt nagyon kevesen. És rossz programból jól működőt írni már művészet kategória. Hangolás: a szoftvert az adott környezethez igazítjuk.) A program udvariatlan (nem felhasználóbarát.): A program csak egyféleképpen kezelhető, de azt nem tudja senki, hogy hogyan. A program hibaüzenetei semmitmondóak. Az outputja használhatatlan. A programok nincsenek dokumentálva. Nem lehet beleavatkozni kívülről a program menetébe. Kérdés, hogy hogyan lehet olyan elveket, gyakorlatokat találni, amelyek ezen hibákat kiküszöbölik? Hol vannak

30 122 MÓDSZERTANOK ÉS TECHNOLÓGIÁK azok az eszközök (programozásmódszertan), amelyekkel jó programot lehet írni, abban az értelemben, hogy: Egy adott programról meg tudjam mondani, hogy mit csinál. Úgy tudjak megírni egy programot, hogy az azt csinálja, amit kell. (Programhelyesség bizonyítás) Válasz a hogyanra: 1. Moduláris programozás módszertana (IBM). 2. Megszületnek az objektumorientált nyelvek. 3. Elkészítenek egy matematikai absztrakt elméletet. Megszületik a struktúrált programozási módszertan a 60- as évek végén 70-es évek elején. Ebből az elméletből születnek meg a feltett kérdésekre a válaszok. 4. A 70-es években megjelennek az újelvű programozási nyelvek és az újelvű programozás. 5. Szintén a 70-es években születik meg a logikai programozás. MÓDSZER (METHOD): Tevékenységek egy olyan szisztematikus együttese, amelyek megvalósítanak egy feladatot, megoldanak egy problémát (ld. algoritmus, pl. a gyorsrendezés egy módszer). TECHNIKA (TECHNIQUE): A módszerek által javasolt tevékenységek végrehajtása, kivitelezése. Például egy rendezési algoritmus végrehajtása manuálisan vagy számítógéppel. (pl. recept) MÓDSZERTAN (METHODOLOGY): Módszerek és technikák együttese, segítségével egy adott cél elérhető, egy adott probléma megoldható. ESZKÖZ (TOOL): Automatikus, vagy kézi erőforrás, módszer vagy módszertan alkalmazását segíti elő. Pl. egy C-ben megírt gyorsrendezést megvalósító függvény. KÖRNYEZET (ENVIRONMENT): Eszközök együttese. TECHNOLÓGIA (TECHNOLOGY): A módszertanok és környezetek együttese.

31 PROGRAMOZÁSI MÓDSZERTANOK 123 PROGRAMOZÁSI MÓDSZERTANOK MODULÁRIS PROGRAMOZÁS A moduláris programozás programozási módszertan. (Kialakulása: kitaláltak valamit, és később elnevezték moduláris programozásnak.) Elve: Oszd meg, és uralkodj elve átvitele a programfejlesztésre. Jellemzője: A moduláris programozást a top-down dekompozíció és a bottom up kompozíció jellemzi. TOP-DOWN DEKOMPOZÍCIÓ A megoldandófeladat komplexitását kell csökkenteni, osszuk fel a feladatot részfeladatokra. Ha a részfeladatok is túl bonyolultak, osszuk azokat is részfeladatokra, és tegyük mindaddig, amíg a részek átláthatóak nem lesznek. Ha ezeket leprogramozom, ezek lesznek a modulok. Ettől moduláris a programozás. A részfeladatokra bontásra vannak eszközök és technikák. Fel kell deríteni, hogy mit kell csinálni. Ezeket a mit -eket darabolom tovább. Funkciók mentén bontunk fel. A részfeladatok közötti kapcsolatokat jól kell specifikálni. Erre is van recept, de nem automatizálható. Ez a top-down dekompozíció, amikor felülről lefelé darabolok. A modul egyfajta logikai egység, amely: Önálló névvel rendelkezik. Önállóan kódolható. Önállóan tesztelhető. A modulok más modulok környezetében vannak, és paramétereken vagy globális változókon keresztül kommunikálnak egymással. A funkció menti szétbontásnál a modulok fajtái a következők: Adatmodulok: megadom, hogy mikkel akarok dolgozni. Funkcionális modulok: leírom, hogy hogyan. I/O modulok: kommunikáció. Vezérlő modulok: öszefűzés. Egymástól teljesen függetlenek a fejlesztés során az adatmodulok és az funkcionális modulok.

32 124 PROGRAMOZÁSI MÓDSZERTANOK A moduláris programtervezés lépései, módszertana: A feladat specifikációjától indulunk, és a top-down segítségével megadjuk a feladatmodul szerkezetét úgy, hogy a funkciók (tevékenység) mentén darabolunk. Modulok specifikációja, kapcsolata más modulokkal, kommunikációjuk leírása. Megtervezzük azokat az algoritmusokat, amelyek ezeket a részproblémákat megoldják. Lekódoljuk. Teszteljük. Az utóbbi négy lépés megvalósításához vannak módszerek, technológiák. BOTTOM UP KOMPOZÍCIÓ Lentről fölfelé felépítjük a programot. Nincs módszer és nincs technika arra, hogy az önmagában tökéletesen jól működő modulokból hogyan lehet jó programot összeállítani. Kézi munka. (A válasz általában: ha van szerencsém.) A programhelyességre nem tud pozitív választ adni. A moduláris programozás előnyei: A programnak van egy áttekinthető szerkezete, tiszták a kapcsolatok a modulok között. Ha módosítanom kell a programomat, ez általában egy vagy csak néhány modul módosítását jelenti. A javítás is csak részfeldatokra korlátozódik. Párhuzamos fejlesztést, tesztelést tesz lehetővé. Felgyorsul a programozás. Egyszerre több ember tud dolgozni 1 adott feladattal. Újrafelhasználhatóság: bizonyos modulok szabványosíthatók. Pl. I/O. A szabványmodulok egy könyvtárban tárolhatók, és újrafelhasználhatók. A moduláris programozás hátránya: Nincs módszer arra, hogy tökéletesen jól működő modulokból hogyan lehet jó programot összeállítani.

33 PROGRAMOZÁSI MÓDSZERTANOK 125 STRUKTURÁLT PROGRAMOZÁS A 60-as évek végén 70-es évek elején alakul ki részben a moduláris programozás hatására a strukturált programozási módszertan. Érdekes, hogy három különböző helyen jelenik meg egyszerre valamilyen módszertan, amelyekről kiderül, hogy ugyanarról szólnak. A harmadik egy absztrakt matematikai módszertan, amely alapján helyes programokat lehet írni. 1. DIJKSTRA: HIERARCHIKUS PROGRAMOZÁS A STRUKTURÁLT MÓDSZERTAN LEGABSZTRAKTABB VÁLTOZATÁT DIJKSTRÁÉK (HOLLAND) DOLGOZTÁK KI. HIERARCHIKUS PROGRAMOZÁSNAK HÍVTÁK EZT A MÓDSZERT. A struktúrált programozás átveszi a moduláris programozás top-down módszerét. A megoldandó feladathoz a program egy absztrakt programsorozat határértékeként alakul ki. Ebben a sorozatban egy későbbi absztrakt program egy őt megelőző program egy változtatásával áll elő úgy, hogy tekintjük valamely tevékenységét, és fokozatosan finomítjuk. A megelőző program valamely tevékenységét kifejtjük (részfeladat). A sorozat minden absztrakt programja mellett ott van egy absztrakt számítógép, amelynek utasításkészlete megegyezik a programban használt utasításokkal. Végül egy konkrét gép konkrét utasításkészletére készül el a program. Pl. egy tanulmányi nyilvántartási rendszer. A sorozat minden programja bizonyítottan helyes (azt a feladatot oldja meg, amit kell). Nincsen bottom-up. Léteznek konkrét matematikai módszerek, vannak automatizálható eszközök, de bizonyos feltételek, leképezések nem automatizálhatóak, ilyenkor a programhelyesség bizonyításához kézi vezérlés szükséges. (ld. még Programozáselmélet) 2. MILLS: FUNKCIONÁLIS PROGRAMOZÁS Ugyanaz az elve, mint a Dijkstra féle programozásnak, csak itt az eljárásmodell az elsődleges, az adatmodell másodlagos. Tevékenység mellett osztja szét a problémát részproblémákra. A feladat határozza meg a program szerkezetét. 3. JACKSON ÉS WARNIER: ADATORIENTÁLT PROGRAMOZÁSI MÓDSZERTAN A harmadik irányzat, amely jóval kevésbé matematizál. A top-down módszert vallja, de az adatmodell az elsődleges. Ha van egy probléma, fel kell derítenem az általa érintett adatok szerkezetét. A program szerkezetét az adatok szerkezete határozza meg. Hátránya: csak adatfeldolgozási területen alkalmazható.