Säg hej till SARA

(Varning för långt och stundtals tekniskt inlägg)

Den mest dominerande typen av programspråk idag är det som vi kallar för imperativa programspråk. I ett imperativt programspråk består ett program av en sekvens av instruktioner till datorn. Oavsett vilket programspråk som vi använder så finns det centrala koncept och instruktioner som återkommer. Det som jag ser som den enklaste vägen till att lära sig programmering på ett sätt som gör en väl rustad för framtiden är att lära sig dessa koncept, vad de innebär och hur de kan användas.

Här brukar jag göra en analogi till slöjden där vi lär oss hantera verktyg. Vi lär oss hur en hammare, en såg, em skruvmejsel fungerar rent konceptuellt. Sen när vi möter dessa verktyg i andra sammanhang så gör det inte så mycket att det inte är exakt samma modell på verktygen så länge de fungerar konceptuellt lika. Har vi lärt oss hur en kapsåg fungerar så kan vi snabbt ta till oss hur en tigersåg kan användas. Helt plötsligt dyker det upp en skruvdragare med torx-bits som vi kan använda eftersom vi fått lära oss hantera en skruvmejsel. Och så vidare.

Samma sak med programmering. Det finns grundläggande ”verktyg” som dels handlar om olika typer av instruktioner, dels om en mental modell av vad en dator är och vad man har att arbeta med. Det finns olika sätt att knyta dessa olika typer av ”verktyg” när vi ska programmera till olika begrepp. Ett av de sätten är den s.k. SARA-modellen som jag personligen tycker är en lämplig ingång till grunderna i programmering. Dessutom har den modellen legat till grund för hur programmeringen har skrivits in i grundskolans läroplan.

SARA är en förkortning som står för Sekvens – Alternativ – Repetition – Abstraktion, vilket är fyra väldigt centrala koncept inom programmering. Jag vill hävda att om man behärskar dessa fyra grundkoncept så är man tillräckligt rustad för den typ av programmering som finns med i grundskolans läroplan från hösten 2018.

Sekvens

Sekvens är där man brukar börja. Här uttrycker man program som en sekvens av instruktioner, vilket är precis vad imperativ programmering handlar om. Olika språk och programmeringsmiljöer har olika grundoperationer vilket är den enklaste form av instruktioner som datorn utför. Att skriva ett program som utför en viss uppgift handlar till mycket stor del om att bryta ner uppgiften till en sekvens av grundoperationer.

Som ett exempel, tänk dig en enkel robot som har följande grundoperationer:

gå framåt
vänd höger
vänd vänster

Med följande sekvens av instruktioner kan roboten instrueras att gå i en fyrkant:

gå framåt
vänd höger
gå framåt
vänd höger
gå framåt
vänd höger
gå framåt
vänd höger

Det vi har här är en sekvens av grundoperationer som utför en uppgift (gå i en fyrkant och återvänd till utgångsläget). Denna typ av programmering kan man börja med väldigt tidigt, även utan att ha tillgång till en dator. Man kan programmera en kompis, en enkel robot eller något annat.

Repetition

Låt oss återkomma till alternativ om en liten stund och istället titta på konceptet repetition. En sak som datorer är jättebra på är att repetera samma sak flera gånger. De typer av grundoperationer som finns i de flesta imperativa programmeringsspråk tillåter datorn att upprepa något antingen ett förutbestämt antal gånger, eller till dess att ett villkor är uppfyllt.

Om vi tar exemplet ovan med roboten som går i en kvadrat så ser vi att samma sekvens av två instruktioner utförs fyra gånger. Jag inför en ny grundoperation som heter upprepa och skapar en slinga som utförs fyra gånger:

upprepa(4) :
  gå framåt
  vänd höger

Effekten blir densamma, men programmet blir kortare och i någon mening mer lättläst. Man kan åstadkomma exakt samma sak utan att använda en slinga, men i allmänhet är det så att efter ett tag kommer man till en punkt när det blir väldigt långa program där samma sak görs flera gånger och då är slingan en smidig grundoperation att nyttja.

Jag lägger till en ny instruktion vrid som kan rotera roboten ett angivet antal grader åt höger eller vänster, där högervridning anges med positiva vinklar och vänstervridningar med negativa vinklar. Då skulle programmet kunna se ut så här:

upprepa(4) :
  gå framåt
  vrid(90)

Instruktionen vänd vrider alltid 90 grader, men instruktionen vrid ger mig större flexibilitet. Nu är jag inte längre begränsad till kvadrater:

upprepa(5) :
  gå framåt
  vrid(72)

Den andra huvudtypen av slingor använder sig av ett villkorsuttryck för att ange hur länge upprepningen skall pågå. Om vi ska fortsätta att använda månghörningar som exempel skulle det kunna se ut så här:

vinkel = fråga("Ange en vinkel")
vinkelsumma = 0
upprepa tills(vinkelsumma >= 360) :
  gå framåt
  vrid(vinkel)
  vinkelsumma = vinkelsumma + vinkel

Ovanstående program frågar efter en vinkel och går framåt + vrider tills ett helt varv har klarats av. Här ser vi en del nya koncept.

En sak som följer naturligt med slingor som styrs av villkor är användandet av variabler, som kan ses som namngivna delar av datorns minne som kan användas för att spara information, men även i olika typer av uttryck. I många textbaserade språk tilldelas variabler värden genom att använda  = -tecknet, vilket är en skillnad i jämförelse med matematiken där det symboliserar likhet. I och med detta lilla exempel har jag introducerat de två grundkoncept utöver SARA som jag tycker är centrala i grundläggande programmering:

  1. Förekomst av ett minne som datorn kan arbeta mot, oftast genom att använda olika typer av variabler som kan tilldelas värden som i sin tur kan vara konstanter (”vinkelsumma = 0”) eller resultatet av en matematisk beräkning (”vinkelsumma = vinkelsumma + vinkel”)
  2. Datorns förmåga att utföra matematiska operationer. Dels de fyra grundläggande räknesätten, men även mer komplicerade matematiska operationer och funktioner.

När man introducerar slingor som styrs av villkorsuttryck så börjar man arbeta med utsagor som kan vara sanna eller falska, ofta inkluderade variabler på något sätt.

Alternativ

En fundamental egenskap hos en dator är att den kan agera olika beroende på olika indata. Det

Låt oss lägga till en grundoperation om till vårt exempel med månghörningar:

sidor = fråga("Antal sidor")
om (sidor < 15) :
  upprepa(sidor) :
    gå framåt
    vrid(360/sidor)

I detta exempel har en om-sats använts för att kontrollera att den månghörning som roboten ska röra sig längs inte har fler än 14 sidor. I annat fall kommer roboten inte att göra någonting.

En vanligt förekommande utvecklad variant av om-satsen är om-annars-satsen där man ger ett alternativt skeende om det angivna villkorsuttrycket skulle visa sig vara falskt. Här har jag utökat programmet så att om man anger fler än 14 sidor kommer roboten istället att pipa 3 gånger:

sidor = fråga("Antal sidor")
om (sidor < 15) :
  upprepa(sidor) :
    gå framåt
    vrid(360/sidor) 
annars:
  pip(3)

Programspråket jag har använt ovan existerar inte (vad jag vet). Kanske kan man kalla det för pseudokod, vilket är något man ofta använder sig av för att beskriva algoritmer som en dator skall utföra. Skulle du bestämma dig för att faktiskt vilja köra något av dessa exempelprogram på en riktig dator behöver du översätta det jag har uttryckt i mitt hittepå-språk med de byggstenar som finns i den programmeringsmiljö du använder dig av.

Detta är en väldigt vanlig uppgift när man arbetar med programmering. Man har en konceptuell idé om hur någonting skall fungera som man kanske har formulerat i någon form av pseudokod. Eller så har man hittat en algoritm eller lösning i en bok eller på Internet som man vill koda in i sitt eget program. Då gäller det att ha en förståelse för grundkoncepten och hur man uttrycker dem i den programmeringsmiljö man för tillfället befinner sig i.

När man sedan skall lära sig använda en ny programmeringsmiljö så handlar det till viss del om hur man rent praktiskt använder den, men framför allt om hur man uttrycker de centrala koncepten i den nya miljön. Därför underlättar det oerhört mycket om man när man pratar om programmering pratar om centrala koncept istället för att låsa in sig i vad som är möjligt i det språk man för tillfället arbetar med.

Att få kläm på hur Sekvens-konceptet fungerar är relativt enkelt och något man kan börja med redan i förskoleklass. Steget till Repetion blir ofta nästa steg i processen när man börjar se mönster i de sekvenser av instruktioner som man skapar. Man kan börja med slingor som utförs ett förutbestämt antal gånger och sedan gå vidare till att introducera slingor som styrs av variabler och villkorsuttryck efter ett tag. Alternativ i form av om-satser kan även det introduceras tidigt innan man går vidare till om-annars-satser. Såväl Repetition som Alternativ kan man utan vidare börja med i årskurs 1-2 och man kan göra det utan att behöva sitta vid en dator.

Jag är ett fan av kodtimmen som code.org tillhandahåller. Kör man igenom angry birds-varianten, vilket man kan göra med barn i årskurs 2 på 45-60 minuter, så har man fått arbeta med sekvens, alternativ och repetition i de övningar som ingår där.

Abstraktion

Den sista delen i SARA-modellen handlar om abstraktioner, vilket förenklat kan beskrivas som att man kan skapa egna funktioner som innehåller kod. Varje gång funktionen anropas utförs den kod som ingår i den.

Om vi fortsätter med månghörningarna:

def sida(steg,vinkel) :
  upprepa(steg) :
    gå framåt
  vrid(vinkel)

def kvadrat :
  upprepa(4) :
    sida(1,90)

Här har jag definierat två stycken funktioner. Till att börja med funktionen sida, som tar två stycken argument. Det första kommer att kallas steg och det andra vinkel. När funktionen sida anropas kommer den att gå det antalet steg som angavs i argumentet steg och därefter vrida lika många grader som angavs i argumentet vinkel.

Jag har även definierat en funktion kvadrat som inte tar något argument, vilket innebär att vad den utför kommer att vara samma sak varje gång (till skillnad från funktionen sida vars beteende beror på de argument som den får). I denna funktion kvadrat anropas i sin tur funktionen sida fyra gånger med argumenten 1 respektive 90. Det kommer i praktiken att innebära att roboten fyra gånger kommer att gå ett steg och därefter vrida sig 90 grader, d.v.s. röra sig längs en kvadrat.

Användandet av abstraktioner i form av funktioner är något som man vill introducera när man börjar skriva lite större och komplexare program där man exempelvis vill upprepa samma sak eller nästan samma sak ett antal gånger. När man börjar utforska matematiska koncept och begrepp blir det naturligt att uttrycka matematiska formler och samband med en funktion i sitt program som man sedan anropar med olika argument.


Detta blev ett långt inlägg. Men om du har orkat läsa hela så bör följande centrala begrepp och koncept ha ingått:

  • Sekvens av grundoperationer
  • Alternativ (OM-satser, OM-ANNARS-satser)
  • Repetition (UPPREPA-satser, UPPREPA-TILLS-satser)
  • Abstraktioner (med eller utan argument)
  • Variabler
  • Villkorsuttryck
  • Argument

Om du behärskar denna lista av begrepp och förstår vad det handlar om, då har du koll på grunderna i programmering. Resten är övning, träning och förmåga att uttrycka dessa olika principer och koncept i den programmeringsmiljö du för tillfället använder dig av. En mycket stor del av det hela kommer att givet en uppgift som du vill utföra, bryta ned det till en sekvens av ovanstående listade koncept som utför uppgiften. Det kan handla om att rita en kvadrat, eller om något lite mer komplicerat. Men det är egentligen det som programmering i grunden handlar om. I alla fall om man ser till den programmering som ska förekomma i grundskolan.

 

 

Kommentera

Fyll i dina uppgifter nedan eller klicka på en ikon för att logga in:

WordPress.com-logga

Du kommenterar med ditt WordPress.com-konto. Logga ut /  Ändra )

Google-foto

Du kommenterar med ditt Google-konto. Logga ut /  Ändra )

Twitter-bild

Du kommenterar med ditt Twitter-konto. Logga ut /  Ändra )

Facebook-foto

Du kommenterar med ditt Facebook-konto. Logga ut /  Ändra )

Ansluter till %s