• FORWARD  (che si abbrevia con FD)  numero passi per camminare avanti
• BACKWARD (che si abbrevia con BK)  numero passi per camminare indietro
• RIGTH (che si abbrevia con RT)  gradi di rotazione per ruotare a destra
• LEFT (che si abbrevia con LT)  gradi di rotazione per ruotare a sinistra
• PENUP  (che si abbrevia con PU) per disattivare la visualizzazione della scia
• PENDOWN (che si abbrevia con PD) per attivare la visualizzazione della scia

• HOME che riporta la tarta nella posizione iniziale sfondo, ecc.
• CLEAN che ripulisce la finestra grafica lasciando la tarta nella posizione in cui si trova
• CLEARSCREEN che è la composizione  ordinata dei due comandi precedenti
• CLEARTEXT che ripulisce la finestra testuale
• FENCE  che blocca la tartaruga ai margini della finestra grafica
• WRAP che consente alla tartaruga  di considerare il mondo su cui opera avvolto su se stesso (un toro)

Prendiamo adesso confidenza con il programma MSW LOGO, che si scarica gratuitamente dalla rete  all’indirizzo www.softronix.com/logo.html e che ci servirà per introdurci concretamente al suo uso.
Una volta messo in funzione, si notano due finestre: la  MSWLogo Screen  dove lavora la tartaruga e la Commander arricchita da pulsanti e da una riga di comando in fondo.
Se su questa scriviamo:
fd 50
rt 90
fd 50
repeat 4 [fd 50 rt 90 ]
vedremo il nostro cursore percorrere il cammino indicato lasciando la sua traccia.
Un comando come:
cs
o un clic sul pulsante Reset ci riporta alle condizioni iniziali.
 Nella finestra Screen possiamo scegliere vari menu a tendina. Cominciamo illustrando il Set. Possiamo scegliere la dimensione del tratto di penna o Pensize …. e poi scrivere sulla riga di comando:
pensize
per sentirci rispondere qualcosa del tipo:
You don't say what to do with [6 6]
In questo modo abbiamo saputo però quali sono le dimensioni della penna. Notiamo che il nostro LOGO non usa la prima coordinata. Infatti  alla successione di comandi:
setpensize [10 20]
show pensize
avremo come risposta:
[20 20]
Possiamo adesso, per prender confidenza con i colori  provare la seguente successione di comandi:
setpencolor [0 0 0]
setpensize [30 30]
repeat 4 [fd 100 rt 90]
setpencolor [0 0 255]
setpensize [20 20]
repeat 4 [fd 100 rt 90]
Allo scopo possiamo digitarne uno alla volta nella riga di comando oppure possiamo scegliere dal menu File la voce Edit e attivare il pulsante OK. O ancora, scegliere il pulsante Edall. Entriamo così nell’ambiente di edit dove ci vengono proposte due righe da completare:
to
end
Cancelliamole e scriviamo tutta la successione di comandi precedente. Possiamo poi selezionarne una alla volta,  o il numero che desideriamo, e attivare il menu Test.
Il comando:
setscreencolor [0 255 255]
cambierà il colore dello schermo sovrapponendosi alla figura tracciata. Possiamo scegliere di riproporre la figura precedente, cosa più semplice se abbiamo usato l’editor.
Osserviamo come il colore si esprima al solito con le tre componenti rosso, verde, blu.  Il comando:
setfloodcolor [255 0 0]
serve infine per “riempire” gli spazi chiusi.
Digitiamo i comandi:
rt 45
pu
fd 30
fill
che conosciamo tutti tranne l’ultimo di ovvia semantica. Osserviamo che tutti i comandi sui colori possono essere assegnati anche dal menu Set. Ci resta da notare che con l’opzione Commander Font possiamo cambiare il font che stiamo utilizzando nella finestra Commander. Più interessante è l’uso del Label Font. Possiamo infatti notare che con il comando:
label  [Ciao mondo!!]
facciamo scrivere la tartaruga sulla sua finestra, in modo dipendente dalla sua posizione e direzione.
Possiamo gradire un font diverso e non è molto semplice settare opportunamente i parametri che lo distinguono. Procediamo al solito. Scegliamolo dal menu e poi con:
show labelfont
abbiamo una risposta del tipo:
 [[Courier New] -21 0 0 400 255 0 0 0 3 2 1 18]
che ci serve per settare opportunamente il nostro font.
La coppia di parentesi [ ] che abbiamo visto in tanti esempi indica una lista. Non sempre si conoscono prima gli elementi della lista e servono dunque operatori che ci consentano di costruirla. Ad esempio possiamo voler cambiare a programma il colore della penna. Per settare i tre valori nell’esempio seguente usiamo l’operatore list che, riferendosi a tre elementi, invece che a due come nel caso standard, deve essere preceduto dalla parentesi (.
Provare allora:
repeat 20[~
setpencolor (list 200 50*repcount 50) fd 10 rt 18]
dove repcount indica il contatore del ciclo di repeat. Cambiare i numeri dei colori e il passo per esaminare le figure che ne risultano.
Per finire questa panoramica introduttiva sulla tartaruga occorre osservare che possiamo governarla anche tramite concetti legati alla geometria cartesiana. Così:
setpos [100 100]
pone la tartaruga nel punto di coordinate indicato, come del resto l’ordine:
setxy 100 100
Inoltre:
show xcor
riporta l’attuale coordinata x,
show ycor
quella invece delle ordinate.
Torniamo allora in edit e scriviamo la seguente procedura:
to ciaomondo
setlabelfont [[Courier New] -21 0 0 400 255 0 0 0 3 2 1 18]
pu rt 90
setxy random 100 random 100
repeat 10 [
label [ciao mondo]
setxy xcor + 100 ycor + 50]
end
Scegliamo Save and exit e digitiamo sulla riga di comando:
ciaomondo
La tartaruga saluta, come di dovere, con il suo primo programma. Se ripetiamo l’esecuzione del programma ci accorgiamo che le nuove scritte non sono messe nella direzione voluta. Perché? Semplice: il programma altera le condizioni con cui la tartaruga entra in esso. Ovvero non ne mantiene lo stato. Possiamo provare a ripristinare l’inclinazione iniziale semplicemente con l’istruzione lt 90.
to ciaomondo
setlabelfont [[Courier New] -21 0 0 400 255 0 0 0 3 2 1 18]
pu rt 90
setxy random 100 random 100
repeat 10 [
label [ciao mondo]
setxy xcor + 100 ycor + 50]
lt 90
end
Ma per essere sicuri che la tartaruga abbia in ogni caso l’inclinazione desiderata si può usare il comando:
setheading 90
dove 90 indica l’angolo, misurato in senso orario a partire dall’asse positivo delle y. Aggiungiamo l’istruzione prima del repeat e infine decidiamo di salvare il file su disco. Poiché desideriamo che il programma parta senza nessun comando aggiuntivo al suo caricamento, noi prima scriviamo:
make "startup [ciaomondo]
e successivamente procediamo come di consueto alla sua memorizzazione.
Infine un bel:
bye
ci riporta al sistema operativo.
Facciamo adesso qualche considerazione sulla geometria della tartaruga sottolineando l’aspetto locale di essa. La tartaruga si muove senza poter visionare il complesso delle cose. Dunque il suo modo per uscire da un labirinto è molto diverso da quello con cui la guida il bambino. Analogamente se vogliamo dirle di costruire un cerchio dobbiamo cercare un modo che non sia legato alla distanza da un punto fisso. Dovremo cercare un sistema diverso osservando che l’accumulo di misure locali porta a risultati globali.
Per le scuole elementari può essere sufficiente fare alcune osservazioni. Intanto rendersi conto, che gli angoli interni nelle figure generate dai cammini della tartaruga non sono interessanti per lei che ha invece “coscienza” di quanto si flette rispetto alla direzione corrente e dunque gli angoli che tratta sono i supplementari di quelli interni. La cosa è evidente con il triangolo.
Tutte le figure generate da cammini:
repeat 4 [fd 50 rt 90], repeat 5 [fd 50 rt 72], repeat 6 [fd 50 rt 60], repeat 5 [fd 50 rt 144] , repeat 3 [fd 50 rt 120]
sono in effetti curve chiuse, poligoni regolari, e ci fanno osservare che:
4*90 = 5*72 = 6*60 = 3* 120  = 360
5* 144  = 720.
A causa della approssimazione sullo schermo i poligoni con i lati molto piccoli si assimilano a circonferenze. Possiamo adesso mettere ancora in pratica quanto visto precedentemente e consideriamo il programma:
to ciao
setlabelfont [[Times New Roman]~
 -48 0 0 400 0 0 0 0 3 2 1 36]
ht
repeat 20[~
setpencolor (list 200 50*repcount 50)
fd 10
rt 18
setheading 18 * repcount
label [ciao a tutti ciao]
wait 10
 

Il tempo in wait è misurato in sessantesimi di secondo.
Alcune versione LOGO impongono l’uso del simbolo ~ per segnalare che l’istruzione continua sulla riga successiva, altre consentono di  evitarlo.
Presentiamo adesso con esempi la sintassi di alcuni semplici comandi di controllo:
if 1 = 1 [show [questo è vero]]

Viene testata la condizione booleana e, in caso positivo, viene eseguita la lista delle istruzioni.
ifelse 1=1 [show [questo è vero]] [show [No questo è falso]]
ifelse 0=1 [show [questo è vero]] [show [No questo è falso]]

Viene testata la condizione ed eseguita la prima lista in caso positivo, la seconda in caso negativo.
stop
viene fermata la procedura nel punto in cui l’istruzione è inserita.
op result
viene fermata la procedura nel punto in cui l’istruzione è inserita e restituito il risultato result.
Il Logo si basa su una idea fondamentale: tutto è fatto usando le procedure. Ve ne sono circa 200 predefinite e su queste si innestano quelle dell’utente. Una procedura è una dichiarazione formale. Essa viene invocata tramite il suo nome. Può essere:

1. un comando :

esempi:

>fd 200

che fa avanzare di 200 passi la tartaruga;

>print  [viva il mondo della tartaruga]

viva il mondo della tartaruga

2. un’operazione con risultato

esempio:

> 3+5

You don't say what to do with 8

Come si nota la risposta Logo sottolinea la differenza ovvero il fatto che non abbiamo scritto una istruzione.

È importante capire come si effettua la valutazione: si parte da sinistra a destra. E si interpreta la prima parola come il nome di una procedura. Si cercano successivamente i suoi parametri valutando analogamente il seguito. In pratica si valutano gli input prima di applicare la procedura. (A meno del solito zucchero sintattico che riguarda il modo comune di scrivere le operazioni aritmetiche.) Le conseguenze di questa scelta offrono grande elasticità programmativa.
Il Logo processa parole e liste. I numeri sono solo parole particolari. Per indicare una parola occorre farla precedere dal segno ". Questo segno indica che non è necessaria alcuna ulteriore interpretazione. Una lista si “quota” mettendola tra la coppia di parentesi [ ].
Infine le variabili sono una coppia data dal nome e dal suo valore.  Assegnato un nome ad una variabile ad esempio
"nome
per fare riferimento al suo contenuto occorre usare l’operazione thing con un parametro. Con riferimento all’esempio
thing  "nome
L’istruzione di assegnazione è fatta con
>make  "stati [italia francia spagna]
>pr thing "stati
italia francia spagna

Si può abbreviare il comando con
>pr :stati
italia francia spagna

Altri esempi elementari d’uso che illustrano alcune procedure predefinite:
>pr first [italia francia spagna]
italia
>pr last [italia francia spagna]
spagna
>pr butfirst [italia francia spagna]
francia spagna
>show butfirst [italia francia spagna]
[francia spagna]
…
Riprendiamo un momento in esame l’istruzione make e notiamo come il primo operando è un nome che può anche risultare da una operazione. Ad esempio:
>make first [gatto cane] first [Meo Lilli]
>pr :gatto
Meo
>make "Meo "gatto
>pr :meo
gatto
>make :meo "graffia
>pr :gatto
graffia

Le variabili definite con make sono globali. È allora buona norma limitarne l’uso.
 

Uso parole e liste
La ricorsività non controllata è molto intuitiva nel bambino. Non ci sono problemi intrinseci nell’accettarla. Alcune storielle sono di quel tipo e si possono facilmente riprodurre. Ad esempio possiamo considerare la seguente istruzione LOGO

make "storia [|Una sera un re disse al suo maggiordomo:
"Arturo, tu che sai tante storie,
perché non ce ne racconti una?"
Arturo guardò il suo re. |]
dove notiamo:

•  L’istruzione make non è altro che l’istruzione di assegnamento. Il nome della variabile è caratterizzato dalle virgolette iniziali.
• L’uso della parentesi quadra indica che stiamo usando una lista.
• Il simbolo barra che indica semplicemente che la visualizzazione nella stampa del testo sarà esattamente quella con cui è stato scritto

il  racconto è infinito. Proviamo a fermarlo nel modo seguente. Scriviamo la procedura inizia
to inizia
make "storia [|Una sera un re disse al suo maggiordomo:
"Arturo, tu che sai tante storie,
perché non ce ne racconti una?"
Arturo guardò il suo re.|]
racconta 3
end

Avendo definito
to racconta :conta
pr :storia
if :conta = 1 [pr [Lo vide adirato e scappò via!!]stop]
pr [ Poi cominció ]
racconta :conta-1
end
 

Programma che costruisce frasi casuali

to componi [:num 10]
repeat :num [print (se item 1+random 5 :soggetto item 1+random 5 :verbo item 1+random 5 :complemento)]
end

to inizia
make "soggetto [[Il cane ][La mamma ][Il sole ][La mia automobile ][Il gatto ]]
make "verbo [ [mangia ] [coccola ] [riscalda ] [ha avuto] [rincorre ]]
make "complemento [[il bambino.] [la cena.]  [la terra.] [un incidente.][il topo.]]
componi
end
 

Cogliamo l’occasione per presentare parametri inizializzati nelle procedure. Se mettiamo tra parentesi quadre una variabile ed un valore essa lo assumerà per default ma in tal caso  quando la procedura viene chiamata senza parentesi viene inviato un messaggio d’errore. Per notare anche l’uso delle variabili globali fare eseguire la procedura inizia e poi, ad esempio, (componi 5)

to bambini
keyboardon [esegui char keyboardvalue]
setfocus [MSWLogo Screen]
end

to esegui :tasto
if  :tasto = "X [label "ok]
if  :tasto = "c   [ClearScreen]
if  :tasto = "i   [bk 10]
if  :tasto = "s   [lt 10]
if  :tasto = "d   [rt 10]
if  :tasto = "a   [fd 10]
if  :tasto = "p   [pd]
if  :tasto = "n   [pu]
end

Notare che non c’è differenza tra maiuscole e minuscole.
Un altro evento che possiamo catturare è quello del mouse. Presentiamo un esempio

mouseon [setpos mousepos pd] [pu] [mouseoff] [] [setpos mousepos]

per mostrare l’uso della istruzione relativa. La prima lista indica i comandi da eseguire quando si tiene giù il bottone sinistro del mouse, la seconda quando il bottone si alza, la terza per il bottone destro abbassato, la quarta nel caso sia alzato e l’ultima riguarda il movimento del mouse.
L’istruzione precedente permette un disegno a mano libera.
Vogliamo adesso insegnare alla tartaruga a mantenere una direzione prefissata evitando gli ostacoli che possiamo mettere sul suo cammino (costruendoli ad esempio con la procedura bambini precedente). A tale scopo dobbiamo darle la capacità di esaminare quello che ha intorno. Facciamo inizialmente l’ipotesi che tutti gli ostacoli siano costruiti ad angoli retti e dotiamola di un paio di sensori

to hoilmuroasinistra?
local "mypixel
make "mypixel pixel
ht lt 90 pu fd 1
if not pixel = :mypixel [bk 1 rt 90 st op "true]
bk 1 rt 90 st op "false
end

to hoilmuroavanti?
local "mypixel
make "mypixel pixel
ht pu fd 1
if not pixel = :mypixel [bk 1 st op "true]
bk 1 st op "false
end

Rispetto alla esercitazione precedente,  la nuova istruzione è pixel che restituisce il valore secondo il sistema RGB del pixel su cui si appoggia la tartaruga.

Per mantenere la direzione iniziale la tartaruga deve tener conto in una variabile delle sue rotazioni sommando quelle in una direzione e sottraendo quelle nell’altra in modo da riprendere il cammino nella direzione corretta dopo aver evitato gli ostacoli. Chiamiamo stato questa variabile. L’algoritmo per evitare gli ostacoli sarà il seguente:
1. Metti a 0 la variabile stato e cammina avanti finché non incontri un ostacolo
2. Gira a destra per lasciare l’ostacolo a sinistra. Somma 90 allo stato
3. Se lo stato non è 360 o un suo multiplo, allora

• Se hai avanti un ostacolo gira a destra aggiornando al solito lo stato altrimenti avanza di un passo.
• Se hai il muro a sinistra continua a camminare
• Se infine puoi girare a destra fallo subito sottraendo 90 allo stato

4. Se lo stato è multiplo di 360 torna al passo 2
In pratica i passi 1 e 2 sono dati dalla procedura

to cammina
wait 1
local "stato
make "stato 0
if  hoilmuroavanti? [make "stato :stato + 90 rt 90 giraattorno stop]
fd 1
cammina
end

e i passi 3  e 4 dalla procedura

to giraattorno
wait 1
if :stato = 0 [cammina]
if  hoilmuroavanti? [make "stato :stato + 90 rt 90 giraattorno stop]
fd 1
if  hoilmuroasinistra? [giraattorno stop]
make "stato :stato – 90 lt 90
ifelse 0 = modulo :stato 360 [cammina stop]  [giraattorno]
end

Da un punto di vista di nuove istruzioni, abbiamo usato
ifelse
modulo.

Si può osservare che l’algoritmo non è sempre efficace. Si possono creare infatti delle trappole. Come nel caso seguente:

Il metodo per fare uscire la tartaruga da questo e da tutti i labirinti (finiti) è una semplice variazione dell’algoritmo precedente dovuta ad un ragazzino dodicenne John Pledge.  Si tratta di considerarsi alle condizioni iniziali non già quando la rotazione è un multiplo di 360 gradi ma solo quando è 0. Per cui trasformando la riga finale:
ifelse 0 = modulo :stato 360 [cammina stop]  [giraattorno]
della procedura giraattorno in
ifelse 0 =  :stato  [cammina]  [giraattorno]
la tartaruga uscirà da qualsiasi labirinto.