La scrittura di un programma è un processo che si può suddividere in cinque fasi chiaramente distinte tra di loro:
In questa fase, chi commissiona un programma descrive in modo
più o meno formale il problema che il programma deve risolvere, ed eventuali
vincoli che il programma dovrà rispettare.
Una specifica informale è un testo che descrive un problema che deve
essere risolto, specificando in termini generali la relazione desiderata tra
dati in ingresso e i dati in uscita, cioè i risultati del calcolo. Oltre a questo,
la specifica potrebbe indicare dei vincoli di risorse che devono essere rispettati
e altre condizioni al contorno che possono influenzare il modo in cui il problema
può essere risolto.
Una specifica formale è una specifica rappresentabile da
una quadrupla S = (X,Y,I,U) dove:
X è un insieme di ingressi, cioè il tipo di
dati che il programma deve aspettarsi che gli vengano forniti;
Y è un insieme
di uscite, cioè il tipo di risultati che il programma deve produrre;
I è un
insieme di condizioni che gli ingressi sono garantiti rispettare, chiamate anche
precondizioni;
U è un insieme di condizioni sulle uscite, anche dette postcondizioni,
cioè le proprietà che i risultati del programma devono soddisfare
In questa fase il programmatore analizza il problema da risolvere e concepisce in modo astratto un algoritmo. Esistono due approcci antitetici alla progettazione:
analisi top down (dall'alto verso il basso), che si basa su una decomposizione gerarchica del problema;
analisi bottom up (dal basso verso l'alto).
L'analisi top down parte dai i requisiti che devono essere
soddisfatti per risolvere il problema. Questi vengono poi divisi in un piccolo
numero di sottorequisiti; ciascun sottorequisito che non sia un compito elementare
viene a sua volta diviso in sottorequisiti. Questa scomposizione termina quando
tutti i sottorequisiti rappresentano compiti elementari. Questo modo di ragionare
conduce alla progettazione di algoritmi chiari e ben strutturati. La chiarezza
e la strutturazione di un algoritmo dovrebbero essere mantenuti dal codice che
lo realizza. Da qui l'esigenza di una programmazione strutturata come naturale
estensione dell'approccio top-down al processo di scrittura del codice.
L'analisi
bottom up, invece, parte dai compiti elementari che si sanno già svolgere, e
cerca il modo di combinarli per svolgere compiti più complessi, fino a risolvere
l'intero problema.
Una tecnica di progettazione più moderna è quella ad oggetti.
Essa consiste nell'analizzare il problema allo scopo di identificare tutti gli
elementi rilevanti che compaiono nella sua definizione. Questi elementi sono
gli oggetti del problema, che avranno tra di loro delle relazioni ben precise,
che determineranno la struttura del programma.
In questa fase, l'algoritmo viene rappresentato in maniera più formale e dettagliata, in modo da rendere evidenti tutti i suoi passi e la sua struttura concettuale. A questo scopo si possono utilizzare diversi strumenti più o meno formali per modellare concettualmente il programma che deve realizzare l'algoritmo progettato. Uno di questi strumenti che ha goduto di una grande popolarità sin dagli albori della programmazione è il diagramma di flusso. Un'altra tecnica di modellazione che molti programmatori trovano comoda, è quella dello pseudocodice. Consiste nello scrivere l'algoritmo in un linguaggio di programmazione "finto", ma con una maggiore flessibilità, con la possibilità di utilizzare delle espressioni in linguaggio naturale laddove sia necessario specificare con maggiore chiarezza che cosa debba fare una linea di codice. Oltre ad aiutare il programmatore ad ottenere un programma corretto, la fase di modellazione concettuale ha l'effetto secondario benefico di concorrere alla produzione di documentazione.
Questa è la fase in cui il programma vero e proprio viene scritto nel linguaggio di programmazione prescelto. La scelta di un particolare linguaggio di programmazione piuttosto che un altro dipende da diversi fattori. Il programmatore in generale tenderà a scegliere il linguaggio di programmazione che gli renderà, per cosi dire, la vita più semplice, cioè che gli permetterà di raggiungere il suo scopo con il minimo sforzo.
Verifica e correzione E' molto improbabile che un programma, soprattutto se lungo e complesso, risulti completamente esente da errori di qualsiasi tipo al primo colpo. Si rende quindi necessaria, dopo la codifica, una fase più o meno lunga di verifica (testing) e di correzione (debugging) del programma. La verifica può essere eseguita in due modi:
Collaudo empirico: provare con dati di prova e vedere se i risultati sono sempre corretti (rispettano le specifiche). Non garantisce la correttezza.
Verifica formale dei programmi
Tutto quanto riportato in questa pagina è a puro scopo informativo personale. Se non ti trovi in accordo con quanto riportato nella pagina, vuoi fare delle precisazioni, vuoi fare delle aggiunte o hai delle proposte e dei consigli da dare, puoi farlo mandando un email. Ogni indicazione è fondamentale per la continua crescita del sito.