Return to Video

01-18 Come Si Creano i Guasti

  • 0:00 - 0:05
    Un programma lo possiamo vedere come una successione di stati di programma.
  • 0:05 - 0:09
    Ogni stato di un programma e' composto da variabili con dei valori.
  • 0:09 - 0:14
    Mentre un programma e' in esecuzione, elabora questi stati e li trasforma in nuovi stati.
  • 0:14 - 0:19
    Per esempio, leggendo le variabili o modificandole. Di norma e' cosi' che opera.
  • 0:19 - 0:24
    Ora comunque, fin dall'inizio, abbiamo un normale input e alla fine un malfunzionamento,
  • 0:24 - 0:29
    ci dev'essere da qualche parte un difetto nel nostro programma che causa in effetti il problema.
  • 0:29 - 0:33
    Lasciami quindi supporre che questa istruzione che eseguiamo qui abbia percio' un difetto.
  • 0:33 - 0:38
    Cio' che succede ora 'e che, quando viene eseguita, introduce
  • 0:38 - 0:42
    un errore nello stato di programma, che noi chiameremo "infezione".
  • 0:42 - 0:47
    Questa infezione si sta ora propagando probabilmente in altri stati
  • 0:47 - 0:52
    ed eventualmente diventa visibile all'utente come malfunzionamento.
  • 0:52 - 0:56
    Cio' che abbiamo qui e' effettivamente un'intera catena di cause-effetti.
  • 0:56 - 1:01
    Vedi, questi malfunzionamenti, cioe' un infezione, e' provocata da infezioni precedenti
  • 1:01 - 1:11
    e se siamo in uno stato in cui l'infezione non ha ulteriori origini, cioe' lo stato e' l'input stesso
  • 1:11 - 1:16
    e l'output e' infettato, allora sappiamo che l'istruzione eseguita in questo preciso momento
  • 1:16 - 1:20
    ha causato la transizione tra lo stato attuale allo stato di infezione,
  • 1:20 - 1:26
    questa e' l'istruzione che causa l'infezione, cioe' l'istruzione che contiene il difetto.
  • 1:26 - 1:31
    Mentre ora facciamo il debugging, dobbiamo individuare questa catena di causa-effetto,
  • 1:31 - 1:36
    e non dobbiamo solo individuarla ma dobbiamo anche spezzare la catena causa-effetto.
  • 1:36 - 1:42
    Se riusciamo a spezzare la catena da difetto a malfunzionamento, avremo terminato il debugging.
  • 1:42 - 1:47
    Tutto cio' sembra quindi molto semplice, comunque, nella vita reale, e' molto piu' complicato di cosi'.
  • 1:47 - 1:51
    Tanto per cominciare, non tutti i difetti causano automaticamente dei malfunzionamenti.
  • 1:51 - 1:56
    Puo' benissimo essere che un difetto causi un'infezione che, in seguito, semplicemente non
  • 1:56 - 1:59
    si propaghi cosi' direttamente in un infezione reale.
  • 1:59 - 2:03
    Quindi l'infezione non verra' propagata e non sara' mai visibile all'utente.
  • 2:03 - 2:08
    Potrebbe non causare nemmeno un malfunzionamento o che l'istruzione difettosa non venga mai eseguita
  • 2:08 - 2:14
    o solo in certe condizioni molto particolari potra' causare un infezione e in seguito un malfunzionamento.
  • 2:14 - 2:18
    Questo e' il problema con il testing. Potresti eseguire un programma piu' volte,
  • 2:18 - 2:24
    mai avere un malfunzionamento e avere comunque dentro un difetto, pero', se un programma si inceppa,
  • 2:24 - 2:33
    cioe' se vediamo in effetti un malfunzionamento, allora potremo sempre tracciare a ritroso il difetto che l'ha provocato.
  • 2:33 - 2:38
    Quindi se c'e' un malfunzionamento, possiamo sempre sistemarlo seguendo a ritroso la catena cusa-effetto.
  • 2:38 - 2:43
    Ma poi il problema sara': gli stati sono moltissimi.
  • 2:43 - 2:50
    Allora qua abbiamo 1,2,3,4, ... 12 variabili. Bella li'.
  • 2:50 - 2:57
    In realta' ne abbiamo 10.000 di queste variabili e non solo ne abbiamo 10.000,
  • 2:57 - 3:02
    ma abbiamo anche 10.000 passaggi tra difetti e malfunzionamenti.
  • 3:02 - 3:06
    Quindi tracciare a ritroso la catena causa-effetto puo' essere molto
  • 3:06 - 3:10
    molto piu' complicato di quel che si vede in questa semplice immagine.
  • 3:10 - 3:14
    Piu' lunga e' la catena causa-effetto, piu' tempo metteremo a percorrerla,
  • 3:14 - 3:19
    piu' stati avremo da percorrere, piu' dura sara' farne il debugging.
  • 3:19 - 3:23
    E anche, piu' grandi saranno gli stati e piu' dovremo stare a cercare l'infezione.
  • 3:23 - 3:27
    Di nuovo, cio' rendera' sempre e sempre piu' dura farne il debugging.
  • 3:27 - 3:31
    E' come cercare l'ago in un pagliaio, solo che l'ago
  • 3:31 - 3:35
    a volte e' molto piu' grande di qualsiasi ago che potreste mai trovare sulla Terra.
Title:
01-18 Come Si Creano i Guasti
Video Language:
English
Team:
Udacity
Project:
CS259 - Software Debugging
Duration:
03:36

Italian subtitles

Revisions Compare revisions