Imperatief programmeren. Introductie 9. Leerkern 10. Zelftoets 15. Terugkoppeling 16. Inhoud leereenheid 16

Transcriptie

1 Inhoud leereenheid 16 Imperatief programmeren Introductie 9 Leerkern 10 1 Sleutelbegrippen 10 2 Pragmatisme 10 3 Case study: C 10 4 Case study: Ada 11 5 Overzicht van concepten in C en Ada 14 Zelftoets 15 Terugkoppeling 16 1 Uitwerking van de opgaven 16 2 Uitwerking van de zelftoets 17 8 OUN

2 Leereenheid 16 Imperatief programmeren I N T R O D U C T I E Het imperatieve programmeerparadigma is nog steeds het meest toegepaste paradigma. Het gebruik van Cobol, een van de oudste imperatieve talen. is vandaag de dag zelfs nog groter dan het gebruik van de qua ontwerp veel modernere talen als Pascal, C en Ada. Voor een deel is dit te verklaren uit het feit dat bedrijven destijds veel geld hebben geïnvesteerd in de ontwikkeling van programmatuur en dat de kosten van het onderhouden van deze programma s het herstellen van fouten en aanpassen aan nieuwe omstandigheden en wensen al zo n zestig procent van het totale softwarebudget opslokken. Het herschrijven van deze programma s in een andere programmeertaal is alleen mogelijk als dit budget fors wordt verhoogd. Een tweede verklaring is dat programma s geschreven in deze talen door de bank genomen efficiënt gebruik maken van de hardware; de talen staan dicht bij de machine en men duidt ze daarom ook wel aan als high level assemblers. In de praktijk zien we dat men voor bestaande toepassingen zo lang mogelijk de oudere talen blijft hanteren en de nieuwere talen (zowel imperatieve talen als niet imperatieve talen) alleen inzet bij de ontwikkeling van nieuwe toepassingen. In deze leereenheid bekijken we twee bekende representanten van de klasse van conventionele imperatieve talen: C en Ada. Met conventioneel bedoelen we hier imperatieve talen die niet specifiek zijn ontworpen voor objectgeoriënteerd programmeren. Op de specifieke verschillen tussen deze beide paradigma s (imperatief en objectgeoriënteerd) gaan we in leereenheid 18 nader in. LEERDOELEN Na het bestuderen van deze leereenheid wordt verwacht dat u vier essentiële kenmerken van een imperatieve taal kunt noemen aan kunt geven of, en op welke wijze, de hierna genoemde concepten zijn gerealiseerd in respectievelijk C en Ada: typen, expressies, opdrachten, variabelen, declaraties, abstracties, parameters, inkapseling, polymorfie, exceptions aan kunt geven in hoeverre C en Ada voldoen aan de in de cursus geformuleerde ontwerpprincipes voor een programmeertaal het verschil kunt aangeven tussen de concepten genericiteit en parametrische polymorfie aan de hand van de behandelde taalconcepten de sterke en zwakke kanten van C en Ada kunt aangeven. Relatie met het tekstboek In deze leereenheid gebruiken we hoofdstuk 11 van het tekstboek. Het voorbeeld A simple spellchecker dient slechts ter illustratie van de concepten. U kunt volstaan met het globaal doorlezen van de paragrafen OUN 9

3 Concepten van programmeertalen die daarop betrekking hebben, namelijk paragraaf en paragraaf Studeeraanwijzingen In deze leereenheid komt uiteraard een aantal C en Ada voorbeelden voor. Het is niet de bedoeling dat u dergelijke voorbeelden zelf kunt schrijven, wel moet u deze voorbeelden kunnen begrijpen. Tevens moet u globaal aan kunnen geven op welke wijze een bepaald concept is geïmplementeerd in C of Ada. Gebruik hiervoor tabel 16.1 als richtlijn. De studielast van deze leereenheid is circa 3 uur. L E E R K E R N 1 Sleutelbegrippen Geen verdere aanvullingen op het tekstboek. 2 Pragmatisme Geen verdere aanvullingen op het tekstboek. 3 Case study: C Opmerking Abstractieprincipe Om te beoordelen of de taal voldoet aan de geformuleerde principes, maken we uitsluitend gebruik van de informatie gegeven in het tekstboek. Andere versies of varianten van de taal kunnen uiteraard andere voorzieningen bevatten, waardoor de beoordeling anders zou komen te liggen. Deze opmerking geldt ook voor de andere beoordeelde talen. C kent alleen blokopdrachten, geen blokexpressies (alleen body van een procedure) of blokdeclaraties. De taal voldoet dus niet aan het in leereenheid 4 geformuleerde kwalificatieprincipe: in elke taalconstructie kunnen lokale declaraties worden gemaakt. In leereenheid 5 hebben we het abstractieprincipe geformuleerd: van elke taalconstructie kan een abstractie worden gemaakt, die later kan worden aangeroepen. OPGAVE 16.1 Voldoet C goed of slecht aan dit abstractieprincipe? Kwalificatieprincipe Correspondentieprincipe C voldoet slecht aan het correspondentieprincipe uit leereenheid 5: elke soort declaratie heeft een corresponderend parametermechanisme en omgekeerd. C kent slecht een parametermechanisme: copy in. De typedeclaratie en proceduredefinitie in C hebben geen corresponderend parametermechanisme. In het voorgaande zagen we dat C slecht voldoet aan de in de cursus geformuleerde ontwerpprincipes voor een programmeertaal. Daarnaast zijn er op basis van de behandelde taalconcepten meer negatieve punten in het ontwerp van C aan te wijzen (zie opgave 16.2). 10 OUN

4 Leereenheid 16 Imperatief programmeren OPGAVE 16.2 a Geef ten minste vijf punten van kritiek op de taal C. b Noem ook een positieve kant van C. 4 Case study: Ada Ada voldoet beter aan het typevolledigheidsprincipe dan C. Waarden van standaardtypen, samengestelde typen en pointer typen mogen alle op dezelfde wijze worden gemanipuleerd. Variabelereferenties mogen we echter alleen als argument van een procedure of functie gebruiken, functies en procedures zelf zijn op geen enkele wijze te manipuleren, ze kunnen zelfs niet als argument worden doorgegeven. Ada kent blokopdrachten en blokdeclaraties (packages), maar geen blokexpressies. De taal voldoet dus niet geheel aan het in leereenheid 4 geformuleerde kwalificatieprincipe. Evenals bij C kunnen we nagaan in hoeverre Ada aan het Abstractieprincipe abstractieprincipe voldoet. OPGAVE 16.3 Voldoet Ada goed of slecht aan het abstractieprincipe? a Toon aan dat de procedureaanroep add(a, b, c) het verwachte effect heeft als er voor de parameters gebruik wordt gemaakt van hetzij het kopieermechanisme of het referentiemechanisme. Gebruik in het geval van het kopieermechanisme voor de in parameters copy in parameters en voor de out parameter een copy out parameter. Gebruik in het geval van het referentiemechanisme voor de inparameters, constant parameters en voor de out parameter een variableparameter. Typevolledigheidsprincipe Kwalificatieprincipe Correspondentieprincipe Evenals C voldoet Ada slecht aan het correspondentieprincipe. De functie en proceduredeclaratie hebben geen corresponderend parametermechanisme. Het reference mechanisme correspondeert niet met een declaratie: Ada kent geen variabeledefinitie. Daar komt nog bij dat een Ada implementatie voor samengestelde typen mag kiezen tussen het kopieermechanisme en het definitiemechanisme. OPGAVE 16.4 Gegeven is de volgende procedure in Ada: type Vector is array (1..n) of Float; procedure add(v, w: in Vector; sum: out Vector) is begin for i in 1.. n loop sum(i) := v(i) + w(i); end loop; end; b Toon dat ook voor de aanroep add(a, b, b) en laat zien dat in dat geval aliasing kan plaatsvinden. OUN 11

5 Concepten van programmeertalen Genericiteit en parametrische polymorfie Polymorfe versus generieke functies In Ada kunnen we generieke packages en generieke procedures en functies declareren. Zo op het eerste gezicht lijkt het concept genericiteit (generics) van Ada hetzelfde als de parametrische polymorfie uit leereeenheid 8. Een generieke functie is echter iets anders dan een polymorfe functie en een generiek type is iets anders dan een (geparametriseerd) polymorf type. We laten aan de hand van twee voorbeelden de verschillen tussen beide concepten zien. De volgende polymorfe Haskell functie snd mogen we op parameters van verschillende typen toepassen: snd :: (a, b) -> b snd (_, y) = y Hugs> snd (13, True) True Hugs> snd ("Jeffrey", "Watt") "Watt" Hugs> a en b zijn typevariabelen die elk een nog vrij te kiezen type representeren. In Ada kunnen we de volgende generieke functie snd declareren. generic type a is private; type b is private; function snd (x : a; y : b) return b is begin return y; end; a en b zijn hier formele typeparameters (dus geen typevariabelen) met behulp waarvan we een type kunnen doorgeven. Voor we snd kunnen gebruiken, moeten we de generieke functie eerst instantiëren met concrete typen als actuele parameters: function snd_1 is new snd (Integer, Boolean); function snd_2 is new snd (String, String); Hierna kunnen we van snd_1 en snd_2 gebruikmaken: snd_1 (13, True) = True snd_2 ("Jeffrey", "Watt") = "Watt" Polymorfe versus generieke typen In feite creëren we eerst twee afzonderlijke functies, een voor de typen Integer en Boolean en een voor het type String, en er is dus geen sprake van één (polymorfe) functie die op parameters van verschillende typen mag worden toegepast. In leereenheid 8 is in voorbeeld 8.10 in Haskell het volgende polymorfe type List gedefinieerd samen met onder andere de functies head en tail met de volgende specificaties: data List a = Nil Cons (a, List a) head :: List a -> a tail :: List a -> List a 12 OUN

6 Leereenheid 16 Imperatief programmeren In de definitie van List geeft de typevariabele a aan dat het type van de elementen van List willekeurig kan zijn. De functies head en tail zijn polymorfe functies, het maakt voor deze functies niet uit wat het type van de lijstelementen is. Een generieke package declaratie voor het type List (een generiek abstract type) kan in Ada als volgt luiden. generic type a is private package list_type is type List is limited private; function cons (x : a; xs : List) return List; function head (xs : List) return a; function tail (xs : List) return List; private type Node; type List is access Node; type Node is record element : a; rest : List; end record; end list_type; a is hier weer een typeparameter. Voor ieder verschillend elementtype van List moet een nieuwe package worden geïnstantieerd met dat elementtype als actuele parameter, bijvoorbeeld: package list_type_int is new list_type (Integer); package list_type_char is new list_type (Character); Deze beide instantiaties resulteren in twee verschillende lijsttypen (namelijk list_type_int.list en list_type_char.list) en in twee verschillende functies voor zowel head als tail (list_type_ int.head en list_type_char.head, idem voor tail). Er is dus geen sprake van één (polymorf) type List en evenmin van polymorfe functies head en tail. Aanvulling bij voorbeeld Hoewel we de naam swap gebruiken voor waarden van een willekeurig type, is ook hier geen sprake van een polymorfe procedure. Door verschillende instantiaties van de generieke procedure krijgen we immers verschillende gewone procedures met elk een eigen naam en parametertype. OPGAVE 16.5 Maak van exercise op bladzijde 294 in het tekstboek de vragen a en b. Aanwijzing: een blokopdracht heeft in Ada de volgende vorm. declare declaraties begin opdrachten end; OUN 13

7 Concepten van programmeertalen Kanttekeningen bij Ada Ada kent meer geavanceerde taalconcepten dan C, onder meer inkapseling en exceptions. Dat is ook logisch, gezien het feit dat de taal tien jaar later dan C is ontworpen. We kunnen ons echter afvragen of het ontwerp van Ada, gezien in het licht van de in de blokken 1 en 2 behandelde taalconcepten, inderdaad zo goed is als men vaak suggereert. In de voorgaande paragraaf zagen we reeds dat Ada aan de vier ontwerpprincipes niet volledig voldoet. Daarnaast zijn nog de volgende punten van kritiek te noemen: polymorfie is niet mogelijk; weliswaar kent Ada het concept generics, maar zoals we in deze paragraaf aangeven, is dit wat anders dan parametrische polymorfie en kunnen we het hoogstens zien als een soort surrogaat hiervoor Ada kent weliswaar contextafhankelijke overloading van procedures, functies en operatoren, maar mist de fundamentele aanpak van overloading met typeklassen à la Haskell net als in C kunnen recursieve typen alleen met behulp van pointers worden gemaakt naast garbage collection kent Ada ook de mogelijkheid om zelf expliciet aan te geven dat een heap variabele niet langer nodig is ( unchecked deallocation), hetgeen het gevaar van dangling references met zich meebrengt naast escape opdrachten en exceptions is er ook nog een (overbodige) goto opdracht de taal is groot en mede daardoor lastig te leren en te interpreteren. 5 Overzicht van concepten in C en Ada In tabel 16.1 zetten we de concepten die al dan niet in Ada en C zijn te vinden, op een rijtje. TABEL 16.1 Taalconcepten in C en Ada (x = aanwezig) taalconcept C Ada primitieve typen numerieke typen x (integer, floating-point) x (integer, floating-point, fixed-point) karakters x boolean x enumeration x x samengestelde typen cartesisch product x (structure) x (record) disjuncte vereniging x (union type, untagged) x (discriminated record) functieruimte x (array) x (array) recursieve typen (via pointers) (via pointers) subtypen (ja, maar is geen type) expressies toekenningsexpressie x functieaanroep x x conditionele expressies x iteratieve expressies blokexpressies variabelen globale variabelen x x locale variabelen x x heap-variabelen x (low-level) x allocator x (malloc) x (new) 14 OUN

8 Leereenheid 16 Imperatief programmeren opdrachten lege opdracht x x toekenningsopdracht x procedureaanroep x sequentiële opdracht x x conditionele opdracht x x iteratieve opdracht x x blokopdracht x x sequencer x (break, continue, return) x (exit, return) jump x x exception handling x binding, scope globale typedefinities program units met globale variabelen procedures, packages, functiedefinities generieke units locale declaraties locale variabelen statische variabelen abstractie van proceduren functie x x procedure (via void) x parametermechanismen copy-in in-parameter geen reference parameter in-out-parameter (wel via pointer) out-parameter functies geen procedures geen eersteklas-waarden eersteklas-waarden voor samengestelde waarden keus tussen by copy of by reference overloading x generieke abstractie x (generieke packages, generieke proceduren) compilatie onafhankelijke gescheiden Z E L F T O E T S l Noem enkele essentiële kenmerken van een imperatieve programmeertaal. 2 Noem enkele taalconcepten die C niet biedt en Ada wel. 3 Wat is het kenmerkende verschil tussen een polymorfe functie in Haskell en een generieke functie in Ada? 4 Geef ten minste vier punten van kritiek op de taal Ada. OUN 15

9 Concepten van programmeertalen T E R U G K O P P E L I N G 1 Uitwerking van de opgaven 16.1 In C kunnen we alleen abstracties maken van een expressie (functie) en een opdracht (functie met terugkeerwaarde van type void). De taal kent geen abstracties van bijvoorbeeld een variable access (selectorabstractie), declaratie (generieke abstractie) of type (abstract type) en voldoet dus slecht aan het abstractieprincipe a Naast het slecht voldoen aan de ontwerpprincipes voor een taal, kunnen als negatieve punten van C verder worden genoemd: het typesysteem is zwak C kent geen abstractie van gegevens, geen generieke abstracties, geen exceptions C heeft een beperkt aantal primitieve typen C ondersteunt geen directe recursie opdrachten kunnen in onleesbare vorm geformuleerd worden door de onafhankelijke compilatie kan de consistentie in gevaar komen. b C is een populaire programmeertaal die uitstekend gebruikt kan worden voor het schrijven van efficiënte software op systeemniveau In Ada kunnen we abstracties maken van een expressie (functie), een opdracht (procedure), een type (abstract type) en een declaratie (generiek package), echter niet van een variable access (selector). Hiermee voldoet de taal in redelijke mate aan het abstractieprincipe a We bekijken eerst de aanroep add(a,b,c) voor beide mechanismen. 1 v en w zijn copy in parameters, sum is een copy out parameter: Bij aanroep van add worden de lokale variabelen v, w en sum gecreëerd en worden de waarden van de actuele parameters a en b toegekend aan respectievelijk v en w. Vervolgens wordt in de procedure de waarde van sum (de som van v en w) bepaald en bij beëindiging van add wordt deze waarde toegekend aan c. De waarden van a en b zijn niet gewijzigd. 2 v en w zijn constant parameters en sum is een variable parameter: Bij aanroep worden de namen v, w en sum gebonden aan respectievelijk a, b en c. In de procedure wordt vervolgens de waarde van sum (= c) gewijzigd in de som van a en b. De waarden van a en b blijven ongewijzigd. b We bekijken nu de aanroep add(a,b,b) voor beide mechanismen. 1 v en w zijn copy in parameters, sum is een copy out parameter: Bij aanroep van add worden de lokale variabelen v, w en sum gecreëerd en worden de waarden van de actuele parameters a en b toegekend aan respectievelijk v en w. Vervolgens wordt in de procedure de waarde van sum (de som van v en w) bepaald en bij beëindiging van add wordt deze waarde toegekend aan b. De waarde van a is niet gewijzigd; de waarde van b is gewijzigd in de som van a en de oude waarde van b. 2 v en w zijn constant parameters en sum is een variable parameter: Bij aanroep wordt de naam v gebonden aan a en de namen w en sum aan b. Vervolgens wordt in de procedure de waarde van sum (de som van v en w) bepaald. Hierdoor verandert tevens de waarde van w (sum en w zijn aliassen). Deze aliasing is in dit geval niet erg, omdat w in de procedure niet meer wordt gebruikt. Bij beëindiging van add is de 16 OUN

10 Leereenheid 16 Imperatief programmeren waarde van a niet gewijzigd; de waarde van b is gewijzigd in de som van a en de oude waarde van b a Instantiatie en aanroep van de generieke procedure kan overal gerealiseerd worden met een blokopdracht: declare procedure swapint is new swap (Integer); begin swapint (a(i), a(i+1)); end; b Instantiatie en aanroep van een generieke functie kan niet op vergelijkbare wijze worden gerealiseerd omdat Ada geen blokexpressie kent. 2 Uitwerking van de zelftoets 1 Een imperatieve programmeertaal is gebaseerd op de architectuur van de hardware. Imperatieve talen kunnen hierdoor in principe efficiënt worden geïmplementeerd. Een programma in een imperatieve taal bestaat uit een rij opdrachten die in een voorgeschreven volgorde moeten worden verwerkt. Voor de opslag van waarden worden (veranderbare) variabelen gebruikt die geheugenplaatsen in de computer representeren. Er bestaat een toekenningsopdracht voor het veranderen van de waarden van deze variabelen. 2 De volgende concepten zijn niet in C aanwezig, maar wel in Ada: packages (inkapseling) generieke abstracties generieke procedures en functies overloading (door programmeur) exceptions. 3 Een polymorfe functie is een functie die geen gebruikmaakt van de specifieke eigenschappen van een parameter. De functie kan daarom op waarden van elk type worden toegepast. In het type van de functie komt dit tot uiting in de vorm van typevariabelen. Een generieke functie heeft een typeparameter met behulp waarvan een type kan worden doorgegeven. Voor we de functie op een bepaald type kunnen toepassen, moeten we eerst een instance van de generieke functie creëren voor dat bepaalde type. Voor alle typen waarvoor we de functie nodig hebben, moeten we evenzovele functies creëren met elk een unieke naam; er is dus geen sprake van één polymorfe functie. 4 Als kritiekpunten op de taal Ada kunnen we onder meer noemen: Ada voldoet aan geen van de ontwerpprincipes volledig polymorfie is niet mogelijk Ada kent geen typeklassen à la Haskell recursieve typen zijn alleen mogelijk met behulp van pointers de mogelijkheid van unchecked deallocation van heap variabelen er is een overbodige goto opdracht de taal is groot en lastig te leren. OUN 17