Bernd
Pol

# Sviluppo su &UNIX;

## Alcune note storiche

Fin dall'inizio &UNIX; ha mantenuto due paradigmi di sviluppo molto diversi tra loro. Uno è costituito dal mondo dei linguaggi di programmazione, dove il codice sorgente è tradotto in linguaggio macchina da un programma di traduzione, solitamente un compilatore o un interprete. Il linguaggio di programmazione C ne è un esempio. &UNIX; fu il primo kernel di sistema operativo ad essere scritto interamente in un linguaggio di alto livello, invece del linguaggio assembler, fortemente legato alla macchina, che era comunemente usato prima di allora. (Di fatto, il linguaggio C venne addirittura inventato per scrivere il kernel &UNIX; e i programmi associati su un computer DEC PDP-11).

L'altro paradigma è costituito dai linguaggi di scripting. Si è evoluto con l'invenzione della shell &UNIX; che era l'interfaccia utente del sistema operativo — e allo stesso tempo un linguaggio di programmazione ad un livello molto alto. Uno script della shell è formato da un insieme di piccoli programmi di utilità come &eg; `grep`, `sed` o `find`. Ognuno di essi è progettato per un compito ben definito. Il trucco consiste nel fatto che ogni programma di questo tipo può essere connesso ad un altro attraverso un semplice meccanismo di trasferimento chiamato pipe, che direziona l'output di una utility nell'input di un'altra successiva. Questo lo rende uno strumento di programmazione molto potente e altamente flessibile.

Col passare del tempo si sono evoluti entrambi gli ambiti. Mentre il C viene ancora usato principalmente come un linguaggio di programmazione di sistema, il C++, una variante del C arricchito dell'orientamento agli oggetti e della programmazione generica, ha trovato negli anni '90 il suo posto nello sviluppo di applicazioni complesse. Esistono numerosi altri linguaggi di programmazione e anche quelli più antichi hanno conservato il loro impiego — il FORTRAN77 e Ada &eg; hanno ancora il loro punto di forza nelle applicazioni numeriche.

## Linguaggi di scripting contemporanei

Nell'area dello scripting, c'è stato un allontanamento dalla shell, che soffriva di problemi di portabilità, verso linguaggi che unificavano tutte le funzionalità necessarie nelle loro librerie standard e se necessario potevano comunque interfacciarsi verso l'esterno attraverso le pipe.

Tutti questi linguaggi di scripting avevano in comune il fatto che erano ampiamente portabili attraverso le varianti di &UNIX;, Microsoft &Windows;, &MacOS; e anche VMS. Inoltre tutti disponevano di implementazioni che erano liberamente distribuibili.

### &perl;

Il &perl; divenne popolare come elaboratore di testo e linguaggio di amministrazione di sistema. All'inizio del World Wide Web, gli script CGI in &perl; erano largamente usati per creare pagine Web dinamiche connesse ai database. Oggi questo metodo è stato rimpiazzato prevalentemente dal plugin `mod_perl` del server web &apache;. Tra i punti di forza del &perl; c'è il suo supporto incorporato per le espressioni regolari avanzate e il suo ricco archivio di moduli liberamente distribuibili.

Per ulteriori informazioni vedere il sito Comprehensive Perl Archive Network (CPAN).

### Python

Il &python; spicca per l'eleganza del suo sistema di classi e la facilità e flessibilità con la quale le librerie esterne possono essere incapsulate in modo da farle apparire come classi e funzioni standard di &python;. In contrasto con il &perl;, &python; ha incluso delle &API; chiare e concise che lo rendono un linguaggio di prima qualità per rendere scriptabili i programmi C e C++.

### PHP

&php; fu inventato come un linguaggio includibile nelle pagine &HTML;, di conseguenza ha il suo principale utilizzo nel trasmettere contenuti dinamici nel web.

## Scripting di alto livello

Le applicazioni &UNIX; di alto livello generalmente non sono veloci e flessibili come i tradizionali script di shell. Questo vale soprattutto per le interfacce grafiche (&GUI;) come &eg; &kde;.

Sono stati fatti tentativi per creare meccanismi simili operanti ad alto livello come CORBA e &DCOP; nell'ambiente &kde;.

### Il protocollo CORBA

CORBA (Common Object Request Broker Architecture) permette alle applicazioni di operare assieme attraverso una rete. È stato ideato dal comitato OMG (Object Management Group).

I programmi basati su CORBA comunicano usando il protocollo standard IIOP. Sono disponibili implementazioni di IIOP per molti sistemi operativi, linguaggi di programmazione e reti, che rendono questo protocollo molto portabile.

Il principale svantaggio è costituito dalla lentezza, che può essere accettabile in un network ma diventa un vero e proprio ostacolo per le comunicazioni in un ambiente costituito da un singolo computer come &kde;.

### L'interfaccia &DCOP;

Un'altra evoluzione dello scripting è il protocollo DCOP progettato per superare le limitazioni di CORBA e usato per le comunicazioni tra applicazioni &kde;.

&DCOP; significa Desktop Communication Protocol ed è implementato come un semplice meccanismo IPC/RPC costruito per operare con i socket. In pratica esso fornisce funzioni simili ai tradizionali meccanismi pipe di &UNIX;.

Lo scripting shell tradizionale è basato completamente su piccoli programmi che sono progettati per lavorare su basi strettamente testuali. &DCOP; permette a programmi grafici complicati di comunicare con altri in modo simile. Questo permette &eg; ad un programma &kde; di inviare messaggi ad un altro programma &kde;, oppure ricevere dati da esso per vari scopi.

Sono comunque presenti alcuni svantaggi: per usare &DCOP; un programma deve essere progettato per contenere una speciale interfaccia &DCOP;, e il processo di comunicazione è piuttosto lento (sebbene sia molto più veloce di CORBA). Tuttavia rende disponibile molto del potere e della flessibilità tipici dello scripting &UNIX; a programmi di alto livello basati sull'interfaccia grafica.

Per ulteriori informazioni, vedere il documento DCOP: Desktop COmmunications Protocol o la documentazione di riferimento alle &API; della libreria &DCOP; di &kde;.

## Sistemi di compilazione

Salvo i casi semplici il proprio progetto consisterà di molti blocchi di codice sorgente collocati in diversi file, in modo da semplificare da manutenzione. Per farlo funzionare è necessario tradurre questo codice in poche unità di linguaggio macchina in un formato appropriato che permetta al sistema operativo di caricare ed eseguire il programma.

I principali strumenti necessari sono:

- un editor di testi per scrivere i file sorgente,

- un programma di traduzione, normalmente un compilatore, per convertire il codice sorgente in file oggetto,

- un librarian che raccoglie i file oggetto in librerie per poterli riutilizzare facilmente senza la necessità di ricompilare,

- un linker che riunisce i vari file oggetto e le librerie in un eseguibile,

- un sistema make che fornisce i mezzi per gestire tutte queste cose e — da non dimenticare

- un debugger per (si spera) trovare tutti gli errori nel programma e altri strumenti di diagnosi.

Il processo di compilazione può diventare laborioso quando si lavora ad un grande progetto che può contenere anche centinaia di file sorgente. Quando si vogliono modificare alcuni di questi file non è opportuno ricompilare tutto il progetto, ma solo i file interessati. Generalmente non è immediato capire quali file debbano essere ricompilati.

Ad esempio, quando si modifica il prototipo di una funzione in un file header si devono ricompilare tutti i file che lo includono. Nel caso di un grande progetto si possono facilmente dimenticare alcuni file che devono essere ricompilati. Quindi è necessario un qualche sistema automatico.

### Il processo make

Uno strumento che si occupa della ricompilazione è `make`. Esso mantiene la traccia di tutto il lavoro usando un insieme di regole che descrivono cosa fare nel caso vengano cambiate alcune parti di informazione (normalmente un file sorgente o oggetto). Tutte le regole che appartengono a un certo progetto sono conservate in un file chiamato `Makefile` che è analizzato da `make` ogni volta che si vuole aggiornare il proprio lavoro.

Ogni regola consiste di diversi blocchi:

- un target, cioè il file che deve essere compilato

- un insieme di dipendenze, fondamentalmente il nome dei file dai quali dipende il target (ad esempio se il target è un file oggetto che deve essere costruito la dipendenza sarà il nome del file sorgente) e

- i comandi che devono essere eseguiti per costruire il target (es. compilarlo o collegare vari file oggetto per costruire il file eseguibile).

Sostanzialmente il comando `make` leggerà le regole una per una, controllando ogni file contenuto nella lista delle dipendenze di un determinato target. Se qualcuno di questi file è stato modificato verrà ricostruito il target usando i comandi elencati nella regola.

Ci sono diversi sistemi per controllare questo processo di compilazione e un `Makefile` può diventare molto complesso. Si raccomanda di abituarsi alla sintassi di `make`: anche se non lo si usa direttamente può essere utile comprendere le nozioni fondamentali del sistema di compilazione. Vedere il Manuale di GNU Make per maggiori informazioni.

Per maggiori dettagli relativi a &kdevelop; vedere il capitolo Compilazione e gestione dei progetti di questo manuale.

Esistono diversi tutorial disponibili, vedere i riferimenti nel capitolo riguardante la compilazione e la gestione dei progetti.

## Sviluppo di &GUI;

In aggiunta alla logica e alle librerie di un programma gli sviluppatori devono anche creare una interfaccia utente facile da usare che sia intuitiva e funzionale. Tuttavia molti programmatori hanno una scarsa preparazione nello sviluppo di &GUI;, che spesso vengono progettate male.

Attraverso gli anni si sono evoluti alcuni principi di progettazione comuni. Si raccomanda caldamente di seguirli, in modo da costruire interfacce utente con un aspetto uniforme che verranno apprezzate dagli utenti.

Per lo sviluppo di &GUI; in &kde; è disponibile una guida allo stile che si può trovare all'indirizzo &kde; User Interface Guidelines della pagina Developer's Corner di &kde;.

Qui è disponibile una breve introduzione ai principi guida più usati nella progettazione di &GUI;.

## Integrare concetti e strumenti – l'IDE

Per quasi tutte le fasi della programmazione — pianificazione, modifica e gestione dei file, compilazione, debug e documentazione sono disponibili diversi strumenti. Tuttavia quando la complessità di un progetto aumenta il processo di programmazione tende a diventare scomodo.

La progettazione, la compilazione e il debug di un programma sono attività molto ripetitive. Si può risparmiare molto lavoro attraverso l'uso di modelli e script e utilizzando strumenti facilmente disponibili e capaci di comunicare tra loro attraverso un'interfaccia utente comune.

Ad esempio— non sarebbe pratico se un debugger potesse aprire il file sorgente in un editor e posizionare il cursore nella posizione in cui viene trovato il bug?

A questo scopo vennero ideati gli Ambienti di sviluppo integrato Integrated Development Environments, (&IDE;). Un &IDE; integra in un singolo ambiente tutti i modelli, gli strumenti e gli script necessari al processo di sviluppo.

&kdevelop; è un &IDE; per la piattaforma &kde;. Esso fornisce una vasta gamma di strumenti che semplificano lo sviluppo di programmi e la loro manutenzione, anche per diversi linguaggi di programmazione e differenti piattaforme.

### Caratteristiche di base di &kdevelop; &kdevrelease;

- Gestisce tutti gli strumenti di sviluppo necessari per la programmazione in C++, come il compilatore, il linker, il debugger e il sistema di compilazione.

- Fornisce una procedura guidata che genera applicazioni di esempio complete e pronte ad essere eseguite.

- Permette all'utente di selezionare un editor integrato basato sull'editor di &kde; &kwrite;, sul QEditor di Trolltech o su altri.

- Fornisce un generatore di classi, per creare nuove classi e integrarle nel progetto corrente.

- Gestisce i file dei sorgenti, degli header, della documentazione, ecc. da includere nel progetto.

- Assiste nella creazione dei manuali utente delle applicazioni scritte con gli strumenti di &kde;.

- Permette di scrivere la documentazione &API; in &HTML; delle classi del progetto con riferimenti incrociati alle librerie usate.

- Supporta l'internazionalizzazione, che permette ai traduttori di aggiungere in modo semplice il loro linguaggio ad un progetto, includendo il supporto per &kbabel;.

- Supporta la gestione di un progetto attraverso un versioning system (&eg; &CVS;) fornendo un frontend facile da usare per le funzioni più importanti.

- Include un frontend integrato per il debugger.

- Fornisce un emulatore integrato di shell.

- Fornisce l'evidenziazione della sintassi nel codice sorgente.

- Effettua il completamento automatico del codice per le variabili di classe, i metodi, gli argomenti di funzione e altro.

- Sono presenti vari modelli per la creazione di vari progetti (moduli del &kcontrol;, applet di &kicker; (panel), KIOSlaves, plugin di &konqueror; e stili del desktop).

- Possiede quattro viste ad albero per passare velocemente attraverso file sorgente, file header, classi e documentazione, evitando la necessità di un gestore file esterno.

- Supporta la cross-compilazione, con la possibilità di specificare diversi compilatori, opzioni, architetture di destinazione, ecc.

- Supporta i progetti Qt/Embedded (come Zaurus e iPAQ)

- Include vari programmi necessari allo sviluppo che possono essere aggiunti al menu Strumenti a seconda delle proprie necessità.