Föreläsning 0: Introduktion av Ada OBS! Detta är antagligen det enda papper som delas ut under hela FÖ serien. Det finns förutom detta ett antal OH:n som kommer att användas under nästa FÖ, men sen är det endast tavelskrivande och diskussioner som gäller. Vad kommer vi att behöva så här i kursstarten? Lite begrepp och lite problemlösning. Dessutom lite hur ett program ser ut. Vi börjar med lite begrepp. Ett antal "reserverade identifierare" (reserverade ord). Dessa används för att strukturera upp programmet och får bara användas till just detta. Lite "ihopklumpande" efter hur/när man använder dem: procedure is loop begin end loop; end ; while loop with ; end loop; use ; for in loop if then end loop; elsif then else exit; end if; exit when ; Ett antal "datatyper" ("beskrivningar" av hur data ser ut). Dessa är några av de "fördefinierade identifierare" vi kommer att komma i kontakt med: Integer = heltal (ex. 1, 2, 145, 4) Float = flyttal (ex. 1.0, 2.0, 3.14, 3.0) Character = tecken (ex. 'a', 'b, '2', '#') String() = "textsnutt" (ex. "kalle", "berta") Boolean = sanningsvärde (False, True) Ett antal "variabler" (lagringsutrymmen att lägga data i). Dessa blir såkallade "egendefinierade identifierare": I : Integer; F : Float; C : Character; S : String(1.. 5); B : Boolean; När man skapar dessa variabler använder man datatyperna för att tala om vilken sorts variabel det är. OBS! En identifierare identifierar något i programmet och skall därför vara unikt (inom det "område i programmet" som använder denna). Regel för identifierare: En "identifierare" måste inledas med en bokstav. Därefter får det följa fler bokstäver och/eller siffror och/eller understrykningsstreck. Man får dock inte avsluta identifieraren med ett understrykningsstreck eller ha två sådana i rad inuti identifieraren.
Det som är beskrivet hittills är saker som redan finns i Ada utan att man behöver säga något extra. När man kommer till programmeringen behöver man dock ofta lite mer att "leka med". Det som behövs kan vara matematiska bibliotek med "Cos", "Sin", etc. eller hantering av externa enheter såsom tangentbord och skärm (såkallad in och utmatning vilket kallas IO efter det engelska "In and Out"). Dessa delar har man i Ada delat upp i olika moduler kallade "paket". Det finns många sådana fördefinierade och här kommer ett par stycken med några av de saker som finns inuti: Ada.Text_IO Put(); Put_Line(); New_Line; New_Line(); Get(); Get_Line(); Skip_Line; Skip_Line(); Ada.Float_Text_IO Put(); Get(); Ada.Integer_Text_IO Put(); Get(); Ada.Numerics.Elementary_Functions Sqrt() Log() Exp() Sin() Cos() Tan() Cot() Sinh() Cosh() Tanh() Coth() Arcsin() Arccos() Arctan() Arccot() Arcsinh() Arccosh() Arctanh() Arccoth() OBS! Det är inte något ';' efter de saker som finns inuti det sista paketet. Varför kommer vi tillbaka till senare på den FÖ som handlar om underprogram.
Stencilen ovan lämnas ut på första FÖ, men finns också tillgänglig via kursens hemsida. Nu sätter vi igång! I denna kurs är det tänkt att vi ska lära oss programspråket Ada för att skriva datorprogram. Vad är ett datorprogram? Vi ser det gärna som en beskrivning, en uppsättning instruktioner som löser ett givet problem. Det är egentligen detta vi är mest intresserade av, att lösa problem. Varför ska man då lära sig just Ada? Det finns ju många programmeringsspråk. För det första så är det som sagt inte jätteintressant exakt vilket språk man använder, det är i allmänhet inte så att vissa språk är bättre än andra, utan det är själva tänket man är ute efter, d.v.s. hur tänker man när man programmerar? Dessvärre måste man ha språket, själva verktyget till hands innan man kan bli bra i en viss färdighet. Man kan jämföra det med att det är svårt att snickra om man inte vet hur man använder sig av sågar, hammare och borrar. För det andra visar det sig att Ada är ett mycket lämpligt språk att börja med. Strukturen i språket är sådan att man lätt ser vad man håller på med, dessutom finns det en mycket "snäll" kompilator, alltså det som gör att man kan översätta sin programkod (ren text) till ett riktigt program. Mer om detta senare. Pappret som ni har fått ut är en kort sammanfattning av de två första föreläsningarna. För tillfället kan vi se det mer som en översikt. På pappret finns det många ord på engelska, det kommer vara dessa (och många fler!) som dina program är uppbyggda av. Vi kommer att prata om "reserverade identifierare", det är ord som har en väldigt specifik betydelse i språket och som man inte får ändra på. (Ungefär som att ändra ordet "är" till "banan" i svenskan, blir lite struligt). Det finns även fördefinierade identifierare, det är ord som finns i programspråket men som man kan ändra på (Om vi t.ex. ändrar ordet Kawazaki till Honda så blir det bara måttlig förvirring). Vi kommer att prata om datatyper och variabler, dessa saker har ihop med hur vi lagrar data (t.ex. ett personnummer, ett banksaldo eller alla dina bilder i din dator). Vi kommer prata om identifierare. Detta är namnen (orden) på allting annat i ett program. Ibland kommer ni att få hitta på helt egna namn på saker, det kanske låter larvigt men är faktiskt mycket mycket viktigt att det blir bra. Det finns också ett stort antal andra "rutiner", man kan tänka sig att dessa rutiner är små färdiga program som ett nytt program kan använda sig av, för att slippa göra grovjobbet. Det finns t.ex. matematiska rutiner (vi kommer att säga underprogram i framtiden), de behövs oftare än man tror! Det finns också underprogram för in- och utmatning. Dessa används för att programmet skall kunna jobba med datorns skärm och tangentbord. Det är så att det är mycket svårt att lära sig programmering om man inte kan se vad som händer i ett program om man skriver in olika saker då programmet körs. Därför tar vi detta i början av kursen, så det är vad lab 0 och resten av föreläsningen kommer att handla om. Hur skriver vi nu ett program med hjälp av dessa saker? Vi kan börja med ett exempel från labserien (den första introduktionslaborationen som följer efter denna FÖ i denna kurs). Följande dialog vill vi att den skall utföras med datorn: Mata in ett heltal: 10 Du matade in heltalet: 10 Mata in en sträng med exakt 5 tecken och ett heltal: Kalle 27 Du matade in heltalet 27 och strängen "Kalle". OBS! Det är meningen att datorn (ditt program) skall skriva ut allt i dialogen på skärmen UTOM det som står efter frågorna "Mata in :". Dessa data skall användaren mata in på tangentbordet och det är just dessa inmatningar som sen skall skrivas ut på raden efter (av ditt program). Vi börjar med uppgiften på tavlan (bra att tala om hur många rader det blir och vilka rader man använder när man skriver programmet): Nedan har jag fyllt i hela programmet. Under FÖ växer detta självklart fram efter hand.
1 with Ada.Text_IO; use Ada.Text_IO; 2 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; 3 5 6 I : Integer; 7 S : String(1.. 5): 8 10 Inmatning av heltal. 11 Ada.Text_IO.Put("Mata in ett heltal: "); 12 Ada.Integer_Text_IO.Get(I); 13 Skip_Line; 14 Utskrift av heltalet. 15 Ada.Text_IO.Put("Du matade in heltalet: "); 16 Ada.Integer_Text_IO.Put(I); 17 Ada.Integer_Text_IO.Put(I, Width => 0); 18 Ada.Text_IO.New_Line; 19 20 Inmatning av sträng och heltal. 21 Put("Mata in en sträng med exakt 5 tecken och ett heltal: "); 22 Get(S); 23 Get(I); 24 Skip_Line; 25 Utskrift av strängen och heltalet. 26 Put("Du matade in heltalet "); 27 Put(I, Width => 0); 28 Put(" och strängen """); 29 Put(S); 30 Put_Line("""."); 31 end In_Och_Utmatning; Först och främst kan jag tala om att det är inget magiskt som jag kommer göra nu. Det vi skriver här är ren text! Tänk er att jag har öppnat programmet "anteckningar"/"notepad" på datorn och skriver in koden. Jag skulle egentligen kunna använda vilket text-editeringsprogram som helst! Kanske inte MS Word dock, Word sparar undan en massa annan information i filerna som inte syns. Vi vill, att i våra filer ska det bara finnas råtext (trots att källkodsfilerna har.adb som fil-ändelse). Det vi kallar för kompilator kommer senare att göra om råtexten till ett program som datorn verkligen förstår, men för tillfället kan vi tänka oss att det som står här i texten är det som datorn kommer att utföra. Så kan man även tänka i allmänhet när man programmerar, vilket är trevligt. Till att börja med måste man få till programmets grundläggande struktur. Det jag kommer skriva nu är något som alla ada-program har. Det är liksom ett programskelett. (Observera att jag inte behöver skriva radnummren, det är bara för att det skall bli lättare för er att följa med i era anteckningar). 10 27 end In_Och_Utmatning;
Om ni tittar på den sidan som ni fick ut så ser ni att "procedure" "is" "begin" "end" är reserverade identifierare. Alltså något som finns specat i språket. Däremot har jag själv hittat på identifieraren "In_Och_Utmatning", själva namnet på programmet. När jag sparar den här filen så kommer jag spar den som "in_och_utmatning.adb" (obs små bokstäver!). När man hittar på identifierare får man ha hur långa ord som helst. Man kan använda understreck och siffror, men det namnet får inte börja på en siffra (se pappret). Programskelettet är inte bara något som ser vackert ut, utan har den funktion (förutom att det finns en plats för programmets namn) att dela upp programmet i två delar, en deklarationsdel och en satsdel (en del med instruktioner). Jag brukar alltid tänka mig detta som ett recept. Högst upp (mellan procedure och begin) har man ingredienser, "dessa saker kommer jag behöva för att utföra programmet", och mellan begin och end har man instruktioner "detta är instruktioner som man skall följa steg för steg för att det skall bli rätt". Obs! Alla språk har inte denna uppdelning, tråkigt för dem. Okej, nu har vi ett program? Nästan. Programmet måste göra något också, det är ju faktiskt helt tomt (förutom skellettet, som inte gör något). Vad vill vi att program ska göra? Vi börjar lite smått med något som torde vara lätt. Textsnutten "Mata in ett heltal: " ska komma ut på skärmen. Detta borde inte vara så komplicerat, men det är det! Varför? Tja, skärmen är komplicerad. Den har ett helt eget gränssnitt som är mycket annorlunda från Ada. Dessutom kan ju inte vårt program göra vad det vill. Det kanske finns andra program som måste få tillgång till skärmen samtidigt, alltså krävs det en tredje part som styr upp så att det inte blir kiv, operativsystemet. INTERNMINNE OPERATIV- SYSTEM EXTERNA ENHETER Put( Mata in ) UTMATNINGSBUFFERT TANGENTBORDSBUFFERT Bilden växer fram tillsammans med att programmet utvecklas. Adas kärna I/O modul för text I/O modul för heltal modul med matematiska funktioner m.m. Så det är antagligen inte så lätt som att bara skriva "skriva ut följande textsnutt "Mata in " på rad 10. Det krävs säkert ett mycket stort och krångligt program bara för att få till detta. Men nu kommer det underbara: Det (under)programmet är redan skrivet, men det ligger på en separat modul. Det finns en hel del moduler, som vi kallar paket eller bibliotek, som man kan välja att ha med när man skriver ett program. Man skulle kunna visualisera språket som en blomma, i mitten finns alla de nyckelord och konstruktioner som man behöver i (nästan) alla program, t.ex. vårt programskelett. De saker som man kanske inte alltid behöver ligger i separata moduler, dessa är blommans kronblad. Anger man inte explicit att man vill ha tillgång till dessa moduler så får man bara tillgång till
de mest grundläggande sakerna i språket. Eftersom Ada är ett programspråk som används för många inbyggda system, d.v.s. system som inte är tänkte att föra dialog med en användare, ligger dess rutiner för in- och utmatning på sådana separata moduler. I Ada kallas modulerna bl.a. för paket. I ett paket som heter Ada.Text_IO (IO som i "Input and Output") finns en rutin som heter "Put" som utför precis det vi vill, och vi slipper bry oss om hur det egentligen fungerar. Vi måste givetvis också ange att vi vill få tillgång till Ada.Text_IO, det gör vi med "with". Detta är så pass speciellt att det hamnar utanför både deklarationsdelen och satsdelen av programmet! 1 with Ada.Text_IO; 10 Ada.Text_IO.Put("Mata in ett heltal: "); 27 end In_Och_Utmatning; Nu har vi fått till vår första instruktion, och ett körbart program på samma gång. Självklart vill vi då testa vårt program och se vad som händer när vi kör det. Exakt hur man gör detta går jag inte igenom nu. Det är enklast att förstå när man sitter själv framför datorn. Oroa er inte för detta nu, labassistenterna hjälper er med det på första laborationen. När vi kör programmet så skickar programmet iväg textsnutten till skärmen (vi operativsystemet) och den visas upp för oss. En viktigt detalj är semi-kolonet sist på rad 10. Den talar om att instruktionen, satsen slutar där. Satser kan fortsätta över flera rader, eller stå på samma (även om det är fult) så man behöver något explicit som skiljer en sats från nästa. Bortsett från att skriva ut (matar ut) denna text gör programmet inget mer, det kommer avslutas efter instruktionen. Man kan tänka sig att datorn fortsätter ner till "end In_Och_Utmatning" och efter det så avslutar den helt enkelt programmet. Nu kommer nästa uppgift. Att låta användaren, alltså den som sitter och kör det här programmet att få mata in något. För det mesta så kommer ni köra era egna program, så det kommer vara ni som är användaren, så det kan vara lite förvirrande att helt plötsligt behöva ha två roller "programmeraren" och "användaren", men man kommer in i det. Om ni tycker att det är besvärligt kan ni tänka er att ni är labassistenten som kör ert program. Vad skulle han/hon tycka/tänka? 10 Ada.Text_IO.Put("Mata in ett heltal: "); 11 Här vill vi hämta ett tal från tangentbordet Hur får vi då in något från tangentbordet? Här är det många saker som skall klaffa. Användaren skall trycka på tangentbordet, programmet skall vara redo att ta emot, och vi måste även se till att det som matades in inte kastas utan sparas någonstans, eftersom vi i nästa skede skall mata ut det igen så att användaren ser vad han skrev in. Vi fokuserar på det första. När kan användaren mata in något? Tja, när som helst faktiskt. Det är faktiskt möjligt för användaren att mata in något innan programmet ens har startat! Detta går att göra, antingen om man är ryyysligt snabb (nu snackar vi nanosekunder), eller om man vet hur man "laddar upp" med inmatning till programmet. Hur man gör detta är inte så intressant nu men vi vet i alla fall att inmatningen kan komma tidigt, vilket kan vara besvärligt om vi inte är beredda på att ta emot än. Tänk er att ni kastar en baseboll och jag har inte ens fått på mig plockhansken än. Den enda lösningen på detta är att användarens
knapptryckningar lagras så att vi kan bearbeta dem (ett par mikrosekunder) senare. Operativsystemet har en sådan lagringsplats, mellan tangentbordet och vårt program, som kallas tangentbordsbufferten. Detta är bra. Allting som trycks på tangentbordet hamnar alltså här tills vi (i vårt program) kommer och hämtar upp det. Datat försvinner då ur tangentbordsbufferten men finns kvar i vårt program. Att användaren är snabb är dock i allmänhet inte ett problem, eftersom användaren ofta är jättelångsam. För datorn är det som att det passerar hela tidsåldrar från den tidpunkt då texten "Mata in ett heltal" kommer upp tills då användaren inser att han måste börja trycka på knapparna. Det kan ju vara frestande för datorn att dumpa användaren och gå vidare med livet, d.v.s. att bara gå vidare till andra instruktioner om det inte finns något att hämta i tangentbordsbufferten. Men så får det absolut inte gå till. Då kommer det uppstå väldiga problem när vi senare vill skriva ut det användaren skrev in. Det enda som datorn då kan skriva ut är ett pinsamt erkännande att den inte vet eftersom han inte lyssnade just då. Dessutom kanske man kommer i "osynk" med kommande inmatningar och det heltal som matades in börjar tolkas som något helt annat. Nej! Det enda logiska är att datorn väntar på användaren, även om det betyder att den får vänta natt och dag tills hin håle kommer. Den tredje saken som var viktig var att vi verkligen kunde "spara" det som matades in. Vi skulle behöva lite av datorns minne, inte särskilt stor bit, så att vi kan lagra ett tal. Men hur blir detta? I bilden ligger ju redan själva programmet i datorns internminne, vart lagrar man då sitt data? Svaret är enkelt, detta ligger också i internminnet. Datorns minne är alltså plats för både program och data. Hur som helst behöver vi nu en liten bit minne som kallas för en variabel, i vårt fall blir det en heltalsvariabel. Variabler har alltid tre saker: En typ (kan t.ex. vara heltal, flyttal, tecken o.s.v), ett namn (en identifierare som vi som programmerare får hitta på). och ett värde. Vi brukar rita detta så här (ritas in i bilden ovan): I : 25 I detta exempel heter variabeln "I" och innehåller värdet 25. Datatypen är underförstådd, det är ett heltal. Det är viktigt att veta att variabler har värden alltid! Även innan man aktivt har petat in något i dem. De kan aldrig vara "tomma". För att få tillstånd (av operativsystemet) att använda en sådana variabel måste vi deklarera att vi har den i programmets deklarationsdel. 1 with Ada.Text_IO; 5 6 I : Integer; "Integer" är alltså typen på variabeln (en fördefinierar identifierare). Och "I" är vårt namn på den. Vi hade kunnat kalla den för "mitt_tal" eller något annat sånt, men nu valde jag just "I". Denna variabel kan vi nu använda i vårt program. Obs, det krävs inga paket eller moduler för att använda variabler av olika typer, de finns i "grundspråket" så att säga. Nu vill vi, förutom de saker som vi sa förut, att det som hämtas från tangentbordsbufferten in skall lagras i den här variabeln "I". Självklart finns det ett underprogram som gör detta, på precis det sätt som vi önskar. Den kallas för Get, och denna rutin ligger i paketet Ada.Integer_Text_IO. På samma sätt som förut måste vi ange att vi vill få tillgång till Ada.Integer_Text_IO.
1 with Ada.Text_IO; 2 with Ada.Integer_Text_IO; 3 5 6 I : Integer; 10 Ada.Text_IO.Put("Mata in ett heltal: "); 11 Ada.Integer_Text_IO.Get(I).. 27 end In_Och_Utmatning; Om vi nu kör programmet så kommer följande att ske: - Programmet startar, vi får tillgång till en heltalsvariabel med namn I. - Texten "mata in ett heltal: " kommer ut på skärmen. - Programmet kommer till Get, och frågar operativsystemet om det finns något i tgb-bufferten. "Nej" får det som svar och sätter sig därför för att vänta. - Användaren vaknar upp och inser att han måste trycka in ett tal. De tecken som användaren knappar in hamnar i tangentbordsbufferten, låt säga att han/hon matar in 5. Observera nu att inget kommer att hända föränn användaren trycker på enter. Tänker man till så inser man att det nog är bra att det är på detta sätt. Om man skulle ha matat in fel så har man ju fortfarande chans att sudda och skriva in något annat. Det är först när enter-tangenten trycks ner som operativysstemet kommer att börja agera. - Operativsystemet upptäcker att det finns data som vårt program är intresserat av. OS:et väcker vårt program och talar om för det att det finns data att hämta. - Rutinen Get hämtar femman och sparar undan den, som ett heltal i variabeln I. - Programmet avslutas. Toppen, vi fortsätter raskt med resten av första biten. I nästa skede skall texten "Du matade in heltalet: " komma ut, det löser vi med Put igen. Och sedan skall det tal som finns lagrat i "I" komma ut på samma rad. Vi behöver inte göra något speciellt för att det ska hamna på samma rad, allting hamnar på samma rad tills man explicit säger att man vill hoppa ner till nästa (eller användaren trycker enter, då sker detta automatiskt). Hur skriver vi ut talet i "I" då, jo med en annan utmatningsrutin, som också heter Put. Put för heltal finns i paketet Ada.Integer_Text_IO.
1 with Ada.Text_IO; 2 with Ada.Integer_Text_IO; 3 5 6 I : Integer; 10 Ada.Text_IO.Put("Mata in ett heltal: "); 11 Ada.Integer_Text_IO.Get(I) 12 13 Ada.Text_IO.Put("Du matade in heltalet: "); 14 Ada.Integer_Text_IO.Put(I, Width => 0); 27 end In_Och_Utmatning; När man använder Put för heltal så får man det "högerjusterat" med 11 teckens "bredd" om man inte säger något. I vårt fall vill vi inte ha detta, vi vill ju bara få ut talet precis som det är (vänsterjusterat), för att få till detta så kan vi sätta denna "bredd" till 0. Vi måste också få till en extra tom rad här, så vi kan använda rutinen New_Line som finns i Ada.Text_IO. 16 Ada.Text_IO.New_Line; Ni kan förstå att det blir trist att skriva ut "Ada.Text_IO" och "Ada.Integer_Text_IO" hela tiden. På ett sätt är det bra, får då ser man ju exakt vilken Put det är man använder (eftersom de heter lika dant), men det är jobbigt att skriva så mycket. Det finns ett sätt att slippa skriva ut paketnamnen. Om man i samband med att man gör "with" på paketet också gör "use" så räcker det med att bara skriva namnet på den rutin man vill ha. jag gör det nu, så blir det mindre att skriva i fortsättningen. 1 with Ada.Text_IO; use Ada.Text_IO; 2 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; Man brukar som sagt inte skriva satser på samma rad, men i detta fall kan det faktiskt vara okej. Frågan är bara, om jag inte skriver ut paketnamnet på de rutiner som jag vill använda, hur vet då datorn (eller egentligen kompilatorn) vilken som den skall använda? Svaret är att den kan titta på det som man skickar till rutinerna. Skickas det ett heltal till Put, då vet den att det är Put för heltal som gäller, om det är en textsnutt (vi kommer att säga "sträng" ofta) så är det Put för text vi vill ha. Att man kan ha samma namn på rutiner som gör olika saker kallas för överlagring och är en smidig feature i ett programmeringsspråk. Programmet är nu såpass färdigt att det kan utföra den första halvan av vårt problem. Men vad händer om användaren inte matar in tecknet 5 då? Vad händer om han skriver 5.6 eller "FEM"? Tja, Get klarar av vissa saker, men inte andra. I fallet då man matar in 5.6 kommer det ändå bara att bli 5 i I eftersom Get anser att den är klar när den stöter på en punkt i tangentbordsbufferten. Allting fungerar alltså ändå i detta fall, men observera att ".6" ligger kvar i tangentbordsbufferten! Hade det kommit en till Get hade denna fått problem. Därför kan det vara bra att göra en strategisk tömning av bufferten i detta läga. Det kan man göra med satsen "Skip_Line". 12 Skip_Line; Jag hade kunnat skriva Ada.Text_IO.Skip_Line, men eftersom vi nu har use på Ada.Text_IO så räcker det med "Skip_Line".
Om det första som Get ser är något som inte kan tolkas som ett heltal, t.ex. en punkt eller tecknet "F", kommer den att få fnatt. Hur ska den göra nu? Vi kommer komma tillbaka till just detta problem senare, men för tillfället räcker det med att ni vet att get kommer inte att fungera i detta fall. Faktum är att get kommer haverera totalt och dra med sig hela programmet ner i graven, ja - programmet dör (det kraschar). När ett program kraschar så avslutas det på en gång, man fortsätter inte med andra instruktioner utan man avslutar tvärt, ofta med ett läskigt felmeddelande. Resten av föreläsningen fortsätter på ett mycket likt sätt. Här är det ett ypperligt läge att låta studenterna vara med och utforma resten av programmet. När strängar tas upp är det viktigt att poängtera skillnaden mellan programmets strängvariabel och tangentbordsbufferten.