Digi Tales

Pensiero computazionale sì o no? Boh, dipende dal linguaggio.

Gen
27

Una delle motivazioni dietro la spinta all’introduzione della programmazione dei computer in giovane età (=coding) è quella per cui questa pratica insegna il pensiero computazionale, che è un modo di affrontare i problemi in maniera scientifica. Anche se Jeannette Wing si è affannata a dire che non si tratta di insegnare ai bambini a pensare come i computer, e Seymour Papert a predicare che bisogna insegnare ai computer come se fossero bambini, questo tema resta nell’aria. Computazionale significa “razionale, finito, corretto, misurabile” eccetera. In pratica, imparare il pensiero computazionale significa, per ogni problema, saper immaginare un algoritmo che lo risolva. Questo algoritmo deve essere eseguibile praticamente da un computer: non deve contenere errori, non deve basarsi su termini ambigui, non deve richiedere un tempo infinito o una memoria infinita per arrivare alla soluzione.

Però gli algoritmi si pensano (e poi si scrivono) diversamente a seconda del linguaggio, e a seconda del tipo di linguaggio che si ha in mente. Usare un linguaggio semplice quando si è ai primi passi è sicuramente una buona idea; ma cosa significa “semplice”? Può significare che costringe ad usare dei concetti e delle operazioni di base, vicine a quelle che sa fare il computer; oppure che spinge a nascondere i dettagli e a concentrarsi “semplicemente” sulla struttura dei dati e sugli obiettivi.

Insegnare ai bambini una forma di pensiero computazionale che li abitua a pensare nei termini del primo significato di “semplicità” rischia di creare più problemi – in futuro – di quelli che risolva adesso.

Voglio provare a spiegare questa differenza con un piccolo esempio.

Partiamo da Snap!, un ambiente di programmazione che pochi conoscono, che assomiglia molto a Scratch (ne è derivato) ma ha delle differenze importanti. Intanto è nato all’Università di Berkeley, dall’altra parte degli USA rispetto a Stanford, dove è nato Scratch. Poi ha un target più ampio, nel senso che può essere usato da bambini ma anche da ragazzi più grandi, perché è basato su un modello di linguaggio più potente di quello che sta sotto Scratch. Le differenze tra Snap! e Scratch sono poco visibili ad un primo approccio (si possono disegnare girandole o creare scenette animate con entrambi), ma sono molto profonde. Ne elenco solo tre fondamentali:

  1. A differenza di Scratch, in Snap! si possono creare funzioni, cioè procedure che alla fine restituiscono un valore, e questo è molto comodo perché permette di costruire delle catene di funzioni che si applicano ai risultati di altre funzioni.
  2. In secondo luogo, in Snap! ci sono delle funzioni per creare e gestire vere liste (di numeri, di lettere, di parole, ma anche di sprite, o di qualsiasi oggetto).
  3. Inoltre le funzioni possono essere usate come oggetti da altre funzioni. In altre parole: una funzione si può applicare non solo a oggetti semplici (come numeri, lettere) ma anche ad altre funzioni. In aritmetica conosciamo questo tipo di cose: la moltiplicazione è l’applicazione ripetuta della funzione somma.

Il terzo punto è particolarmente utile quando si vogliono trattare delle serie di dati. Se vogliamo trasformare una lista di numeri, o di lettere, o di parole, in qualche altra cosa dobbiamo applicare una trasformazione ad ognuno degli elementi della lista per ottenere una nuova lista; avere un linguaggio che permetta di fare direttamente questo tipo di operazioni permette di concentrarsi sul problema, e non sul meccanismo delle soluzione.

Mettiamo, per esempio, di voler generare la lista dei quadrati dei primi 10 numeri interi. Partendo da una lista di numeri interi, vogliamo moltiplicare ogni numero per se stesso. Cioè da 1,2,3,4,5… vogliamo ottenere 1,4,9,16,25 …

Questo in Scratch si può fare così:

  • crea una lista di numeri interi e dagli il nome “numeri”
  • crea una seconda lista e dagli un nome “quadrati”
  • crea un contatore e dagli il nome “i”, e valore 0
  • ripeti tante volte quanto è la lunghezza della lista “numeri”:
    • aumenta “i” di 1
    • moltiplica l’elemento i della lista “numeri” per se stesso
    • aggiungi il risultato alla lista “quadrati”

Saltando la parte di creazione delle variabili, ecco i blocchetti:

E’ semplice, sì, ma è anche un modo di pensare molto meccanico, che segue esattamente quello che succede “sotto il cofano”. Siamo noi che ci adeguiamo al modo di lavorare del computer, e non viceversa. Arrivare a questa formulazione non è banale: bisogna imparare a pensare in un certo modo. Bisogna imparare il concetto di contatore, di indice di una lista, quello di ciclo, di test di terminazione, eccetera. Sono gli elementi di base della programmazione classica.

Proprio questo è uno dei limiti dell’approccio “computazionale” di cui parlavamo sopra: si impara a pensare come un computer, o meglio secondo gli schemi che il linguaggio di programmazione che usiamo (in questo caso Scratch) mette a disposizione.

Da un lato questo apprendimento ha degli aspetti positivi: ogni volta che ci poniamo un limite impariamo nuovi modi di risolvere problemi. Dall’altro, restare dentro quei limiti non ci permette di andare molto lontano. Potrebbe esserci (non è mai stato studiato a fondo) una forma di imprinting per cui il primo modello di programmazione imparato resta quello fondamentale, un po’ come la lingua madre. Se i bambini imparano a usare i cicli per scorrere le liste, poi continueranno a farsi venire in mente questa modalità anche in futuro.

Ma usare i cicli è solo uno dei possibili modi di risolvere il problema dei quadrati. Ce ne sono altri, che dipendono dal linguaggio che si usa.

In Snap! si possono disporre i blocchetti esattamente nello stesso modo che in Scratch:

Ma si può fare anche qualcosa di diverso, più semplice e soprattutto più vicino alla struttura del problema.

Per risolvere il problema dei quadrati dei numeri interi non siamo costretti a pensare in termini di contatori e di indici, non dobbiamo per forza preoccuparci di sapere quando fermare il processo, dove mettere i risultati. Queste sono cose che riguardano la meccanica dell’algoritmo, non il problema in sé.

Qual era la cosa che volevamo fare, l’idea iniziale? Applicare la funzione “moltiplica per se stesso” a tutti gli elementi di una lista. Bene, allora cominciamo dalla lista

Questo blocchetto è una funzione che restituisce una lista costruita con gli oggetti che mettiamo negli spazi bianchi, in questo caso i primi cinque numeri interi. Non abbiamo bisogno di creare una variabile perché la funzione restituisce sempre quello che ci serve. Ora possiamo disporre i blocchetti in modo da rispettare esattamente l’idea originale di applicare la moltiplicazione alla lista:

Finito. Non c’è altro da fare. Questo blocchetto (“applica”) fa da solo tutto il lavoro: prende il primo elemento della lista, lo inserisce nei due buchi del blocchetto verde, esegue la moltiplicazione e mette da parte il risultato, poi passa al successivo. Alla fine restituisce una nuova lista con i risultati.

La presenza del blocchetto “applica” è una delle caratteristiche di Snap! (e dei linguaggi funzionali a cui si ispira) a cui facevamo riferimento prima. E’ una funzione che lavora su altre funzioni. Usando questo approccio, non ci servono variabili, contatori, cicli. Per certi versi, è molto più intuitivo e vicino al problema questo approccio di quello precedente, in cui dovevamo introdurre una serie di concetti di supporto.


In Snap! c’è un’altra maniera di ottenere questo risultato, ancora più semplice di quella che abbiamo visto adesso. Torniamo all’idea di partenza: “moltiplicare ogni numero di una lista per se stesso”. Ma invece di moltiplicare ogni numero per se stesso, possiamo partire da due liste identiche, e moltiplicare ogni elemento della prima lista per il corrispondente elemento della seconda.

Proviamo a fare esattamente questo:

Il risultato è lo stesso. In sostanza, l’operazione “moltiplicazione” normalmente si applica a dei numeri; ma in Snap! è stata estesa per applicarsi anche a delle liste. Naturalmente potremmo pensare di utilizzarla anche per moltiplicare due liste diverse, o per moltiplicare una lista per un numero singolo. Forse funziona anche con altre operazioni? Proviamo con l’operazione “elevamento a potenza”:

Funziona. Ed è abbastanza chiaro che è molto più semplice di tutto l’ambaradam che avevamo dovuto mettere in campo prima. Questa modalità ci libera di tutta la parte meccanica e ci spinge invece verso una maniera diversa di concepire il problema che volevamo risolvere, che a sua volta ci apre la strada verso altre possibilità.

In conclusione: attenzione al linguaggio che si sceglie, e non confondiamo la razionalità con la meccanicità.

Tecniche e tecnologie per la fantasia

Dic
11

Fantasia e tecnica non vanno d’accordo, si direbbe. Meno ancora fantasia e tecnologia: se c’è una, scompare l’altra. Quando entra in campo la tecnologia, il libero gioco dell’immaginazione dove va a finire? Però, però…

La tecnica del sasso nello stagno è descritta da Gianni Rodari nel secondo capitolo della Grammatica della Fantasia, come parte dello strumentario che serve a chi vuole inventare storie per i bambini, o con i bambini.
E’ una tecnica fondata sulle relazioni che uniscono parole nella mente, ma anche sul potere del caso nel sorprenderci e generare l’inizio di una storia.

Si pensa una parola… o meglio: la si chiede a qualcuno che passa di là, oppure la si pesca da un dizionario, o da un libro. Perché un libro? Perché è ancora più casuale, e dunque più sorprendente. Apri il libro a pagina 27, prendi la terza parola della quinta riga.
Poi si parte da quella parola per esplorare una serie di associazioni che servono a far emergere altre parole.
Per esempio, partendo da stasera possiamo andare a cercare:

le parole che cominciano allo stesso modo: stabilire, staccare, stagione, storia, studiare, stupido, …

le parole che finiscono allo stesso modo , cioè che sono più o meno in rima con stasera: camera, eccetera, lettera, maniera, opera

le parole simili, che si usano nello stesso contesto: stamattina, stanotte, prima, dopo, più tardi

E già nasce una storia:

Stasera, in camera, apro una lettera: sempre la stessa storia, la solita maniera, come un’opera eccetera eccetera – stupido! –

fino ad usare la lettere che compongono la parola per fare un acrostico:

  • Strada
  • Treno
  • Anima
  • Sangue
  • Egli
  • Ritornare
  • Appunto

Tutte queste parole nuove possono essere usate per creare una storia o una filastrocca.
Posiamo programmare un computer per fare (almeno una parte di) queste operazioni?
Sì, ed è quello che ho fatto qui con iKojo, la versione online di Kojo:
http://ikojo.in/sf/vylXgjC/10
Cliccate su RUN, prendete nota delle parole che vengono fuori (compreso l’acrostico) e poi iniziate a scrivere.
A me, partendo dall’acrostico di sopra – generato appunto dal programma – viene in mente una storia titanica (nel senso del film):

Lui è partito, col treno, chissà quanta strada ha fatto, ma ama lei fin nel profondo dell’anima. Lo ha giurato col sangue. Le aveva detto che sarebbe tornato, una sera di queste, e appunto, stasera…

Fa piangere già così, immaginate se poi lui stasera non dovesse arrivare …

Un altro risultato del Sasso nello Stagno

Il binomio fantastico è un’altra tecnica notissima, sempre dai primi capitoli della Grammatica.
Qui si prendono due parole a caso, possibilmente dalla mente di due persone diverse, o ancora una volta da un dizionario, da un giornale (dal web?).
Gli esempi di Rodari riguardano due sostantivi, ma non si vede perché non si potrebbero usare aggettivi o verbi; anzi, ci sono splendidi esempi di applicazione di questa variante nei racconti che mettono in scena i gemelli terribili, Marco e Mirko: “il leone bela”, “il lupo è dolce”, “il cielo è maturo”.
I due sostantivi si mettono insieme usando delle preposizioni: con, di, su, in (ma io aggiungerei: sotto, sopra, con, senza…).
Cosa fanno? si incontrano, si scontrano, vanno d’amore e d’accordo?
Per esempio: sasso, stagno (guarda un po’ che fantasia…)

  • il sasso nello stagno
  • il sasso di stagno
  • il sasso sotto lo stagno
  • lo stagno del sasso
    eccetera.

Ogni frase può essere l’inizio di una storia.
A me il sasso di stagno piace molto, mi fa pensare ad una palla di carta stagnola, di quelle della cioccolata, che usavo per giocare a calcio in corridoio da piccolo. E’ un sasso gentile e bellissimo, luccica come una pepita.

Una volta un minatore che lavorava a Canale Serci, sul monte Mannu, volle fare una sorpresa a suo figlio di tre anni e gli portò un sasso di stagno. Ma non era un sasso, era …

Se preferite, partiamo con una filastrocca. Il sasso di stagno richiama subito un ragno dispettoso, forse geloso, ma di chi? facile: di un cigno

Quel sasso di stagno
tirato da un ragno
geloso di un cigno
più bianco del regno…

Di nuovo vi chiedo: potremmo programmare un computer per fare (almeno una parte di) queste operazioni?
Sì, ed è quello che ho fatto qui:
http://ikojo.in/sf/EnNhE3O/12
Cliccate su RUN e state a guardare.


Sull’importanza del caso, sulla sua magia che ci costringe a renderci conto di quello che siamo (esseri che non possono impedirsi di dare senso a qualsiasi configurazione casuale, che vedono strutture chiuse ovunque) e sulla sua importanza per la didattica ho già scritto qui.

Se date un’occhiata al codice sorgente (a sinistra) vedete che a dispetto della semplicità apparente c’è invece parecchio lavoro sotterraneo per riuscire a mettere un articolo davanti ad un nome, o per costruire la preposizione articolata corretta. Non perché sia difficile la programmazione: perché è difficile la grammatica italiana, che deve dar conto di quasi mille anni di storia, di prestiti, di varianti locali, di sovrapposizioni. Anche questo è un esercizio di coding interessante, che richiede riflessione su come funzionano i meccanismi della lingua per poterli trasformare in algoritmi. Non è sempre necessario ricostruire tutto da capo, si può partire da pezzettini già pronti – è quello che ho fatto io e che fa chiunque programmi un computer.
L’idea più generale di accoppiare a caso sostantivi, proprietà, azioni, luoghi sta all’origine delle creazione di Limericks casuali a partire da una struttura (sintattica, ma anche narrativa): qualcuno, in qualche posto, fa qualcosa, e allora succede qualche altra cosa. Come finisce? E’ lo schema di tanti giochi, e anche delle fiabe a ricalco, un’altra tecnica descritta nella Grammatica della Fantasia nel capitolo 21 (ma ripresa anche in molti di quelli seguenti).
Entrambe queste possibili “applicazioni rodariane” del coding le ho descritte in “Lingua, coding e creatività”, che è un libro che cerca di scardinare l’idea che fare coding sia solo un’attività carina o che si debba fare solo per studiare le STEM; i codici sorgenti relativi, in Logo, Prolog e Kojo, sono nel sito di accompagnamento al libro e li possono scaricate tutti.

Bene, ora arriva la domanda cruciale: ma se usiamo un computer per tirar fuori tutte queste parole, non stiamo limitando la creatività nostra o dei bambini?
Io non credo. Per due motivi che mi pare possano fondarsi proprio su quello che Rodari ha scritto, come ho cercato di spiegare in “Rodari digitale“, l’ultima fatica di quest’anno.

Primo: la parte creativa non è quella di andare a cercare le parole, ma quella di costruire la storia. La ricerca delle parole è la parte meccanica, che richiede l’accesso ad un archivio di parole e alcune regole. Altrimenti basterebbe avere nove parole per fare una poesia (“Si sta come d’autunno sugli alberi le foglie”).

Secondo motivo: non sto proponendo di usare un programma bello e pronto, e nemmeno di cominciare da zero. Propongo di partire da un codice sorgente che funziona, ma di metterci le mani da subito. Cambiando le parole di partenza, cambiando le regole (per esempio: solo sostantivi o anche verbi? quali preposizioni?). Variando la tecnica: tre parole invece di due; oppure aggiungendo i prefissi e i suffissi, i diminutivi e vezzeggiativi.

Terzo motivo (non era previsto, ma lo aggiungo lo stesso): un computer sarà pure ottuso, ma non c’è limite alle cose creative che possono fare un umano e un computer, insieme.

Caso amico ti scrivo

Dic
04

Il ruolo del caso nella sperimentazione è fondamentale. Lo sanno gli artisti, che l’hanno usato come motore di generazione di opere. Basta andarsi a riprendere gli esempi di Queneau, di Calvino, dei dadaisti.
Ma a me il caso interessa come strumento didattico, di didattica della lingua e delle letteratura.
Per la precisione, come strumento che mette in evidenza la relazione tra semantica e sintassi, o meglio tra la staticità semantica e la tensione sintattica. La sintassi vista come una forza che spinge in una direzione precisa, mentre la semantica cerca di opporsi. Chiaro? Non tanto? Vediamo.

Partiamo da questa affermazione: “Un testo ha un significato complessivo che dipende dalle parole che lo compongono“.
Sembra una teoria banale. Ma è proprio vera?

Prendiamo un esempio: la poesia di Chamie Gorkin “Worst Day Ever?”. Questa poesia ha la particolarità di potersi leggere dall’inizio alla fine, oppure dalla fine all’inizio; ma offre un’interpretazione diversa, anzi opposta, a seconda della direzione. Non è un caso, naturalmente, è stata scritta apposta, sulla base delle convinzioni chassidiche dell’autrice.
Allora possiamo riformulare la nostra teoria: “Un testo ha un significato complessivo che dipende dalle parole che lo compongono e dal loro ordine. Se l’ordine delle parti del testo cambia, cambia anche il significato”.

Che succede se invece si mescolano i versi a caso? Beh, se gli elementi vengono mescolati a caso, il significato del testo si perde del tutto.
Ho scritto un frammento di codice in Snap! che fa proprio questo: scrive la poesia della Gorkin al dritto, al rovescio, e poi mescola i versi, ogni volta in maniera diversa. Lo trovate qui: https://snap.berkeley.edu/project?user=stefano63&project=worst_day

A priori potremmo dire che mescolando non si capirà nulla; ma se provate avrete delle sorprese. Compaiono dei frammenti, a volte lunghi tre-quattro versi, che sembrano avere un significato compiuto.
Perché? E’ una caratteristica di questa poesia particolare? Delle poesie in generale? O della maniera con cui sono stati scritti i versi?

In effetti, alcuni versi sono composti da una singola parola molto generica, che non ha valore di per sé, ma solo come aggancio tra il verso precedente e quello seguente (es. “Perché”, “Anche se”), oppure possono avere facilmente sia il ruolo di soggetto che di oggetti (“La realtà”, “Il mio atteggiamento”).
Altri sono fatti per rovesciare l’interpretazione del verso seguente (“E non è vero che”, “Non provare a convincermi che”). Insomma, il significato dei frammenti si costruisce in base all’accostamento di due o più versi, e il significato complessivo – se esiste – risulta dall’aggregazione di questi sotto-significati. Anzi: il significato si stabilizza alla fine della lettura, come una specie di media tra i sotto-significati.

Si può fare la stessa analisi, in maniera più semplice, a livello di frase. Prendiamo una frase semplice, di tre parole: due sostantivi (lupo, pecora) e un verbo transitivo (insegue).
La sintassi ci dice che quando il verbo è transitivo, il primo sostantivo è il soggetto e il secondo l’oggetto dell’azione espressa dal verbo. Il significato di:
lupo insegue pecora
è molto chiaro. Invertendo l’ordine delle parole la frase diventa
pecora insegue lupo
Dopo un momento di attrito, di sorpresa Rodariana, l’interpretazione torna ad assestarsi su quella precedente. Anzi, tutta la poesia che abbiamo imparato a scuola ci ha abituato a questo tipo di inversioni. Quella pecora messa all’inizio è un rafforzativo: è proprio la pecora che il lupo insegue, non un coniglio o una gallina.
Anche se si mescolano le parole, così:
pecora lupo insegue
insegue pecora lupo

il significato sembra resistere a tutti i nostri tentativi di scardinarlo.

Prendiamo una frase più complessa e mescoliamola.
il vorace gatto insegue un furbo topo
Potremmo ottenere:
topo gatto un vorace furbo insegue il
oppure
furbo un insegue gatto vorace il topo
Anche qui, il significato generale si capisce lo stesso, no? Perché?
Perché le parole sono semanticamente dense, e il rapporto tra esse si definisce indipendentemente dalla posizione reciproca. C’è una conoscenza implicita, anche se non diretta (non tutti hanno visto un gatto inseguire un topo) ma derivata dalle storie che abbiamo ascoltato o letto, che ci spinge verso un’interpretazione statisticamente più accettabile di quella opposta. I topi non sono descritti come voraci, e di solito non inseguono i gatti, tranne appunto nelle opere di Rodari.

Cambiamo frase di partenza:
credi che la vita sia felice non triste
Ora facciamo delle variazioni:
vita triste la credi non felice sia
la non credi felice vita sia triste

sia la vita credi triste non felice

Qui invece è evidente che l’ordine è fondamentale. “Triste” e “felice” si possono entrambi abbinare con “vita” senza che si possa sapere a priori quale relazione è più probabile (almeno, senza altre informazioni contestuali sulla biografia dell’autore, sul suo obiettivo, il destinatario).
Ci sono poi delle parole che acquistano un senso diverso a seconda della posizione. “Sia” è una parola ambigua, come un attore che può recitare parti diverse: può funzionare da verbo o da congiunzione; “credi” può essere un indicativo o un imperativo e anche “la” può essere articolo o pronome. Ovviamente la punteggiatura aiuterebbe a precisarne il ruolo (“ecco a che serve! ecco perché se non si usa succedono pasticci…”).

vita triste, la credi!, non felice sia
la non credi felice vita sia triste

sia vita – la credi triste? – non felice

Ecco allora spiegato il senso dell’esperimento: mescolare a caso consente di evidenziare il peso semantico, l’inerzia dei segmenti (delle parole, dei versi, delle frasi) rispetto alla tensione della sintassi, la quale invece spinge verso un’interpretazione che dipende dall’ordine degli elementi, secondo uno schema che si sovrappone alle parole. A seconda del valore di questo peso, la sintassi riesce, o non riesce, a rompere l’inerzia e a trascinare il significato nella direzione che vuole.
Questo è il valore didattico dell’uso del caso: rompere con l’abitudine a vedere le cose sempre nello stesso modo. Il caso ci propone un mondo non semplicemente al contrario, ma retto da regole diverse da quelle che conosciamo. Ci spinge ad esplorare queste regole, a confrontarle con quelle abituali e a capirle meglio.


Seconda parte: questo esercizio di applicazione del caso alla lingua si può fare a mente? Sì; ma è complicato se il testo è lungo. Si può fare su carta? Sì; ma se vogliamo cambiare testo dobbiamo ricominciare ogni volta da capo. Allora si può far fare ad un programma di computer? Eccoci qua.
Intanto sappiate che non è un’idea nuova; smontare e rimontare frasi lo si faceva anche con il linguaggio Logo, quello delle tartarughe, che oltre a permette di disegnare girandole e casette permette molto, ma molto facilmente di lavorare con liste di parole, rigirarle, estrarre pezzetti. Inoltre i computer sono abbastanza bravi a tirare fuori un numero a caso; più bravi di noi, che in qualche modo rischiamo di essere orientati da qualche associazione inconsapevole. Quindi sì, si può fare, e in più ha il vantaggio di permetterci di sperimentare con tanti testi diversi senza modificare il programma. Per esempio, invece della poesia della Gorkin si può provare con i versi della Divina Commedia. Come ho fatto qui: https://www.stefanopenge.it/inferno/

Il sommo poeta avrebbe amato
i computer?

Ma non c’è solo il vantaggio della forza bruta del computer.

Prima di provare a scrivere un pezzetto di codice che permette di rovesciare una poesia, bisogna domandarsi come si farebbe a mano, sulla carta. La risposta probabilmente è questa: si prende l’ultima riga della poesia, si cancella, e si ricopia in testa, e così via. E invece no, questa modalità non funziona: alla fine si ottiene la stessa poesia iniziale (provate). Quindi?
Quindi si possono usare due liste: quella iniziale (la poesia originale) e quella finale (la poesia rovesciata). Si prende l’ultimo verso dalla prima, lo si cancella e lo si mette come primo della seconda, e così via, finché la prima lista di versi è vuota.
Lo stesso sistema si può usare per mescolare a caso i versi di una poesia. Si prende una riga a caso dalla poesia originale, la si cancella da lì e la si inserisce in testa alla seconda lista. Quando la prima lista è vuota, la seconda contiene una copia mescolata.
Perché questa attenzione alla modalità carta-e-matita? Perché il coding serve soprattutto a questo: a riflettere sulla maniera in cui facciamo le cose, esplicitarla, discuterla, verificarla. A volte alcune cose pensiamo di saperle fare, ma non è vero; in questo caso, è l’occasione per andare a cercare dei metodi, che poi potremo mettere in pratica. In generale, il percorso è da dentro a fuori, e non il contrario. Una volta fatto questo, si può cominciare a scrivere codice (o a trascinare blocchetti, come preferite).
Ma ci sono tanti modi diversi di mescolare un testo. Possiamo aggiungere dei vincoli: nessun verso deve restare nella posizione originale; oppure le coppie di versi presenti nella poesia originale non devono ripresentarsi insieme in quella mescolata. Questo sarebbe un po’ noioso da fare sulla carta, ma non particolarmente con la versione digitale.
Usare un computer per programmare questo frullatore di testi offre però un altro vantaggio che è legato alla “consapevolezza” dei programmi, cioè al fatto che quando fanno un’azione possono registrarne il risultato, cosa che per noi umani è più lungo e faticoso, e soggetto ad errore. Siccome le azioni che fa il programma le possiamo accelerare e rallentare a piacere, possiamo fargli generare cento volte una nuova versione mescolata a caso e registrarle tutte.
Potremmo misurare il grado di mescolamento della frase in termini di distanza dalla versione originale. Poi possiamo “votare” le versioni in cui il significato è più chiaro, e mettere i voti in relazione con il grado di mescolamento degli elementi. Alla fine potremo verificare se è proprio vero che un’insalata più assomiglia all’originale, più mantiene il significato; o forse scopriremo altre regolarità. Per esempio, pensando ad una frase: ci sono parole che galleggiano più facilmente di altre? i verbi hanno un ruolo più importante? oppure le preposizioni? o le parole astratte? E le relazioni transitive soffrono di più dello spostamento rispetto alle descrizioni di una qualità o di uno stato? Eccetera.

Insomma ecco un altro esempio di come fare coding possa servire a mettere alla prova una teoria implicita e a imparare qualcosa su come funziona il mondo.

The body snatcher (carrozze, videoconferenze ed educazione)

Apr
07

Tempo fa, a proposito degli ipertesti, scrivevo che il digitale è un vampiro, che succhia la realtà. Avrei dovuto scrivere che è più simile agli ultracorpi del film omonimo del 1955 (che penso tutti conoscano, in una delle sue versioni). Il titolo originale del film era “The body snatchers”, i ladri di corpi.

Secondo Bolter e Grusin (che all’epoca non conoscevo), il digitale “remediates” l’analogico, secondo una dialettica propria del processo mediatico, di tutti i media: la fotografia rimedia la pittura, etc. Mescola insieme media diversi (hypermediacy) e così facendo tenta di diventare trasparente (immediacy) come medium.

A me sembra che il digitale faccia una cosa un po’ diversa e specifica. Imita e sostituisce. Copia con il preciso scopo di prendere il posto dell’originale, come gli ultracorpi appunto.

La maggior parte degli artefatti digitali nasce come imitazioni di artefatti analogici. A partire da immagini e suoni digitali, che sono campionamenti discreti e che vengono rimesse insieme con un software per dare l’illusione della realtà. Lo smartphone imita il telefono, non solo nel senso che ne assume tutte le funzioni, ma nel senso che digitalizza tutte le sue parti (la rubrica, la selezione, la codifica della voce, l’invio e la ricezione) e le trasforma in software e dati.

Una volta fatta questa operazione, l’intero oggetto telefono si può rappresentare dentro un altro sistema digitale, cioè un computer. Per esempio ci sono simulatori di videogiochi, ma anche simulatori dei computer con cui si giocava a quei videgiochi.

La pagina del quaderno e quella del libro, compreso l’inchiostro, e poi l’indice e la copertina, sono stati digitalizzati. A questo punto, l’hardware che li contiene e permette l’interazione da parte di organismi fisici come noi diventa quasi indifferente (immediacy). Di qui, tra l’altro, l’ambiguità e confusione tra ebook (contenuto), ebook reader (software) ed ebook reader (hardware contenente).

Va anche detto che di solito si pensa solo ai dati che vengono convertiti e si mette meno l’accento sul software, che invece è essenziale per imitare i comportamenti che ci sono consueti con quei dati. Se i dati possono essere semplicemente campionati e riprodotti, le funzioni invece vanno analizzate e ricreate (poggiare la punta della penna sul foglio, premere, trascinare, staccare; e poi cancellare, sottolineare, etc.).

Non affronto questo tema per denunciare i rischi della virtualizzazione e per decantare la bontà del buon vecchio oggetto fisico o della sua rappresentazione analogica. Voglio solo sottolineare il fatto che questa capacità di replicare completamente per sostituire è tipica del digitale ed è una rottura rispetto a tutta la storia dei media precedenti.

Qual è il vantaggio di questo processo? Sullo stesso hardware posso simulare infiniti oggetti diversi. Quindi mi costa di meno. Con lo stesso linguaggio di programmazione posso creare infinite simulazioni. Quindi ottimizzo le competenze. Lo stesso stile di interazione si può applicare a infiniti ambiti diversi. Quindi ne facilito l’uso.

Queste, in breve, le ragioni economiche e sociali che hanno spinto il digitale fino alla situazione di dominio che oggi gli riconosciamo. Ma più interessante è, a mio parere, quello che succede quando ci si allontana dall’imitazione e si provano a creare modi di interazione del tutto nuovi. Interessante soprattutto per i fini educativi.

___

L’automobile è stata concepita, e poi presentata e quindi venduta, come carrozza senza cavalli. Si è portata dietro questo schema antico, per evolversi e allontanarsene un po’ alla volta (ma ancora parliamo di potenza in termini di cavalli). Non può staccarsi troppo perché trova dei limiti: il guidatore e il passeggero devono essere seduti comodamente, protetti dalle intemperie, ma contemporaneamente devono poter vedere la strada, etc. Fa qualcosa di diverso del carro con i cavalli: corre molto di più, è più piccola, ha maggiore autonomia, può rimanere ferma per mesi e poi ripartire, se non è in funzione non gli si deve dare da mangiare. Ma in fondo niente di radicalmente diverso dal carro.

Un po’ come la videoconferenza usata per le lezioni a distanza. Oggi è usata come una cattedra molto, molto lontana. Ancora non riusciamo a immaginarne un uso in quanto tale, non come simulazione di qualche altra cosa.

Spostiamoci un attimo nel mondo del coding. Guardando agli ambienti di programmazione visuale (sì, parlo di Scratch; ma pure di Snap! e di tanti altri) viene inevitabilmente in mente il LEGO come metafora. Ora immaginiamo una simulazione digitale proprio del LEGO originale (esiste davvero, in una versione più semplice di come la descrivo nel seguito, http://ldd.lego.com/en-us/). I mattoncini sono parallelepipedi colorati su uno schermo. Si possono girare in tutte le direzioni, spostare, congiungere.

Quali sarebbero le differenze con il LEGO del mondo reale?

  1. il numero dei mattoncini è teoricamente infinito (non lo è in pratica perché la il software, e la macchina su cui gira, hanno dei limiti fisici)
  2. è facile assegnare ai mattoncini digitali altre proprietà o comportamenti. Potrebbero diventare trasparenti, crescere; ma anche suonare, muoversi da soli, staccarsi e attaccarsi dopo un certo tempo.
  3. sulla base di queste proprietà si possono immaginare regole, giochi, interazioni che con i mattoncini di plastica non sarebbero possibili.
  4. queste nuove regole e interazioni possono essere immaginati da chi ha progettato il software, ma anche da chi lo usa, ammesso che il software lo permetta

Insomma questa immaginaria versione digitale del LEGO potrebbe essere riprogrammata, anche dai bambini. Questa è una differenza importante. Non è solo questione di portabilità, leggerezza, facilità, ma di legge costitutiva, di regole che sono in mano all’utente e non solo al produttore.

Qui il digitale mostra la sua potenzialità.

Ecco, questa è la strada. Staccarsi dai limiti che erano appiccicati all’immagine precedente, il LEGO, la cattedra,la carrozza con i cavalli, e creare qualcosa di davvero nuovo.

Ambiguità felice dei linguaggi

Feb
23

C’è una barzelletta che gira da tempo sui programmatori, esseri inadatti al mondo reale. Dice così:

La mamma dice a Pierino: vai al mercato e compra 2 litri di latte. Se ci sono le uova, comprane 6.
Pierino va e torna con 6 litri di latte.
La mamma: Perché hai comprato 6 litri di latte?
Pierino: Perché c’erano le uova.

Finite le risate per la risposta di Pierino (che immaginiamo essere il risultato di una specie di programma: IF ci sono le uova THEN comprane 6), ci accorgiamo che il problema è in quella particella “ne”, che è un riferimento pronominale. Di quelle cose che abbiamo detto prima. Un link, una URL relativa.
In Italiano, di solito, si riferisce all’ultimo sostantivo utilizzato. Quando ce ne sono più di uno (di che? di sostantivi) di solito con un minimo di interpretazione si capisce a quale ci si riferisce.
Se la mamma avesse detto:
[…] Se c’è lo zucchero, comprane 6 litri.
un parlante Italiano avrebbe capito che il riferimento era al latte, perché sa che lo zucchero non si vende a litri.

E’ uno degli aspetti tipici del linguaggio naturale: un riferimento generico può essere comodo in molti casi, ma può creare dubbi in altri. Dubbi che vanno risolti con delle ipotesi, oppure nell’interazione (“Scusa, mamma: 6 di cosa?”).

Si dice che i linguaggi di programmazione, essendo “formali”, non soffrono di queste malattie, anzi sono stati costruiti apposto per esserne immuni. La barzelletta prende in giro proprio questa ottusità dei computer, dei linguaggi, dei programmi. I computer non interpretano i programmi, ma li eseguono rigidamente. Per cui niente libertà, niente interpretazione, niente poesia, solo correttezza e efficienza.

Ma siamo proprio sicuri che sia così? Facciamo un gioco: traduciamo la storiella in un linguaggio molto usato per il web, ovvero PHP (tranquilli: il discorso può essere seguito da chiunque, anche senza nessuna competenza informatica).

$lista = Array (
 latte => 1,
 uova => 6
 );

In questo frammento di codice sorgente viene creato un dizionario ($lista), cioè una set di dati organizzati per coppie chiave/valore (latte=1, uova=6).
Ci si mettono dentro le informazioni e poi si possono estrarre quando servono.
Scrivendo così:

 print_r($lista);

possiamo vedere cosa c’è dentro $lista:

Array
(
    [uova] => 6
    [latte] => 1
)

Oppure, volendo andare più in dettaglio:

 
print_r($lista[latte]);

cioè: scrivi sullo schermo il valore della chiave “latte” nell’array $lista.
Che è, ovviamente, 1.

Se però guardiamo cosa succede dietro le quinte, ci accorgiamo che l’interprete ha segnalato due errori veniali:

PHP Notice: Use of undefined constant latte - assumed 'latte'
PHP Notice: Use of undefined constant uova - assumed 'uova'

E’ un nostro errore di scrittura: le chiavi sono state scritte come se fossero costanti (cioè senza le virgolette che invece accompagnano le stringhe di caratteri), ma non esiste nessuna costante che si chiama latte, né uova. Ma cosa ha fatto l’interprete PHP, oltre a segnalare l’errore? Ha fatto un’illazione, cioè ha supposto che si volesse scrivere:

'latte' =>1,
'uova' => 6

che sembra in effetti l’interpretazione più ragionevole.

Se siamo bravi programmatori e programmatrici, una volta letta la segnalazione correggiamo il codice, e tutto fila liscio.
Anzi, per essere ancora più precisini, creiamo una costante (visto che ci era stato chiesto), ma le diamo un valore un po’ bizzarro:

define('latte',uova);

Cioè: abbiamo definito una costante che ha come nome “latte”, ma come valore “uova”.
Vi sembra confondente? Ma il linguaggi di programmazione sono precisi, no? Quindi nessun problema: da un lato la costante, dall’altro la chiave.
E infatti, se avessimo lasciato le cose come stavano, non ci sarebbero stati problemi. Ma noi abbiamo voluto essere rigorosi e abbiamo creato la costante E messo gli apici intorno alle chiavi.
Ora se chiediamo:

print_r(latte);

(ovvero: qual è il valore della costante “latte”?), otteniamo la stringa “uova”, come prevedibile; mentre se chiediamo di nuovo:

print_r($lista[latte]);

il risultato non è né “uova”, né 1 ma …  6 !
Il che naturalmente ha una sua logica. Si potrebbe dire che l’interprete ha usato il riferimento pronominale nella nostra richiesta, e ha interpretato la chiave dell’array $lista[latte] come la costante “latte” che era stata definita prima. Ma non è quello che volevamo dire. Insomma, dal nostro punto di vista,  si confonde e restituisce 6, cioè interpreta il codice come se avessimo scritto:

print_r($lista[uova]);

Proprio come Pierino.

Ora cambiamo l’ordine delle chiavi:

$lista = Array (
 'uova' => 6,
 'latte' => 1
 );

e chiediamo di nuovo:

print_r($lista[latte]);

Dovrebbe essere uguale a prima, no?
Eh no, adesso il valore restituito è tornato ad essere 1!
Meglio, dite? Insomma… se provate a scrivere:

print_r($lista);

vi accorgete del pasticcio:

Array
(
    [uova] => 1
)

La chiave latte è stata sostituita da uova (con valore 1) e la chiave uova, che avevamo inserito con valore 6, è stata cancellata.

Certo PHP non è un modello di precisione, per un linguaggio di programmazione. Ma insomma: anche un linguaggio di programmazione è soggetto ad una forma di ambiguità referenziale. E questo dipende, come abbiamo visto, dall’ordine in cui vengono inserite le informazioni nel testo.
Come in una qualsiasi lingua naturale…

Le sfide del digitale

Feb
16

A conclusione ed integrazione del corso “Le sfide del digitale”, due seminari aperti al pubblico.

Quando: Lunedì 26 Febbraio 2018 h 18
Dove: CESEDI della Città metropolitana di Torino, Via Gaudenzio Ferrari n. 1
Cosa:  “Dialogo tra un libro e un e-book
Con:
R. Marchisio docente corso e autore. “Dialogo tra un libro e un e-book.”
M.A. Donna scrittrice e poetessa. “Le ragioni del libro.
C. Manselli scrittrice e docente di scrittura creativa. “Le ragioni dell’e-book.”

______________________________________________________________

Quando: Giovedì 8 marzo 2018 h 16 – 18
Dove: Museo tecnologic@mente di Ivrea, Piazza San Francesco d’Assisi 4

ma per chi se lo fosse perso, anche:

Quando: Venerdì 9 marzo 2018 h 15 – 18
Dove: CESEDI della Città metropolitana di Torino, Via Gaudenzio Ferrari n. 1
Cosa: “Linguaggio e cultura digitale: progetti, idee, riflessioni”,

Con:
Rodolfo Marchisio “Perché è necessario continuare a parlare di cultura digitale.”
Eleonora Pantò, “Diversità in classe e Rosadigitale.”
Stefano Penge, “Codice sorgente, lingue e letteratura.”

I seminari di Torino  fanno parte del corso, autorizzato dall’USR Piemonte con decreto prot. n. 6547 del 19 luglio 2017 e, vista la presenza di esperti qualificati, sono aperti a tutti, ai soci della Associazione, ai corsisti Cesedi e a tutti i docenti interessati alle tematiche.
Per motivi organizzativi si prega di segnalare la propria partecipazione a mariagrazia.pacifico@cittametropolitana.torino.it (Maria Grazia Pacifico), marchisi@inrete.it (Rodolfo Marchisio).

Poeti, navigatori, santi e cuochi: cosa insegna la linguistica computazionale al coding?

Gen
31

L’incontro tra informatica e letteratura avviene ufficialmente, almeno in Italia, quando nel 1949 Padre Busa SJ si dedica all’immane compito di compilare un Index Thomisticus, cioè un repertorio di tutti i termini utilizzati dall’Aquinate nelle sue opere. Per farlo, chiede il supporto dell’IBM (parlando con il suo fondatore, Watson) e inizia un lavoro di lemmatizzazione durato trent’anni. Dopo la versione cartacea (1980) e quella su cdrom (1989), nel 2005 nasce la versione web (http://www.corpusthomisticum.org/it/index.age).

La linguistica computazionale si presenta così con un aria seriosa, doppiamente sostenuta dall’oggetto (il testo classico) e lo strumento (il programma di lemmatizzazione e ricerca), per non parlare dello scopo scientifico.

Ma ci sono stati altri incontri meno nobili, come quello tra il libro cartaceo Cent Mille Miliards de Poèms di Raymond Queneau e il web. Per chi non avesse avuto la fortuna di sfogliare quel meraviglioso oggetto, si tratta di un libro pubblicato nel 1961 che raccoglie dieci sonetti di quattordici versi ognuno. La peculiarità che lo rende unico è la pagina è tagliata in orizzontale in modo da rendere ogni verso un oggetto autonomo; è possibile così leggere (e costruire con la mente) un sonetto costituito, poniamo, dal primo verso della prima pagina, il secondo dalla decima, il terzo dalla quinta, e così via. Le possibilità totali sono 1014, cioè appunto 100.000.000.000.000. Di questa macchina per generare sonetti ne esistono varie versioni consultabili su web, come per esempio questa: http://www.growndodo.com/wordplay/oulipo/10%5e14sonnets.html

Queneau realizza (cioè “dimostra la possibilità”) di qualcosa che nel cielo delle invenzioni letterarie era ben nota. A partire per lo meno dalla macchina creata dagli scienziati dell’Accademia di Laputa:

La superficie risultava di vari pezzetti di legno, grossi press’a poco come dadi, alcuni di maggiore dimensione degli altri. Erano tutti congiunti da esili fili di ferro. Incollata sopra le quattro facce dei pezzetti di legno era della carta, e su questa si trovavano scritte tutte le parole della loro lingua, coniugate nei diversi modi e tempi e declinate nei vari casi, ma senza ordine veruno. Il professore m’invitò a prestare attenzione, ché appunto s’accingeva a mettere in moto la macchina. Ciascun discepolo prese, al cenno del maestro, un manico di ferro (ce n’erano quaranta fissati intorno agli orli della macchina) e d’un tratto lo fece girare. Naturalmente la disposizione delle parole cambiò in tutto e per tutto. Il maestro ordinò allora a trentasei scolari di leggere pian pianino i vari righi così come apparivano sulla macchina; e quando quelli trovavano tre o quattro parole unite insieme che potevano far parte d’una sentenza, le dettavano ai quattro rimanenti discepoli che fungevano da scrivani (Jonathan Swift, I viaggi di Gulliver, Traduzione di Carlo Formichi, a cura di Masolino d’Amico, Mondadori, Milano, 1982, p. 393).

passando, naturalmente, per Borges, Levi, Landolfi e Dahl. Molti altri esempi sono citati in questa trascrizione di una bellissima conferenza del 2015 tenuta da Paolo Albani (a meno che non sia anche questo un testo generato automaticamente) che potete leggere qui: http://www.paoloalbani.it/Letteraturacombinatoria.pdf.

Cosa mostra davvero questo strano artefatto, nella versione cartacea come in quella digitale? Che la letteratura (e in particolare la poesia) non è tutta intuizione ed espressione libera. Che il gioco tra sistema e creatività, tra regola ed eccezione, non è proprio così chiuso come sembra. La poesia, in particolare, nasce proprio dal vincolo (tematico, formale), come orizzonte e come sfida. Non lo dico io, lo dice Calvino: la letteratura è

“un’ostinata serie di tentativi di far stare una parola dietro l’altra seguendo certe regole definite, o più spesso regole non definite né definibili ma estrapolabili da una serie di esempi o protocolli, o regole che ci siamo inventate per l’occasione cioè che abbiamo derivato da altre regole seguite da altri” (Cibernetica e fantasmi. Appunti sulla narrativa come processo combinatorio, in: Una pietra sopra. Discorsi di letteratura e società, Einaudi, Torino, 1980, pp. 164).

E cosa fa il poeta quando crea, se non andare a pescare nella sua memoria linguistica e scegliere combinazioni di parole, vincolate da regole precise (come il metro o la rima)? Certo, la scelta è anche governata dal significato – in maniera difficile da precisare. Il poeta parte con l’idea da esprimere e cerca le parole più adatte? Oppure si lascia guidare dalle parole stesse, sfruttando somiglianze fonetiche, rimandi per analogia o opposizioni? O ancora, più probabilmente, attua un misto delle due strategie? Insomma: come si scrive, praticamente, una poesia?

E di qui l’idea di proporre delle attività didattiche di coding intorno ai temi della forma e della variazione, delle categorie, dell’accettabilità. In un periodo in cui il machine learning sembra riproporre il vecchio mito dell’intelligenza artificiale, viene voglia di ragionare intorno ai processi creativi anche utilizzando paradossi, e di provare a costruire un automa in grado, se non di scrivere poesie originali (come questo: http://thinkzone.wlonk.com/PoemGen/PoemGen.htm, o quest’altro fatto addirittura in Scratch che lavora per sottrazione da una poesia di Walt Whitman: https://scratch.mit.edu/projects/12331423/) almeno di inventare ricette sempre nuove, che tutto sommato sono sempre forme di testo vincolate, come questa: http://www.lynxlab.com/staff/steve/public/ricette.

Per restare nel dominio letterario, due modesti esempi di macchine figlie di quella di Queneau (ma che pescano nel testo di due classici sempreverdi come l’Inferno di Dante Alighieri e l’Orlando Furioso di Ludovico Ariosto) li trovate qui http://www.lynxlab.com/staff/steve/public/inferno e qui http://www.lynxlab.com/staff/steve/public/orlando. Oltre a Queneau, questi due oggetti digitali si ispirano più precisamente a “Il centunesimo canto. Philologica dantesca“di Luca Chiti, che è un meraviglioso esempio di centone umoristico che “crea” un intero canto giustapponendo versi esistenti ma dandogli un senso completamente nuovo. Per realizzarli, ho dovuto affrontare problemi letterari, come la definizione di rima, di struttura metrica, di novità e ripetizione (oltre che qualche problema informatico, come il loop infinito o la conversione dei caratteri in UTF-8). Non ho seguito alla lettera le indicazioni di Nanni Balestrini, ma ci sono andato vicino. Ed ecco apparire terzine più o meno improbabili come la seguente:

Parlando cose che ‘l tacere è bello
rispuosemi: «non omo, omo già fui
venimmo al piè d’un nobile castello

o come questa:

Nel nome che sonò la voce sola
poscia vid’io mille visi cagnazzi
cosí vidi adunar la bella scola

Una valutazione estetica del risultato? Non è l’obiettivo, anche se può essere divertente provare e riprovare, fino a far emergere dei frammenti di senso che possono essere anche divertenti. Ma quelle che mi paiono importanti, come sempre, sono le domande che emergono ogni volta che si prova a realizzare un modello funzionante di una teoria: come si riconosce una rima? Come si produce una struttura metrica? Come si ottiene un testo casuale sempre diverso? Come si riconosce che il testo non è stato scritto da un poeta umano?

Mi sembrano tutte domande legittime da porsi in una classe che studia letteratura: portano con sé riflessioni e discussioni che integrano, anche se non sostituiscono, l’apprendimento di nomi di forme di testo come “trimetro scazonte” o “endecasillabo sciolto” o di opere particolari.

E ancora una volta mostrano come la costruzione reale di un programma possa essere un’attività didattica sensata al di là di ogni mitologia computazionale.

 

Un elefante, sei ciechi e quattro saggi

Gen
12

Warning: count(): Parameter must be an array or an object that implements Countable in /web/htdocs/www.stefanopenge.it/home/wp/wp-includes/formatting.php on line 3361

Costruire teorie sperimentali con il Coding

Nov
07

Tra le tante ragioni usate per giustificare la pratica (anticipata) del Coding, quella che mi pare più sensata per la scuola è la possibilità che viene data agli studenti di costruire in maniera sperimentale una teoria di un dominio. Per esempio: come funziona il ciclo dell’acqua? Perché a volte i semi germogliano ma poi si seccano? Quando va usato il congiuntivo?

Costruire una teoria significa capire, ma capire ad un livello diverso da “apprendere una regola o una formula”. Costruire in maniera sperimentale significa arrivare un po’ alla volta alla teoria giusta, provando modi diversi di mettere in relazione parametri e vedendo immediatamente, sensibilmente, il risultato.

Questo modo di apprendere è reso possibile dall’esistenza dei computer, nella loro essenza di artefatti digitali programmabili, e dalla loro accessibilità per gli studenti. Esistono esempi meravigliosi di simulazioni digitali  in campi diversi, ma che di solito hanno il difetto di essere chiuse, cioè non programmabili. Si riesce a intuire quali sono le regole in gioco, a verificarne le relazioni, ma non a formalizzarle.

Il coding ha senso in questo contesto a patto di avere presente dove si va a parare fin dall’inizio, e a patto di non fermarsi ai primi passi. E’ praticabile in tempi ragionevoli se si hanno a disposizione degli ambienti programmabili non vuoti, cioè in cui le regole del dominio sono già cablate. E’ utile se dopo la fase di scoperta e costruzione della teoria in un ambito limitato si passa alla sua estensione e riapplicazione in altri domini.

Passo 1. Se creo una storia animata usando un programma di disegno, che permette di aggiungere suoni e musiche e di muovere sprites sullo schermo, sto facendo quello che potrei fare a mano, con infinita fatica e molti più errori, disegnando su una pellicola. Quella storia avrà sempre lo stesso svolgimento non importa quante volte la esegua. Per creare la storia devo aver già chiare le regole dell’ambiente.
Cosa sto imparando? Ad usare certi strumenti, punto. Se programmo questa storia, sto imparando ad usare altri strumenti e concetti (ripetizione, spostamento) ma niente di più.

Passo 2. Se invece ho un ambiente dinamico, in cui succedono delle cose (immaginiamo un gioco: arrivano mostri, si presentano nuovi ostacoli etc) e devo muovere manualmente un personaggio, quello che succede dipende dalle mie azioni e ogni volta è diverso. Se il mostro si avvicina troppo, mi mangia. Ma se sta esattamente sopra di me, in verticale, gli posso sparare. Che invece di spostare il personaggio manualmente utilizzando un joystick, un mouse o un touchscreen io possa scrivere un comando per spostarlo non cambia molto le cose, ma è un primo passo.
Cosa sto imparando qui? A individuare i parametri e a stimare intuitivamente i valori di soglia di questi parametri cui devo reagire. Bene, ma ancora non basta.

Passo 3. Il tutto diventa interessante solo quando riesco a programmare il personaggio non in modo che esegua sempre lo stesso movimento, ma in modo che esegua un movimento diverso in funzione della situazione.

Senza scomodare l’intelligenza artificiale, posso definire delle semplici regole:

  1. se c’è un mostro nella linea di tiro, spara
  2. se il mostro si avvicina troppo, spostati verso l’area dove ci sono meno mostri

Bisogna definire cos’è la linea di tiro, quanto è grande e come si verifica la sicurezza di un’area, eccetera. Cosa si sta imparando qui? A costruire una strategia che sia buona in qualsiasi situazione. Per costruire la strategia bisogna non solo individuare i parametri dell’ambiente più significativi ma anche definire in maniera precisa i valori di soglia, e poi stabilire le azioni migliori per far fronte alla situazione definita dal superamento di quei valori, cioè bisogna costruire una teoria. Il fatto che io debba programmare questa strategia mi obbliga a formalizzarla e a verificarla. La possibilità di rappresentarla in un codice sorgente mi permette di discuterla con gli altri, di rivederla in un momento successivo, di correggerla, di generalizzarla.

Non è tanto importante l’apprendimento delle tecniche di programmazione – che però sono funzionali alla costruzione della teoria e alla sua verifica immediata – , quanto il fatto che questo approccio permette di affrontare domini (che tradizionalmente mi chiederebbero di imparare in maniera fideistica certe nozioni, per esempio che l’accelerazione di gravità sulla Terra è 9,8 m/s) in una maniera costruttiva, esperienziale e collaborativa. Posso sperimentare direttamente la relazione tra certe cause e certi effetti, come potrei fare anche nel mondo reale se avessi risorse a sufficienza o se potessi accelerare o rallentare il tempo (come faceva Galilei). Il fatto che la mia teoria sia scritta in una forma eseguibile facilità sia la verifica immediata, sia il confronto con gli altri.

Per esempio, ho un seme. Se c’è sole e acqua, il seme germoglia e nasce un fiore. Se c’è acqua, ma non sole, il seme germoglia ma non nasce il fiore. Se c’è sole, ma non acqua, il fiore crepa. I parametri qui sono luce e umidità; i valori soglia li devo scoprire. E poi devo trovare le azioni che permettono al mio seme di fornire la performance migliore (innaffiare, drenare, coprire, illuminare). Se riesco a programmare queste azioni significa che ho costruito una teoria dell’ambiente. Non: ho costruito una teoria perché avevo imparato le regole, ma: costruendo una teoria ho capito le regole.

Ci sono infinite applicazioni possibili. Papert ha pensato alla geometria piana, ma si può spaziare dalla fisica alla biologia, dalla storia alla grammatica, dalla musica alla lingua due. Forse all’inizio potrà sembrare bizzarro concepire lo studio della lingua in maniera sperimentale, ma niente lo vieta. L’importante è che ci siano delle regole che producono effetti (diacronici o sincronici) e che queste regole si possano inserire in un ambiente che ne mostra gli effetti. E’ vero che le “regole” in ambito linguistico hanno tantissime eccezioni, mentre la fisica ci ha abituato a situazioni più lineari; ma si può immaginare una lingua artificiale senza eccezioni dove si possa sperimentare in assenza di attrito, o un universo fantastico dove le carestie portino inevitabilmente alle guerre. In fondo, la geometria euclidea o la logica aristotelica sono nate con la stessa idea di fare astrazione dai dettagli reali per arrivare più facilmente ai concetti e alle regole chiave.

Far costruire agli studenti un ambiente del genere partendo da zero è troppo complesso. Per farlo bisognerebbe sapere in anticipo quali sono i parametri fondamentali e la loro relazione, che invece dovrebbe essere l’obiettivo dell’attività. Sarebbe molto meglio avere a disposizione un ambiente con le sue regole già cablate (ma ispezionabili, o addirittura modificabili), che però mi permettesse di programmare le azioni con cui interagisco con l’ambiente. Che so: un ambiente in cui la relazione tra massa e peso è definita, in cui però il tempo si possa rallentare a piacere o la resistenza dell’aria azzerare.

Passo 4. Non si tratta di ricostruire tutto il sapere a forza di esperimenti. Una volta capito il meccanismo dell’elaborazione di teorie, si può cercare di capire se esistono delle invarianti che mi permettono di applicare uno schema che ha funzionato una volta anche in situazioni diverse. Per far questo, devo catalogare i miei schemi in funzioni delle caratteristiche delle situazioni che ne suggeriscono l’applicazione. Naturalmente questa è la parte più difficile. Ma la fase metacognitiva (cosa abbiamo scoperto? come potremmo riusarlo) è altrettanto importante di quelle precedenti e la competenza nell’applicazione di schemi a situazioni nuove è in fondo l’obiettivo che giustifica tutta l’educazione.

Passo 5. Inoltre gli schemi si possono rendere più potenti, grazie ad elaborazioni formali (generalizzazioni, trasformazioni). Qui forse vale la pena non provare a inventare tutto, ma sfruttare le esperienze di quelli che hanno già studiato e sperimentato prima di noi. Ma si inverte l’ordine tradizionale: prima si capisce, sperimentando in un ambiente semplificato e controllato,  quali sono le regole di fondo, e solo dopo si imparano i trucchi che permettono di riapplicarle in maniera estesa e rapida. Non mi si chiede di imparare prima i prodotti notevoli e poi, forse, capire a cosa mai possono servire, ma il contrario.

Serve necessariamente un computer e un ambiente di programmazione semplificato per praticare questo tipo di didattica? No, certo. Ma senza un ambiente digitale programmabile questo approccio sarebbe talmente difficile e lungo che in pratica si finisce per non applicarlo quasi mai.