Object Z – valodas Z objektorientēts paplašinājums

1. Object Z – valodas Z objektorientēts paplašinājums Specifikāciju valodu pamati

2. Object Z: ievada piezīmes Object Z – valodas Z paplašinājums, kas veicina objektorientēta specifikācijas stila lietošanu. Object Z – valodas Z paplašinājums. Katra Z specifikācija – arī derīga specifikācija valodā Object Z. Klases jēdziens – apvieno objekta stāvokļa, inicializācijas un operāciju shēmas vienā strukturētā kopībā Objektorientācija valodā Object Z: atļauj mantošanu, polimorfismu. Iespējama daudzkāršā mantošana. Sistēmu strukturizācija Object Z – citāda, nekā Z: valodā Z: salikts objekts satur komponentes kā sastāvdaļas, objektorientētajā pieejā: salikts objekts satur norādes uz “komponenšu” objektiem. Valodas Object Z izmantošana: programmatūras sistēmu specifikācija, t.sk. paralēlu sistēmu specifikācija (valodā Object Z ietverti komunikācijas starp objektiem primitīvi, paralēlās kompozīcijas operatori). Literatūra: G.Smith, The Object Z Specification Language, pieejama bibliotēkā.

3. Vienkārša specifikācija: Z un Object Z Queue[Item] Queue[Item] Klase, redzamie elementi items: seq Item count: N l ̀(count, Init, Join, Leave) items: seq Item count: N Shēma bez vārda - stāvoklis QueueInit[Item] Queue[Item] Init Init– rezervēts vārds, sākuma stāvoklis items =   count = 0 items =   count = 0 Join[Item] Join Queue(Item) item? : Item (items, count) item? : Item - mainīgie, kas var mainīties items’ = items ^  item?  count’ = count + 1 items’ = items ^  item?  count’ = count + 1 Leave[Item] Leave Queue(Item) item! : Item Par count neko nav jāsaka (items) item! : Item items =  item!  ^ items’ count’ = count items =  item!  ^ items’ Object Z – strukturēta specifikācija, ir skaidrs, “kas ir kas”

4. Object Z : klases specifikācijas “anatomija” Queue[Item] Klase, redzamie elementi Object Z klasei tiek definēts interfeiss. Šāda iespēja valodā Z nav. l ̀(count, Init, Join, Leave) items: seq Item count: N Shēma bez vārda - stāvoklis Shēmai Init nav savas deklarāciju daļas. Tiek pieņemts, ka šajā shēmā ir klātesoša stāvokļa shēma (t.sk. tās deklarāciju daļa). Init Init – rezervēts vārds, sākuma stāvoklis items =   count = 0 Join Shēmas operācijās implicīti klātesoša ir gan pati stāvokļa shēma (atbilst sākuma stāvoklim), gan arī tās ar ’ dekorētā versija (atbilst beigu stāvoklim). (items, count) item? : Item  - mainīgie, kas var mainīties items’ = items ^  item?  count’ = count + 1 Leave Par count neko nav jāsaka (items) item! : Item Object Z – strukturēta specifikācija, ir skaidrs, “kas ir kas”, valodā Z dažādo shēmu lomas (stāvoklis, inicializācija, u.c.) tiek uzdotas neformāli. items =  item!  ^ items’

5. Multiplekseris: izmanto klases objektus [Message] Status ::= idle | busy Queue[Item] l ̀(count, Init, Join, Leave) Multiplexer items: seq Item count: N l ̀(status, Init, Join1, Join2, Transfer, Leave) inp1, inp2, outp: Queue[Message] source: Queue[Queue[Message]]  -- atdalītājs stāvokļa shēmā status: Status -- palīgmainīgais ( visās op.) Init items =   count = 0 Join inp1inp2  inp1outp  inp2outp status=idle  outp.count = inp1.count + inp2.count (items, count) item? : Item items’ = items ^  item?  count’ = count + 1 Init inp1.Init  inp2.Init  outp.Init  source.Init Join1  inp1.Join Join2  inp2.Join Leave1  inp1.Leave  source.Join[inp1/item?] Leave2  inp2.Leave  source.Join[inp2/item?] Transfer  (Leave1 [] Leave2) || outp.Join Leave  outp.Leave || source.Leave Leave (items) item! : Item items =  item!  ^ items’ -- Nedeterminēta izvēle, paralēla kompozīcija

6. Object Z: objekta identitātes jēdziens Queue – Object Z klase Katrai netukšai Object Z klasei atbilst sanumurējama šīs klases elementu kopa. Elementi šajā kopā ir t.s. objektu “identitātes”. Līdzīgs jēdziens programmēšanā: norāde, pointeris. [Message] Status ::= idle | busy Multiplexer l ̀(status, Init, Join1, Join2, Transfer, Leave) inp1, inp2, outp: Queue[Message] source: Queue[Queue[Message]]  status: Status -- palīgmainīgais ( visās op.) Prasība, lai inp1, inp2 un outp norādītu uz dažādām Queue[Message] instancēm (šiem mainīgajiem atbilstošajām objektu identitātēm jābūt dažādām). inp1inp2  inp1outp  inp2outp status=idle  outp.count = inp1.count + inp2.count <-------- Init inp1.Init  inp2.Init  outp.Init  source.Init Šīs operācijas faktiski nemaina mainīgo inp1, inp2, outp un source vērtības (šo operāciju  - saraksti ir tukši), jo šo mainīgo vērtības ir objektu identitātes. Tas, kas tiek mainīts, ir objektu, kam piemīt šīs identitātes, saturs. Join1  inp1.Join Join2  inp2.Join Leave1  inp1.Leave  source.Join[inp1/item?] Leave2  inp2.Leave  source.Join[inp2/item?] Transfer  (Leave1 [] Leave2) || outp.Join Leave  outp.Leave || source.Leave <--------

7. Nedeterminēta izvēle, paralēla kompozīcija Queue[Item] Multiplexer … l ̀(count, Init, Join, Leave) inp1, inp2, outp: Queue[Message] source: Queue[Queue[Message]] items: seq Item count: N … … Init Join1  inp1.Join Join2  inp2.Join Leave1  inp1.Leave  source.Join[inp1/item?] Leave2  inp2.Leave  source.Join[inp2/item?] Transfer  (Leave1 [] Leave2) || outp.Join Leave  outp.Leave || source.Leave items =   count = 0 Join (items, count) item? : Item items’ = items ^  item?  count’ = count + 1 [] – nedeterminēta izvēle: izvēlas vienu vai otru alternatīvu, kura ir iespējama, vai arī abas reizē. Analoģiska operācija disjunkcijai  valodā Z.Piezīme. Šajā gadījumā izpildīt abas reizē nebūs iespējams source dēļ. Leave (items) item! : Item items =  item!  ^ items’ || – paralēla kompozīcija: izpilda abas operācijas, turklāt savieto vienas operācijas izejas mainīgos ar otras operācijas ieejas mainīgajiem, ja to nosaukumi sakrīt. Šādi savietotie mainīgie tiek paslēpti no operācijas signatūras.

8. 2 veidu paralēlās kompozīcijas || – paralēla kompozīcija: izpilda abas operācijas, turklāt savieto vienas operācijasizejas mainīgos ar otras operācijas ieejas mainīgajiem, ja to nosaukumi sakrīt. Šādi savietotie mainīgie tiek paslēpti no operācijas signatūras. || ir komutatīva, bet nav asociatīva.(a || b) || c var atšķirties no a || (b || c), piemēram, ja b signatūrā būs x!, un x? būs gan a, gan c signatūrā. Pirmajā gadījumā x vērtību no b dabūs a, bet otrajā gadījumā – c (otram no a, c attiecīgo x vērtību vajadzēs saņemt operācijas izpildes laikā no ārējās vides). a  [ x? , y! | y! = x? ] b  [ x! | x! = 5 ] c  [ x? , z! | z! = x? ] Papildus d  [ x! | x! = 7 ] (“ārējā vide”). (a || (b || c)) || d  [ y!, z! | z!=5  y!=7 ] ((a || b) || c) || d  [ y!, z! | z!=7  y!=5 ] Asociatīvā paralēlā kompozīcija: a ||! b – tāpat izpilda abas operācijas, savieto ieeju ar izeju, paslēpj ieejas mainīgos, bet nepaslēpj izejas mainīgos (tos var izmantot tālākā sinhronizācijā un informācijas apmaiņā ar vēl citām paralēlām komponentēm). a ||! (b ||! c)  [ x!, y!, z! | x!=5  y!=5  z!=5 ]

9. OO specifikācijas: mantošana Queue[Item] BoundedQueue[Item] l ̀(count, Init, Join, Leave) l ̀(count, Init, Join, Leave) – interfeiss netiekQueue[Item] mantots, jānorāda šeit| max: N items: seq Item count: N Init #items  max – Papildināts stāvokļa invariants items =   count = 0 Join #items < max -- Papildināts operācijas nosac. Join (items, count) item? : Item ResettableQueue[Item] l ̀(count, Init, Join, Leave, Reset) Queue[Item] items’ = items ^  item?  count’ = count + 1 Reset -- pievienota jauna operācija Leave (count) (items) item! : Item count’ = 0 items =  item!  ^ items’ ResettableBoundedQueue[Item] l ̀(count, Init, Join, Leave, Reset) BoundedQueue[Item] -- iespējama daudzkāršā mantošanaResettableQueue[Item]

10. OO specifikācijas: polimorfisms Queue[Item] Klašu hierarhija: BoundedQueue[Item] ResettableQueue[Item] Queue[Item] redzamības saraksts (interfeiss) l ̀(count, Init, Join, Leave) ietilpst arī visu apakšklašu redzamības sarakstos. Ja definējam: queue: Queue[Item],tad queue var būt elements jebkurā no šīm 4 klasēm. Varam rakstīt queue.Join, queue.Leave.queue.Reset tiešā veidā rakstīt nevar (vajadzīga kvalifikācija queue  ResettableQueue[Item]). Lai varētu lietot arī queue.Reset, varam deklarēt queue: ResettableQueue[Item]. Iespējama arī pārdefinēšana: HonorsStudent [ Student [ redef Enrol ] | Enrol  [ … | … ] ] ResettableBoundedQueue[Item]

11. Mantošana: kā rindu pārveidot par steku? Queue[Item] Stack[Item] l ̀(count, Init, Join, Leave) l ̀(Init, Push, Pop) Queue[Item] [Pop/Leave] items: seq Item count: N Push Init (items) item? : Item items =   count = 0 items’ =  item?  ^ items Join (items, count) item? : Item Iespējams, ka šis nav pats dabiskākais veids, kā definēt steku. Ilustrē mantošanu līdzekli, koda atkārtotai izmantošanai (reuse). Leave – pārsaukts par Pop. Join vienkārši izslēgts no klases interfeisa. Jāņem vērā, ka Join tomēr nav pavisam pazudis, un šādi definētas klases Stack apakšklasēs tas atkal var tikt iekļauts klases interfeisā. items’ = items ^  item?  count’ = count + 1 Leave (items) item! : Item items =  item!  ^ items’

12. Rekursīvi definētas shēmas: papildmateriāls Tree | nodes: P Tree val: N left_tree, right_tree: Tree null: B Definē koku klasi, šīs pašas klases terminos. Šāda veida definīcijas iespējamas tikai tāpēc, ka Object Z izmanto pointeru semantiku. Jautājums, vai rekursīvi definētai shēmai kaut kas “reāli” atbilst? Fiksēto punktu objekti. Rekursīvai shēmai var veidot atbilstošu nerekursīvu shēmu. left_tree.nodes, {self}, right_tree.nodes partitions nodes t : left_tree.nodes  t.null  t.val < val t : right_tree.nodes  t.null  t.val  val Init null  left_tree.init  right_tree.init Insert  [(null, val), v?: N | null  val’ = val?   null ] [] [ null ]  (left_tree.Insert [] right_tree.Insert)

13. Klases vēstures invariants Ideja: ar katru klasi saistīt vēstures invariantu, kas aprakstīts temporālajā loģikā, raksturo kādu īpašību, kas piemīt šīs klases objekta darbības vēsturei kopumā. Temporālās loģikas predikāts: TP :: = P | Opn enabled [ | P ] | Opn occurs [ | P ] | □ TP | ◊ TP | TP | TP  TP | TP  TP | TP  TP | TP  TP Šādam predikātam priekšā iespējami arī kvantori. LiveVendingMachine VendingMachine □ (credit  100  ◊ (Choc occurs)

14. Object Z: tālāki jautājumi Vairāki labi komentēti piemēri atrodami G.Smith grāmatā par Object Z (nodaļas 1.6: Tetris spēle, 5.1 – 5.4.: notikumu plānotājs laboratorijā, 5.5: kāršu spēle Hearts), ieteicams izlasīt, var būt labas tēmas referātiem. Laba tēma referātam: kādas praktiski nozīmīgas specifikācijas ir uzrakstītas valodā Object Z? Dziļāki pētījumi: kāda ir Object Z vieta paralēlu sistēmu specifikāciju formālismu spektrā? Iespējams, ka daļēju atbildi varēsim iegūt kursa tālākajā daļā, pievēršoties paralēlu un reālā laika sistēmu specifikācijai. Dziļāki pētījumi: kā valodā Object Z modelēt sistēmas ar kvantitatīvām reālā laika īpašībām? Interesanti būtu saprast: kādas ir praktiskas specifikāciju metodoloģijas, kas tiek atbalstītas un izmantotas valodā Z, bet kuras netiek atbalstītas ar Object Z klases jēdzienu?