7. luokan matematiikan tunneilla koodattiin Racket - pelejä

Syksyllä kun aloitimme Racket - koodauksen opiskelun, menin lupaamaan oppilaille, että koodaisimme vielä pelin. Keväällä viimeisen matikan kokeen jälkeen oli tullut aika lunastaa lupaukset...

Käytimme pelin koodaamiseen tekemääni Peruspelin pohjaa, eli hyvin pitkälle vietyä koodia, johon oppilaiden piti täydentää vain muutamia rivejä Racket - koodia. Päätin käyttää pelin tekemiseen Bootstrap - projektin WeScheme - sivustoa. Se mahdollistaa pelin koodaamisen selaimen kautta. Koska WeScheme toimii Google - tilin kautta, tein ryhmälle yhden yhteisen Google - tilin ja kopioin valmiiksi kahdeksan Peruspeli - pohjaa. Tähän päädyin, koska halusin, että peliä tehtäisiin pareittain useamman tunnin aikana (ja molempien oppilaiden piti päästä koodiin käsiksi).

Huom! Jos haluat kokeilla peruspelipohjaa, kirjaudu ensin WeScheme-sivustolle ja avaa sitten peruspelin linkki ja tallenna.

WeScheme.org sivustolle kirjaudutaan Google-tunnuksilla

Ensimmäiset kaksi tuntia meni pelin suunnitteluun ja grafiikoiden työstämiseen. Pelin idea on hyvin yksinkertainen: pelaaja liikkuu näppäimillä ylös ja alas, ja samalla väistelee vaaroja ja kerää kerättäviä, jotka liikkuvat vaakasuoraan. Oppilaat etsivät netistä taustakuvat sekä pelaajan, vaaran ja kerättävän kuvan. Tässä yhteydessä kävimme läpi myös sen, miten Googlen kuvahausta filteröidään näkyville vain sellaiset kuvat, joita saa uudelleenkäyttää ja muokata (kuinkahan moni lopulta näin teki?).

Pelaajan, kerättävän ja vaaran kuvista piti poistaa taustat (tehdä tausta läpinäkyväksi). Tähän käytimme GIMP2:sta (joku toinen ohjelma olisi voinut olla kätevämpi). Kuvat (png) ladattiin jokaisen omaan peliin WeSchemessä (kuvat tallentuvat samalla GoogleDriveen). Kuvan lataaminen generoi valmiin linkin koodin (HUOM! kursorin piti olla oikeassa kohdassa koodia, ettei generoinut linkkiä väärään kohtaan):

(bitmap/url "https://drive.google.com/uc?export=download&id=0B5CH7_F_YAvoX2RrbDl3N3JGam8")

Kuvat ladataan WeSchemeen Images-napin kautta

Kuvien lataamisen jälkeen niitä piti tietysti skaalata (scale) oikean kokoisiksi. Vaara ja kerättävä myös siirrettiin oikeille lähtöpaikoilleen, eli pelikentän reunoille. Tämä tehtiin muuttamalla kahden vakion arvioa:

(define VAARA-LÄHTÖ-X -50)
(define KERÄTTÄVÄ-LÄHTÖ-X 750)

Kun tämän jälkeen pelihahmot piti saada liikkeelle. Alussa "liikuta-varaa" - funktio näytti tältä:

;(check-expect (liikuta-vaaraa ..) ..)
;(check-expect (liikuta-vaaraa ..) ..)

;; liikuta-vaaraa : Number -> Number
(define (liikuta-vaaraa x)
  x)

Mietimme ensin mihin suuntaan vaaran piti liikkua ja teimme pari esimerkkiä. Jos vaara on kohdassa x=100 niin funktiokutsun jälkeen se on kohdassa x=110 (eli liikkuu oikealle). Tämä kirjoitettiin check-expect - lauseeseen:

(check-expect (liikuta-vaaraa 100) 110)

Kun funktion toiminta oli ymmärretty, täydennettiin funktion koodi toimivaksi:
;; liikuta-vaaraa : Number -> Number
(define (liikuta-vaaraa x)
  (+ x 10))

Vastaava operaatio tehtiin kerättävälle. Tietysti mielessä piti pitää mihin suuntaan halusi hahmojen etenevän (mahdollisesti tarvittiin miinusmerkkiäkin).

Nyt hahmot jatkoivat eteenpäin tulematta koskaan takaisin joten lisäsimme testin, jolla voitiin testata ollaanko vielä sallitulla alueella. Aloitimme chack-expect - pohdinnoilla, ja sitten kirjoitimme funktion.

(check-expect (alueella? -100) false)
(check-expect (alueella? 100) true)
(check-expect (alueella? 1000) false)

;; alueella? : Number -> Boolean
(define (alueella? x)
  (<= -50 x 750)) 

Tässä piti tajuta ottaa mukaan välin päätepisteet (jos käytti samoja lukemia kuin VAARA-LÄHTÖ-X ja KERÄTTÄVÄ-LÄHTÖ-X) muuten hahmo jäi nykimään eikä lähtenyt enää liikkeelle ollenkaan.

Seuraava vaihe oli näppäinohjauksen lisääminen pelaajalle. Suunnittelimme senkin ensin yhdessä check-expect lauseiden avulla. Nuolinäppäimet ovat "up" ja "down", tässä voi käyttää myös "w" ja "s" näppäimiä:

(check-expect (siirrä-pelaajaa 100 "up") 120)
(check-expect (siirrä-pelaajaa 100 "down") 80)
(check-expect (siirrä-pelaajaa 100 " ") 100)

;; siirrä-pelaajaa : Number Key -> Number
(define (siirrä-pelaajaa y näppäin)
  (cond [(key=? näppäin "up")(+ y 20)]
        [(key=? näppäin "down")(- y 20)]
        [else y]))

Nyt hahmot liikkuivat mutta mitään ei tapahtunut vaikka ne törmäsivät. Peruspelissä hahmojen törmääminen päätellään siitä, ovatko ne pelaajan ympärille piirretyn laatikon sisällä. Säädimme ensin laatikon koon sopivaksi ja katselimme sitä "pause"-moodissa (painetaan pelissä p-näppäintä).

(define TÖRMÄYSVARA-X 50)
(define TÖRMÄYSVARA-Y 80)

Pause - moodissa nähdään hahmojen sijainnit sekä laatikon koko (keltainen)

Koko pelin vaikein lauseke oli törmäysehtojen kirjoittaminen. Aloitimme x-suunnasta. Jotta törmäys tapahtuisi, täytyisi hahmon x-koodinaatin (x2) olla laatikon koordinaattien sisällä. Vasemman reunan x-koodinaatti saataisiin laskemalla: x1 - TÖRMÄYSVARA-X ja oikea laita laskemalla x1 + TÖRMÄYSVARA-X. Matemaattisesti ilmaistuna siis:

(x1 - TÖRMÄYSVARA-X) <  x2  < (x1 + TÖRMÄYSVARA-X)

Törmäysvarat

Ensimmäinen ehto Racket - muotoon kirjoitettuna olisi:

(define (törmäsikö? x1 y1 x2 y2)
   (< (- x1 TÖRMÄYSVARA-X) 
       x2 
      (+ x1 TÖRMÄYSVARA-X))

Tätä testattaessa käy nopeasti ilmi, että törmäys tapahtuu aina kun pelaaja ja vaara/kerättävä ovat samalla linjalla, joten tarkistus on tehtävä myös y-koordinaatille. Tähän tarvitaan myös and:iä. Valmis funktio oli tällainen:

(define (törmäsikö? x1 y1 x2 y2)
   (and (< (- x1 TÖRMÄYSVARA-X) 
         x2 
        (+ x1 TÖRMÄYSVARA-X))
        (< (- y1 TÖRMÄYSVARA-Y) 
         y2 
        (+ y1 TÖRMÄYSVARA-Y))))

Viimeinen silaus pelille saadaan, kun lisätään pisteiden päivittäminen. Pelissä on kaksi tilannetta "törmäys-vaara" ja "törmäys-kerättävä". Tämänkin funktion suunnittelu tehtiin check-expect:ien kanssa:

(check-expect (päivitä-pisteet 100 "törmäys-vaara") 90)
(check-expect (päivitä-pisteet 100 "törmäys-kerättävä") 110)

;; päivitä-pisteet : Number String -> Number
(define (päivitä-pisteet pisteet tapahtuma)
  (cond [(string=? tapahtuma "törmäys-vaara") (- pisteet 10)]
        [(string=? tapahtuma "törmäys-vaara") (+ pisteet 10)] ))        
  
Pelien tekemiseen meni kaikkiaan 6 matematiikan oppituntia (niistä kaksi kuvien käsittelyyn). Aivan kaikki parit eivät saaneet peliänsä valmiiksi mutta valmiitakin pelejä saatiin aikaiseksi. Yksi pari jatkoi koodauskerhossa aloitettua peliänsä (Bootstrap II pelipohjalla tehty). Pelin tekeminen tuntui kiinnostavan oppilaita, ja oli tärkeää että jokaisella oli oma ideansa toteutettavaksi. Peliä tehdessään oppilaat kyselivät mm. miten kerättävät saisi liikkumaan pystysuuntaan tai pelaajan sivusuuntaan, miten voisi vaihtaa pelaajan hahmoa, zoomata lähemmäs tms. Peruspelin pohjalla ei näitä muutoksia kuitenkaan tässä ajassa olisi pystynyt tekemään, vaikka kaikki on tietysti periaatteessa mahdollista... Aikaa oli nytkin hieman liian vähän, asioiden sulatteluun menee  yllättävän kauan. Pari tuntia olisi tarvittu vielä lisää niin olisimme saaneet kaikki pelit valmiiksi, ja ehtineet hieman pelatakin niitä.

Tällaisia esimerkkejä siitä millaisia pelejä matikan tunnilla syntyi (osasta puuttuu pisteiden laskeminen). Pelaaminen joko nuolinäppäimillä tai s ja w näppäimillä. Peli alkaa välilyönnillä (myös uusi peli alkaa välilyönnillä). Voit katsoa törmäysaluetta pause - moodilla (paina "p"):

Ammu tuomari - peli (pelaa)

Racket War:issa kerätään Sprite - juomia ja vältellään punaista rakettia (pelaa)

Apinapelissä kerätään banaaneja ja vältellään leijonaa (pelaa)

Homer-pelissä pisteitä saa, jos hamppari osuu Homerin suuhun, pisteitä lähtee jos se joutuu roskikseen (pelaa)

Avaruuspelissä ammutaan vihreitä ammuksia ja pujotellaan asteroidien välistä (pelaa)

Tämä ryhmä oli koodanneet Racket - kielellä jo aikaisemmin, pohjalla oli n. 10 tuntia Racket-koodausta. Osalle oppilaista oli selvästikin syntynyt jonkinlaista ymmärrystä ohjelmoinnista, joten pelin tekeminen ei tuntunut ollenkaan mahdottomalta. Mielenkiinnolla odotan mitä tämä porukka saa aikaan syksyllä kun peliohjelmoinnin kurssi alkaa. 

Racket Turtle GitHub:ssa

Racket Turtlella voidaan piirtää geometrisia kuvioita käyttäen Racket-kieltä ja DrRacket:iä. Koodin voi ladata nyt GitHub:ista. Päivitän koodia jatkossakin sinne, eli kannattaa latada koodi zip-pakettina suoraan sieltä.

Tässä lyhyet käyttöohjeet Racket Turtlelle:

1) Asenna DrRacket täältä : http://download.racket-lang.org/ 
2) Lataa Racket Turtle:n koodi täältä (Download ZIP): https://github.com/tyynetyyne/racket_turtle
3) Pura ZIP-paketti
4) Avaa racket_turtle_esimerkit.rkt tiedosto DrRacket:lla
5) Paina "run"
    Huom! jos DrRacket ei tunnistanut tiedoston ohjelmointikieltä automaattisesti, valitse se valikosta
     --> Language --> Choose Language --> Student Languages --> Beginning Student

Nyt voit testata Racket-Turtlen esimerkkikoodeja. Kirjoita DrRacket:in REPL:iin (alempaan ikkunaan): (piirrä neliö) ja paina <enter> ja Racket-Turtle piirtää sen.

Tämä toimii, koska racket_turtle_esimerkit.rkt tiedostossa on määritelty neliölle ohjeet näin:

(define neliö
  (list (forward 100)
        (turn-left 90)
        (forward 100)
        (turn-left 90)
        (forward 100)
        (turn-left 90)
        (forward 100)))

Racket-Turtle osaa myös toistorakenteita eli repeat - käskyn avulla voit ensin määritellä yksinkertaisen kuvion (sivu), jota toistetaan haluamasi määrä:

(define sivu
  (list (forward 100)
        (turn-left 90)))

(define toisto-neliö
  (repeat 4 sivu))

Racket-Turtlen kynän voi myös nostaa ilmaan/laskea, sekä sen värin voi muuttaa haluamakseen:

(define siirry
  (list (pen-up)
        (forward 100)
        (pen-down)
        (change-color "red")))

Racket-Turtlen avulla voidaan opetella kirjoittamaan myös funktioita. Tämän esimerkkikoodin avulla voidaan piirtää minkä tahansa kokoinen neliö (x on sivun pituus):

(define (muuttuva-sivu x)
  (list (forward x)
        (turn-left 90)))

(define (muuttuva-neliö x)
  (repeat 4 (muuttuva-sivu x)))

GitHub:ssa on myös racket_turtle_harjoitukset_1.rkt tiedosto, josta löytyy 7.luokan matematiikan tunnille sopivia geometrian harjoituksia.

Omat oppilaani ovat tykänneet leikkiä Racket Turtlella joten uskon, että tästä on iloa myös teille muillekin! Tässä Lielahden koulun 7F-luokan oppilaiden Racket Turtle taidetta, jota he piirsivät matematiikan tunnilla:

7. luokkalaisten Racket Turtle - taidetta

Muuttujien ja funktioiden opiskelua 7. luokan matematiikan tunnilla

Lataa harjoitus: Muuttujat.

Racket-turtle 7.luokan matikan tunneilla

Tällä viikolla olemme koodanneet 7. luokkalaisten kanssa geometrisia kuvioita Racket-turtlella. Olimme juuri opiskelleet erilaisten monikulmioiden nimiä, joten nyt pääsimme hyödyntämään tietojamme. Näytin oppilaille ensin miten Turtlelle annetaan ohjeet neliön piirtämiseksi. Tämän jälkeen he saivat tehtäväksi piirtää tasasivuisen kolmion, säännöllisen kuusikulmion, suunnikkaan tai neljäkkään, ympyrän sekä itse keksimänsä kuvion. Lopuksi kuviot piti saada piirtymään samaan kuvaan eri väreillä.

Osa oppilaista keksi nopeasti miten Turtlea ohjataan, osalla kesti hieman kauemmin, mutta jokainen sai ensimmäisen tunnin jälkeen vähintäänkin kolmion valmiiksi (myös yksi ympyrä ilmestyi jo ensimmäisellä tunnilla). Toisella tunnilla nopeimmat pääsivät jo yhdistämään kuvioitansa. 
Ohjelmointi vaikutti innostavalta, koska jälleen kerran kun kello soi, useampi oppilas jäi vielä koodaamaan kuvioitansa ja lopuksi minulta kysyttiin: kai me jatketaan näitä vielä?

Tunnin jälkeen parantelin Racket-Turtle koodiani, koska tulin siihen tulokseen, että yksinkertaisuuden vuoksi on kuitenkin helpompaa, että ohjeissa sallitaan sittenkin sisäkkäiset listat (eli ohjeiden antajan ei tarvitse osata käyttää "append:ia" tai "cons":ia, pelkkä "list" toimii). Rajoitin piirtämistä myös niin, että vain piirtoalueelle osuvat viivat piirretään (jotta animaatio ei sekoaisi liian isojen kuvien kanssa). Oppilaiden oli myös vaikea hahmottaa mihin kohtaan tiedostoa omat ohjeet kirjoitettiin, joten laitoin Racket-turtle-koodin omaan tiedostoonsa (teachpacks/racket_turtle.rkt), esimerkit omaansa (turtle_esimerkit.rkt) ja tehtävät kolmanteen (turtle_harjoitukset_1.rkt).

Jos haluat kokeilla oppilaittesi kanssa Racket-turtle: lataa racket_turtle.zip. Pura paketti esim. kotihakemistoosi ja tutustu turtle_esimerkit.rkt - tiedostoon. Avaa sitten turtle_harjoitukset_1.rkt ja koodaa ohjeen mukaiset kuviot (kuva alla). Zip-paketti sisältää kaiken tarvittavan (paitsi itse DrRacket:iä).

Racket-turtle:lla piirretty harjoitus 1 (yksi mahdollinen ratkaisu)

Näillä matematiikan tunneilla Racket-turtlen käytössä pääpaino oli kuvioiden piirtämisessä. Pohdimme kuvioiden geometrisia ominaisuuksien kuten vaatimuksia sivujen pituuksille sekä kulmien suuruuksille. En edes yrittänyt ottaa esille ns. ohjelmointiteknisiä juttuja, kuten sitä että turhaa toistoa pitäisi välttää (en puuttunut siihen, että kuusikulmiossa oli kuusi kertaa sama koodin pätkä). Toki otimme esille repeat:in käytön, mutta vasta ympyrän kohdalla, koska ympyrän piirtämisessä tarvittava toistojen määrä olisi ollut järjetöntä koodata käsin. Myös siirtymät kirjoitettiin jokainen erikseen: siirtymä1, siitymä2 jne. vaikka siirtymäkoodi olisi toki järkevämpää kirjoittaa funktion muodossa, jossa annetaan käännöksen suuruus, siirtymän pituus ja uuden kuvion väri. Ehkä seuraava askel voisi olla oman funktion kirjoittaminen?

Seymour Papert:in Turtlet

Ostin itselleni joululahjaksi Seymour Papert:in klassikkokirjan "Mindstorms: Children, Computers, and Powerful Ideas". Vaikka kirja on ilmestynyt ensimmäisen kerran vuonna 1980, se on silti hämmästyttävän ajankohtainen ja ajatuksia herättelevä. Erityisesti Papertin kritiikki "koulumatematiikkaa" ja "koulufysiikkaa" kohtaan osui ja upposi. Ne todellakin ovat historian muovaamia konstruktioita, aihepiirejä joitka ovat valikoituneet mukaan sen mukaan mitä on perinteisesti voitu opettaa ja oppia niillä välineillä, joita kouluissa on ollut saatavilla: kynä, kumi, paperi, viivoitin ja harppi. Papert näki jo 1980, että tietokoneita käytettiin opetuksessa aivan väärin, niiden avulla yritettiin opettaa näitä "kuolleita kynä-plus-paperi-ajan taitoja". Hänen mielestään on jo lähtökohtaisesti väärin ohjelmoida drillaavia opetusohjelmia, jotka "ohjelmoivat" oppilaita toimimaan tietyllä tavalla. Hänen mielestään asian pitäisi olla täysin päinvastainen eli oppilaiden pitäisi päästä ratkomaan oikeita "aikuisten" ongelmia eli ohjelmoimaan tietokoneita. Tämä on Papertin mukaan ainoa tapa saada kuollut (paperille kirjoitettu) koulumatematiikka palautettua elävien kirjoihin.

Papertin ratkaisu tähän oli LOGO-ohjelmointikieli ja turtle-geometria, joita en itse lapsena valitettavasti päässyt kokeilemaan. Omassa peruskoulussani/lukiossani ei 1980-luvulla ollut tarjolla kuin konekirjoitusta. Heti kirjan luettuani halusin päästä kokeilemaan Turtlen ohjaamista, joten koodasin itselleni sellaisen Racket:illä. Halusin seurata kirjan "design principles"-ohjeita, ja tehdä niiden pohjalta oman versioni klassikosta. Jos Lego Mindstorms:in, Scratch:in sekä Turtle-Roy:n kehittäjät ovat seuranneet Papertin jalanjälkiä, niin aion minäkin. Ja kivastihan siinä lomapäivä vierähtikin...

Olin toki aikaisemminkin piirrellyt "turtle-geometrisia"-kuvioita Scratch:illä, joten periaate oli sinänsä tuttu. Miksi halusin tehdä vastaavan Racket:illä, johtui siitä että olemme jo käyttäneet oppilaideni kanssa Racket:iä, joten saman välineen kanssa jatkaminen tuntuisi paremmalta idealta kuin eri ympäristöjen välillä sinkoilu. 7. luokan koulugeometrian opettamisen lisäksi, mietin samalla miten voisin opettaa listojen ja rekursion käyttöä KoodauksenABC-kurssilaisilleni. Ja aina kannattaa käyttää tilaisuus hyväksi: koodaamista oppii vain itse koodaamalla :-)

Racket-turtle:a ohjataan periaatteessa samalla tavalla kuin esikuvaansa LOGO-Turtlea, mutta komennot annetaan listana. Esim. tämä koodin pätkä määrittelee Turtle-komentolistan neliön piirtämiselle:

(define neliö
  (list (forward 100)
        (turn-left 90)
        (forward 100)
        (turn-left 90)
        (forward 100)
        (turn-left 90)
        (forward 100)))

Varsinainen piirtäminen tehdään kutsumalla "piirrä"-funktiota tai "piirrä-osissa"-funktiota, joka piirtää kuvan pala palalta, kun jotain näppäintä painetaan. Eli näin piirrettäisiin neliö:

(piirrä neliö) TAI
(piirrä-osissa neliö)

Ensimmäinen Racket-turtlella piirretty kuvio

Kynän väri on oletuksena sininen ja se on aina laskettuna, mutta kynää voi halutessaan ohjailla myös näillä komennoilla:

(pen-up)
(pen-down)
(change-color "red")
(change-color (make-color 255 0 0))

Jos haluaa tehdä neliönsä älykkäämmin käyttäen toistorakennetta, sekin onnistuu repeat:in avulla:

(define sivu
  (list (forward 100)
        (turn-left 90)))

(define toisto-neliö
  (repeat 4 sivu))

(piirrä toisto-neliö)

Jos haluaa tehdä samaan kuvaan kaksi kuviota, komentolistat voi yhdistään käyttämällä append:a:

(define siirry
  (list (pen-up)
        (forward 100)
        (pen-down)
        (change-color "red")))

(define kaksi-neliötä
  (append neliö
          siirry
          toisto-neliö))

Yhdistelmäkuvio

Koska Racket on oikea ohjelmointikieli, sillä voi koodata myös funktioita, jotka tekevät komentolistoja eri kokoisille tai värisille kuvioille. Nämä funktiot yhdessä piirtävät halutun kokoisen ja värisen neliön:

(define (sivu2 pituus kulma)
  (list (forward pituus)
        (turn-left kulma)))

(define (neliö2 pituus väri)
  (cons (change-color väri)
        (repeat 4 (sivu2 pituus 90))))

(piirrä (neliö2 50 "red"))

Neliö muuttuvalla sivun pituudella sekä värillä

Yllä olevan sivu2-koodin avulla voi rakentaa funktioita myös muille säännöllisille monikulmioille. Huomaa, että neliö2:ssa on käytetty cons:ia list:in tilalla, koska repeat palauttaa kokonaisen listan ja (change-color väri) on pelkkä lista-alkio (list vaatisi kaksi lista-alkiota ja append puolestaan kaksi listaa). Racket-turtlen yksi tarkoitus on opettaa listojen käsittelyä, ja listojen käsittelyssä on pidettävä mielessä listan ja alkion ero. Seuraava dia selventänee list, cons ja append - funktioiden käyttöä:

Mitä eroa on list, cons ja append - funktioilla

Kun sain Racket-turtleni toimimaan, mopo karkasi välittömästi lapasista ja huomasin leikkiväni sillä  kuin pieni lapsi. Illan aikana tuli piirrettyä mm. nämä Papertin kirjan innoittamat kuviot:

Ympyrä-kukka

Random-kukat (random koko, random väri)

Vino "squiral"

Ja tässä vielä video Racket-turtlen toiminnasta (melko hypnoottista):

Jos haluat itse kokeilla Racket-turtlea niin lataa tästä tiedosto ja avaa se DrRacket:iin. Kirjoita tiedoston loppussa olevien esimerkkien tilalle omat komentosi. Pidä hauskaa!

Videolla näkyvä "squiral" on toteutettu rekursion avulla. Jos haluat kokeilla sitä itse niin tässä on koodi, joka generoi tarvittavan komentolistan Racket-turtlelle:

(define (squiral pituus kerrokset)
  (if (<= kerrokset 0)
      '()
      (append (list (forward (* 5 pituus)) 
                    (turn-left 90)) 
              (squiral (add1 pituus) (sub1 kerrokset)))))

Koodattuja joulukortteja (7.lk)

Viimeisellä kouluviikolla koodasimme 7. luokan matematiikan ryhmäni kanssa joulukortteja Racket:illa. Käytimme tähän kaksi 45 min oppituntia. Ensimmäisellä tunnilla opettelimme miten piirretään ympyrä, kolmio ja tähti ja miten niille annetaan define:llä nimet. Toisella tunnilla yhdistimme niitä overlay/xy:llä joulukuuseksi, johon sijoiteltiin koristeita. Nopeimmat ehtivät kirjoittaa myös joulutoivotuksensakin "korttiin".

Harjoitus oli mukava ja sopi hyvin sekä geometrian aihepiiriin, että ajankohtaan. Viimeisellä tunnilla luokkaan jäi vielä pari kolme koodaria vaikka kello soikin, tällaista tilannetta ei ole matikan tunnin jälkeen vielä tapahtunutkaan :-)

Näillä ohjeilla mentiin:

 

 

 

Hienoimmissa joulukuusissa oli monta palloa ja tähti. Tärkeintä oli kuitenkin se, että jokainen sai tehtyä jonkinlaisen kuusen. Tässä kolmen oppilaani näkemykset joulukuusesta sekä joulutoivotukset koodattuna Racketillä.

Laskujärjestysharjoituksia Racketilla

Harjoittelimme 7. luokkalaisten kanssa Racketin peruslaskutoimituksia sekä laskujärjestyssääntöjä tekemällä tätä harjoitusta:

Lataa Racket - tiedosto.

Heti alussa huomasin, että ennen tehtävää pitää käydä tietysti läpi aivan peruslaskutoimitukset Racketillä, joten teimme oheiset peruslaskut yhdessä ennen varsinaisia tehtäviä.

Tunnin alussa oppilaille annetut ohjeet

Laskujärjestys osoitetaan Racket:ille käyttämällä sisäkkäisiä sulkulausekkeita