Debugging: differenze tra le versioni

Versione delle 16:59, 1 ago 2017

Versione attuale delle 06:23, 1 gen 2025

(45 versioni intermedie di 21 utenti non mostrate)

Riga 1:

{{nota disambigua|il termine nel contesto del [[ciclo di vita del software]]|Ispezione del software}}

[[File:Coding Shots Annual Plan high res-5.jpg|thumb|Uno [[sviluppatore software]] esegue un debugging]]

{{F|software|gennaio 2019}}

Il '''debugging''' (o semplicemente '''debug''') o '''depurazione''', in [[informatica]], nell'ambito dello [[sviluppo software]], indica l'attività che consiste nell'individuazione e correzione da parte del [[programmatore]] di uno o più errori ([[bug]]) rilevati nel [[software]], direttamente in fase di [[programmazione (informatica)|programmazione]] oppure a seguito della fase di ''[[collaudo del software|testing]]'' o dell'utilizzo finale del [[programma (informatica)|programma]] stesso.

L'attività di debug è una delle operazioni più importanti e difficili per la messa a punto di un [[programma (informatica)|programma]], spesso estremamente difficilecomplicata per la complessità dei software oggi in uso e delicata per il pericolo di introdurre nuovi errori o comportamenti difformi da quelli desiderati nel tentativo di correggere quelli per cui si è svolta l'attività di ''debug''.

== Operazioni di base ==

Sebbene ogni sessione di debug sia unica e costituisca una storia a sé, alcuni principi generici sono applicabili a tutte le sessioni di debug. In particolare, per il debug di applicazioni software, in genere si possono riconoscere cinque fasi nel debug:

* identificazione del bug

* individuazione del componente in cui è presente il bug

Riga 16:

=== Rilevazione dell'errore ===

{{vedi anche|Bug (informatica)|Debugger}}

Alla fine della stesura del codice il programmatore opera una prima fase di test valutando se l'output del programma è quello atteso compilando/interpretando ed eseguendo il codice. All'eventuale rilevazione dell'errore segue la fase di ''debugging'', ossia di individuazione della parte di [[software]], a volte molto complesso, nella quale si annida l'errore.

AllaMentre gli ''errori di sintassi'' sono tipicamente evidenziati dall'[[Ambiente di sviluppo integrato|IDE]], alla fine della stesura del codice il programmatore opera una primaseconda fase di test valutando se l'output del programma è quello atteso compilando/interpretando ed eseguendo il codice. All'eventuale rilevazione dell{{'}}''errore di semantica'' e di ''runtime'' segue la fase di ''debugging'', ossia di individuazione della parte di [[software]], a volte molto complesso, nella quale si annida l'errore. Spesso tale operazione viene svolta dal programmatore di pari passo con la stesura del codice stesso, testando continuamente il codice ed evitando così l'accumulo degli errori.

Questa attività è oggi supportata da programmi specifici ([[debugger]]) messi a disposizione dall'[[Integrated development environment|IDE]] grazie anche all'uso di [[breakpoint]] e dai messaggi di [[standard error]] emessi nei [[file]] di [[log]] (es. rilevamento [[eccezione (informatica)|eccezioni]]), che indicano e mostrano allo [[programmatore|sviluppatore]] l'esecuzione, [[istruzione (informatica)|istruzione]] per istruzione, del programma, permettendo nel contempo l'analisi dei dati trattati dal programma stesso. In assenza di tali strumenti per le attività di ''debugging'', si ricorre alla più semplice, ma anche meno efficace tecnica di stampare a [[monitor (video)|video]] o su [[file]] le istruzioni che il programma sta eseguendo, inserendo a tal scopo nel codice delle istruzioni di ''debug'' che evidenzino il punto di arrivo dell'esecuzione del programma fino all'errore. Una volta individuato l'errore nel codice il programmatore corregge l'errore in maniera iterativa finché il programma non fa ciò che è desiderato.

Questa attività è oggi supportata da programmi specifici ([[debugger]]) messi a disposizione dall'[[Integrated development environment|IDE]] grazie anche all'uso di [[breakpoint]] su linee di codice e dai messaggi di [[standard error]] emessi nei [[file]] di [[log]] (es. rilevamento [[eccezione (informatica)|eccezioni]] nelle console dell'IDE), che indicano e mostrano allo [[programmatore|sviluppatore]] l'esecuzione, [[istruzione (informatica)|istruzione]] per istruzione, del programma, permettendo nel contempo l'analisi dei dati trattati dal programma stesso. In assenza di tali strumenti per le attività di ''debugging'', si ricorre alla più semplice, ma anche meno efficace tecnica di stampare a [[monitor (video)|video]] o su [[file]] le istruzioni che il programma sta eseguendo, inserendo a tal scopo nel codice delle istruzioni di ''debug'' che evidenzino il punto di arrivo dell'esecuzione del programma fino all'errore. Sempre a questo scopo, il programmatore può, con l'ausilio dei [[Commento (informatica)|commenti]], far eseguire solo alcune parti del codice o al contrario non far eseguire particolari parti del codice, sospette di causare l'errore. Una volta individuato l'errore nel codice il programmatore corregge l'errore in maniera iterativa finché il programma non fa ciò che è desiderato.

Una seconda fase di debug è quella che il programmatore deve risolvere quando il software prodotto è stato mandato in fase di ''testing'' o [[collaudo]] al rispettivo team ed è stato rimandato indietro con la lista dei difetti riscontrati. In genere in questo casi molto spesso sono presenti errori nella stesura o interpretazione delle specifiche rispetto a ciò che è realmente desiderato.

Una secondaterza fase di debug è quella che il programmatore deve risolvere quando il software prodotto è stato mandato in fase di ''testing'' o [[collaudo]] al rispettivo team ed è stato rimandato indietro con la lista dei difetti riscontrati.; Inin genere in questoquesti casi molto spesso sono presenti errori nella stesura o interpretazione delle specifiche rispetto a ciò che è realmente desiderato senza andare in errore.

Un terza fase di debug può succedere quando in fase di utilizzo del programma da parte dell'utente finale questi riscontra delle anomalie.

Una quarta fase di debug può avvenire quando in fase di utilizzo del programma da parte dell'utente finale questi riscontra delle anomalie; in genere in questi casi si ingenera un errore con relativo messaggio che viene inviato tramite [[Internet]] alla casa produttrice del software che aggiornerà periodicamente con nuove [[release (informatica)|release]] senza errori o [[Aggiornamento (informatica)|aggiornamenti]] il prodotto (es. [[Windows|Microsoft Windows]]).

== Accorgimenti per accelerare il processo di debug ==

=== Il correttoCorretto atteggiamento mentale ===

È necessario fare autocritica, e accettare il fatto che il programma non si comporta come dovrebbe e che si è fatto un errore, cosa del tutto normale e frequente in fase di sviluppo; se tutto fosse stato previsto e non ci fossero errori, il programma funzionerebbe correttamente, ma spesso questo risultato non si ottiene quasi mai alla prima stesura del codice, ma solo per successive modifiche e correzioni. Tale atteggiamento mentale incrementa significativamente la possibilità di trovare e risolvere dei bug.

=== Usare dei file di log ===

CreareOltre all'uso della console dell'IDE è opportuno creare uno o più [[log|file di log]] che può risultare molto utile per verificare se il programma funziona come previsto, e cosa succede prima, dopo e durante il verificarsi del malfunzionamento.

=== Fare attenzione all'input fornito al programma ===

Tutti gli [[input]] forniti dall'utente devono essere validati prima [[sintassi|sintatticamente]] e successivamente anche [[Semantica (informatica)|semanticamente]] dal programma prima di essere elaborati. Ciò migliora anche la sicurezza del programma.

=== RicordareMemorizzare le proprietipologie esperienzedi errori ===

Nel caso si siano già scritti dei programmi simili e ci si sia trovati a bug simili a quello attuale, è buona norma, sulla scorta dell'esperienza, cercare di ricordare l'errore commesso e la soluzione adottata.

== Accorgimenti per ridurre la necessità di debug ==

=== Disegno del codice ===

Disegnare accuratamente le [[strutture dati]] e le funzioni nella [[programmazione strutturata]] e le [[classe (informatica)|classi]] in quella [[programmazione orientata agli oggetti|orientata agli oggetti]] è il sistema migliore per ridurre gli errori nel codice e nel facilitare l'individuazione dell'errore nel caso il programma non funzioni correttamente.

Line 60 ⟶ 61:

* [[Sistema di sviluppo]]

* [[Troubleshooting]]

== Altri progetti ==

{{interprogetto|preposizione=sul}}

== Collegamenti esterni ==

* {{Collegamenti esterni}}

* {{cita web|http://heather.cs.ucdavis.edu/~matloff/UnixAndC/CLanguage/Debug.html|Guida a un debug rapido|lingua=en}}

{{Collaudo del software}}

{{Controllo di autorità}}

{{portale|informatica}}