Coding A Scuola (1) - Libro

risorse PER L’INSEGNANTE
Alberto Pian
Coding a scuola
Ambiente
educativo
Digitale CONTENUTI ZONA
LIBRO MISTO E-BOOK INTEGRATIVI MATEMATICA IN CLASSE
internet: deascuola.it
e-mail: info@deascuola.it
Redattore responsabile: Alessio Delfrati

Tecnico responsabile: Alessandro Cafagna
Redazione: Matteo Dell’Orto, Mandeka Papini
Redazione digitale: Vincenzo Belluomo
Progetto grafico: Maura Santini, Ediset s.r.l.
Impaginazione: Annalisa Possenti
Copertina: Maura Santini, Simona Speranza
Disegni: Claudia Benassi, Gabriella Bianco
Art Director: Nadia Maestri
Proprietà letteraria riservata

© 2015 De Agostini Scuola SpA – Novara
1ª edizione: Febbraio 2015
Printed in Italy
Le fotografie di questo volume sono state fornite da: Shutterstock
Immagini di copertina: Shutterstock

Ricerca iconografica per la copertina: Cristina Colombo
L’Editore dichiara la propria disponibilità a regolarizzare eventuali omissioni o errori di attribuzione.

Nel rispetto del DL 74/92 sulla trasparenza nella pubblicità, le immagini escludono ogni e qualsiasi possibile intenzione o effetto promo-
zionale verso i lettori.
Tutti i diritti riservati. Nessuna parte del materiale protetto da questo copyright potrà essere riprodotta in alcuna forma senza l’autorizzazione
scritta dell’Editore.
Il software è protetto dalle leggi italiane e internazionali. In base ad esse è quindi vietato decompilare, disassemblare, ricostruire il progetto
originario, copiare, manipolare in qualsiasi modo i contenuti di questo software. Analogamente le leggi italiane e internazionali sul diritto
d’autore proteggono il contenuto di questo software sia esso testo, suoni e immagini (fisse o in movimento). Ne è quindi espressamente
vietata la diffusione, anche parziale, con qualsiasi mezzo. Ogni utilizzo dei contenuti di questo software diverso da quello per uso personale
deve essere espressamente autorizzato per iscritto dall’Editore, che non potrà in nessun caso essere ritenuto responsabile per eventuali
malfunzionamenti e/o danni di qualunque natura.
Eventuali segnalazioni di errori, refusi, richieste di chiarimento/funzionamento dei supporti multimediali o spiegazioni sulle scelte operate
dagli autori e dalla Casa Editrice possono essere inviate all’indirizzo di posta elettronica info@deascuola.it
INDICE
1. PROGRAMMARE NON È QUELLO CHE PENSATE....................................................................................................... 5

PROGRAMMARE È COME ESSERE PROPRIETARI DI UN LIDO A RIMINI.......................................5
Partiamo dal mondo reale (real world)...................................................................................................5
Complessità e interazione......................................................................................................................6
Il punto di vista del governo. La buona scuola................................................................................................7
Intercettare i messaggi per provocare un’azione...................................................................................7
Dal coding al gioco.................................................................................................................................8
QUANTE CONOSCENZE, ABILITÀ E COMPETENZE SI METTONO IN MOTO!..................................8
VERSO COMPETENZE MULTIDISCIPLINARI E TRASVERSALI...........................................................9

Conoscenze e abilità...............................................................................................................................9
Competenze multidisciplinari logiche....................................................................................................9
Competenze multidisciplinari linguistiche.............................................................................................9
Competenze multidisciplinari creative.................................................................................................10
Competenze sociali...............................................................................................................................10
Competenze diffuse..............................................................................................................................10
Indicazioni utili per iniziare........................................................................................................................10
Il parere dello psicologo Jacopo Lorenzetti...................................................................................................11
“E SE…”: UN GIOCO CHE NON FINISCE MAI.................................................................................12

Il ruolo del docente...............................................................................................................................13
COME E PERCHÉ PARTIRE DA UNA DIDATTICA INDUTTIVA FONDATA SUI PROBLEMI

E SULLE SFIDE.....................................................................................................................................13
Il Challenge Based Learning.................................................................................................................13
La “prova del joystick”, ovvero: l’importanza della sfida................................................................................14
La tradizione dell’indagine...................................................................................................................14
Workflow. Il coding in una metodologia induttiva ..............................................................................15
IL CODING IN AMBITO MULTIDISCIPLINARE E INTERDISCIPLINARE..........................................16

Un esempio di workflow multidisciplinare più complesso. Diventiamo reporter multicanali...............................16
NON C’È CODING SENZA INTERFACCIA, SPECIALMENTE IN CAMPO EDUCATIVO...................18

Programmare non vuol dire solo stilare una lista di istruzioni.............................................................18
Come può un insegnante aiutare i suoi studenti a costruire efficaci interfacce?................................................19
3
2. IL CODING E IL GIOCO, UN BINOMIO VINCENTE............................................................................................. 20
PROGRAMMAZIONE E GIOCO AI DUE POLI....................................................................................20
Programmare giocando........................................................................................................................20
Apprendimento e multicanalità............................................................................................................20
Carlo Cioppa, lo studente che ha imparato a sviluppare con YouTube..............................................................21
Il ruolo del docente: come sollecitare lo studente al coding................................................................22
PARTIAMO DA UN DIAGRAMMA DI FLUSSO..................................................................................22
Applicazioni suggerite per creare diagrammi di flusso........................................................................22
PROGRAMMARE INTERAZIONI E GIOCHI CON APPLICAZIONI CONOSCIUTE...........................23
Creiamo un puzzle investigation con Keynote o PPT...........................................................................23
Workflow di base per la creazione di una struttura a tre ancoraggi....................................................25
Un altro esempio con iPad: Make It......................................................................................................25
3. DIVERSI LIVELLI E STRUMENTI DI PROGRAMMAZIONE..................................................................................... 27

PROGRAMMARE GIOCANDO: SCRATCH.........................................................................................27
I blocchi programmabili........................................................................................................................27
L’ambiente di Scratch............................................................................................................................27
L’esempio del lido e altri script.............................................................................................................28
PROGRAMMARE A OGGETTI IN MODO GRAFICO CON SCRIPT: LIVECODE...............................31
Sviluppare contemporaneamente per tutti i dispositivi.......................................................................31
Associare gli script agli oggetti............................................................................................................32
Catturare i messaggi, provocare degli eventi.......................................................................................34
L’esempio del lido.................................................................................................................................35
PROGRAMMARE A OGGETTI IN MODO GRAFICO SENZA SCRIPT: HYPERSTUDIO...................36
Web app, HTML 5 e widget..................................................................................................................36
Una struttura a stack e card.................................................................................................................36
Web app e Hyperstudio.............................................................................................................................38
I linguaggi del futuro: Swift........................................................................................................................38
4. NON TRASCURIAMO LA ROBOTICA.................................................................................................................. 40

PARLANO GLI INSEGNANTI: UNA TRADIZIONE CHE VIENE DA LONTANO.................................40
I kit Lego...............................................................................................................................................40
La robotica educativa secondo Donatella Merlo della Casa degli insegnanti.....................................41
SPHERO: MATEMATICA E STORYTELLING.......................................................................................42
Obiettivi..................................................................................................................................................42
Tracciare un triangolo senza un piano cartesiano................................................................................43
Scheda di controllo (triangolo)...................................................................................................................45
Sfidare gli studenti................................................................................................................................45
Coding e storytelling con Sphero..........................................................................................................45
GLOSSARIO DI BASE DEL CODING...................................................................................................47
4
Coding a scuola
1. Programmare non è quello che pensate

PROGRAMMARE È COME ESSERE PROPRIETARI DI UN LIDO A RIMINI
Partiamo dal mondo reale (real world)

Siamo i proprietari di un lido (uno stabilimento balneare) a Rimini. Vogliamo offrire un servizio impec-
cabile ai nostri clienti, che sono comodamente sdraiati sui loro lettini o seduti sulle loro sedie a sdraio.
C’è chi vuole da bere, chi cerca un materassino per andare a fare il bagno, chi desidera un pallone,
chi chiede lezioni di nuoto, chi desidererebbe un servizio di baby sitting, chi vorrebbe una crema so-
lare con un fattore di protezione più elevato, chi si vuole semplicemente alzare per fare due passi sul
bagnasciuga.
Per soddisfare tutte le richieste dei nostri bagnanti ci siamo impegnati molto. Prima dell’estate abbia-
mo stipulato un accordo con il vicino istituto alberghiero e molti ragazzi di quattordici-quindici anni
hanno accettato di aiutarci per imparare il mestiere e per guadagnare qualcosa. Dato che non hanno
mai prestato servizio in un lido e sono in difficoltà, abbiamo predisposto delle istruzioni da eseguire
automaticamente.
© De Agostini Scuola 5
Coding a scuola
Il meccanismo è semplice: quando da un nostro cliente parte il messaggio perfavore, i ragazzi in servizio
più vicini lo intercettano.
inizio messaggio perfavore

guarda chi_chiama
ascolta che_cosa_vuole
se che_cosa_vuole contiene “acqua”
allora
vai al bar
prendi l’acqua
portala a chi_chiama
altrimenti
lascia passare il messaggio perfavore
fine se che_cosa_vuole contiene “acqua”
fine messaggio perfavore
Solo il ragazzo addetto all’acqua consegnerà la bottiglietta al cliente. Tutti gli altri lasceranno passare il
messaggio.
Complessità e interazione
Le cose possono essere anche un po’ più complesse di così. Per esempio, se il cliente chiede una ribollita,
che è una zuppa toscana, probabilmente non sarà nel menu del lido e può anche capitare che i gestori
non conoscano questo piatto e quindi, in entrambi i casi, il cliente non potrà essere accontentato.
Bisogna che i ragazzi abbiano a disposizione un elenco di prodotti che possono offrire in modo da con-
trollare se è possibile soddisfare le richieste dei clienti.
Allora le istruzioni di prima potrebbero essere riscritte in questo modo:
inizio messaggio perfavore

guarda chi_chiama
ascolta che_cosa_vuole
consulta l’elenco
se che_cosa_vuole non è in elenco
allora
parla a chi_chiama: Mi scusi non abbiamo che_cosa_vuole
quindi
fine se che_cosa_vuole non è in elenco
se che_cosa_vuole contiene “acqua”
allora
vai al bar
prendi l’acqua
portala a chi_chiama
altrimenti
fine se che_cosa_vuole contiene “acqua”
fine messaggio perfavore
6 © De Agostini Scuola
Coding a scuola
Il ragazzo che serve l’acqua intercetta il messaggio del cliente, controlla se la richiesta compare nell’e-
lenco. Se non compare, lo comunica al cliente. Se invece compare e si tratta di acqua, gli servirà la bot-
tiglietta, altrimenti lascerà passare il messaggio. Lasciare passare il messaggio significa che il messaggio
passerà di ragazzo in ragazzo finché sarà raccolto da chi potrà soddisfare la richiesta. Così se il cliente
desidera fare un giro in gommone, il ragazzo addetto al deposito delle imbarcazioni del lido gliene potrà
noleggiare uno. Analogamente, il ragazzo addetto all’apertura degli ombrelloni raccoglierà la richiesta
dei clienti che desiderano un po’ d’ombra.
Per eseguire queste istruzioni abbiamo utilizzato una “struttura di controllo” del tipo se–allora–altrimenti
(if–then–else) tipica del coding. Con questa semplice struttura si possono fornire istruzioni anche molto
complesse.
Il punto di vista del governo. La buona scuola1

Serve un piano nazionale che consenta di introdurre il coding (la programmazione) nella scuola
italiana. A partire dalla primaria: vogliamo che nei prossimi tre anni in ogni classe gli alunni impari-
no a risolvere problemi complessi applicando la logica del paradigma informatico anche attraverso
modalità ludiche (gamification). A partire dall’autunno, dopo Stati Uniti e Inghilterra, lanceremo in
Italia l’iniziativa Code.org, aggregando associazioni, università e imprese, in una grande mobilita-
zione per portare l’esperienza nel maggior numero di scuole possibili.
Come sollecitiamo i ragazzi a essere “produttori digitali” nella scuola secondaria? Il punto di arrivo
sarà promuovere l’informatica per ogni indirizzo scolastico. Fin dal prossimo anno, vogliamo attiva-
re un programma per “Digital Makers”, sostenuto dal Ministero e anche da accordi dedicati con la
società civile, le imprese, l’editoria digitale innovativa. Concretamente, ogni studente avrà l’oppor-
tunità di vivere un’esperienza di creatività e di acquisire consapevolezza digitale, anche attraverso
l’educazione all’uso positivo e critico dei social media e degli altri strumenti della rete. E imparando
a utilizzare i dati aperti per raccontare una storia o creare un’inchiesta, oppure imparando a gestire
al meglio le dimensioni della riservatezza e della sicurezza in rete, o ancora praticando tecniche di
stampa 3D. Questo servirà a rafforzare le ore di Tecnologia e di Cittadinanza e Costituzione nella
scuola secondaria di primo grado, quelle di Informatica nei licei scientifici e negli istituti tecnici e
professionali, promuovendo inoltre la contaminazione con ogni altra disciplina.
Intercettare i messaggi per provocare un’azione

Però che gusto c’è a gestire un servizio di ragazzi che servono ai tavoli e custodiscono gommoni e aprono
ombrelloni? Perché non rendiamo un po’ più divertente questo servizio?
Cominciamo affidando lo stesso compito a più ragazzi. Non sarà più solo uno a fornire acqua, ma due
o tre. A custodire i gommoni saranno in quattro, ad aprire gli ombrelloni in cinque. Inoltre ogni ragazzo
potrà eseguire più compiti: il ragazzo A potrà fornire acqua e custodire gommoni, B custodire gommoni
e aprire ombrelloni, C potrà fare tutto quanto. Immaginiamo anche di essere i proprietari di un lido molto
affollato e che diversi clienti avanzano richieste nello stesso momento: chi vuole l’acqua, chi chiede di
aprire l’ombrellone, chi desidera noleggiare un gommone. Anzi, c’è qualcuno che vuole l’acqua da por-
tare in gommone e un altro che vuole aprire l’ombrellone e desidera anche l’acqua.
1 https://labuonascuola.gov.it/documenti/La%20Buona%20Scuola.pdf?v=d0f805a
Coding a scuola
Che pasticcio! Chi intercetterà i messaggi dei clienti? I ragazzi più vicini? Quelli più veloci? Quelli che
hanno meno compiti da eseguire in quel momento?
Non solo: se un ragazzo intercetta tre messaggi riguardanti compiti che può eseguire, che cosa farà? A
quale messaggio risponderà per primo? Lascerà passare gli altri messaggi o dovrà rispondere lui?
Questa è una bella complicazione!
Dal coding al gioco

Potremmo creare un gioco: il gioco del lido. Il giocatore deve fare in modo, manovrando i suoi ragazzi, di
soddisfare il maggior numero di richieste che provengono da clienti sempre più agitati e impazienti, che
vogliono sempre di più e sempre più in fretta. Se un ragazzo per tre volte non soddisfa un cliente, viene
licenziato (eliminato). Chi vincerà? I ragazzi manovrati dal giocatore o i clienti?
Le istruzioni si complicheranno parecchio. Dovremo inserire parametri quali distanza e velocità dei ra-
gazzi, assegnare loro dei livelli di potenza che aumentano o diminuiscono in base al numero di richie-
ste che devono soddisfare. Dovremo prevedere delle azioni ripetitive (cicli di repeat), delle variabili che
possono contenere oggetti da verificare in base a determinate condizioni (per esempio la variabile fret-
ta_del_cliente conterrà un numero da 1 a 5 che esprime la velocità con cui il cliente deve essere servito).
Programmare è infatti un lavoro complesso ma divertente. Bisogna procedere per gradi e pensare bene
a tutte le interazioni.
Tuttavia non è così che possiamo proporre un gioco per il pubblico dei videogame. Infatti, non bastano
delle istruzioni per creare un gioco. Anzi, direi che, agli occhi del cliente, le istruzioni che noi scriviamo
non sono affatto determinanti. Quello che conta sono la grafica, i disegni, gli oggetti 3D che ruotano
su se stessi, la musica, la fluidità e la definizione delle immagini. Se il gioco sarà destinato a tablet e
smartphone allora conterà anche come reagirà al “tocco” delle dita, se sarà più o meno sensibile e rapido.
Per il cliente l’aspetto del gioco e la sua funzionalità sono più importanti delle istruzioni che lo compon-
gono. Il gameplay (la giocabilità del videogame) è più importante. Non si può giocare male, anche se le
istruzioni sono perfette!
Bisogna quindi pensare alla grafica, al modo in cui ragazzi e clienti sono rappresentati, a come deve
essere raffigurato l’ambiente di gioco del lido, alle sdraio, agli ombrelloni. Ci occorrono dei designer di
interfaccia, gente tosta che sappia disegnare, studiare i colori, creare le forme.
E se poi, dopo tanta fatica, riusciamo finalmente a creare il nostro gioco, che cosa resta ancora da fare?
Be’, lo dovremo promuovere, bisognerà studiare una campagna pubblicitaria, stampare un opuscolo,
scrivere degli articoli, preparare una guida al gioco, diffondere la notizia sui social network, creare un sito
di riferimento. Avremo bisogno anche di un consulente di marketing e di qualcuno che tenga i conti degli
incassi, delle tasse da pagare, delle spese e dei guadagni.
Vogliamo ragionare insieme su questo processo che abbiamo appena descritto?
QUANTE CONOSCENZE, ABILITÀ E COMPETENZE

SI METTONO IN MOTO!
Avete idea di quante competenze si possono sviluppare intorno a un’attività di programmazione di un
videogioco? Proviamo a elencarle. In questo elenco teniamo conto del fatto che le conoscenze e le abi-
lità puramente disciplinari sono elementi specifici e puntuali, relativi all’informatica. Ora, la questione di
fondo è che tutta la logica delle strutture di programmazione è applicabile in qualsiasi contesto e per
qualsiasi disciplina. Se consideriamo una didattica attiva e multicanale, fondata sulla ricerca di risposte,
Coding a scuola
su indagini e problem solving, le abilità e le conoscenze in ambito di coding diventano facilmente delle
competenze multidisciplinari, se lo studente è in grado di utilizzarle in altri ambiti che non siano quello
strettamente informatico.
Per questo ci pare importante che le potenzialità cognitive del coding siano effettivamente sfruttate fino
in fondo grazie alla collaborazione delle altre discipline, rispetto alle quali il coding può rappresentare il
filo rosso, il tessuto che le tiene legate.
VERSO COMPETENZE MULTIDISCIPLINARI E TRASVERSALI
Conoscenze e abilità
• capacità di creare valori e proprietà
• capacità di assegnare valori e proprietà a “oggetti”
• capacità di creare messaggi
• capacità di costruire condizioni
• capacità di creare opposizioni
• capacità di creare collegamenti
• capacità di creare interazioni temporali
• capacità di creare interazioni con dati quantitativi (velocità, distanza ecc.)
• capacità di effettuare calcoli, dai più semplici ai più complessi (dipende dal grado di programmazione
che si vuole raggiungere)
• saper scrivere un piano di passaggi da realizzare secondo un ordine
• saper individuare una nomenclatura appropriata di oggetti
• saper scrivere le istruzioni in forma sequenziale
• saper scrivere una guida
• saper tradurre le istruzioni in lingua 2
• saper rappresentare con degli schizzi semplici oggetti e sfondi
• saper scegliere i colori in modo funzionale al gioco e alla funzione degli oggetti
• saper ricercare immagini e disegni nei diversi canali
• saper raccogliere informazioni su tutti gli aspetti dei videogame
• saper raccogliere informazioni sull’utilizzo dei videogame da parte del pubblico
• saper confrontare le strutture e le funzioni dei videogame
• saper individuare i target di riferimento per il proprio gioco
Competenze multidisciplinari logiche

• legare le condizioni fra loro
• creare e gestire strutture di controllo fondate su scelte
• creare e gestire variabili
• creare e gestire ripetizioni, cicli e loop
• gestire funzioni (dipende dal grado che si vuole raggiungere con la programmazione)
• creare e rappresentare diagrammi di flusso
Competenze multidisciplinari linguistiche

• esporre le proprie idee a voce
• rappresentare le proprie idee in forma di appunti e bozzetti
Coding a scuola
• organizzare in forma logica e sequenziale le proprie idee

• raccontare un procedimento logico
• raccontare il gioco e le sue parti
• spiegare il gioco
• comunicare con il team di compagni che collabora alla creazione e con il docente
Competenze multidisciplinari creative

• trarre ispirazione da altri giochi e interfacce di videogame e di applicazioni
• creare situazioni di gioco originali
• offrire al giocare un’esperienza coinvolgente
• scegliere le colonne sonore appropriate
• selezionare proposte grafiche coerenti
• costruire una visione coerente e armonica del prodotto
Competenze sociali
• organizzare e richiedere dei test e coordinare i beta testing
• comprendere e analizzare le aspettative del pubblico
• sapersi confrontare con le critiche
• gestire la comunicazione nei forum e nei social network
Competenze diffuse
Oltre a quelle che abbiamo elencato, esiste una serie molto estesa di conoscenze, abilità e competenze
associate alla programmazione di un videogioco. Queste sono attinenti a tutti i campi del sapere: se il
videogioco è ambientato nel passato saranno messe in moto conoscenze e competenze storiche e geo
grafiche, se è regolato da leggi fisiche (la forza di attrazione di corpi celesti, per esempio), richiederà cono-
scenze e competenze in quel campo, e così via. Poi ci sono anche altre conoscenze e competenze disciplinari
che hanno un carattere potenzialmente trasversale. Per esempio la matematica è un pilastro della program-
mazione, quali che siano il tema del videogioco o il suo ambito disciplinare. Anche l’italiano e la lingua stra-
niera (non solo per una pubblicazione in lingua inglese, ma anche per acquisire informazioni utili nel mondo
dei videogame) mettono in gioco altrettante competenze e conoscenze disciplinari di carattere trasversale.
Quindi abbiamo innumerevoli motivi per trasformare il coding in un’attività didattica in grado di unire
fra loro argomenti, saperi e competenze che provengono da differenti ambiti disciplinari. Per questo la
costruzione di un videogioco può essere concepita proprio come la tela che unisce ciò che a scuola nor-
malmente è separato, diviso in compartimenti stagni, come le diverse discipline di insegnamento.
Indicazioni utili per iniziare

Le attività di coding a scuola sono molto diffuse da parecchi anni in tutto il mondo. Fino dagli
anni Settanta molti docenti si sono posti il problema di impiegare il coding nella didattica. Esiste
quindi una grande mole di risorse, applicazioni, siti Web, articoli, libri in tutte le lingue che sarebbe
un’impresa titanica documentare. Volendo suggerire qualche riferimento, diamo al lettore alcune
indicazioni come semplici punti di partenza per sviluppare autonome ricerche in questo campo.
Il sito di riferimento delle indicazioni governative è http://code.org. Nella settimana internazionale
del coding ci sono invece numerosi eventi legati a questo tema segnalati dal sito http://codeweek.eu
Coding a scuola
(per una ricerca dettagliata basta andare su http://events.codeweek.eu/search/). Un’occhiata al

documento del Ministero A scuola di coding è necessaria per capire le motivazioni dell’intro-
duzione del coding nei programmi di studio e anche per avviare “l’ora del codice” nelle classi:
http://hubmiur.pubblica.istruzione.it/web/ministero/cs230914. Fra queste iniziative figura un corso
per la programmazione con Scratch, un linguaggio che permette di programmare in maniera
intuitiva tramite l’utilizzo di oggetti: http://studio.code.org. L’insegnante che si iscrive ha a disposi-
zione un ambiente interattivo per gestire la propria classe, mentre gli studenti seguono le lezioni
e fanno gli esercizi proposti. Per approfondire diversi linguaggi e tecniche, relativi in particolare
all’HTML 5, ci possiamo rivolgere a http://www.html.it; mentre per i corsi (in lingua inglese) il
sito di riferimento è https://www.codeschool.com Infine segnaliamo un articolo interessante (fra
i numerosi disponibili) di Immacolata Nappi, Robotica Creativa e New Technology: un supporto
reciproco per l’apprendimento, che propone una visione interessante a proposito della robotica:
http://www.educationduepuntozero.it/tecnologie-e-ambienti-di-apprendimento/robotica-creati-
va-new-technology-supporto-reciproco-l-apprendimento-40102012153.shtml.
Il parere dello psicologo Jacopo Lorenzetti

Quali competenze mettono in moto le attività di programmazione?
Le attività legate alla programmazione richiedono un misto di competenze, abilità e conoscenze.
Da un lato la razionalità del programmatore, che pianifica passo dopo passo la procedura necessa-
ria, dall’altro la sensibilità del grafico nel progettare l’interfaccia in una maniera che sia intuitiva e
comprensibile per l’utente. Come posso assicurarmi che il prodotto del mio lavoro non sia frainteso
o, peggio, incompreso? Quali operazioni devo fare e in che ordine per raggiungere il mio risultato?
Ho una chiara visione d’insieme o mi sono perso nei dettagli? La mia idea è concreta, so come si fa
a realizzarla? E se non lo so, come posso impararlo?
Quindi, sul piano didattico, si tratta di attività di problem solving?
Sì. Per esempio il punto di vista della psicologia dello sviluppo e dell’apprendimento, la questione è
chiara: la programmazione e la costruzione dell’interfaccia stimolano il problem solving, la metaco-
gnizione, l’immedesimazione negli altri (teoria della mente), il pensiero logico. Le domande che si
pone il professionista (o l’appassionato) al lavoro sono le stesse domande che si pone lo studente
nel suo apprendimento. Ancora meglio, sono le stesse domande che noi insegnanti/educatori vo-
gliamo che i nostri studenti imparino a porsi.
Quindi tu credi molto nelle possibilità cognitive offerte dal coding?
Io credo che programmare (e progettare, al di là dell’aspetto tecnico del coding) possa diventare
un’esperienza di apprendimento completa per un ragazzo, che nello sviluppare il proprio progetto
trova modo di monitorarsi, riflettere sui propri obiettivi, e infine trova gratificazione nel risultato
prodotto, forse anche più di quanta può dargliene un voto. Questo tipo di compito ha il grande
potere di essere realmente immersivo: io sono protagonista del mio studio, libero nella speri-
mentazione, e quindi anche nella scoperta, la forma più spontanea e solida di apprendimento.
In questo modo l’insegnante può anche catalizzare l’attenzione e promuovere le competenze di
quegli studenti che normalmente hanno difficoltà ad apprendere con i canali tradizionali della
lezione frontale (come chi ha difficoltà di letto-scrittura) oppure faticano a trovare la motivazione
allo studio.
Coding a scuola
Mi ricorda un caso che hai seguito, quello di R. (uno studente con bisogni educativi speciali).
Pensavo proprio a lui. Quando l’ho incontrato per la prima volta aveva 12 anni e frequentava la
prima media. Aveva ricevuto una diagnosi mista di dislessia grave e ADHD (deficit dell’attenzione
con iperattività) dal consultorio locale e la famiglia lamentava la sua intolleranza nei confronti dello
studio e dei compiti, come anche i suoi insegnanti che, esasperati, erano giunti a chiedere addirit-
tura l’aiuto del sostegno. R. si era seduto davanti a me nello studio e parlava liberamente dei suoi
interessi, la sua passione per i videogiochi di guerra e di combattimento. Un ragazzino molto educa-
to e solare. A un certo punto, era necessario valutare a che punto fossero le sue abilità linguistiche
e quindi gli ho dovuto sottoporre un compito scritto di natura molto scolastica, simile a una verifica
sul lessico. Nel giro di pochi secondi R. si è spento, come se si fosse “disattivato”. Quello non era il
suo mondo. Ho provato allora a fare delle attività con l’iPad e con la LIM: qualcosa andava meglio,
ma il ragazzino che affrontava quei compiti non era lo stesso che descriveva con passione la trama
dei propri videogiochi preferiti. In seguito è stato inserito in un gruppetto di lavoro (insieme ad
altri ragazzini con diagnosi di disturbo specifico di apprendimento, DSA) per il potenziamento del
metodo di studio e la partecipazione, ma è sempre stato “distante”. Un giorno, molti mesi dopo,
mentre si parlava di YouTube, R. dal nulla mi ha detto: «Io ho un mio canale». Ed ecco scoperchiato
un mondo: numerosi video, recensioni di videogiochi, trucchi, tutorial, tutto registrato da lui, con ac-
curata progettazione, metodo, e chiarezza. Tutte capacità che R. non mostrava nella vita scolastica.
Il prossimo passo, allora, sarebbe stato quello di insegnargli a sviluppare il pensiero logico e pratico
attraverso un mezzo più adatto a lui, per farlo entrare in contatto con il proprio potenziale, e per
guidarlo nell’utilizzare queste stesse abilità nella vita di tutti i giorni. E questo è ciò che impariamo
dalla sua storia.
Quali considerazioni ti hanno lasciato esperienze come questa?
Dobbiamo riferirci alla tassonomia di Bloom, che resta la più valida in questo campo. Infatti essa
affronta i diversi obiettivi di apprendimento che un individuo può raggiungere, classificandoli uno
dopo l’altro in ordine di qualità. Alla base di tutto abbiamo obiettivi come ricordare e capire, che
sono le richieste cognitive fondamentali. Ma al livello più alto si trova la creatività, ossia la capacità
di produrre e operare tramite il pensiero divergente e l’intuito (o insight).
Noi, come educatori e insegnanti, vogliamo che i nostri alunni crescano come padroni della propria
conoscenza, e che possano averne una consapevolezza tale da manipolarla e utilizzarla per “fare”,
per “stupire”; vogliamo che riescano a esserne soddisfatti al di là di difficoltà visuospaziali che non
permettono loro di incolonnare le operazioni, o difficoltà ortografiche, o bisogni educativi speciali
di qualsiasi categoria.
Se per raggiungere questo l’insegnante deve progettare un compito in modo da far apprendere
gli studenti interattivamente e per scoperte, in un ambiente dove loro sono liberi di sperimentare,
sbagliare e capire, allora secondo la mia esperienza con ragazzi, educatori, e nella scuola 2.0, il
coding e la ludicizzazione/gamification sono due delle risposte corrette possibili.
“E SE…”: UN GIOCO CHE NON FINISCE MAI
Torniamo al nostro piccolo gioco del lido. Siamo partiti da una struttura molto semplice, che si è via via
complicata con nuovi livelli di programmazione. A una struttura ne abbiamo aggiunta un’altra. Questo è
il meccanismo dell’“e se…”. E se un cliente chiedesse…? E se un ragazzo ricevesse una telefonata? E se
sulla spiaggia ci fosse un pericolo? E se improvvisamente piovesse?
Coding a scuola
Il ruolo del docente

A ogni “e se…” la programmazione si complica perché deve tenere conto di nuove strutture logiche che
rispondono a nuove condizioni. Qui interviene l’abilità del docente. Infatti, la sua capacità professionale non
consiste nell’insegnare qualche riga di codice o gli elementi di base della programmazione affinché i propri
allievi riescano a creare una sequenza che li conduce a soddisfare le richieste dei clienti di un lido. Sarebbe
troppo banale! Esistono numerosi servizi, applicazioni e siti attraverso i quali i ragazzi imparano a program-
mare senza alcuna conoscenza preliminare e senza che nessuno li indirizzi (per esempio SCRATCH)2. Il loro
mondo non ha bisogno di particolari guide e indicazioni, almeno per un primo approccio. L’insegnante si
occuperà invece proprio di questa complicazione della struttura della programmazione. Aiuterà gli studenti
a porre gli “e se…” corretti, a farli interagire fra loro. Solleciterà gli studenti a ragionare, a disegnare dia-
grammi di flusso, a ritagliare quadrati, cerchi e frecce di carta per simulare su un tavolo quello che accadrà
a livello di coding, ma prima che il codice sia scritto e prima che le azioni siano compiute.
Se gli studenti apprendono a programmare attraverso il metodo del trial and error (per tentativi ed errori),
l’insegnante li porterà a riflettere prima della prova pratica, ad aumentare il loro livello di astrazione e di
concettualizzazione.
Il compito del docente non sarà di correggere un listato (l’elenco di istruzioni di un programma) o una
serie di interazioni create attraverso oggetti, ma di lanciare agli studenti delle sfide che li aiuteranno a
impadronirsi della logica della programmazione. Queste sfide si fondano su metodologie induttive e di
problem solving e possono essere anche interdisciplinari o multidisciplinari, coinvolgendo così diversi in-
segnanti e discipline nella costruzione di un progetto di encoding.
COME E PERCHÉ PARTIRE DA UNA DIDATTICA INDUTTIVA

FONDATA SUI PROBLEMI E SULLE SFIDE
Il Challenge Based Learning

Una delle principali esperienze di apprendimento collaborativo – in cui gli insegnanti e gli studenti lavora-
no insieme per proporre soluzioni di problemi reali e impellenti e quindi per agire – è il Challenge Based
Learning. Il CBL fa parte di una lunga tradizione didattica fondata su metodi “induttivi”, che partono
dall’esperienza sul campo per trarre delle conclusioni generali: il PBL (Problem Based Learning)3 e l’In-
quiry Based Learning, una efficace e nota metodologia di apprendimento delle scienze. L’Inquiry Based
Learning (IBL)4 è un metodo didattico di apprendimento fondato sulla ricerca, sull’osservazione, sulla for-
mulazione di ipotesi, sull’analisi, cioè sul metodo scientifico. L’IBL è stato elaborato negli Stati Uniti dove,
nel 1996, il National Research Council l’ha definito il miglior metodo didattico per l’apprendimento delle
scienze5. Più tardi, nel 2007, la Commissione Europea lo ha adottato nel quadro del rapporto stilato da
Michel Rocard, il quale in seguito ha pubblicato Science Education Now: A Renewed Pedagogy for the
2 Uno dei principali linguaggi di programmazione attiva, a oggetti e intuitiva, che consente a chiunque di creare
una serie di interazioni (http://scratch.mit.edu/).
3 Il PBL nasce in Canada intorno agli anni Sessanta nel settore medico. Vedi: The Challenge of Problem Based
Learning, a cura di David Bound e Grahame E. Feletti, Routledge, New York 1997 (http://books.google.it/
books?id=vIUuAgAAQBAJ&printsec=frontcover&hl=it).
4 Sull’IBL, vedi: http://www.exploratorium.edu/ifi/index.html; Wynne Harlen, Progress in Science Inquiry Skills and
How to Help it, Lisbona, 15 settembre 2012 (http://www.cienciaviva.pt/img/upload/Aprender_ciencia_Wynne_
Harlen.pdf) e il progetto Inquire: (http://www.inquirebotany.org/it/) con esempi di attività nel campo della
botanica (http://www.inquirebotany.org/it/resources.html).
5 Vedi: NRC, National Science Education Standards, 1996.
Coding a scuola
Future of Europe6. Questo documento riconosce la necessità di un nuovo approccio didattico allo studio
delle scienze, proprio attraverso il metodo IBL7 e uno dei modelli che si possono impiegare per implemen-
tare tale metodologia è il cosiddetto “modello delle 5e”8.
La “prova del joystick”, ovvero: l’importanza della sfida.

Il racconto di Nunzio Lo Regio, studente di liceo presso il Convitto di Avellino
Una delle mie passioni è la tecnologia e il motivo è che rende le cose più semplici, anche se è frutto
di un duro lavoro. Frequentando un liceo classico europeo, non ho mai avuto nel mio orario scola-
stico nemmeno un’ora di informatica. Probabilmente se avessi dovuto seguire delle lezioni di infor-
matica, questa materia mi sarebbe sembrata meno interessante, avrei perso il piacere di scegliere
cosa fare, come e quando farlo e anche la soddisfazione di vedere realizzata una mia idea solo con
i miei mezzi, senza l’aiuto di nessuno. Il mio interesse per l’informatica penso sia iniziato quando da
bambino guardavo mio padre usare il computer, ed è stato amore a prima vista. Con il passare del
tempo ho capito che potevo utilizzare la tecnologia per fare di tutto e ho cominciato a pormi sfide
sempre più difficili, fino ad arrivare alla programmazione. Dopo la realizzazione di semplici giochi,
grazie alla musica elettronica (un’altra mia grande passione) ho capito davvero le potenzialità della
programmazione. La cosa è iniziata un po’ per gioco: mi serviva un controller per utilizzare alcune
funzionalità di un programma. Avevo con me un joystick per videogiochi e scherzando ho detto
a un mio amico: «Adesso uso il joystick per controllare questo programma». Perché non provarci
davvero? Dopo svariati tentativi e ore al computer è nata la prima bozza di codice che mi ha per-
messo di vincere questa sfida. La cosa che mi ha spinto a continuare, superando le difficoltà, è stato
l’amore per la musica, perché è questo che ci guida: la passione per quello che facciamo.
La tradizione dell’indagine
Compiendo un viaggio a ritroso, a loro volta i metodi del CBL, PBL e IBL sono stati ispirati dalle tecniche
di problem solving. Il problem solving aveva lo scopo di superare i classici compiti fondati sulla soluzione
di esercizi e di problemi che venivano presentati nei momenti di verifica. I tradizionali problemi ed esercizi,
infatti, mettono in gioco ciò che lo studente già conosce. L’idea invece era di problematizzare l’insegna-
mento attraverso la ricerca di soluzioni che non implicassero necessariamente l’appello a un bagaglio di
conoscenze già acquisito. Le soluzioni devono essere trovate attraverso la ricerca e la riflessione logica.
Così, per esempio, il Problem Based Learning propone di affrontare sistematicamente i contenuti discipli-
nari problematizzando l’apprendimento. A questo scopo fornisce agli studenti un problema “autentico”
6 UE, Science Education Now: A Renewed Pedagogy for the Future of Europe (http://ec.europa.eu/research/science-
society/document_library/pdf_06/report-rocard-on-science-education_en.pdf).
7 In Europa viene talvolta chiamato IBSE (Inquiry Based Science Education).
8 Il modello si basa sulle seguenti fasi: Engage – Explore – Explain – Elaborate – Evaluate. Lo studente si interroga
e pone domande in modo che l’attività inizi sempre da una sua curiosità (Engage). Poi raccoglie, organizza,
interpreta, analizza e valuta i dati (Explore). In seguito comunica in differenti modi e forme le conclusioni e le
scoperte, le generalizzazioni a cui è giunto (Explain). Infine applica le sue scoperte e le sue teorie per risolvere
problemi, prendere decisioni, svolgere compiti, risolvere i conflitti o stabilire dei significati (Elaborate). Gli
studenti in gruppo valutano le conoscenze, le competenze e le abilità che hanno acquisito (Evaluate). Una
sintetica ed efficace descrizione si trova sul sito dell’Università del Maryland (http://faculty.mwsu.edu/west/
maryann.coe/coe/inquire/inquiry.htm).
Coding a scuola
da risolvere. Cioè un problema che esiste nel mondo reale. I metodi e le tecniche del PBL e di pratiche
analoghe sono diverse, ma tutte tendono a fare degli studenti dei soggetti attivi nella ricerca delle solu-
zioni. Infatti se il Problem Based Learning si struttura attorno a una presentazione che illustra il progetto,
l’idea e quindi la soluzione elaborata dagli studenti, dal canto suo il Design Based Learning si sviluppa
attraverso l’articolazione di un progetto che consente di risolvere un problema complesso.
In tutti questi casi di didattica attiva e induttiva abbiamo a che fare con processi metacognitivi (che inse-
gnano a pensare come pensare) che aiutano gli studenti ad assumere la padronanza del proprio appren-
dimento. Infatti tutte queste pratiche integrano anche gli strumenti necessari affinché lo studente sia in
grado di monitorare la sua stessa comprensione dei procedimenti di cui si occupa.
Workflow. Il coding in una metodologia induttiva

Se queste sono le metodologie più efficaci per affrontare il coding in classe con gli studenti, vediamo una
struttura di base che l’insegnante può sottoporre ai propri allievi:
• il docente dovrà creare un semplice gioco simulando un problema esistente nel mondo reale (non
una tartarughina che si muove sullo schermo, o un oggetto qualsiasi che si sposta e interagisce con
altri). Per fare questo potrà prendere spunto dai contenuti dei suoi colleghi. Per esempio il professore
di inglese gli può fornire un orologio al quale devono venire associate delle attività in lingua e delle
immagini. Se l’associazione è corretta, dovrebbe comparire una spiegazione;
• partendo dal problema (associare testi e immagini lungo una linea temporale) e impiegando meto-
dologie induttive (scoprendo per esempio il significato del testo in lingua, che cosa viene prima e che
cosa viene dopo e perché), l’insegnante costruirà una semplice mappa o un diagramma di flusso con
gli studenti, prima di passare alla programmazione vera e propria;
• in seguito il docente imposterà con gli allievi gli script di programmazione e ne analizzerà con loro la
logica e le proprietà verificandone la correttezza;
• infine l’insegnante rifletterà sull’intero procedimento e introdurrà nodi concettuali come il concetto di
variabile, di struttura di controllo ecc., che riguardano i nuclei fondanti della programmazione.
Coding a scuola
IL CODING IN AMBITO MULTIDISCIPLINARE

E INTERDISCIPLINARE
Come si possono affrontare i temi della programmazione in un contesto multidisciplinare nel quale, per
esempio, lo studente possa portare un’esperienza integrata di attività di coding, sviluppata insieme ad
altre discipline, al suo esame di fine ciclo, oppure a una presentazione ufficiale, a un concorso, o a un
evento?
Qui riportiamo un esempio di workflow che coinvolge più discipline nella preparazione di un reportage
sull’antico Egitto.
Un esempio di workflow multidisciplinare più complesso.

Diventiamo reporter multicanali
Impostiamo un’attività didattica di tipo multidisciplinare che comprenda attività di coding insieme
ad altre discipline quali geografia, scienze, storia, inglese e matematica.
Scegliamo un role-play (un gioco di ruolo) che sia il filo conduttore dell’attività. Compiamo un
viaggio nell’antico Egitto per diventare reporter multicanali. Il nostro obiettivo sarà di produrre dei
reportage che uniscano diversi temi disciplinari. Svolgeremo numerose attività correlate a questi
temi.
Qui sotto suggeriamo il compito da eseguire per ciascuna disciplina e indichiamo alcune applicazio-
ni di riferimento per tablet e smartphone.
Geografia
L’insegnante recupera le immagini necessarie con un’applicazione che simula un mappamondo,
come World Atlas.
• Scarichiamo World Atlas del National Geographic (http://social.zune.net/redirect?type=phone
App&id=4abd2110-d6d6-df11-a844-00237de2db9e; https://itunes.apple.com/it/app/national-
geographic-world/id364733950?mt=8) o un’altra app che mostri le informazioni sui singoli Stati
simulando un mappamondo. Esploriamo il mappamondo con un dito. Osserviamo come sono
presentate le informazioni. Scattiamo uno screenshot dell’Egitto mantenendo la visualizzazione
del mappamondo.
• Importiamo lo screenshot in un’app per prendere appunti come Evernote (https://www.ever-
note.com) o Notability (https://itunes.apple.com/it/app/notability/id360593530?mt=8) per an-
notarlo a mano libera o per inserire altre informazioni in forma di schema o disegno. Scriviamo
anche una didascalia e aggiungiamo un breve testo. Utilizziamo il modulo di navigazione Inter-
net per inserire una pagina Web che tratti di un tema quale l’orografia dell’Egitto.
Scienze
L’insegnante con i suoi allievi disegna alcuni volti di antichi egizi usando applicazioni per creare
identikit.
• Con app come Face Creator Free (https://play.google.com/store/apps/details?id=com.idicreative.
facecreator) o FaceKit (https://itunes.apple.com/it/app/facekit-gratis/id520866753?mt=8) creia-
mo l’identikit del volto di un antico egizio e di un’antica egizia. Importiamolo nelle nostre note
e scriviamo le informazioni che abbiamo rintracciato sulla costituzione fisica di questo popolo
(altezza media, caratteri somatici ecc.).
Coding a scuola
Storia
L’insegnante lavora con i suoi studenti per rappresentare la sala di un museo dove sono conservati
antichi reperti egizi, traendo ispirazione dagli ambienti del celebre Museo delle Antichità Egizie di
Torino (http://www.museoegizio.it).
• Creiamo due scenari di un museo all’interno del quale sono conservati reperti dei primi impor-
tanti ritrovamenti di epoca napoleonica. Registriamo lo screenshot di ciascuno scenario.
Inglese
L’insegnante crea con i suoi studenti un breve fumetto in lingua che ha come tema la vita di un
giovane egizio.
Montiamo ogni scena con un’applicazione per creare fumetti come Comic Life per Mac e Win-
dows (http://plasq.com/apps/comiclife/macwin/) o Strip designer (https://itunes.apple.com/it/app/
strip-designer/id314780738?mt=8). Inseriamo i dialoghi e le didascalie che raccontano la storia in
lingua inglese.
Coding
L’insegnante stimola l’apprendimento dei principi base della programmazione con applicazioni di
gioco che permettono di assemblare gli script come mattoncini, rendendo così visivamente chiara
la costruzione di una parte di codice.
• Siamo sulle rive del Nilo, e con un’applicazione come Pocket Frogs (https://play.google.com/
store/apps/details?id=com.mobage.ww.a435.pocketfrogs_android&hl=it; https://itunes.apple.
com/us/app/pocket-frogs-free-pet-farming/id386644958?mt=8) vogliamo stabilire le condizioni
che determinano la vita e la proliferazione delle rane e degli animali in quell’ambiente. Allo stes-
so tempo con Hopscotch (https://itunes.apple.com/it/app/hopscotch-programming-designed/
id617098629?mt=8) impariamo semplici diagrammi di flusso e un po’ di inglese. Mostriamo
che si può utilizzare la condizione “if” per costruire semplici procedure con Scratch. Scattiamo
una foto dello schermo e la importiamo nel programma di appunti per annotarla spiegando la
procedura che abbiamo utilizzato.
• Con Mind Map (https://play.google.com/store/apps/details?id=com.takahicorp.MindMap) o In-
spiration Maps (https://itunes.apple.com/it/app/inspiration-maps/id510031612?mt=8) creiamo
una semplice mappa sia grafica sia logica, utile anche per DSA. Scattiamo la foto e la importia-
mo nel nostro quaderno per raccontare quello che abbiamo fatto.
Matematica
• Cerchiamo l’immagine di una piramide e con Explain Everything (https://play.google.com/store/
apps/details?id=com.morriscooke.explaineverything; https://itunes.apple.com/it/app/explain-
everything/id431493086?mt=8) creiamo un filmato didattico che spiega alcune caratteristiche
matematiche delle piramidi. Il filmato sarà composto da immagini, disegni a mano libera, colle-
gamenti a pagine Web.
Gamification e coding
Creiamo un piccolo gioco didattico che unisce tutti questi elementi. Vengono presentate immagini,
nomenclatura, pulsanti interattivi da associare per determinare l’operazione corretta (vedi il capito-
lo: “Programmare interazioni e giochi con applicazioni conosciute”).
Conclusione
Presentiamo il lavoro a fine anno, lo pubblichiamo sul sito della scuola come Web app, oppure i
ragazzini lo portano agli esami come tesina multidisciplinare.
Coding a scuola
NON C’È CODING SENZA INTERFACCIA, SPECIALMENTE

IN CAMPO EDUCATIVO
Quando nel Settecento la porcellana si diffuse alla corte di Sassonia, nessuno sapeva veramente che farsene
e tutti la usavano per dare vita agli stessi oggetti che precedentemente si scolpivano nella pietra. Solo col
tempo si imparò a sfruttare la plasticità di quell’impasto di caolino e altre sostanze per inventare forme del
tutto nuove prima di cuocerlo in forno. A quel punto l’Europa venne invasa da migliaia di oggetti di porcellana.
Considerate che l’interfaccia di una qualsiasi applicazione è come la porcellana alla corte di Sassonia: si
modella bene, ma è difficile utilizzarla in modo davvero intelligente. Inoltre la maggior parte delle persone
conoscono poco questo ambito dell’informatica. L’interfaccia è ciò che appare quando si lancia un sistema
operativo, un’applicazione, una presentazione multimediale. Per effettuare i suoi calcoli, un computer utilizza
i numeri binari 0 e 1 (linguaggio macchina) che compongono il codice della programmazione (coding). L’in-
terfaccia è ciò che trasforma le serie di numeri, i listati o gli oggetti della programmazione in immagini, testi,
filmati, grafica e suoni. L’interfaccia è una specie di diaframma, di porta di comunicazione con l’elaboratore.
Anche un eBook interattivo e multimediale come un Multi Touch Book (http://www.apple.com/it/ibooks-
author/gallery.html) richiede un complesso lavoro di sviluppo informatico che viene reso coerente da
un’interfaccia che lega i contenuti fra loro. Così in questo eBook il lettore può scegliere di associare alla
lettura di una poesia anche immagini consultabili contemporaneamente, giochi e percorsi alternativi, e il
prodotto acquista nuove chiavi di lettura.
Tutto questo non sarebbe possibile senza la rappresentazione simbolica e grafica costituita da un’inter-
faccia. Detto in altri termini: non può esistere una programmazione che implichi una manipolazione di
dati senza la sua interfaccia, non può esistere codice senza rappresentazione, non possono esistere listati
logici senza una grafica che li renda fruibili.
Programmare non vuol dire solo stilare una lista di istruzioni

Esistono due modi per affrontare il coding: o si ritiene che significhi semplicemente far muovere una tar-
taruga avanti e indietro sullo schermo (come nel linguaggio di programmazione LOGO di qualche anno fa:
http://it.wikipedia.org/wiki/Logo_(informatica)), o disegnare un cerchio, o effettuare un calcolo, oppure si
ritiene che il coding abbia un senso per i nostri studenti solo se produciamo un oggetto concreto destina-
to a un pubblico, un oggetto che deve essere fruito realmente. Nel primo caso compiamo un’operazione
fine a se stessa, un puro esercizio di stile al quale lo stile mancherà sicuramente, perché prima di occuparsi
dell’eleganza della programmazione, bisogna masticarne di codice informatico! Nel secondo caso invece
svolgiamo un compito nel real word che stimola i ragazzi attraverso le sfide che noi proponiamo. In que-
sto secondo caso è indispensabile ragionare sulla rappresentazione dell’oggetto, su chi ne deve fruire, sul
modo di presentare il prodotto. In sostanza è impossibile non occuparsi della progettazione dell’interfaccia.
Consideriamo anche che esistono importanti motivazioni educative e culturali che ci devono spingere a
non ignorare questo problema. Il nostro universo comunicativo si basa sull’immagine, sull’associazione
della parola alla fotografia, su elementi grafici e in movimento e anche sul gioco e i livelli di interazione.
Questo tipo di comunicazione diventa lo strumento di una cultura poliedrica, cosicché oggi un’app o una
pagina Web raccolgono diversi contributi strettamente integrati fra loro. Ciò che unisce questi contributi
e i canali di riferimento sono proprio le interfacce, cioè il modo in cui i dati sono rappresentati per chi ne
fruisce. Per questo il lato multidisciplinare dei prodotti multimediali – che impiegano testi, film, grafica,
musica all’interno di una forma data – è parte integrante della stessa identità dell’oggetto prodotto, è il
modo in cui l’oggetto viene riconosciuto.
Coding a scuola
ITunes U è un’applicazione gratuita che raccoglie contributi messi a disposizione da oltre 3000 atenei di tutto il mondo. L’Università
di Pisa, per esempio, ha reso disponibili i suoi seminari di informatica umanistica (https://itunes.apple.com/it/itunes-u/seminari-di-
informatica-umanistica/id426146844?mt=10).
Come può un insegnante aiutare i suoi studenti a costruire

efficaci interfacce?
Anche un docente che non sa disegnare e non ha competenze con le interfacce può però insegnare
agli studenti a occuparsi di questo aspetto.
Prima di tutto può invitarli a ragionare ponendo le domande appropriate. A chi è destinato l’ogget-
to che si vuole costruire? Quali sono i gusti di questo target? Quale ambiente deve rappresentare?
Quali colori sono più adatti all’oggetto? Come disponiamo gli elementi nello spazio in modo che
siano visibili? Come facciamo a spiegare in che modo si usa il nostro oggetto? Dobbiamo scrivere
un tutorial? L’oggetto è sufficientemente intuitivo da essere utilizzato con facilità?
Queste e tante altre domande concorreranno ad aiutare i ragazzi a riflettere su questi aspetti e
quindi a operare delle scelte. Per aiutarli a riflettere possiamo invitare i nostri studenti a creare un
diagramma di flusso con un’applicazione per disegnare mappe concettuali e mentali.
Per disegnare i progetti e per schizzare le strutture di gioco delle attività possiamo avvalerci di
diverse applicazioni, specialmente per fare disegni e prendere appunti. Per chi predilige uno stile
informale, che piace molto agli studenti (e che, progettando un gioco, è coerente con il contesto),
le app più conosciute e apprezzate sono:
• PenSupremacy per Android (https://play.google.com/store/apps/details?id=com.apking.ultipen);
• Penultimate per iOS (https://itunes.apple.com/it/app/penultimate/id354098826?mt=8);
• Paper 53 per iOS (https://itunes.apple.com/it/app/paper-by-fiftythree/id506003812?mt=8),
Bamboo Paper per Android (https://play.google.com/store/search?q=bamboo%20paper&c=apps)
o per iOS (https://itunes.apple.com/it/app/bamboo-paper-quaderno/id443131313?mt=8);
• Sketchbook Express per Android (https://play.google.com/store/apps/details?id=com.adsk
sketchbook hdexpress) o per iOS (https://itunes.apple.com/it/app/sketchbook-express-for-ipad/
id410871280?mt=8).
Coding a scuola
2. Il coding e il gioco, un binomio vincente

PROGRAMMAZIONE E GIOCO AI DUE POLI
La programmazione e il gioco sono due attività molto diverse tra loro, addirittura opposte. Programmare
significa predisporre delle operazioni razionali e logiche, conformi a un determinato linguaggio, con lo
scopo di ottenere un certo risultato prefissato in anticipo. L’obiettivo della programmazione non è ludico,
anche se lo sviluppatore sta creando un gioco, egli non gioca mentre programma. Al contrario, chi gioca
non ha altro fine se non quello di giocare, la sua attività è libera e sperimentale, integralmente basata
sulla scoperta. Inoltre la sua attività non è necessariamente logica perché l’intuizione e una pratica fon-
data su tentativi rivestono un ruolo importante. Il gioco è libero, il lavoro no. Programmare è un lavoro.
Naturalmente chi programma si basa anche sul suo intuito, sperimenta delle soluzioni e si può divertire,
ma l’insieme della sua attività non è un gioco.
Quindi non è una contraddizione in termini voler abbinare la programmazione con il gioco? In parte sì,
ma in realtà dipende dal contesto e dagli scopi della programmazione. In ambito scolastico, diciamolo
subito, programmazione e gioco vanno a braccetto. Ecco per quale motivo.
Programmare giocando
Bisogna comprendere che il coding a scuola viene introdotto come un’attiva educativa e logica, non come
disciplina. Questo vuol dire che il suo oggetto non è il coding stesso, ma l’attività metacognitiva (che cioè
permette di conoscere la propria capacità cognitiva e l’attitudine a modificare il proprio modo di apprendi-
mento) che è in grado di sviluppare. Se fosse introdotto come disciplina, si dovrebbero insegnare i linguag-
gi di programmazione in quanto tali. Lo studente dovrebbe conoscere il C++, oppure Swift, JavaScript o
altri ancora. Invece è possibile impiegare diversi linguaggi e differenti strumenti di programmazione senza
doverne apprendere alcuno nello specifico, perché il coding viene introdotto a scuola come attività trasver-
sale che stimola le capacità logiche e cognitive. Queste capacità possono aiutare lo studente che sviluppa
una sua particolare passione per l’informatica, o che sceglie il coding come strada per la sua crescita pro-
fessionale. Dunque non si può fare del coding una pedante e tradizionale attività didattica il cui scopo sia
l’apprendimento di un linguaggio informatico fine a se stesso. Al contrario, bisogna affrontare i processi di
codifica, di programmazione, di costruzione di app, attraverso la formulazione di quesiti, la realizzazione
di esperimenti, l’indagine e la ricerca per tentativi: tutti elementi autonomi che devono essere privilegiati
rispetto all’assimilazione di specifiche procedure. L’eventuale apprendimento di un linguaggio di program-
mazione dovrebbe essere concepito come un effetto secondario e collaterale di un processo che ne vede
l’impiego per svolgere attività libere e creative, per sollecitare la ricerca di soluzioni empiriche partendo da
quesiti posti in contesti reali. In altre parole bisogna fare del coding un’attività ludica.
Apprendimento e multicanalità
Un ragazzo che mostra passione verso i linguaggi di programmazione, così come verso qualsiasi altra
attività, non farà fatica a documentarsi e, addirittura, a imparare a programmare semplicemente rivol-
gendosi alla rete. I ragazzi sono abituati ad avere un rapporto con la multicanalità9, cioè con i molteplici
veicoli delle informazioni che oggi possono essere reperite attraverso migliaia di canali in tutte le lingue
9 Vedi Alberto Pian, Didattica multicanale, iBookStore, 2012 (https://itunes.apple.com/it/book/la-didattica-

multicanale/id645246356?mt=13).
Coding a scuola
del mondo. L’Università di Pisa, per esempio, ha messo online da qualche anno un intero corso sulla
programmazione di app che è seguito da molti giovani10. Ma anche su YouTube, nel mondo editoriale
digitale e cartaceo, nei blog, nei forum, nelle specifiche app dedicate all’apprendimento, nelle scuole e
università di tutto il mondo, nei centri di formazione, si possono trovare informazioni e interi corsi per
imparare a programmare. I contenuti oggi sono ovunque e largamente diffusi in tutti gli ambiti discipli-
nari, compreso il coding. I giovani non sono estranei a questo mondo e non fanno fatica a reperire le
informazioni che servono, come dimostra il ragazzo di 17 anni di cui parliamo nel box seguente, che ha
imparato completamente da solo a programmare applicazioni per iPad.
Carlo Cioppa, lo studente che ha imparato a sviluppare

con YouTube
Carlo Cioppa ha 17 anni quando lo incontriamo al Convitto di Avellino in un evento che
ha per tema l’iPad a scuola.
Come è nata la tua passione per lo sviluppo di applicazioni per iPad?
È molto facile spiegare come sia nata la mia passione per la programmazione. Come tutti i ragazzini
appassionati di informatica, vedendo videogiochi molto curati e programmi dalle enormi potenzialità,
ho iniziato a chiedermi come questi “capolavori” virtuali fossero stati creati. Prendendo informazioni
su Internet ho iniziato a conoscere il mondo del coding, a me ignoto. Ho capito che avrei dovuto impa-
rare nuove lingue, delle lingue che servono a creare oggetti, a restituire informazioni e qualunque altra
cosa la mia mente possa immaginare. Poi ho scoperto altri strumenti che permettevano di program-
mare senza scrivere chissà quante righe di comando e da lì sono iniziati i primi esperimenti. Ho impa-
rato molto guardato filmati su YouTube e reperendo materiali e documentazione dal Web. La mia idea
quindi era quella di riuscire a dimostrare a tutti che anche io posso creare qualcosa, da solo, senza che
nessuno me lo insegni. Purtroppo la strada per un autodidatta è davvero difficile, ma spero di farcela!
Complimenti, ci vogliono coraggio, passione e tenacia. Inoltre hai scoperto che program-
mare ti piace.
Si, mi piace molto. Vuoi sapere perché? Perché è un po’ come elaborare un tema o un discorso in
classe. Gli strumenti che si hanno a disposizione sono gli stessi per tutti, ma primeggia solo chi li sfrutta
al massimo. I linguaggi di programmazione ormai sono di facile accesso, sta poi al programmatore
sfruttarli al massimo per ottenere grandi risultati. Partire da zero per creare qualcosa di bello, qualcosa
di mio, questa è un’altra cosa che amo della programmazione. È un nuovo modo di esprimere e dare
vita alle proprie idee. Inoltre imparare non costa niente, ma un buon lavoro un giorno potrebbe anche
fruttarmi del denaro: credo basti questa prospettiva a motivare un adolescente a provarci, no?
Perché sul piano didattico, secondo te, può essere utile programmare?
Dal punto di vista didattico la programmazione mi ricorda molto l’apprendimento delle lingue. Infatti,
una volta acquisito, il lessico non è soggettivo, come non lo sono, nella programmazione, i vari coman-
di. A essere soggettivo in entrambi casi è il modo in cui si utilizzano sia il lessico sia i comandi. Una so-
miglianza che invece ho riscontrato con la matematica è l’influenza di un errore, seppur minimo, sul pro-
dotto finale. Potremmo paragonare un errore di codice a un segno errato in un’equazione, esso influirà
su tutti i passaggi successivi. Forse però la lezione più importante che mi ha regalato questa passione
è la possibilità di apprendere in poco tempo e da solo contando unicamente sulla mia forza di volontà.
10 Corso iOS del dipartimento di Informatica dell’Università di Pisa (https://itunes.apple.com/it/itunes-u/corso-

ios/id434824250?mt=10).
Coding a scuola
Il ruolo del docente: come sollecitare lo studente al coding

Da queste semplici osservazioni possiamo stabilire il principio che il docente deve fornire ai suoi studenti
un qualcosa in più che questi non possono trovare nel mondo della multicanalità e della rete. Certo, per
scrivere un codice sono sufficienti delle informazioni online, ma per sollecitare maggiormente la curiosità,
per sostenere le indagini necessarie a risolvere problemi sempre più complessi, per guidare lo studente
nell’applicazione delle regole attraverso il gioco e per aiutarlo a riflettere sulla sua esperienza, c’è bisogno
di un insegnante che si assuma il compito di guida. Questa evoluzione del docente da semplice “istruttore”
che insegna un linguaggio a colui che aiuta i suoi studenti a imparare un linguaggio attraverso il gioco, ri-
solvendo problemi e lavorando empiricamente, lo colloca in una dimensione professionale più gratificante.
Come può il docente assumersi questo compito? Senza avere la pretesa di dispensare soluzioni preconfe-
zionate, suggeriamo di partire da un problema concreto che si pone all’interno della scuola o della classe
o in un contesto reale limitrofo e osservabile empiricamente.
Per esempio, potremmo sollecitare i nostri studenti a osservare il comportamento di determinati vegetali
o animali e a porsi il problema di come favorirne la tutela e la crescita (vedi box Un esempio di workflow
multidisciplinare più complesso. Diventiamo reporter multicanali). Oppure potremmo stimolarli a com-
prendere come diminuire l’impiego della carta a scuola o come organizzare un torneo sportivo formando
squadre equilibrate.
PARTIAMO DA UN DIAGRAMMA DI FLUSSO
La costruzione di un diagramma di flusso permette di ragionare sulle procedure logiche da seguire senza
mettere subito mano alla costruzione di un oggetto. Se l’attività parte dalla costruzione di un diagramma
di flusso, possiamo poi scegliere con quale metodo e quale applicazione creare l’oggetto.
Applicazioni suggerite per creare diagrammi di flusso

Esistono innumerevoli applicazioni per la maggior parte dei sistemi operativi e dei dispositivi. Basta fare
una ricerca per parole chiave in Google Play, in iTunes Store e nei diversi store online per tablet e PC. Qui
suggeriamo qualche applicazione indicando i motivi per cui è interessante.
• Inspiration (https://itunes.apple.com/us/app/inspiration-maps-vpp/id510173686?mt=8). Oltre a for-
nire una libreria di oggetti che permette di rappresentare visivamente il movimento e le azioni degli
oggetti interessati al processo di coding, presenta due ambienti di creazione: uno grafico e uno te-
stuale. In questo modo è sempre possibile fare dei raffronti fra la rappresentazione lineare del flusso
e quella grafica.
• Mindjet Maps (https://play.google.com/store/apps/details?id=net.thinkingspace; https://itunes.ap-
ple.com/us/app/mindjet-maps-for-ipad/id440272860?mt=8). Applicazione che consente di creare una
mappa online condivisa e modificabile da più persone.
• SuperMappe (https://itunes.apple.com/it/app/supermappe/id774854641?mt=8) e Idea Sketch
(https://itunes.apple.com/it/app/idea-sketch/id367246522?mt=8). Applicazioni molto intuitive che
non richiedono particolari conoscenze.
• PowerPoint e Keynote. Sono applicazioni molto diffuse nella maggior parte dei sistemi operativi e
dei dispositivi. Attraverso gli strumenti grafici che mettono a disposizione si possono facilmente creare
diagrammi di flusso.
Coding a scuola
PROGRAMMARE INTERAZIONI E GIOCHI CON APPLICAZIONI

CONOSCIUTE
Esiste un agevole terreno di incontro fra coding, interfaccia e gioco che è possibile proporre senza sco-
modare subito i linguaggi di programmazione e ottenendo risultati eccezionali. Si tratta di rendere “gio-
cabile” un argomento didattico attraverso la costruzione di un’interfaccia appropriata e l’impiego di una
struttura tipica dei linguaggi di coding come quella di controllo if–then–else.
Per svolgere questa attività possiamo impiegare applicazioni conosciute come Keynote e PowerPoint,
che non determinano lo spaesamento tipico di un linguaggio di coding. I risultati sono però molto simili
sotto diversi aspetti.
Creiamo un puzzle investigation con Keynote o PPT

La struttura di controllo if–then–else viene qui riprodotta utilizzando una struttura che si potrebbe de-
finire a tre ancoraggi. Nella sua struttura minima abbiamo bisogno di tre slide per ogni livello del gioco.
La prima slide contiene la proposta di gioco, che consiste in una caccia all’oggetto nascosto all’interno
di un ambiente; in questa dinamica, l’oggetto giusto va utilizzato per passare allo step successivo. Se il
giocatore sceglie un oggetto sbagliato, accede alla seconda slide, che riporta un messaggio di errore e
riconduce all’inizio per ripetere la ricerca. Alla terza slide si accede solo selezionando l’oggetto corretto.
Questa slide contiene anche un messaggio di approfondimento o di rinforzo all’apprendimento e propo-
ne di proseguire nel gioco.
Coding a scuola
Se affidiamo agli studenti la progettazione del gioco, il divertimento sarà assicurato. I ragazzi infatti
conoscono già le classiche strutture dei giochi tradizionali basati sulla narrazione (storytelling), fondati
sulla ricerca di indizi, partendo da un ragionamento o da semplici tentativi. Un modello del genere si può
mutuare anche per costruire semplici ma efficaci giochi con Keynote e PowerPoint. Di questi software si
possono utilizzare le potenzialità ipermediali, inserendo all’interno delle slide dei link che consentono di
navigare in modo non sequenziale tra i contenuti.
Immaginiamo di creare un gioco in cui si deve indovinare il titolo di un romanzo, raccogliendo indizi diver-
si (in quale ambiente si svolge, quali sono i personaggi ecc.) per tentativi. Creiamo innanzitutto una prima
slide sulla quale collochiamo gli elementi da scoprire. Assegniamo alla slide un tema; il primo potrebbe
riguardare i protagonisti del romanzo. Nascondiamo in questa slide degli oggetti che il giocatore dovrà
scoprire. La prima volta ovviamente procederà per tentativi, perché non ha alcun indizio sul romanzo.
Però appena scoprirà l’elemento giusto (nascosto nella slide), allora avrà accumulato un’informazione che
sarà utile per indovinare il titolo dell’opera.
Si va avanti così fino al punto in cui gli indizi dovrebbero essere sufficienti per indovinare il romanzo e
concludere il gioco.
Questa è la slide di partenza, contenente collegamenti multimediali. Le immagini dei personaggi vengono posizionate in delle
finestre e vicino a questi è posto un pulsante che indirizza l’utente a una slide di avanzamento nel gioco o a una slide di errore
appropriata. Questa informazione compare dopo aver cliccato sulla figura che secondo lui sarà quella giusta. Se (if) la scelta è cor-
retta, si andrà quindi (then) al livello successivo, altrimenti (else) si andrà alla slide che segnala l’errore e si sarà ricondotti all’inizio o
a eventuali informazioni di rinforzo didattico.
Coding a scuola
La diapositiva di errore può essere una sola, collocata alla fine di tutti i percorsi errati. Contiene un pulsante che consente di tornare
ogni volta al punto di partenza, cioè all’ultima diapositiva visionata.
Workflow di base per la creazione di una struttura

a tre ancoraggi
Creiamo tre slide: la prima, di ambientazione, nella quale si pongono le domande, la seconda che fornisce
la soluzione della prima e la terza che permette di proseguire e aggiunge un rinforzo. Utilizziamo una sola
slide per gli errori che inseriamo alla fine del percorso. Aggiungiamo le funzioni di hyperlink interattivi per
stabilire l’interazione e le transizioni.
• Fra la slide del titolo e quella di fine gioco inseriamo la prima slide, importiamo i disegni, aggiungiamo
gli oggetti e i testi;
• creiamo la slide di errore che poniamo alla fine di tutte le slide che creeremo;
• creiamo la seconda slide, che rappresenta il passaggio di livello. Questa slide può contenere delle
informazioni aggiuntive oppure può essere la prima slide del livello successivo;
• colleghiamo gli oggetti e i testi della prima slide che rappresentano un errore alla slide di errore;
• colleghiamo la slide di errore alla slide di partenza in modo che automaticamente, dopo aver letto
l’errore, il giocatore torni alla slide di partenza:
• colleghiamo l’oggetto corretto alla seconda slide;
• aggiungiamo il tipo di transizione fra una slide e l’altra e gli effetti speciali agli oggetti.
Un altro esempio con iPad: Make It

Make It (http://www.lafactoriainteractiva.com/make-it; https://itunes.apple.com/us/app/make-it-create-
share-your/id739190902?l=ca&ls=1&mt=8) è una delle numerose applicazioni che ci consentono di cre-
are su tablet dei giochi interattivi impiegabili in ambito didattico. Non è una vera e propria applicazione
di coding, ma questo ambiente in particolare aiuta a sviluppare le capacità connettive logiche attraverso
elementi grafici. Make It non presenta linguaggi di sviluppo, ma alcuni moduli per la creazione di piccoli
Coding a scuola
giochi che vengono realizzati trascinando al suo interno oggetti grafici e attribuendo loro delle proprie-
tà. Può essere impiegato in fase preliminare, per ragionare sulle connessioni logiche e sulla costruzione
dell’interfaccia.
Sulla sinistra la finestra che mostra le otto attività che è possibile creare con questa applicazione. Nello spazio di lavoro si possono
inserire elementi grafici, immagini, testi e si possono anche registrare contributi audio. Il tasto di condivisione consente di condivide-
re il proprio lavoro in modo che un altro utente al quale venga comunicato l’indirizzo lo possa scaricare sul proprio iPad per giocare
o per modificarlo.
Coding a scuola
3. Diversi livelli e strumenti di programmazione

PROGRAMMARE GIOCANDO: SCRATCH
I blocchi programmabili
Quello di Scratch11 è un ambiente molto noto per la programmazione in ambito didattico, che fa riferimento,
come il Lego, alle teorie costruttiviste dell’apprendimento. Di solito con questo ambiente i ragazzi creano storie
perché possono animare oggetti sullo schermo tagliando e incollando set di istruzioni che prevedono l’impiego
anche di sofisticate strutture di controllo e ripetizioni. Il linguaggio di Scratch è grafico e a oggetti. Lo studente
ha a disposizione dei blocchi che si incastrano fra loro come le tessere di un puzzle. Ciascun blocco contiene
una istruzione di programmazione, perciò la successione articolata dei blocchi fra loro costituisce il set di istru-
zioni che un dato oggetto deve eseguire. Tuttavia non tutti i blocchi sono incastrabili con gli altri: si limitano così
gli errori strutturali di programmazione. In questo modo lo studente si concentra sugli effetti delle istruzioni e
sulla loro successione logica. Dato che gli oggetti possono interagire fra loro sullo schermo, si possono creare
situazioni legate alle relazioni che si stabiliscono tra gli oggetti, creando anche vere e proprie storie animate.
L’ambiente di Scratch
Scratch è concepito come una Web app da impiegare online, ma anche come applicazione per sistemi
operativi Windows, Os e Linux e per i dispositivi mobili Android e iOS. Gli oggetti si chiamano sprite, come
nel linguaggio flash, creato da Macromedia e poi passato ad Adobe. Agli sprite possono essere assegnate
delle azioni attraverso la scheda “Script”. Inoltre le applicazioni realizzate con Scratch sono a codice aper-
to: ciò significa che chiunque può utilizzare le applicazioni realizzate come base per nuovi sviluppi e nuovi
esperimenti. Per esempio questa applicazione è stata creata da un utente di Scratch, ma noi siamo potuti
entrare nel codice perché possiamo anche creare un derivato, cioè un’altra applicazione basata sulla prima.
Per chi volesse approfondire il tema dello sviluppo in ambienti che utilizzano la filosofia dei “blocchi” può
utilizzare anche Blockly (https://blockly-games.appspot.com/), un’applicazione Web di Google.
11 http://scratch.mit.edu/
Coding a scuola
Questa è la stessa applicazione di prima, mostrata dal punto vista dell’utente che ne vuole usufruire. Il pulsante “Guarda dentro” ci
permette di vedere gli script dell’applicazione. L’applicazione è inserita in un contesto social attraverso il quale possiamo inserire dei
commenti, condividere l’applicazione, esplorare migliaia di applicazioni realizzate da altri utenti sparsi per il mondo.
L’esempio del lido e altri script

Con Scratch si possono realizzare semplici interazioni per insegnare i segreti della logica del coding o
giochi complessi a più livelli.
Prendiamo l’esempio del lido per mostrare come i messaggi possono essere lanciati e raccolti. Consideria-
mo che ogni oggetto collocato a video è chiamato sprite. Avremo tre sprite: un cliente che deve ordinare
l’acqua e due ragazzi per servirlo. Di questi due ragazzi solo uno è preposto a servire l’acqua e quindi
sarà l’unico che potrà accogliere il messaggio che proviene dal cliente. Ecco come si dispongono gli sprite
con i loro script di programmazione.
Coding a scuola
I tre sprite disposti sulla pagina: il cliente chiede l’acqua e solo uno dei due ragazzi risponde. Lo script associato al cliente è mostrato
sul lato destro. Quando si fa clic sullo sprite (cioè sul ragazzo), il ragazzo chiede a voce alta l’acqua, quindi aspetta un secondo e
infine invia un messaggio di richiesta dell’acqua.
Quando il ragazzo abilitato a soddisfare la richiesta riceve il messaggio di richiesta dell’acqua, può rispondere: “Arriva subito”.
Quando l’altro ragazzo riceve lo stesso messaggio invece penserà: “Io non ho l’acqua”.
Nella sostanza, tutti ricevono lo stesso messaggio, ma solo uno può soddisfare la condizione posta. Natu-
ralmente questa è una struttura molto semplice che può essere anche scritta in altri modi, più complessi,
in grado di gestire richieste molto più avanzate. Per esempio, senza complicare eccessivamente le cose,
possiamo immaginare una struttura condizionale più articolata.
Prendiamo l’esempio mostrato prima nel box Un esempio di workflow multidisciplinare più complesso,
dove abbiamo immaginato di costruire un modello nel quale le rane mangiano gli insetti. Proviamo a
costruire quest’interazione : quando i due personaggi si avvicinano, la rana si ingrandisce mentre l’insetto
sparisce.
Coding a scuola
Ecco lo script associato alla rana. Quando si fa clic sulla bandiera verde che rappresenta il play (l’inizio dell’interazione), la rana pren-
de posizione, si mostra e assume le sue dimensioni normali. A questo punto inizia un ciclo di ripetizione (loop o ciclo di repeat) che
implica due condizioni. La prima è che il ciclo si ripete fino a quando la rana non tocca il bordo dello schermo. Se tocca il bordo dello
schermo allora deve scomparire (istruzione “nasconditi”). La seconda condizione è che la rana continua a muoversi di 3 passi finché
non tocca l’insetto. Quando tocca l’insetto invia il messaggio “muori” a tutti gli sprite, dice: “Slurp!”, dà il comando di raddoppiare
le proprie dimensioni e crea un nuovo sprite (che sostituirà il precedente) uguale ma con le nuove dimensioni.
Lo script associato all’insetto è composto da due parti. Nella prima l’insetto prende posizione sullo schermo e, attraverso il ciclo “per
sempre” (loop o ciclo di repeat), compie continuamente un tragitto. La seconda parte invece serve per stabilirne il comportamento
quando viene toccato dalla rana. Ciò avviene quando riceve il messaggio “muori”. In tal caso si rimpicciolisce fino a scomparire.
Poi l’insetto compie un percorso, mentre è invisibile, per ricomparire in un altro punto dello schermo e ricominciare con il suo ciclo
finché non riceverà di nuovo il messaggio “muori”.
Coding a scuola
Ecco tre esempi che si possono esplorare e che mostrano tre diversi tipi di interazione e di coding.
• Videogame: colpire un animaletto prima che sparisca dallo schermo. Riferimento: http://scratch.mit.
edu/projects/10128368/ Codice: http://scratch.mit.edu/projects/10128368/#editor
• Storytelling: una visita virtuale del Media Lab del Massachusetts Institute of Technology. Riferimento:
http://scratch.mit.edu/projects/11804271/ Codice: http://scratch.mit.edu/projects/11804271/#editor
• Animazioni: vesti la bambina Tera. Riferimento: http://scratch.mit.edu/projects/11656680/ Codice:
http://scratch.mit.edu/projects/11656680/#editor
L’ambiente di Scratch si può utilizzare anche su iPad con Scratch Jr. Molto più elementare dell’applicazione nativa, contiene però un
numero elevato di istruzioni che permettono di creare soprattutto animazioni di storytelling. Si possono anche creare ambienti e
personaggi utilizzando la fotocamera e il disegno a mano libera.
PROGRAMMARE A OGGETTI IN MODO GRAFICO

CON SCRIPT: LIVECODE12
Sviluppare contemporaneamente per tutti i dispositivi

Un altro ambiente di sviluppo molto interessante da impiegare in classe è LiveCode. Si tratta di un am-
biente open source che consente di sviluppare applicazioni per praticamente tutte le piattaforme oggi in
circolazione: dai diversi sistemi operativi per PC a quelli per dispositivi mobili come iOS e Android. Anche
12 Sito di riferimento: livecode.com; sito di di riferimento italiano: livecodeitalia.it; guida in lingua italiana: http://
www.maxvessi.net/pmwiki/pmwiki.php?n=Main.GuidaALivecode; corso in italiano: http://www.didacta.com/
corsi_livecode.html
Coding a scuola
questo ambiente impiega un’interfaccia grafica che si basa su una struttura di card (schede sulle quali
possono essere disposti più oggetti), a loro volta aggregate in stack (“pile” di schede).
La programmazione in ambienti come LiveCode avviene impostando le caratteristiche degli oggetti che
si possono inserire nella card: foto, filmati, box di testo, pulsanti, elementi grafici di qualsiasi tipo.
Agli oggetti si possono associare degli script per regolarne il comportamento. Con gli script, per esempio,
posso decidere se gli oggetti sono sensibili al passaggio del mouse, o al clic. Sempre grazie a uno script si
può applicare come attributo un’istruzione condizionale a un oggetto. Così, facendo clic su un oggetto,
si esegue il programma a esso associato.
Però gli oggetti non reagiscono solo al “clic” del mouse. Quando viene usato per programmare applica-
zioni per i tablet o gli smartphone, LiveCode consente di gestire i comandi touch, adattandosi al device
in cui sta girando. Un pulsante potrebbe reagire all’ingresso del mouse nella sua area e in questo caso
potrebbe contenere un’istruzione come questa: “Se il mouse passa su di me, oppure il dito effettua un
‘tap’ prolungato, fai comparire una finestra di dialogo che spiega cosa succederà se verrò premuto defi-
nitivamente”. Quando il mouse uscirà dall’area di quel bottone o il dito allenterà la pressione, entrerà in
azione un’altra istruzione: “Fai scomparire il messaggio che ho appena visualizzato”.
Associare gli script agli oggetti

Inserire questi messaggi dentro gli oggetti per farli reagire a differenti azioni combinandoli in modo ar-
monico e funzionale costituisce l’arte della programmazione di prodotti interattivi. In LiveCode esiste una
“gerarchia dei messaggi”. Ciò significa che se clicchiamo su una immagine collocata nella card, il mes-
saggio che noi lanciamo potrebbe non essere raccolto perché a quella immagine potrebbe non essere
associato uno script. Però il messaggio potrebbe essere raccolto da uno script posto a un livello superiore
della gerarchia. Facciamo un esempio. Quando clicchiamo e rilasciamo il dito dal pulsante del mouse, par-
te un messaggio denominato “mouseUp”. Se facciamo clic sul pulsante “Informazioni”, questo potrebbe
contenere al suo interno uno script del genere:
on mouseUp
go to card “Informazioni”
end mouseUp
Il pulsante raccoglie il messaggio “mouseUp” e farà apparire sullo schermo una nuova scheda (card)
denominata “Informazioni”.
Se invece facciamo lo stesso clic fuori da quel bottone, potrebbe non accadere nulla. Tuttavia, se voles-
simo raccogliere tutti i messaggi di mouseUp che non hanno un esito nella card, per informare l’utente
che ha sbagliato posizione, allora dovremmo inserire uno script al livello più alto possibile della gerarchia.
Questo livello è quello dello stack, cioè della pila che raccoglie un insieme di card. A livello di stack scri-
veremo:
on mouseUp
answer: “Spiacente! Hai fatto clic in uno spazio vuoto non interattivo!”
end mouseUp
Il comando “answer” inserito in questo script farà apparire sullo schermo la frase di scuse.
Coding a scuola
In questo esempio, premendo il bottone “Comincia a scrivere la storia”, viene richiesto all’utente di inserire alcune parole che l’ap-
plicazione userà per comporre il racconto. Nella finestra a destra appare il codice che è stato associato al bottone: raccogliendo le
parole digitate il programma le inserisce in apposite caselle di testo nella card successiva.
Coding a scuola
In LiveCode esiste quindi una gerarchia di messaggi così disposta:
a) pulsanti e tutti gli oggetti grafici inseriti nella card;

b) card;
c) substack;
d) main stack.
Partendo da un pulsante, LiveCode cercherà via via sempre più in alto, passando dalla card, finché troverà
l’handler (istruzione) in questione. E se non lo trovasse? Pazienza, vuol dire che quel messaggio non deve
essere raccolto.
Catturare i messaggi, provocare degli eventi

Questa regola vale per tutti gli eventi. Tutte le volte che il mouse compie un’azione o il dito tocca lo scher-
mo in un determinato punto, parte un messaggio che sale nella gerarchia finché non incontra un handler
che gestisce questo messaggio, lo intercetta e mette in moto un’azione. L’handler inizierà con la formula
“on MessaggioTalDeiTali ”. Questo vale per ogni messaggio. Ma vale anche se non succede nulla. Infatti,
periodicamente viene spedito alla card corrente un messaggio chiamato idle che si attiva nel caso in cui
nessun altro messaggio sia stato spedito. L’idle risulta utile per controllare costantemente lo stato di un
oggetto, il contenuto di una variabile o per svolgere attività periodiche.
L’arte della programmazione con questo tipo di linguaggio consiste nel catturare i messaggi di sistema
per assegnare loro delle istruzioni specifiche, affinché avvenga una interazione con l’azione compiuta
dall’utente. Naturalmente LiveCode, essendo un linguaggio completo e sofisticato, consente di allestire
strutture di controllo (if–then–else ecc.), cicli (repeats), funzioni e variabili.
Ecco uno script che gestisce il pulsate di avvio (button “Play”) di un’applicazione di gioco (PlayPian) che
ho creato per aiutare gli studenti a fare dei collegamenti in letteratura.
Da notare, in questo script di LiveCode, le variabili globali (il cui contenuto persiste in tutto lo stack), sono dichiarate dalla funzione
“global”. Così “global NumeroAutori” indica che è stata creata la variabile globale NumeroAutori. La riga “put empty into Nuo-
vaSelezione” vuol dire che si è svuotata la variabile NuovaSelezione. Invece “If field Consegne contains ‘casuale’ then” significa
che se il campo di testo denominato “Consegne” contiene il termine “casuale”, allora si compiranno una serie di operazioni sotto
in elenco.
Coding a scuola
L’esempio del lido

Anche in questo caso abbiamo un cliente e due ragazzi. Il cliente chiede dell’acqua e solo uno dei due
ragazzi può soddisfare la richiesta.
Su uno sfondo abbiamo collocato i due oggetti: un filmato di animazione (ragazzo) e l’immagine di una ragazza (cliente). Il filmato
di animazione nello script si chiama player 1.
Ecco come possiamo programmare gli script. Ci collochiamo nella gerarchia dei messaggi a livello del
cliente (l’immagine della ragazza) a cui associamo questo script.
on mouseUp
global Richiesta
answer “Vorrei dell’acqua per favore!”
put “acqua” into Richiesta
Verifica
end mouseUp
Questo script ci dice che abbiamo dichiarato una variabile globale che si chiama “Richiesta”. Un variabile
globale è un contenitore che conserva dei dati che possono essere recuperati da qualsiasi script associato
a qualsiasi oggetto. Lo script quindi invia un messaggio che si chiama “Verifica”. Questo messaggio dovrà
essere raccolto da uno dei ragazzi del lido.
A livello di stack inseriamo questo script che raccoglie il messaggio “Verifica”.
Coding a scuola
on Verifica
global Richiesta
if Richiesta contains “acqua” then
answer “Arrivo!”
start player 1
end if
end Verifica
Lo script controlla il contenuto della variabile globale “Richiesta”: se contiene la parola “acqua” allora
potrà avviare il filmato di animazione che mostrerà il ragazzo recarsi dal cliente.
PROGRAMMARE A OGGETTI IN MODO GRAFICO SENZA

SCRIPT: HYPERSTUDIO13
Web app, HTML 5 e widget

Hyperstudio 5 è ambiente di sviluppo per sistemi operativi Windows e OS per la creazione di applicazioni
dal carattere marcatamente multimediale e interattivo attraverso un linguaggio a oggetti i cui script sono già
predisposti. Non si debbono scrivere righe di codice ma solo inserire gli oggetti nella pagina di lavoro (card),
assegnare le proprietà a ciascun oggetto e quindi le azioni che devono compiere, comprese le azioni di ani-
mazione. Non c’è un linguaggio da apprendere, ma bisogna saper combinare fra loro gli elementi necessari
per dare vita agli oggetti (testi, immagini, filmati) con i quali l’utente dovrà interagire. Il pacchetto Hyperstu-
dio Author contiene gli stessi elementi di Hyperstudio con l’aggiunta di due possibilità per noi importanti:
1. creare Web applications (applicazioni web) nel linguaggio HTML 5. In questo caso l’applicazione è
automaticamente compilata senza bisogno di conoscere il codice specifico, che si può sempre leggere e
studiare da qualsiasi browser;
2. creare dei widget da impiegare nei Multi Touch Book, i libri interattivi di Apple che si producono con
iBooks Authors. Si tratta di un’opportunità molto interessante perché permette di lavorare all’interno di
classi che impiegano iBooks Authors per creare i propri libri di testo e non.
Una struttura a stack e card

I prodotti creati con Hyperstudio si chiamano “stack”. Lo stack o “pila” è un oggetto composto da più
“card” (schede). Ogni scheda è uno spazio di lavoro nel quale collocare componenti multimediali e vi-
suali, i testi e i pulsanti. I pulsanti e tutti gli oggetti possono essere sensibili al tocco del mouse e quindi
rilasciano un feedback nel momento in cui catturano un messaggio a loro indirizzato. Gli oggetti inseriti
nella card possono quindi essere programmati per compiere determinate azioni. Per esempio, un pulsan-
te denominato “Ascolta il suo verso” in una card dove compare l’immagine di un tapiro (vedi immagine
nella pagina successiva), sarà programmato per far ascoltare all’utente il suono registrato quando il pul-
sante viene premuto. Il codice però non deve essere scritto, bisogna semplicemente associare al pulsante
le istruzioni già pronte che Hyperstudio mette a disposizione. Queste istruzioni devono essere scelte e
combinate fra loro per ottenere il risultato voluto.
13 Sito di riferimento: http://www.mackiev.com/hyperstudio/; Amazon: http://www.amazon.com/Software-

MacKiev-HyperStudio-AUTHOR/dp/B00IWZJ6PK/ref=sr_1_14?m=ADGYTS41PDRTY&s=merchant-items&ie=UT
F8&qid=1412336367&sr=1-14
Coding a scuola
L’interfaccia di Hyperstudio: abbiamo collocato nella card l’immagine di un tapiro e quindi abbiamo creato un pulsante che abbiamo
chiamato “Ascolta il suo verso”. Al pulsante è stato associato un suono tramite le opzioni della sezione Actions. Sulla parte destra
si può notare l’utile libreria di immagini ed elementi grafici di Hyperstudio.
Dal punto di vista del coding è possibile creare dei set di comandi molto complessi associando le diverse funzioni rese disponibili
dall’ambiente di sviluppo. Per esempio la funzione GhostWriter permette di fare comporre automaticamente al programma un testo
in un oggetto specifico.
Coding a scuola
Da un punto di vista logico-creativo Hyperstudio permette di concentrarsi sulla costruzione di un’interfac-

cia e sulla disposizione degli oggetti nella card. Hyperstudio mette a disposizione una libreria molto ben
fornita di immagini per progettare l’interfaccia dell’applicazione che si intende creare e contiene anche
tutti gli elementi per realizzare fumetti interattivi.
Proprio per questo il suo ruolo didattico è molto interessante: perché permette a tutti (anche ragazzi
con difficoltà di apprendimento) di ottenere dei risultati immediati. Inoltre permette agli studenti di porsi
domande rilevanti sulla costruzione di una interfaccia e sulle sue funzionalità. Infine, essendo un’applica-
zione di coding dedicata allo sviluppo di applicazioni multimediali e interattive, permette di collaborare
con docenti di altre discipline e di creare anche Web app da utilizzare in ambito scolastico ma anche per
lo studio, come test, giochi interattivi, database, schede di sintesi e tanti altri strumenti.
Web app e Hyperstudio

Una volta creato, lo stack si può esportare in formato HTML5 (seguendo il percorso File → Create a
Web App) e quindi si può caricare l’applicazione su un server Web (per esempio, nella cartella pub-
blica di Dropbox o in Google Drive). In questo modo tutti potranno impiegare la Web app tramite
un semplice browser, senza bisogno di plug-in aggiuntivi. Può essere interessante sapere che, dopo
che l’applicazione è stata caricata una volta, da allora in poi può essere visualizzata sullo stesso
dispositivo anche senza connessione a Internet. Con queste operazioni ricaverete anche il codice di
embedding in HTML5 da incorporare nelle pagine Web per poter utilizzare l’app.
La finestra di Hyperstudio per creare

una Web app.
I linguaggi del futuro: Swift14

Nel 2014 Apple ha introdotto un nuovo linguaggio di programmazione, chiamato Swift, che rende
più agevole programmare applicazioni anche complesse per iOS. Si tratta di una vera e propria rivo-
luzione perché Swift si basa sulla struttura di Objective-C, semplificando la sintassi e aggiungendo
nuove funzioni. Tutto ciò viene combinato in un ambiente di programmazione di tipo grafico dove
il design dell’interfaccia procede di pari passo con la scrittura del codice. Questo ambiente, molto
diffuso tra gli sviluppatori Apple, si chiama XCode e permette l’integrazione fra la progettazione
grafica di un programma e il codice con cui viene scritto, dimostrando che questo è il futuro della
programmazione. Per i più esperti, ecco che cosa dicono di Swift Fabrizio e Luca Infante, due svi-
luppatori e docenti di sviluppo di applicazioni presso lo IED di Milano: “Swift raccoglie i punti di
14 Sito di riferimento: https://developer.apple.com/swift/; una guida italiana: https://itunes.apple.com/it/book/

creare-applicazioni-per-iphone/id920445878?mt=11
Coding a scuola
forza di C e Objective-C senza avere i limiti della compatibilità con C. Le sue caratteristiche sono la
semplicità d’utilizzo e il suo non essere verboso come invece accadeva con il precedente linguaggio
di programmazione Objective-C. Ma il confronto non si limita al linguaggio di casa Apple, Swift
infatti raccoglie i punti di forza dei linguaggi più usati in ambito informatico sia lato app che lato
Web (alcuni esempi sono Python, Ruby e C). Da questi linguaggi, che sono studiati dalla maggior
parte degli sviluppatori, eredita la struttura semplificata dei linguaggi di scripting. Un esempio è la
gestione della memoria che, pur mantenendo un approccio semplice simile al garbage collector di
Java, possiede la stessa profondità e qualità che contraddistingue i linguaggi della famiglia C. Ma
Swift non guarda solo i concorrenti, ha anche occhio per il futuro. Introduce infatti concetti nuovi
come la programmazione funzionale, che potrebbe costituire un nuovo caposaldo della program-
mazione, così come è avvenuto con l’introduzione della programmazione a oggetti”.
Coding a scuola
4. Non trascuriamo la robotica

PARLANO GLI INSEGNANTI: UNA TRADIZIONE CHE VIENE
DA LONTANO15
La Casa degli insegnanti è un’associazione torinese molto conosciuta, composta da docenti che a partire
dagli anni Ottanta hanno introdotto nelle classi la robotica e il coding come efficaci strumenti didattici
non solo in campo informatico e matematico, proponendo una visione molto più ampia dell’impiego dei
linguaggi di programmazione.
Per diffondere la cultura della robotica e della programmazione, la Casa presta i kit Lego Mindstorms e
Lego WeDo alle scuole che non hanno fondi immediatamente disponibili per acquistarli, in modo che gli
insegnanti possano avviare subito degli esperimenti e comprendere la validità della proposta educativa
prima di far investire del denaro all’istituto. Allo stesso tempo la Casa organizza corsi di formazione a ri-
chiesta delle scuole o di gruppi di insegnanti o di altri enti educativi. Le esperienze in questo campo sono
ormai innumerevoli e i risultati ottenuti molto interessanti, a parte il fatto che per i bambini rappresenta
ovviamente un’attività motivante e coinvolgente. I siti di numerose scuole documentano le attività della
Casa, che collabora anche con la Scuola di Robotica di Genova (http://www.scuoladirobotica.it), associa-
zione ed ente formatore attualmente tra i più attivi in questo campo a livello nazionale e internazionale.
I kit Lego
Uno degli strumenti più utilizzati per la robotica didattica è il Lego. In questo caso i robot sono costruiti
soprattutto con i kit Lego Mindstorms e Lego WeDo. I kit Lego per la robotica però non comprendono
solo mattoncini e pezzi speciali tipo quelli del Lego Technics, ma anche motori e sensori e, soprattutto,
il “mattoncino programmabile”, praticamente un minicomputer dotato di microprocessore e quindi di
un linguaggio di programmazione a icone, molto semplice da utilizzare ma molto versatile.16 La Lego,
nota per aver creato i famosi mattoncini, è stata la prima azienda a introdurre kit di robotica seguendo i
progetti di Mitchel Resnick, docente che si occupa di ricerca nel campo dell’apprendimento al Media Lab
del Massachusetts Institute of Technology (http://web.media.mit.edu/~mres/).
I docenti che impiegano la robotica in classe utilizzano anche linguaggi di programmazione specifici nati
proprio per introdurre il coding in campo educativo, come Logo e Scratch. Questi linguaggi permettono
di controllare degli oggetti che si muovono e compiono azioni a schermo, in base a determinati set di
istruzioni che vengono impartite dagli studenti. Queste istruzioni possono essere a riga di comando op-
pure oggetti grafici che si incastrano fra loro come tessere di un puzzle.
Per un docente è importante capire il valore di queste diverse esperienze e degli ambienti di programmazio-
ne che le sottendono, come, per esempio, comprendere la differenza fra costruire un robot e programmare
oggetti a schermo, anche se, in entrambi i casi, si tratta sempre di impiegare un linguaggio di coding.
15 Per le attività della Casa degli insegnanti: http://www.lacasadegliinsegnanti.it/PORTALE/?page_id=1056;

per l’applicazione della robotica in ambito didattico: http://www.lacasadegliinsegnanti.it/PORTALE/?page_
id=3424
16 Per saperne di più basta andare sul sito Lego: http://www.lego.com/en-us/mindstorms/?domainredir=m
indstorms.lego.com e per acquistare i kit su quello di Campustore (http://www.campustore.it/robotica-
ed-elettronica/lego-education/mindstorms-ev3.html?utm_source=google&utm_medium=cpc&utm_
campaign=search_lego&gclid=CjwKEAjwzeihBRCQ84bhxrz_0w8SJAAohyh1gWQ-VM6v8JDTg3WRlfjsh4X_
VpG44hfFLR-9AY2pixoCuFXw_wcB) che li commercializza in Italia.
Coding a scuola
La robotica educativa secondo Donatella Merlo

della Casa degli insegnanti
Ecco la testimonianza di una delle fondatrici del gruppo che si occupa di robotica didattica e coding
fin dagli anni Ottanta: Donatella Merlo, insegnante di scuola elementare in pensione che oggi col-
labora con la Casa degli insegnanti in questo campo.
Che cosa intendete esattamente con “robotica”?
La robotica di cui stiamo parlando è la cosiddetta “robotica educativa”, che cioè sfrutta le poten-
zialità di questa scienza per educare e per far apprendere, collocandosi quindi nell’ambito delle
scuole e degli enti educativi in generale. Si tratta di rendere i bambini autonomi nella risoluzione di
problemi, fornire stimoli ad approfondire le loro conoscenze, motivarli a studiare.
Quali sono le principali differenze fra programmare un robot con i Lego o usare un lin-
guaggio come Scratch?
La differenza tra programmare robot e programmare personaggi o oggetti sullo schermo, come
consentono sia Logo sia Scratch, è che i bambini hanno a che fare con oggetti concreti di cui posso-
no immaginare azioni, comportamenti. Il lavoro che si compie è di puro e semplice problem solving,
una strategia fondamentale per l’apprendimento che questi oggetti permettono di concretizzare.
C’è molta matematica e molta scienza in tutto ciò. Basti pensare a che tipo di ragionamenti entrano
in gioco se si deve far spostare un robot nel mondo fisico: le problematiche che emergono sono le
più varie, da come vincere o tener conto dell’attrito, a come fare per far compiere al nostro robot
un determinato percorso. Ma l’aspetto più interessante è la presenza dei sensori sensibili alla luce,
di distanza, di suono, di contatto e altri ancora. Programmare i sensori vuol dire capire che tipo di
interazione può avvenire tra un robot e l’ambiente e trovare il modo, sfruttando questa interazione,
di far compiere al robot determinate azioni.
Per esempio uno dei programmi più interessanti da realizzare ha come scopo di far seguire al robot
una linea nera tracciata su un piano orizzontale. Il sensore sensibile alla luce si “accorge” della dif-
ferenza tra chiaro e scuro e invia al processore un certo input con il risultato che il movimento viene
aggiustato in modo tale da far mantenere al robot la traiettoria.
Il robot può assumere il comportamento di determinati animali: per esempio quello del pipistrello
se si sfrutta il sensore di distanza che gli consente di evitare gli ostacoli, emulando il sistema di
ecolocazione.
I robot possono anche interagire tra di loro attraverso i raggi infrarossi o il bluetooth, ricevere e
inviare messaggi e modificare il proprio comportamento in base al messaggio ricevuto.
Questi sono solo alcuni esempi tra i mille che si potrebbero fare. Molti sono documentati sia da
video su YouTube sia da siti dedicati, compresi quelli di alcune università americane che da tempo
hanno colto la validità di questa attività nelle scuole.
Giocando con i robot si impara quindi a programmare, si acquisiscono le principali strutture della
programmazione (dalla sequenzialità all’uso dei cicli), delle ripetizioni, del controllo condizionale e
così via. Il tutto avviene però in una situazione in cui i bambini imparano praticamente tutto dai
propri errori, si autocorreggono, inventano strategie, si servono di tutte le loro conoscenze per
raggiungere uno scopo.
Le gare della First Lego League (http://www.firstlegoleague.org/country/italy) vanno in questa dire-
zione e tengono in gran conto il legame tra queste attività e discipline come matematica, informa-
tica e scienze fisiche. Ma anche la biologia, come abbiamo visto, può svolgere la sua parte.
Coding a scuola
Per quale motivi, secondo te, la robotica è importante a scuola?

È importante perché è un’attività che mette in gioco competenze di tutte le discipline e quindi
va proposta proprio perché fa sì che gli alunni siano stimolati ad approfondire le loro conoscenze
avendo uno scopo per studiare.
Qual è il modo migliore per introdurre la robotica in classe?
Molto semplicemente portando un kit in classe e lasciando i bambini liberi di esplorarlo. Nella
scatola trovano tutto ciò che serve: i manuali di istruzioni per costruire i robot passo passo nella
migliore tradizione Lego, il software per programmarli e dei tutorial semplicissimi da seguire. I più
grandicelli non hanno praticamente bisogno di mediazione da parte dell’insegnante che, tuttavia,
può aiutarli a mettere a fuoco un obiettivo, a progettare un’attività. In genere, una volta organiz-
zati in gruppi di 4/5 allievi (uno per ogni kit), fanno tutto da soli, anche bambini molto piccoli. Il
kit Lego WeDo, in teoria, può essere utilizzato dai 7 anni in su, ma noi l’abbiamo impiegato anche
con bambini di 4/5 anni, sotto la guida dell’insegnante e con una metodologia idonea, e funziona
benissimo. Nelle scuole dell’infanzia della mia ex scuola ci sono ormai molti insegnanti che ogni
anno fanno esperienze con i loro alunni e la robotica è da tempo inserita in modo organico nel POF.
SPHERO17: MATEMATICA E STORYTELLING
La palla robotica Sphero può essere controllata mediante un linguaggio di programmazione molto simile
al Basic. Digitando le righe di comando Sphero nell’applicazione Sphero MACROLAB, la palla compie
le operazioni programmate. Con questo strumento i ragazzi possono applicare il coding a un oggetto
ludico come una palla e contemporaneamente possono ricavarne degli insegnamenti nel campo della
matematica, della fisica, della scrittura e dell’ottica. Com’è possibile che una sfera robotica programma-
bile possa interessare cinque ambiti disciplinari, alcuni dei quali così distanti fra loro?
Quando un insegnante rappresenta dei poligoni, traccia delle linee su un piano cartesiano: così un triangolo
è individuato dai suoi tre vertici, che sono il punto di incontro di tre segmenti. Proviamo a impiegare Sphero
per andare oltre i concetti di vertice utilizzando il “linguaggio” degli angoli per rappresentare un triangolo.
Obiettivi
Con il nostro esempio gli studenti imparano:
• a disegnare figure geometriche utilizzando il linguaggio degli angoli invece di quello dei segmenti;
• a determinare la direzione di movimento in base all’angolo stabilito da 0 a 360 gradi;
• a scrivere un programma nella corretta successione logica per disegnare figure geometriche (nel
nostro caso un triangolo);
• a calcolare i colori in base numerica secondo la composizione RGB;
• a creare successioni di colori;
• a costruire una sceneggiatura e una narrazione in cui la palla è un soggetto;
• a giocare sulle riprese e sul montaggio per creare degli effetti speciali;
• a girare, montare e condividere un filmato.
17 Sito di riferimento: http://www.gosphero.com
Coding a scuola
Questa figura mostra come il linguaggio di Sphero sia fondato sugli an-
goli. Il percorso di Sphero è infatti determinato dai valori angolari che si
dovrebbero usare per dirigerlo in una particolare direzione (questo schema
mostra solo incrementi di 90 gradi, ma si possono stabilire quanti angoli
si vuole).
Tracciare un triangolo senza un piano cartesiano

In questo esempio gli studenti devono creare un programma per disegnare un triangolo. Innanzitutto
per costruire un triangolo, bisogna dividere il cerchio in 3 parti uguali, ciascuna definita da un angolo di
120 gradi. Il primo vertice è posto a zero gradi, il secondo a 120 gradi, e il terzo a 240 gradi (120 + 120).
Si noti che nel listato, per rendere gli an-

goli più netti, gli studenti inseriscono uno
Stop e un Delay (il tempo di attesa prima
di una nuova azione) alla fine di ogni lato
del triangolo.
Coding a scuola
Inizialmente si potrebbe essere tentati di scrivere un programma come questo:

• Roll (rotola) per 2 secondi
• Ruotare di 120 gradi a destra
• Roll per 2 secondi
Ma Sphero non funziona in questo modo: utilizza infatti un linguaggio fondato sugli angoli, non traccia
dei segmenti “svoltando” a destra. Sphero si sposta dal punto di partenza in modo rettilineo, se il vertice
è a zero gradi. Affinché ruoti a destra è necessario impostare la direzione angolare (heading) a 120 gradi.
Per far girare di nuovo a destra la sfera e tornare verso chi la guida, è necessario impostarla a 180 gradi.
Come si vede, non bisogna pensare in termini di “svoltare a destra” o ”svoltare a sinistra”, ma in termini
di gradi e di direzioni angolari.
La finestra del comando Roll. Speed è la velocità rapportata percentualmente alla velocità massima di Sphero. Heading è il valore
della direzione angolare: impostato a 0 la palla disegnerà un segmento. Delay è il tempo di attesa necessario affinché la palla si
riassesti dopo ogni azione complessa.
Dunque impostiamo il nostro programma, affinché la palla disegni un triangolo. Noteremo che i suoi
angoli si presentano po’ arrotondati. Questo accade perché Sphero conserva dell’energia cinetica
quando raggiunge il vertice di ogni angolo. In altre parole, conserva un po’ di velocità e non cambia
direzione né riaccelera immediatamente. Per evitare questo effetto abbiamo inserito i due comandi
Stop e Delay in ciascuno dei comandi Roll. Questi comandi fermeranno Sphero e lo faranno attendere
prima di passare alla tappa successiva. Un altro parametro configurabile è quello del colore che Sphero
può assumere nei suoi itinerari: può essere regolato impostando le percentuali dei colori di sistema
rosso, verde e blu.
Coding a scuola
Scheda di controllo (triangolo)

Studente: ___________________________________________________
Quali sono i tre angoli che hai impostato per definire i vertici del triangolo?
0, __________, __________, _____________
Quali tempi hai scelto? ____________________
Quali sono i tre colori che hai usato?
Verde: ______% = rosso, ________% verde, _________% blu
Blu: ______% = rosso, ________% verde, _________% blu
Giallo: ______% = rosso, ________% verde, _________% blu
A quale velocità si spostava la palla? _______________________________
NB: il calcolo deve essere effettuato tenendo conto dei millisecondi stabiliti e della distanza per-
corsa (lati del triangolo), che deve essere misurata anche attraverso dei segnaposto fra i punti di
partenza e di arrivo per ogni lato. Inoltre bisogna stabilire la scala di misurazione: per le distanze
percorse sarebbe assurdo calcolare la velocità in km orari, come se fosse un’auto, ma bisognerebbe
utilizzare i metri al secondo.
Sfidare gli studenti

Sulla base di queste operazioni possiamo lanciare agli studenti una serie di sfide in modo che possano
realizzare e assimilare un lavoro concettuale importante.
Per esempio, si può proporre di disegnare un pentagono viola.
• Di quanti step ci sarà bisogno?
• Quanti gradi vanno aggiunti a ogni vertice per raggiungere quello successivo?
• Quali sono i colori da mescolare per ottenere il viola?
Con queste e altre domande gli studenti saranno sollecitati a raggiungere il risultato svolgendo delle
indagini.
Coding e storytelling con Sphero

Ogni volta che viene attivata, Sphero assume un nome che viene indicato da una successione di colori.
Se lampeggia con questa sequenza: viola, giallo, verde, allora il suo nome, in quel momento, è PYG. E
se la palla ha un nome, allora parliamo di antropomorfismo. Del resto le caratteristiche “umane” della
palla sono notevoli: possiamo muoverla verso una persona e farla saltare bruscamente indietro, come
se quella persona fosse antipatica oppure rappresentasse un pericolo. E se la palla danza tutta contenta
cambiando colore? Possiamo pensare che così esprima la sua gioia.
Dunque entrano in gioco non solo la matematica o il coding: infatti, proprio le caratteristiche antropo-
morfiche di Sphero ci aiutano a impiegare la palla per creare storie e filmati. Coding e storytelling vanno
dunque a braccetto, come dimostrano tre filmati educativi realizzati con Sphero: Hai un problema?
(https://vimeo.com/108698532), Stress e seduzione (https://vimeo.com/108698531) e Bullismo? Non
fare l’indifferente (https://vimeo.com/108698531). Notiamo che tutti i percorsi che la pallina compie
possono essere programmati con precisione quando si decide la trama della storia (storyboard). Le
azioni da compiere vengono suddivise in scene e in ogni scena la pallina sarà governata dal codice di
programmazione.
Coding a scuola
La pallina che salta e fa acrobazie è protagonista di un filmato contro il bullismo.
Come si imposta uno storytelling con una palla manovrabile a distanza e programmabile? Quali suggeri-
menti possiamo fornire in tal senso? Ecco un workflow di base che consente, con opportune variazioni e
contestualizzazioni, di realizzare tutte le narrazioni possibili che hanno come protagonista Sphero.
Innanzitutto bisognerà scegliere un carattere antropomorfo per Sphero. Infatti la palla dovrà diventare
a tutti gli effetti un attore dalle caratteristiche “umane”. A questo punto bisognerà immaginare una si-
tuazione in cui il personaggio di Sphero può agire per determinare un cambiamento. Dovremo pensare
all’azione attraverso la quale Sphero modificherà la situazione esistente. Il cambiamento potrà essere di
tipo positivo (si risolve una situazione intricata nella quale qualcuno soffre) oppure negativo (l’intervento
di Sphero crea il problema che ci aiuta a riflettere). In ogni caso il cambiamento dovrà condurre a una
riflessione finale di carattere etico.
In seguito si formeranno squadre di tre o quattro persone per ciascuna storia, ciascuna delle quali ide-
erà la ”sceneggiatura”, anche per sommi capi. Uno studente collegherà il tablet o lo smartphone a un
televisore HD o a un proiettore per visualizzare e monitorare i movimenti di Sphero. A questo punto gli
studenti programmeranno e metteranno a punto il percorso di Sphero per ciascuna scena.
Il linguaggio di programmazione di Sphero ci consentirà anche di controllare la velocità della palla, che è
modificabile anche con un’applicazione di montaggio video come iMovie per OS. Si potranno anche rea-
lizzare gli effetti necessari per l’azione: cadute, salti, curve. La storia verrà costruita in sede di montaggio:
ciò vuol dire che si proveranno le scene in sequenza, una dopo l’altra, montando direttamente le riprese
riuscite e scartando quelle che presentano errori. Se una ripresa non andrà bene – tutti la potranno ve-
dere dal televisore – verrà subito rigirata e, allo stesso modo, anche le righe di codice che non saranno
ottimali potranno essere subito corrette.
Alla fine si metterà a punto il filmato e lo si pubblicherà.
Coding a scuola
Glossario di base del coding

Applicazione
Il termine in informatica indica un programma o una serie di programmi in fase di esecuzione su un
computer al fine di rendere possibile una o più funzionalità su richiesta dell’utente tramite un’interfaccia.
Beta testing
Fase di collaudo del software non ancora pubblicato con lo scopo di trovare eventuali errori (bug). Questa
operazione può essere svolta da professionisti oppure da semplici appassionati di informatica, chiamati
beta tester.
C
Uno dei più diffusi linguaggi di programmazione che combina istruzioni di alto livello (più intuitive e
comprensibili per il programmatore) con altre di basso livello (più vicine al linguaggio macchina). C è stato
sviluppato da Dennis M. Ritchie e Brian W. Kernighan nel 1972 come evoluzione del linguaggio B di Ken
Thompson.
Codice
Sequenza di istruzioni che compongono un programma.
Coding
Coding, in italiano “programmare”, è l’azione che indica la stesura di un programma, cioè di una sequen-
za di istruzioni che possono essere eseguite da un computer.
Embedding, codice di
Codice che permette di incorporare in un sito Web app, video, foto e altri contenuti multimediali.
Gameplay
Il termine indica quanto un gioco è “giocabile”, ovvero quanto è immediata la risposta ai comandi del
giocatore, quanto è fluida l’esperienza di gioco, la semplicità con cui effettuare le azioni e la varietà di
queste ultime.
Gamification
Termine traducibile in italiano come “ludicizzazione” che indica l’utilizzo di dinamiche proprie del gioco
(per esempio punti, livelli, premi) in contesti non ludici, per sollecitare impegno e competitività, per sti-
molare la ricerca di una soluzione a un problema ecc.
HTML 5
Linguaggio utilizzato per la strutturazione di pagine Web.
Interfaccia grafica
L’interfaccia grafica consente all’utente di interagire con il computer manipolando su schermo degli og-
getti in maniera intuitiva, al contrario di quanto avviene in una riga di codice, in cui l’esecuzione del
programma viene guidata da istruzioni o comandi impartiti dall’utente tramite tastiera.
Listato: vedi Codice
Messaggio
Un insieme di informazioni organizzate in modo tale da poter essere trasmesse, memorizzate o elaborate
come un unico blocco. È formato da un involucro (envelope), che contiene le informazioni relative al mit-
tente e al destinatario, e da un corpo (body), che contiene l’informazione da comunicare.
Coding a scuola
Objective-C
Linguaggio per la programmazione a oggetti derivato da C, con il quale mantiene una piena compatibi-
lità.
Oggetto
Nell’ambito della programmazione un oggetto è una “raccolta” di dati e procedure che agiscono sui dati.
Le procedure vengono indicate con il termine “metodi”.
Problem solving
Termine che indica il processo cognitivo messo in atto per analizzare un problema ed escogitare una
soluzione.
Programmazione orientata agli oggetti

Tipologia di programmazione (denominata OOP, Object Oriented Programming, in inglese) introdotta
tra la seconda metà degli anni Cinquanta e l’inizio degli anni Sessanta nei laboratori di ricerca e svilup-
po del Massachusetts Institute of Technology. È particolarmente adatta alla definizione e alla creazione
dell’interfaccia grafica di programmi, in quanto permette di definire gli oggetti software e stabilirne le
modalità di interazione e le relazioni di interdipendenza. Questo metodo di programmazione facilita la
creazione degli oggetti naturali (bottoni, menu, cerchi e quadrati) all’interno dell’infrastruttura software,
agevola la gestione e la manutenzione dei programmi di grandi dimensioni e favorisce la modularità e il
riutilizzo del codice.
Python
Linguaggio di programmazione orientato agli oggetti apprezzato per la semplicità della sua sintassi. Le
sue istruzioni possono essere interpretate in molti sistemi operativi differenti basati su Unix, Windows o
Mac OS.
Robotica
Branca dell’ingegneria che sviluppa metodi che permettano a un robot di eseguire compiti specifici
riproducendo il lavoro umano. In questa disciplina ne confluiscono altre sia di natura umanistica, come
linguistica e psicologia, sia di natura scientifica, come biologia, fisiologia, automazione, elettronica, fisica,
informatica, matematica e meccanica.
Ruby
Ideato nel 1993 dal giapponese Yukihiro Matsumoto, Ruby è stato il primo linguaggio di programmazio-
ne a oggetti sviluppato in Oriente abbastanza popolare da essere usato anche in Occidente per progetti
di rilievo.
Script
Programma scritto con uno specifico linguaggio di programmazione.
Store
Piattaforma Internet che permette agli utenti di scaricare e acquistare applicazioni. Le applicazioni pos-
sono essere gratuite o a pagamento, e possono essere scaricate direttamente su un dispositivo mobile
(tablet o smartphone) o su un computer.
Struttura di controllo
Particolare istruzione di un linguaggio di programmazione che serve a specificare se, quando, in quale
ordine e quante volte devono essere eseguite le altre istruzioni che compongono il codice.
Coding a scuola
Variabile
Insieme di dati situati in una porzione di memoria destinata a contenerli e modificabili nel corso dell’e-
secuzione di un programma. Una variabile è caratterizzata da un nome composto da una sequenza di
caratteri e cifre.
Web app
Abbreviazione di Web application (applicazione web) che indica un’applicazione accessibile o fruibile
attraverso una rete (Intranet o Internet).
Widget
Componente di un’interfaccia grafica che fornisce l’accesso a una particolare funzione o informazione. Il
termine widget viene spesso utilizzato anche per indicare piccole applicazioni da scrivania quali meteo,
calendario, calcolatrice, dizionario, ora e fusi orari ecc.

Coding A Scuola (1) - Libro

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Coding A Scuola (1) - Libro

Caricato da

Copyright:

Formati disponibili

risorse PER L’INSEGNANTE

Redattore responsabile: Alessio Delfrati

Art Director: Nadia Maestri

Proprietà letteraria riservata

Le fotografie di questo volume sono state fornite da: Shutterstock

Immagini di copertina: Shutterstock

L’Editore dichiara la propria disponibilità a regolarizzare eventuali omissioni o errori di attribuzione.

1. PROGRAMMARE NON È QUELLO CHE PENSATE....................................................................................................... 5

QUANTE CONOSCENZE, ABILITÀ E COMPETENZE SI METTONO IN MOTO!..................................8

VERSO COMPETENZE MULTIDISCIPLINARI E TRASVERSALI...........................................................9

“E SE…”: UN GIOCO CHE NON FINISCE MAI.................................................................................12

COME E PERCHÉ PARTIRE DA UNA DIDATTICA INDUTTIVA FONDATA SUI PROBLEMI

IL CODING IN AMBITO MULTIDISCIPLINARE E INTERDISCIPLINARE..........................................16

NON C’È CODING SENZA INTERFACCIA, SPECIALMENTE IN CAMPO EDUCATIVO...................18

3. DIVERSI LIVELLI E STRUMENTI DI PROGRAMMAZIONE..................................................................................... 27

4. NON TRASCURIAMO LA ROBOTICA.................................................................................................................. 40

1. Programmare non è quello che pensate

Partiamo dal mondo reale (real world)

inizio messaggio perfavore

inizio messaggio perfavore

Il punto di vista del governo. La buona scuola1

Intercettare i messaggi per provocare un’azione

Dal coding al gioco

QUANTE CONOSCENZE, ABILITÀ E COMPETENZE

VERSO COMPETENZE MULTIDISCIPLINARI E TRASVERSALI

Competenze multidisciplinari logiche

Competenze multidisciplinari linguistiche

• organizzare in forma logica e sequenziale le proprie idee

Competenze multidisciplinari creative

Indicazioni utili per iniziare

(per una ricerca dettagliata basta andare su http://events.codeweek.eu/search/). Un’occhiata al

Il parere dello psicologo Jacopo Lorenzetti

“E SE…”: UN GIOCO CHE NON FINISCE MAI

Il ruolo del docente

COME E PERCHÉ PARTIRE DA UNA DIDATTICA INDUTTIVA

Il Challenge Based Learning

La “prova del joystick”, ovvero: l’importanza della sfida.

Workflow. Il coding in una metodologia induttiva

IL CODING IN AMBITO MULTIDISCIPLINARE

Un esempio di workflow multidisciplinare più complesso.

NON C’È CODING SENZA INTERFACCIA, SPECIALMENTE

Programmare non vuol dire solo stilare una lista di istruzioni

Come può un insegnante aiutare i suoi studenti a costruire

2. Il coding e il gioco, un binomio vincente

9 Vedi Alberto Pian, Didattica multicanale, iBookStore, 2012 (https://itunes.apple.com/it/book/la-didattica-

Carlo Cioppa, lo studente che ha imparato a sviluppare

10 Corso iOS del dipartimento di Informatica dell’Università di Pisa (https://itunes.apple.com/it/itunes-u/corso-

Il ruolo del docente: come sollecitare lo studente al coding

PARTIAMO DA UN DIAGRAMMA DI FLUSSO

Applicazioni suggerite per creare diagrammi di flusso

PROGRAMMARE INTERAZIONI E GIOCHI CON APPLICAZIONI

Creiamo un puzzle investigation con Keynote o PPT

Workflow di base per la creazione di una struttura

Un altro esempio con iPad: Make It

3. Diversi livelli e strumenti di programmazione

L’esempio del lido e altri script

PROGRAMMARE A OGGETTI IN MODO GRAFICO

Sviluppare contemporaneamente per tutti i dispositivi

Associare gli script agli oggetti

In LiveCode esiste quindi una gerarchia di messaggi così disposta:

a) pulsanti e tutti gli oggetti grafici inseriti nella card;

Catturare i messaggi, provocare degli eventi

L’esempio del lido