Introduzione al linguaggio REBOL - Parte 1

Mario Cassani
04 Dicembre 2005

Contents:

1. Linguaggi e traduttori

1.1 Premesse e caratteristiche

La presente guida introduttiva al linguaggio REBOL deriva dalle mie esperienze di insegnamento alle seconde classi del Liceo Scientifico presso la scuola per cui lavoro.

Lo utilizzo per dimostrare l'algebra di Boole (la logica) e la propagazione degli errori oltre che per introdurre le basi della programmazione. Il presente testo rispecchia queste necessita', almeno nelle parti iniziali. Questo permette di essere operativi in breve tempo senza approfondire subito tutti gli aspetti, per esempio, delle variabili e passare velocemente alla grafica per permettere anche a chi e' alle prime armi di vedere subito qualcosa di concreto materializzarsi sullo schermo.

Ritengo che questi siano gli obiettivi che chi si accosta per le prime volte alla programmazione cerchi in una guida.

I piu' esperti che sanno gia' programmare in altri linguaggi non dovrebbero comunque sottovalutare le nozioni iniziali perche' il REBOL e' un linguaggio molto particolare per il quale i dati sono programma ed il programma e' costituito da dati.

La scelta del REBOL, oltre che dalla mia passione per questo linguaggio, deriva da tre importanti motivi:

1. Il REBOL e' compatto e puo' essere trasportato su un dischetto insieme a svariati programmi scritti nel linguaggio medesimo
2. Il REBOL e' multipiattaforma ovvero puo' funzionare su tanti computer e sistemi oprativi diversi tra cui Windows, Apple e Linux
3. Il REBOL e' studiato per risultare simile al linguaggio naturale. Una volta presa dimestichezza con i meccanismi del linguaggio diventa semplice realizzare programmi complessi con poco sforzo

1.2 Nozioni preliminari

Il REBOL e' un linguaggio interpretato. Questo significa che il programma che scriviamo non viene trasformato nel linguaggio della macchina prima di essere eseguito.

L'interprete REBOL si occupa di fare, appunto, da traduttore tra il programma e la macchina. Il paragone con un interprete che accompagna delle persone di lingua straniera rende l'idea.

Vi sono due interpreti gratuiti di REBOL: il REBOL/Core, completamente testuale, ed il REBOL/View, che include delle funzioni grafiche e di interfaccia.

Entrambi gli interpreti sono interattivi e possono essere utilizzati, oltre che per eseguire direttamente dei programmi, anche nella modalita' di interazione con il programmatore. In altre parole noi possiamo scrivere una istruzione alla volta e ricevere dall'interprete REBOL informazioni su quello che sta accadendo e si mette in attesa di nuove istruzioni permettendoci di fare con facilita' il debugging ovvero l'eliminazione degli errori di programmazione.

Visto che il REBOL ce lo permette, mentre impariamo, teniamoci l'interprete aperto, inseriamo gli esempi del corso e facciamo delle prove, altrimenti le informazioni non entrano in testa o non ci rimangono per molto.

Usiamo il REBOL/View che si puo' scaricare da Internet al seguente indirizzo:

http://www.rebol.com/view-platforms.html

1.2.1 L'interprete interattivo

Lanciamolo, comparira' un'interfaccia grafica. Seguiamo le istruzioni a schermo e passiamo a "Console":

REBOL/View 1.3.1.4.2 9-Aug-2005 Core 2.6.0
Copyright 2000-2005 REBOL Technologies.  All rights reserved.
REBOL is a trademark of REBOL Technologies. WWW.REBOL.COM
>>

L'interprete ci dice di che tipo sia (/View), in che versione (1.3.1 per Linux: .4.2) la data di distribuzione del linguaggio e su quale versione di /Core e' basato (2.6.0) infatti il /View e' costruito sul /Core. Mostra poi il "prompt" interattivo:

>>

che indica che l'interprete e' in attesa di istruzioni.

1.2.2 Gli errori

Scriviamo qualcosa di "assurdo":

>> Buongiorno!
** Script Error: Buongiorno! has no value
** Where: halt-view
** Near: Buongiorno!
>>

Il REBOL ci restituisce delle informazioni (evidenziate con **) che, in questo caso, sono relative ad un errore, per poi tornare in modalita' interattiva (con il solito >>).

Anche se scritto in inglese il messaggio di errore e' prezioso con le informazioni che ci fornisce.

La prima riga parla di uno "Script Error:", errore del programma, poi specifica l'errore dicendo che: "Buongiorno! has no value" cioe' che Buongiorno! non ha valore.

L'interprete capisce solo cio' che e' proprio del linguaggio o quello che gli "spieghiamo" noi scrivendo il programma.

La seconda riga ci dice DOVE ("Where:", in inglese) si e' verificato tale problema. In questo caso "halt-view" ci indica che e' avvenuto mentre l'interprete /View era in modo interattivo.

La terza riga e' quella che ci mostra vicino ("Near:", in inglese) a quale istruzione ha riscontrato l'errore.

1.2.3 Gli script

Se uscissimo dall'interprete tutto quello che abbiamo scritto verrebbe "dimenticato" dal REBOL e, per eseguire le stesse istruzioni, dovremmo riscrivere tutto dall'inizio.

Per ovviare a questo problema gli interpreti possono lavorare con degli "script", ovvero delle sequenze di istruzioni e comandi, dei programmi memorizzati in file di testo.

Vediamo un semplicissimo script che scrive, stavolta senza errori, il "Buongiorno!" visto sopra. Possiamo scriverlo in un testo e salvarlo in un file di testo nome saluto.r

REBOL [
    Title: "Scrive un saluto"
    Author: "Mario Cassani"
]

print "Buongiorno!"

La prima parte si chiama "Header", intestazione e specifica qualche informazione relativa al programma. In questo caso, estremamente conciso, vengono indicati solo il titolo ("Title:", in inglese) e l'autore ("Author:", in inglese) dello script.

Da notare che il titolo e l'autore sono riportati tra virgolette: "Scrive un saluto" e "Mario Cassani".

La seconda parte, che e' lo script vero e proprio, contiene solo un'istruzione che stampa ("print", in inglese) una sequenza di caratteri (inclusa tra virgolette).

ATTENZIONE!

Si usa, come convenzione, mettere un apostrofo prima dei comandi
del linguaggio scritti all'interno di una frase:

Posso stampare con il comando 'print seguito da un argomento

'halt viene spiegato più sotto

L'apostrofo indica che stiamo usando una parola (word) del linguaggio
REBOL, come spiegato più sotto.
Tale apostrofo va omesso quando si fornisce come comando o istruzione
al linguaggio REBOL.

1.2.3.1 Esecuzione di uno script

Se facessimo eseguire il programma scrivendo, da linea di comando:

rebol.exe saluto.r

o trascinando il file saluto.r sull'interprete rebol.exe, otterremmo di veder scritto:

Buongiorno!

In realta' la cosa, tranne con Linux da linea di comando, avviene in modo talmente rapido che, forse, si riesce ad intravedere una finestra che si apre e si chiude quasi istantaneamente. Questo avviene perche' l'interprete, una volta eseguito il suo compito, esce e si chiude.

Per ovviare a questo problema dobbiamo chiedere all'interprete di fermarsi in attesa di istruzioni, cioe' passare in modalita' interattiva.

Infatti, quando esegue gli script, l'interprete "perde" la propria interattivita' ed esegue il programma "tutto in un fiato".

1.2.3.2 L'istruzione 'halt

L'istruzione che ci permette di far fermare in modo interattivo anche uno script e' la 'halt. Andiamo pertanto a scriverla in fondo al nostro script saluto.r:

REBOL [
    Title: "Scrive un saluto"
    Author: "Mario Cassani"
]
print "Buongiorno!"
halt

Provate!

1.2.3.3 I commenti

Quando comincio a scrivere script, programmi, di una certa lunghezza potrebbe tornarmi utile, per poi capire in un secondo tempo cosa ho scritto e per quale ragione, aggiungere dei commenti cioe' delle frasi che non vengano interpretate dal REBOL ma "saltate". Per farlo usiamo il punto e virgola all'inizio di ciascun commento (non necessariamente l'inizio di una nuova riga).

Commentiamo lo script appena visto:

REBOL [
    Title: "Scrive un saluto"
    Author: "Mario Cassani"
]
; Stampa un saluto
print "Buongiorno!"
halt ; Questo ferma il REBOL in modo interattivo
; Serve per non far chiudere tutto senza lasciarci il tempo di leggere.

Non cambia nulla, eseguendo il programma, ma noi possiamo segnarci degli "appunti" all'interno del programma

2. Valori e dati

Come anticipato nelle premesse con il REBOL i dati sono programma ed il programma e' costituito da dati.

Cerchiamo di movere i primi passi per capire cosa significhi questa affermazione.

2.1 Variabili

Quando scriviamo un programma potremmo non sapere sin dall'inizio che valori utilizzare oppure ne potremmo voler usare alcuni che possano cambiare nel tempo o, ancora piu' semplicemente, essere previdenti e predisporre tutto in modo che, basti cambiare qualche riga, per avere comportamenti diversi del programma rendendolo piu' flessibile.

Questa e' una cosa comune, in un linguaggio di programmazione ed il REBOL non trascura questo importante meccanismo analogo a quello dell'algebra e della matematica dove si usano le espressioni.

Le variabili sono dei valori che possono cambiare nel tempo o in base alla situazione. Possono essere predeterminate o decise al momento dell'esecuzione del programma.

2.1.1 Assegnamento

Apriamo l'interprete, senza usare uno script ed, essendo in modalita' interattiva, assegnamo un valore ad una variabile.

Per assegnare il valore usiamo i due punti ":" che devono essere attaccati al nome della variabile e separati dal valore da almeno uno spazio:

>> saluto: "Buongiorno!"
== "Buongiorno!"
>>

La variabile in questione si chiama "saluto" ed il valore che le assegneremo e' una sequenza di caratteri (che va quindi inclusa tra le virgolette): "Buongiorno!".

Il REBOL stampa (seconda riga) il valore restituito dall'operazione che si chiama assegnamento di variabile ovvero: ad un nome di variabile si associa un valore.

Se omettessimo i due punti

>> saluta "Buongiorno!"
** Script Error: saluta has no value
** Where: halt-view
** Near: saluta "Buongiorno!"
>>

le virgolette

>> saluta: Buongiorno!
** Script Error: Buongiorno! has no value
** Where: halt-view
** Near: saluta: Buongiorno!
>>

o mettessimo degli spazio di troppo

>> saluta : Buongiorno!
** Syntax Error: Invalid word-get -- :
** Near: (line 1) saluta : Buongiorno!
>>

avremmo, ovviamente, degli errori.

Ho usato la variabile "saluta" perche', se non usciamo da REBOL la variabile "saluto" e' gia' assegnata e, in alcuni casi, non restituirebbe errori.

Bisogna fare anche attenzione ai nomi che si scelgono per le variabili evitando di utilizzare quelli già utilizzati per altri scopi come, per esempio: print.

Invito il lettore a ripetere gli esempi qui sopra con la variabile "saluto" per prendere confidenza con quello che accade.

Il REBOL quando trova dei valori che non sono istruzioni (ovvero che non gli fanno eseguire un'azione) ma valori o variabili passa oltre senza errore. In modalita' interattiva l'unica cosa che fa, in questi casi, e' di informarci sull'ultimo valore con un:

== "Ultimo valore"

Giunti a questo punto non ci resta che verificare cosa accade se chiediamo al REBOL di stampare la variabile:

>> print saluto
Buongiorno!
>>

notate che, di seguito al nome della variabile, non compaiono i due punti perche' non stiamo assegnandole un valore ma lo stiamo usando, "leggendo".

Lascio al lettore la verifica e la comprensione di cosa accade scrivendo:

>> print saluto: "Buonanotte!"

2.1.2 Tipi

Le variabili possono contenere qualcosa di diverso da una stringa (ovvero la sequenza di caratteri tra virgolette). Potremmo aver bisogno di usare numeri o, per i primi esempi che ci saranno utili, anche delle variabili logiche.

2.1.2.1 Stringhe

Prima di arrivare qui ci sono già capitate le sequenze di caratteri, le stringhe.

Questo tipo di dato va indicato utilizzando qualcosa che racchiuda l'inizio e la fine perché, nelle sequenze, potrebbero esseci degli spazi ed il REBOL si confonderebbe su dove termini un dato e dove ne inizi un altro.

>> "Stringa significa: Sequenza di caratteri"
== "Stringa significa: Sequenza di caratteri"
>>

Il sistema che abbiamo già visto é quello delle virgolette ma, in situazioni particolari, potremmo desiderare di inserire nella sequenza dei caratteri speciali. Banalmente potremmo voler mettere nella stringa le virgolette:

>> "Stringa significa: "Sequenza di caratteri""
** Script Error: Sequenza has no value
** Where: halt-view
** Near: Sequenza di caratteri ""
>>

cosa é successo? Perchè il REBOL ci restituisce un errore?

Osservando bene cosa abbiamo scritto dopo i due punti c'é uno spazio e poi delle virgolette.

Il REBOL crede che la stringa sia terminata e cerca di interpretare la parola Sequenza che, però, non ha alcun significato (istruzione) o valore (variabile).

Riproviamo così:

>> {Stringa significa: "Sequenza di caratteri"}
== {Stringa significa: "Sequenza di caratteri"}
>>

Usando le parentesi graffe tutto torna a funzionare.

NOTA

Chi avesse utilizzato altri linguaggi sarebbe portato ad usare le
doppie virgolette. Questo non funziona con il REBOL

2.1.2.2 Numeri

Scriviamo, nell'interprete interattivo, un numero:

>> 25
== 25
>>

e vediamo che viene considerato un valore valido.

Scriviamo adesso un numero con la "virgola" (gli inglesi usano il punto per i decimali e noi dovremo fare la stessa cosa):

>> 2.5
== 2.5
>>

risulta anche questo valido ed, infatti, viene stampato come risultato.

Questo significa che il REBOL elabora quello che scriviamo e restituisce un risultato a meno che non rilevi un errore.

2.1.2.3 Valori logici, l'amico Boole

Sappiamo che una proposizione può essere vera o falsa.

Se dicessi che la luna é quadrata direi qualcosa di falso.

Se dicessi che la somma di 2 e di 3 vale 5 direi qualcosa di vero.

In REBOL usiamo l'inglese quidni vero diventa 'true e falso si scrive 'false:

>> true
== true
>> false
== false
>>

o, addirittura:

>> 2 + 3 = 5
== true
>>

Posso avere dei valori logici da un confronto.

2.1.2.4 Andiamo un po' oltre

Abbiamo visto le sequenze di caratteri, dette stringhe, i numeri, sia interi che decimali e i valori logici.

Posso definire delle variabili con ciascuno di questi tipi:

>> stringa1: {Sequenza di caratteri}
== "Sequenza di caratteri"
>> stringa2: "Sequenza di caratteri"
== "Sequenza di caratteri"
>> numero-i: 25
== 25
>> numero-d: 2.5
== 2.5
>> logico: true
== true
>>

notiamo che, al REBOL, basta che quello che scriviamo abbia un senso e sia scritto correttamente (virgolette, graffe, punto decimale al posto della virgola...) e tutto fnziona per il meglio.

2.1.2.5 L'istruzione 'type?

Cerchiamo di capire un po' di più dei tipi usando il comando 'type? come segue:

>> type? {Sequenza di caratteri}
== string!
>> type? "Sequenza di caratteri"
== string!
>> type? 25
== integer!
>> type? 2.5
== decimal!
>> type? true
== logic!
>>

Impariamo così che, in REBOL, i tipi si chiamano, rispettivamente:

1. Stringa: 'string!
2. Numero Intero: 'integer!
3. Numero Decimale: 'decimal!
4. Valore Logico: 'logic!

Il comando 'type? finisce con un punto interrogativo perchè, quando lo scrivo, é come se chiedessi all'interprete: di che tipo é...?

I nomi dei tipi, invece, sono seguiti da un punto esclamativo, come a rafforzare la dichiarazione del tipo.

Questa, ovviamente, é una convenzione, la cosa più importante é la seguente:

Non devo usare nomi di variabili uguali a quelli dei comandi o dei tipi
altrimenti "cancello" il comando o il tipo.

2.1.2.6 Il tipo cambia: niente di male!

Il nostro interprete, ovviamente, non si scandalizza neanche se facciamo cose strane come questa:

>> stringa1: "25"
== "25"
>> stringa1: 25
== 25
>>

ovviamente:

>> type? stringa1: "25"
== string!
>> type? stringa1: 25
== integer!
>>

perchè non é il nome della variabile a darle il tipo e neanche il primo valore che assume, ma quello che le é assegnato nel momento in cui andiamo a verificare:

>> type? stringa1
== integer!
>>

perchè, non avendo più cambiato il valore, continua a rimanere un intero, un 'integer!

2.1.2.7 Conclusioni

Esistono anche dei tipi più complessi ed articolati ma, per ora, ci basti sapere che:

1. Il REBOL riconosce i tipi dal modo in cui vengono scritti
2. Le variabili in REBOL possono passare da un tipo ad un altro senza doverlo stabilire a priori
3. Possiamo stabilire il tipo di un valore o di una variabile usando 'type?

2.2 Word

Il REBOL, a differenza di molti altri linguaggi, non ha delle "parole chiave" che non e' possibile ridefinire con una variabile o una funzione (vedremo il concetto di funzione in seguito).

Se scrivessimo:

>> print "ciao"
ciao
>> print: "Stampa"
== "Stampa"
>> print "ciao"
== "ciao"
>>

cerchiamo di capire cosa e' accaduto.

Nella prima riga dico a REBOL di stamparmi la stringa "ciao" e lui esegue la cosa scrivendo

ciao

senza virgolette.

Poi assegno alla parola print il valore stringa "Stampa" ed il REBOL mi restituisce come risultato la stringa "Stampa".

Ebbene abbiamo, a tutti gli effetti, fatto un assegnamento di variabile alla print che, da istruzione, o comando, e' diventata una variabile stringa.

Infatti, richiedendo al REBOL di stampare la stringa lui mi restituisce la stringa come valore, con il == e le virgolette.

Il comando 'print e' di fatto "scomparso" ed e' stato sostituito da un valore, diventando percio' una variabile e non un'istruzione.

Il REBOL usa dei simboli, non delle parole chiave intoccabili.
Associa al simbolo un valore (variabile) o una funzione (comando)
e cerca di interpretare tutto quello che gli viene "passato".

se al simbolo non corrisponde nessun valore o funzione otterremo un errore.

Le word possono vengono interpretate indipendentemente dal
fatto che siano scritte in maiuscolo o minuscolo ed, oltre alle
lettere, possono contenere solo alcuni altri caratteri:

+ - ` * ! - & . ?

NON sono accettati, invece, questi caratteri:

@ # $ % ^ ,

Va anche detto che:

Le word terminano con uno spazio, un a-capo o uno dei seguenti
caratteri:

[ ] ( ) { } " : ; /

Anche le word sono dei tipi e vengono indicati precedendole con un'apostrofo:

>> type? 'simbolo
== word!
>>

ecco spiegato il motivo per cui, i comandi, vengono scritti all'interno di una frase con l'apostrofo davanti, per far capire che sono simboli riconosciuti dal REBOL.

>> type? 'simbolo
== word!
>> simbolo "Ciao"
** Script Error: simbolo has no value
** Near: simbolo "Ciao"
>> type? 'print
== word!
>> print "Ciao"
Ciao
>>

Tutto cio' che e' preceduto da un'apostrofo costituisce un valore di tipo 'word! ma, se non ha assegnato nessun valore o funzione, come nel caso di 'simbolo, ci viene restituito un errore che dice che il simbolo 'simbolo non ha valore.

In questo senso si dice che, in REBOL, i dati sono programma ed il programma e' costituito da dati.

3. Stampare e controllare i valori

Quando non siamo in modalita' interattiva diventa indispensabile avere la possibilita' di stampare sullo schermo delle informazioni, sia quando esse siano delle semplici frasi o valori che quando siano il risultato di qualcosa che viene eseguito nel nostro programma.

3.1 Differenza tra 'probe e 'print

'probe stampa il valore e lo ritorna al programma che lo usa (come se non ci fosse scritto probe) 'print stampa il valore e se lo tiene senza restituire niente al programma

Apriamo l'interprete (insisto: le prove vanno fatte di persona) e facciamo qualche esperimento:

>> frase: "Mi chiamo Mario"
== "Mi chiamo Mario"
>>

Assegnamo alla variabile 'frase un valore di tipo string! (ovvero una sequenza di caratteri).

>> print probe frase
"Mi chiamo Mario"
Mi chiamo Mario
>>

La 'print si aspetta un valore da stampare. La 'probe si aspetta un valore da stampare e noi le diamo la variabile 'frase.

La 'probe stampa la variabile e la passa a 'print, come se 'probe fosse lei stessa la variabile 'frase.

>> probe print frase
Mi chiamo Mario
** Script Error: probe is missing its value argument
** Near: probe print frase
>>

La 'probe si aspetta una variabile da stampare e restituire al programma.

La 'print pure e si prende 'frase ma, dopo averla stampata, non la passa più al programma e la 'probe da' errore perchè le manca il valore da stampare.

>> probe probe frase
"Mi chiamo Mario"
"Mi chiamo Mario"
== "Mi chiamo Mario"
>>

La prima 'probe si aspetta una variabile da stampare e da passare al programma.

L'altra 'probe si aspetta una variabile da stampare e da passare al programma e trova 'frase.

La stampa e la passa al programma in modo che la prima 'probe la stampi e la passi nuovamente al programma infatti, alla fine, esce:

== "Mi chiamo Mario"

che, come avevamo visto, é il modo che ha il REBOL in modalità interattiva per far vedere che ha un risultato dell'operazione.

Oltre a questo, osservando bene, la 'print stampa senza le virgolette mentre la 'probe stampa anche quelle. Questo accade perche' la 'probe non stampa un risultato ma un valore puro, con le sue caratteristiche. La variabile 'frase contiene una string!, caratterizzata dall'essere compresa tra virgolette o parentesi graffe per cui stampa le virgolette per permettere al programmatore di capire con che tipo di valori sta lavorando.

3.2 L'istruzione '??

Proseguendo dall'esempio precedente, senza chiudere l'interprete, possiamo stampare la variabile 'frase in un altro modo:

>> ?? frase
frase: "Mi chiamo Mario"
== "Mi chiamo Mario"
>>

L'istruzione '?? stampa la variabile mostrandone l'assegnamento e ne restituisce il valore che, infatti, compare come risultato in modalita' interattiva:

== "Mi chiamo Mario"

4. Un po' di algebra di Boole

Abbiamo visto il tipo logico, 'logic! parlando delle variabili. Definiamone un paio:

>> a: true
== true
>> b: false
== false
>>

A questo punto vediamo cosa ci possiamo fare.

4.1 Gli operatori logici

Illustriamo di seguito, con degli esempi, quali istruzioni logiche possiamo usare con i valori 'true (vero) e 'false (falso).

Il titolo indica l'operatore seguito dalle definizioni utilizzate in logica, algebra o matematica per richiamare i relativi concetti a quanti li conoscessero gia'.

4.1.1 L'istruzione 'and - La moltiplicazione logica - ET

>> a and b
== false
>> a and a
== true
>> b and a
== false
>> b and b
== false
>>

Per ottenere un risultato "vero", entrambi i valori o variabili devono essere "veri".

4.1.2 L'istruzione 'or - La somma logica - VEL

>> a or b
== true
>> a or a
== true
>> b or a
== true
>> b or b
== false
>>

Per ottenere un risultato "vero", almeno uno dei valori o variabili deve essere "vero"

4.1.3 L'istruzione 'xor - La mutua esclusione logica - AUT-AUT

>> a xor b
== true
>> a xor a
== false
>> b xor a
== true
>> b xor b
== false
>>

Per ottenere un risultato "vero", solo uno dei valori o variabili deve essere "vero"

4.1.4 L'istruzione 'not - La negazione logica - NON

>> not a
== false
>> not b
== true
>> not not a
== true
>> not not b
== false
>>

Non fa altro che invertire il valore logico.

4.1.5 Combinare gli operatori logici

Ovviamente si possono anche usare piu' operatori. Aiutiamoci con le parentesi:

>> (not a) and a
== false
>> (not b) and b
== false
>> (not b) or b
== true
>> (not b) xor b
== true
>> (not a) or (b and a)
== false
>> (not b) or (b and a)
== true
>>

4.2 Confrontare dei valori logici

Utilizzando l'operatore di uguaglianza possiamo verificare se dei valori, delle variabili o i risultati di un'operazione logica siano

>> true = a
== true
>> false = b
== true
>> true = b
== false
>>

In altre parole, nell'ordine:

• Risulta vero che 'a sia vero
• Risulta vero che 'b sia falso
• Risulta falso che 'b sia vero

Possiamo anche fare confronti piu' articolati:

>> (a or b) = true
== true
>> (a and b) = false
== true
>> (a and a) = false
== false
>> (a and a) = (a or b)
== true
>>

Tutto questo ci sara' estremamente utile per la prossima lezione ed e' molto importante comprendere gli operatori Booleani.

Ricordo ancora che la sperimentazione aiuta, oltre che a memorizzare, anche a capire.

Con quanto abbiamo visto fino ad ora non c'e' alcun rischio di
perdere dati o documenti sul computer.