4 LA PROGRAMMAZIONE AD ALTO LIVELLO

I linguaggi

I linguaggi formali sono linguaggi artificiali che seguono delle regole prestabilite. Sono esempi di linguaggi formali quello della matematica, della logica e anche i linguaggi di programmazione usati in informatica. Le regole per la loro compilazione sono state create “a tavolino”, quindi questi linguaggi sono privi di eccezioni e perciò sono non ambigui.

I linguaggi di programmazione vengono usati dai programmatori per “parlare” con il computer e si dividono in:

• linguaggi ad alto livello: usano parole in una lingua (per esempio inglese) che è più “vicina” (comprensibile) all’uomo rispetto al computer. Sono esempi di linguaggi ad alto livello il C, C++, Java, Python, Visual Basic, PHP ecc. Un’importante caratteristica dei linguaggi ad alto livello è quella di rendere il codice del programma indipendente dalla macchina su cui viene eseguito. Un codice sorgente scritto in linguaggio C può funzionare su qualunque computer: è compito del compilatore renderlo comprensibile al processore, traducendolo nel linguaggio macchina di quel processore specifico;
• linguaggi a basso livello: i computer non sono in grado di comprendere direttamente i linguaggi ad alto livello che devono quindi essere tradotti in linguaggio a basso livello (linguaggio macchina), direttamente comprensibile al processore. Scrivere un programma in linguaggio macchina, per un uomo, non è banale. Un’importante caratteristica dei linguaggi a basso livello è quella di essere totalmente dipendenti dalla macchina su cui viene eseguito il codice.

Gli errori

Quando un programma sorgente viene compilato, il compilatore potrebbe trovare e segnalare la presenza di errori formali, cioè di errori lessicali o sintattici (parole o sintassi sbagliate) che possono essere di due tipi:

1. warning: si tratta di avvertimenti segnalati dal compilatore. Consentono la creazione del programma oggetto, ma potrebbero creare problemi in fase di esecuzione al verificarsi di particolari condizioni. Il programmatore può decidere se ignorarli o correggerli. Per esempio il compilatore potrebbe segnalare che è stato dichiarato che esiste una variabile, ma nel programma non è mai stata usata;

2. error: sono errori veri e propri, che non consentono la creazione del programma oggetto: bloccano il lavoro di traduzione in fase di compilazione e devono essere corretti. Per esempio se nel programma sorgente una parentesi viene aperta ma non viene chiusa, il programma non viene compilato; il computer evidenzia l’errore impedendo la generazione del codice eseguibile.

Per correggere gli errori formali, il programmatore deve passare all’editor di testo, correggere l’errore e ricompilare il codice sorgente.

Gli errori di run-time sono quelli segnalati durante l’esecuzione di un programma. Non sono segnalati durante la compilazione e sono errori logici (cioè introdotti da un algoritmo errato) che bloccano l’avanzamento del processo in esecuzione. Il programma viene compilato normalmente, il computer non evidenzia alcun errore e non impedisce la generazione del codice eseguibile perché dal punto di vista formale, il programma è accettabile.

Il confronto tra compilatore e interprete

Un compilatore è un software che traduce il codice sorgente (cioè le istruzioni scritte in un linguaggio di programmazione) in codice oggetto (cioè in istruzioni in linguaggio macchina). Il processo di “traduzione” si chiama compilazione.

In generale il compilatore è in grado di riconoscere alcune classi di errori presenti nel programma e, in alcuni casi, di suggerire come correggerli.

Un interprete è un software che esegue un programma scritto in linguaggio di alto livello senza passare attraverso la compilazione (codice oggetto), ma eseguendo le istruzioni partendo direttamente dal codice sorgente, traducendole di volta in volta in istruzioni in linguaggio macchina.

Utilizzare un interprete (invece di un compilatore) comporta minore efficienza durante l’esecuzione del programma (run-time). La quantità di memoria richiesta è maggiore e l’esecuzione viene rallentata dalle continue attività di interpretazione delle istruzioni eseguite dall’interprete. D’altro canto, però, l’interpretazione di un programma velocizza la fase di sviluppo del codice. Se si utilizza un compilatore non è possibile eseguire il programma finché non è completamente corretto. Gli interpreti, invece, sono in grado di eseguire anche i programmi che contengono istruzioni non interpretabili. Se l’interprete non è in grado di eseguire un’istruzione, la salta e passa a quella successiva.

I programmi compilati hanno il vantaggio di poter essere considerati più sicuri, rispetto a quelli interpretati, perché i programmi eseguibili possono essere testati e installati su macchine specifiche.

I programmi interpretati, essendo tradotti nello stesso momento in cui vengono eseguiti, hanno il vantaggio di risultare maggiormente indipendenti dalla piattaforma utilizzata.

Il debugger

Quando viene commesso un errore logico (per esempio una soluzione sbagliata, ma scritta correttamente), il computer non se ne accorge. È compito del programmatore trovare questi errori durante la fase di validazione del codice.

Il ▶ debugger è un software che aiuta il programmatore a individuare gli errori logici consentendo di eseguire un’istruzione per volta o di stabilire dei ▶ breakpoint, per permettere al programmatore di controllare i valori assunti dalle variabili in determinati punti del programma.

La documentazione

La documentazione del software è costituita da un insieme di testi che spiegano come funziona il programma o come si utilizza.

La documentazione può essere destinata a:

• programmatori: viene prodotta dal programmatore durante la fase di codifica e aiuta a capire che cosa c’è scritto nel programma. È utile sia al programmatore che ha scritto il codice sorgente, che potrebbe aver bisogno di modificare, ampliare o migliorare il programma a distanza di tempo, sia ad altri programmatori, che potranno fare riferimento alla documentazione per “avere un’idea” del codice sorgente su cui dovranno lavorare, in modo da non dover partire completamente da zero.

  La documentazione destinata ai programmatori può essere scritta sotto forma di:

  • commenti: all’interno del codice sorgente, il programmatore può inserire delle frasi che “commentano” e spiegano come funziona il codice stesso. I commenti vengono ignorati dal compilatore, ma sono molto utili per coloro che mettono mano al codice sorgente;
  • documenti di testo: il programmatore può scrivere dei manuali, sia in formato cartaceo sia in formato elettronico, che forniscono informazioni sul programma ai programmatori. Per documentare i grandi progetti spesso vengono utilizzati dei software wiki, cioè dei software “collaborativi” che consentono di creare e modificare intere pagine web utilizzando semplicemente un browser. Le pagine web generate vengono condivise tra i vari programmatori;
• utenti: è destinata agli utenti finali del programma e, all’interno dei grandi progetti, viene scritta da persone diverse dai programmatori, che conoscono il programma e soprattutto la sua interfaccia utente. La documentazione destinata agli utenti finali descrive come utilizzare il programma e può essere presentata sotto forma di:
  • tutorial e videotutorial: guidano l’utente (soprattutto alle “prime armi”) alla conoscenza del programma, passo dopo passo;
  • manuale: utile all’utente intermedio per concentrarsi su una particolare area di interesse;
  • guida in linea: valida per l’utente esperto che conosce quali informazioni cercare.

Le regole per una buona programmazione

Lo sviluppo di un software può richiedere qualche anno, ma la sua manutenzione può durare anche per decenni.

Dopo che un programma è stato consegnato all’utente finale, infatti, è necessario continuare a correggere gli errori che possono verificarsi, apportare le modifiche che consentono di migliorarne le prestazioni o aggiungere funzionalità e adattare il programma ai sistemi informatici che, per loro natura, sono in continua evoluzione.

Per contenere i costi di manutenzione, in fase di codifica è fondamentale realizzare una buona programmazione seguendo alcuni accorgimenti, spesso piuttosto semplici, come:

• usare nomi significativi per le variabili (per esempio “nome” invece di “n”);
• esplicitare i tipi previsti per i dati di input e di output (interi, reali ecc.);
• scrivere i programmi utilizzando le tre strutture di controllo fondamentali e quelle derivate;
• utilizzare i sottoprogrammi, quindi suddividere i programmi in moduli che svolgano determinate funzioni all’interno del programma complessivo;
• inserire frequenti commenti;
• provare l’esecuzione con dati verosimili per validare la correttezza del programma, testando tutte le diramazioni del codice;
• fornire il manuale per l’utente, con le istruzioni per l’uso del programma.

Scrivere un programma funzionante non è sufficiente. In base al paradigma della programmazione strutturata, un programma è strutturato se:

1. non ha salti incondizionati: non usa le istruzioni di goto, tipiche dei vecchi linguaggi;

2. è indentato: le sue righe di codice rientrano in base al principio di annidamento delle istruzioni;

3. è documentato: è commentato e corredato dalla documentazione del software.