Debugger GX-TXT · Modulo 01 — Fondamenti e primo Debug Job
Il debugger di GX-TXT · Corso in 10 moduli
Un calcolo può andare storto anche quando il programma termina senza segnalare errori. Partiamo da una conversione di temperatura con un risultato noto e seguiamo il valore che si discosta dalle attese. La stessa prova ci accompagna dalla preparazione della Session al primo breakpoint, fino alla conclusione del Debug Job.
Scarica gli esempi Python e GNU Octave (ZIP). Estrai tutte le cartelle dell’archivio e mantieni insieme i file degli esempi multifile.
D01 — Il debugging come metodo
Un programma può terminare senza errori e produrre comunque un risultato sbagliato. Il debugging serve a capire dove nasce la differenza fra ciò che ci aspettiamo e ciò che osserviamo. In questa lezione seguiamo un piccolo calcolo con il debugger integrato di GX-TXT.
Obiettivi e prerequisiti
Saprai formulare un risultato atteso, riprodurre un difetto intenzionale, fermare un’esecuzione e individuare una possibile causa. Occorrono le basi di Python o GNU Octave e una Session aperta in GX-TXT. La prova illustrata usa Python Scripts nella copia GX-TXT dev112-P011-bis; lo stesso calcolo è fornito anche in Octave.
Un risultato da mettere in discussione
Per convertire Celsius in kelvin si somma 273,15. Quindi 20 °C corrispondono a 293,15 K. I due esempi seguenti contengono invece un errore intenzionale:
Entrambi assegnano a offset il valore 237,15 e
restituiscono Temperature: 257.15 K. Il programma è
sintatticamente valido: il sintomo è un valore numerico errato.
L’ipotesi da esaminare è che il problema si trovi nella costante di
conversione.
Fermarsi prima del calcolo in Python
- Apri una Session e, in Viewers, cerca
Python Scripts. Apri il viewer e importa
temperature_bug.pydal menu File. - Usa lo scope
session, assegna uno Script ID e salva lo script. Il debugger esegue la revisione registrata: importa il file e salva le successive modifiche prima di una nuova prova. - In View → Debugger, apri il pannello di debug. Nel
margine accanto alla riga
kelvin = celsius + offset, imposta un breakpoint sulla riga eseguibile. - Premi Start Debug. Se l’esecuzione si ferma inizialmente prima del breakpoint, premi Continue per raggiungerlo. La freccia gialla indica la riga selezionata in pausa; il punto rosso indica il breakpoint.
- Osserva la riga e i valori del frame nel pannello Locals /
Globals. Se necessario ridimensiona i pannelli o scorri
l’elenco: prima dell’assegnazione di
kelvin,celsiusvale 20 eoffsetvale 237,15. Con Step Over esegui la riga e confronta il valore ottenuto con quello atteso.
Nell’immagine si vede il debugger realmente fermo prima della somma. Il pannello delle variabili può mostrare solo una parte dell’elenco: scorri o aumenta lo spazio disponibile. Non è una console per modificare o valutare espressioni.
Correggere e verificare
Termina il Debug Job con Continue o
Stop. Sostituisci 237.15 con
273.15, salva e ripeti il controllo sulla nuova revisione.
Le versioni corrette sono disponibili come temperature_fixed.py e temperature_fixed.m: entrambe
devono stampare Temperature: 293.15 K.
Per ripetere il ragionamento in Octave, importa il file
.m in Octave Scripts e segui la stessa
sequenza generale. I dettagli dei controlli specifici di Octave verranno
approfonditi nei moduli successivi; in particolare la pausa asincrona
non è disponibile nell’adapter Octave descritto dal manuale della
versione di riferimento.
Esercizio
Con la versione corretta, quale risultato ti aspetti per 0 °C? Modifica il valore iniziale su una copia, salva, esegui e verifica il risultato. Perché la sola assenza di messaggi di errore non dimostrava che la prima versione fosse corretta?
Soluzione ragionata
0 °C corrispondono a 273,15 K. La prima versione non violava la sintassi: usava semplicemente una costante sbagliata. Serviva un risultato atteso indipendente per riconoscere il difetto.
D02 — Preparare Session e Viewer
Una Session raccoglie il lavoro che vogliamo riprendere: fra le altre cose, può contenere gli script registrati che useremo nel debugger. In questa lezione prepariamo un ambiente dedicato e importiamo lo stesso semplice calcolo nei viewer Python e Octave.
Prima di iniziare
Occorrono GX-TXT e i file corretti della lezione precedente: Python e Octave. I file
calcolano la temperatura equivalente a 20 °C: il risultato atteso è
Temperature: 293.15 K.
Creare una Session
- In Configuration → Storage, controlla il profilo di archiviazione e la cartella indicata come New Session root. Se vuoi mantenere gli esercizi separati, crea e applica un profilo con una cartella dedicata.
- Apri la scheda Sessions, poi Session → New Session.
- Inserisci un nome riconoscibile e seleziona la posizione proposta.
Nella prova abbiamo usato
debugger_coursecome Session autonoma. - Premi Create e conferma il messaggio. Il nome della Session appare nella barra superiore di GX-TXT.
La cartella della Session non è necessariamente quella che contiene i file originali: l’importazione nello script workspace crea una copia gestita nella Session. Non modificare i file della Session direttamente per simulare un salvataggio nell’editor.
Trovare i viewer
Apri Viewers. In Scientific Scripting trovi Python Scripts, Octave Scripts e Script Library. Puoi filtrare l’elenco con il campo Search. I primi due viewer permettono di preparare codice nei rispettivi linguaggi; la libreria aiuta a ritrovare gli script registrati.
Importare e registrare uno script Python
Apri Python Scripts e scegli l’importazione di uno
script Python dal menu File. Seleziona
temperature_fixed.py. Imposta lo scope su
session, assegna uno Script ID come
course.debug.temperature.python e salva con
Ctrl+S. La barra in basso mostra l’identità Session, la
revisione e lo stato salvato.
Apri poi Octave Scripts dalla pagina Viewers e
ripeti l’operazione con temperature_fixed.m, usando un
identificativo distinto, ad esempio
course.debug.temperature.octave.
La copia mostrata nell’editor è quella registrata nel framework. Se modifichi il file originale esterno dopo l’importazione, non dare per scontato che la copia nella Session cambi automaticamente. Le prossime lezioni mostrano come eseguirla e fermarla nel debugger.
Esercizio
Crea una Session di prova e importa i due file con identificativi diversi. Quale controllo ti permette di capire se hai salvato la copia nello scope previsto?
Soluzione ragionata
Controlla che lo scope sia session e che la barra di
stato riporti l’identità dello script di Session e lo stato salvato. I
nomi degli script sono simili, ma il viewer e l’estensione identificano
il linguaggio.
Indice del corso · Lezione precedente
D03 — Run e Debug: due percorsi
Un’esecuzione ordinaria e una in debug possono usare lo stesso script salvato, ma servono a scopi diversi. Con Run osserviamo il risultato finale; con Debug possiamo fermarci e seguire il percorso che lo produce.
Preparazione
Apri la Session della lezione D02 e il viewer
Octave Scripts. Usa temperature_fixed.m,
importato e salvato nello scope session. Il valore atteso è
Temperature: 293.15 K.
Esecuzione ordinaria
Nel viewer scegli Run → Open Script Runner. La finestra mostra l’identità dello script e permette di rivedere parametri e input; questo esempio non richiede parametri né Dataset. Premi Run Job e apri i dettagli del Job concluso.
La prova si è conclusa con COMPLETED e il programma ha
stampato Temperature: 293.15 K:
Il risultato finale ci permette di verificare il calcolo, ma non racconta automaticamente i valori intermedi e l’ordine in cui sono stati ottenuti.
Esecuzione con Debug
Torna all’editor e apri View → Debugger. Premi
Start Debug sulla revisione salvata. Nella prova il
debugger si è fermato inizialmente sulla prima istruzione eseguibile.
Premi Step Over tre volte, aspettando ogni
aggiornamento: la freccia raggiunge la riga fprintf, dopo
le assegnazioni di celsius, offset e
kelvin.
Mentre il programma è in pausa puoi esaminare stack e variabili. La
riga evidenziata indica il punto da cui riprenderà l’esecuzione: prima
della stampa, kelvin è già stato calcolato. Se l’elenco
delle variabili è piccolo, scorri o ridimensiona i pannelli. Premi
Continue e apri Program output /
diagnostics per vedere il risultato dell’esecuzione in
debug.
Anche qui il risultato è 293,15 K. Il testo prodotto dal programma va
cercato nei dettagli del Job; Debugger output contiene
invece comunicazioni dei controlli di debug. La procedura generale vale
anche per Python Scripts, usando il corrispondente file .py
della D02.
Esercizio
Ripeti la prova con celsius = 0.0 su una copia dello
script: quale valore deve comparire? Che cosa aggiunge Debug rispetto al
solo output finale?
Soluzione ragionata
Il risultato atteso è 273.15 K. Debug consente di
fermarsi e osservare le assegnazioni e il contesto prima della stampa;
la sola esecuzione ordinaria mostra il risultato una volta prodotto.
Indice del corso · Lezione precedente
D04 — Primo breakpoint e prima pausa
Un breakpoint chiede al debugger di fermare il programma in un punto preciso. È utile quando conosciamo la zona da osservare e non vogliamo seguire tutte le istruzioni precedenti una per una.
Preparazione
Apri la Session e la copia salvata di temperature_fixed.m preparate in D02. Il calcolo deve produrre 293,15 K. La procedura illustrata è stata provata in Octave Scripts con GX-TXT dev112-P011-bis.
Fermarsi alla stampa
- Apri View → Debugger e verifica che non sia già attivo un Debug Job.
- Individua la riga
fprintf, che stampa il risultato. Se necessario scorri il sorgente fino a vederla. - Fai clic nella corsia dei breakpoint, a sinistra del numero della riga. Compare un punto rosso pieno; un secondo clic lo rimuove. Puoi anche posizionare il cursore sulla riga e premere F9.
- Premi Start Debug e attendi la pausa. Nella prova il debugger si è fermato direttamente sulla riga con il breakpoint; a seconda del percorso può presentarsi anche una pausa iniziale, dalla quale puoi usare Continue per proseguire fino al punto impostato.
- Controlla che PAUSED, la riga nello stack e la freccia gialla siano coerenti. L’istruzione evidenziata è la prossima da eseguire nel frame selezionato: qui il valore è già stato calcolato e la stampa deve ancora avvenire.
Il punto rosso indica la posizione richiesta; la freccia gialla indica la posizione mostrata dal debugger nel frame selezionato. Sono simboli distinti, anche quando si trovano sulla stessa riga. Premi Continue per terminare e confronta l’output con 293,15 K.
Esercizio
Imposta il breakpoint sulla riga
kelvin = celsius + offset e ripeti. Quale operazione deve
ancora essere eseguita quando il programma si ferma?
Soluzione ragionata
Deve ancora essere eseguita l’assegnazione a kelvin. I
valori celsius e offset sono stati assegnati
nelle righe precedenti. Il debugger mostra il punto di arresto prima di
eseguire la riga evidenziata.
Indice del corso · Lezione precedente
D05 — Orientarsi nella superficie Debug
Quando il programma è in pausa, sorgente, stack e variabili raccontano parti diverse dello stesso stato. Organizzare lo spazio rende la lettura più semplice, soprattutto su schermi piccoli.
Aprire e riconoscere i pannelli
Apri la Session e lo script Octave della lezione D04. Imposta il
breakpoint sulla stampa, apri View → Debugger e avvia
il debug. Quando compare PAUSED, osserva:
- Sorgente: mostra la freccia gialla e la riga selezionata; il punto rosso è il breakpoint.
- Call Stack: mostra i frame, con funzione, file e linea. Selezionare un frame serve a esaminarlo e non fa avanzare il programma.
- Locals / Globals: presenta un riepilogo delle variabili del frame selezionato, con tipo, forma e valore quando disponibili.
- Breakpoints: elenca i punti impostati e le relative informazioni.
- Debugger output: raccoglie comunicazioni del debugger; l’output del programma si apre separatamente con Program output / diagnostics.
Dare spazio alle informazioni utili
Nel menu View, nascondi Script properties e Parameters se non servono per la prova. Puoi ripristinarli dalla stessa voce di menu o dal pulsante mostrato nell’area delle proprietà. Usa i separatori trascinabili per modificare lo spazio assegnato ai pannelli; puoi anche scorrere gli elenchi. Queste opzioni modificano il layout, non i valori dello script.
Nella prova la riga di stampa è in pausa e il pannello mostra
celsius = 20, offset = 273.15 e
kelvin = 293.15. Il campo Shape indica
1 1: sono scalari Octave. Alcune righe aggiuntive
appartengono all’ambiente di esecuzione; concentrati sulle variabili
introdotte dal tuo script.
Esercizio
Nascondi e ripristina Variables / Locals dal menu View. Qual è la differenza fra nascondere quel pannello e premere Continue?
Soluzione ragionata
Nascondere il pannello cambia la visualizzazione; Continue riprende l’esecuzione. Per terminare la prova premi Continue oppure usa Stop quando vuoi annullarla.
Indice del corso · Lezione precedente
D06 — Completare e interrompere
Al termine di una pausa possiamo lasciare che lo script arrivi alla fine oppure interrompere la prova. I due comandi hanno conseguenze diverse: Continue riprende l’esecuzione, Stop richiede la cancellazione del Debug Job.
Continuare fino alla conclusione
Riprendi lo script Octave temperature_fixed.m
nella Session preparata in D02. Imposta un breakpoint sulla stampa, apri
View → Debugger e premi Start Debug.
Quando la riga è in pausa, premi Continue. Se non ci
sono altri breakpoint e il programma termina senza errori, il pannello
mostra COMPLETED.
Apri Program output / diagnostics: il risultato
della prova è Temperature: 293.15 K. Al termine, freccia e
variabili attive vengono rimosse: non sono più uno stato vivo del
programma.
Interrompere una seconda prova
Avvia un nuovo Debug Job con lo stesso breakpoint. Quando è in pausa,
premi Stop. Nella prova il pannello mostra
CANCELLED e lo stack e le variabili non sono più
attivi:
La cancellazione di un Job non equivale a una correzione dello script e non garantisce che il programma sia arrivato alla stampa. Il breakpoint può rimanere impostato per una prova successiva: rimuovilo dalla corsia o con Clear all quando il Job non è attivo.
Esercizio
In quale caso è appropriato usare Continue? E in quale caso Stop? Dopo Stop puoi ancora usare il pannello delle variabili per sapere quale sarebbe stato il valore finale?
Soluzione ragionata
Usa Continue per proseguire verso la fine o il prossimo breakpoint. Usa Stop per annullare la prova quando non serve più. Una volta cancellato il Job non c’è uno stato vivo da cui dedurre il risultato finale: per verificarlo bisogna eseguire una nuova prova.
Indice del corso · Lezione precedente
Con un calcolo atteso e una prima pausa osservata, possiamo ora controllare con precisione dove fermarci e a quale revisione appartiene il breakpoint.
Altre tappe del progetto
- Debugger GNU Octave in GX-TXT: breakpoint, variabili e API pubbliche
- Debugger GX-TXT · Modulo 09 — Casi pratici integrati
- Debugger GX-TXT · Modulo 10 — Autonomia e progetto conclusivo
- Debugger GX-TXT · Modulo 05 — Python: casi fondamentali
- Debugger GX-TXT · Modulo 02 — Breakpoint e sorgente
- Debugger GX-TXT · Modulo 03 — Controllo del flusso e stack