linguaggio+di+programmazione

In [|informatica], un **linguaggio di programmazione** è un [|linguaggio formale], dotato (al pari di un qualsiasi linguaggio naturale) di un lessico, di una sintassi e di una semantica ben definiti, utilizzabile per il controllo del comportamento di una [|macchina formale] o di una implementazione di essa (tipicamente, un [|computer]). Condizione sufficiente per un linguaggio per essere considerato un linguaggio di programmazione è di essere [|Turing-complete].



__ Concetti base __
Tutti i linguaggi di programmazione esistenti possiedono (almeno) questi due concetti chiave: Alcuni concetti sono poi presenti nella gran parte dei linguaggi:
 * [|Variabile]: un dato o un insieme di dati, noti o ignoti, già memorizzati o da memorizzare; ad una variabile corrisponde sempre, da qualche parte, un certo numero (fisso o variabile) di locazioni di memoria che vengono //allocate//, cioè riservate, per contenere i dati stessi. Molti linguaggi inoltre attribuiscono alle variabili un tipo, con differenti proprietà (stringhe di testo, numeri, liste, //atomi// ecc.).
 * [|Istruzione]: un comando, una funzione, oppure una regola descrittiva: anche il concetto di istruzione è molto variabile fra i vari linguaggi. A prescindere dal particolare linguaggio però, ogni volta che un'istruzione viene eseguita, lo stato interno del calcolatore (che sia lo stato reale della macchina oppure un ambiente virtuale, teorico, creato dal linguaggio) cambia.
 * [|Espressione]: una combinazione di variabili e [|costanti], unite da [|operatori]; le espressioni sono state introdotte inizialmente per rappresentare le espressioni matematiche, ma in seguito la loro funzionalità si è estesa. Una espressione viene **valutata** per produrre un valore, e la sua valutazione può produrre "effetti collaterali" sul sistema e/o sugli oggetti che vi partecipano.
 * [|Strutture di controllo], che permettono di governare il flusso dell'esecuzione del programma, alterandolo in base al risultato o valutazione di una espressione (che può ridursi al contenuto di una variabile, o essere anche molto complessa).
 * [|Sottoprogramma]: un blocco di codice che può essere richiamato da qualsiasi altro punto del programma.
 * [|Strutture dati], meccanismi che permettono di organizzare e gestire dati complessi.
 * funzionalità di [|input] dati da tastiera e visualizzazione in [|output] (stampa a video).



Il codice sorgente
Programmare in un dato linguaggio di programmazione significa generalmente scrivere uno o più semplici file di testo ASCII, chiamato **[|codice sorgente]**. I font, i colori e in generale l'aspetto grafico sono irrilevanti ai fini della programmazione in sé: per questo i programmatori non usano programmi di videoscrittura ma degli //editor// di testo (come //emacs// e //brief//) che invece offrono funzioni avanzate di trattamento testi (//[|espressioni regolari]//, sostituzioni condizionali e ricerche su file multipli, possibilità di richiamare strumenti esterni ecc). Se un dato editor è in grado di lavorare a stretto contatto con gli altri strumenti di lavoro (compilatore, linker, interprete ecc.: vedi più avanti) allora più che di semplice editor si parla di **[|IDE]** o ambiente di sviluppo integrato. Va notato che alcuni linguaggi di programmazione recenti consentono anche una forma mista di programmazione, in cui alla stesura di codice sorgente ASCII si associano anche operazioni di [|programmazione visuale], attraverso le quali il programmatore descrive alcuni aspetti del programma //disegnando// a video attraverso il mouse; un'applicazione tipica di quest'ultima forma di programmazione è il disegno interattivo della [|GUI] del programma (finestre, menù, e così via).

Compilazione e interpretazione
Il codice sorgente, contenente le istruzioni da eseguire e (spesso) alcuni dati noti e costanti, può essere poi eseguito passandolo ad un [|interprete] che eseguirà le istruzioni in esso contenute, il che è la prassi normale per i [|linguaggi di scripting]; oppure può venire compilato, cioè tradotto in istruzioni di linguaggio macchina da un programma [|compilatore]: il risultato è un file binario 'eseguibile' ([|codice eseguibile]) che non ha bisogno di altri programmi per andare in esecuzione, ed è anche molto più veloce di un programma interpretato. In passato, la compilazione è stata la norma per tutti i linguaggi di programmazione di uso generale; attualmente vi sono numerosi linguaggi interpretati e di uso generale, come il linguaggio [|Java] o quelli della piattaforma [|.NET], che applicano un approccio ibrido fra le due soluzioni, utilizzando un compilatore per produrre del codice in un linguaggio //intermedio// (detto [|bytecode]) che viene successivamente interpretato. La differenza di prestazioni tra i linguaggi interpretati e quelli compilati è stata ridotta con tecniche di [|compilazione just-in-time], sebbene si continui ad utilizzare i linguaggi compilati (se non addirittura l'[|assembly]) per le applicazioni che richiedono le massime prestazioni possibili.

La compilazione
La compilazione è il processo per cui il programma, scritto in un linguaggio di programmazione ad alto livello, viene tradotto in un [|codice eseguibile] per mezzo di un altro programma detto appunto [|compilatore]. La compilazione offre numerosi vantaggi, primo fra tutti il fatto di ottenere eseguibili velocissimi nella fase di run (esecuzione) adattando vari parametri di questa fase all'hardware a disposizione; ma ha lo svantaggio principale nel fatto che è necessario compilare un eseguibile diverso per ogni sistema operativo o hardware (piattaforma) sul quale si desidera rendere disponibile l'esecuzione ovvero viene a mancare la cosiddetta [|portabilità].

__ Il collegamento (linking) __
Se il programma, come spesso accade, usa delle [|librerie], o è composto da più [|moduli software], questi devono essere 'collegati' tra loro. Lo strumento che effettua questa operazione è detto appunto [|linker] ("collegatore"), e si occupa principalmente di risolvere le interconnessioni tra i diversi moduli. Esistono principalmente due tipi differenti di collegamento: **dinamico** e **statico**.

** Collegamento statico **
Tutti i moduli del programma e le librerie utilizzate vengono incluse nell'eseguibile, che risulta grande, ma contiene tutto quanto necessario per la sua esecuzione. Se si rende necessaria una modifica ad una delle librerie, per correggere un errore o un problema di [|sicurezza], tutti i programmi che le usano con collegamento statico devono essere ricollegati con le nuove versioni delle librerie.

** Collegamento dinamico **
Le librerie utilizzate sono caricate dal sistema operativo quando necessario (//linking dinamico//; le librerie esterne sono chiamate "DLL", //[|Dynamic-link libraries]// nei sistemi Microsoft Windows, mentre "SO" //[|Shared Object]// nei sistemi [|Unix-like]). L'eseguibile risultante è più compatto, ma dipende dalla presenza delle librerie utilizzate nel sistema operativo per poter essere eseguito. In questo modo, le librerie possono essere aggiornate una sola volta a livello di sistema operativo, senza necessità di ricollegare i programmi. Diventa anche possibile usare diverse versioni della stessa libreria, o usare librerie personalizzate con caratteristiche specifiche per il particolare host. Nella realizzazione di un progetto software complesso, può succedere che alcune parti del programma vengano realizzate come librerie, per comodità di manutenzione o per poterle usare in diversi programmi che fanno parte dello stesso progetto. La complicazione aggiunta è che quando si installa un programma con collegamento dinamico è necessario verificare la presenza delle librerie che utilizza, ed eventualmente installare anche queste. I sistemi di package management, che si occupano di installare i programmi su un sistema operativo, di solito tengono traccia automaticamente di queste dipendenze. In genere si preferisce il collegamento dinamico, in modo da creare programmi piccoli e in generale ridurre la memoria RAM occupata, assumendo che le librerie necessarie siano già presenti nel sistema, o talvolta distribuendole insieme al programma.

media type="youtube" key="aAkaw1hY07Y?fs=1" height="287" width="358" align="right"__ L'interpretazione __


Il grosso difetto di questi linguaggi è la lentezza dell'esecuzione; però hanno il grosso pregio di permettere di usare lo stesso programma senza modifica su più piattaforme. Si dice in questo caso che il programma è [|portabile]. La perdita di prestazioni che è alla base dei linguaggi interpretati è il doppio lavoro che è affidato alla macchina che si accinge ad elaborare tale programma. Al contrario di un programma compilato, infatti, ogni istruzione viene controllata e interpretata ad ogni esecuzione da un [|interprete]. Si usano linguaggi interpretati nella fase di messa a punto di un [|programma] per evitare di effettuare numerose compilazioni o invece quando si vuole creare software che svolgono operazioni non critiche che non necessitano di ottimizzazioni riguardanti velocità o dimensioni, ma che traggono più vantaggio dalla portabilità. I linguaggi di [|scripting] e tutti quelli orientati al [|Web] sono quasi sempre interpretati. [|PHP], [|Perl], [|Tcl/Tk], [|Java] volendo, e [|JavaScript], [|Python] e molti altri sono esempi concreti di interazione non vincolata alla piattaforma. Ci sono vari tentativi per rendere i compilatori multipiattaforma creando un livello intermedio, una sorta di semi-interpretazione, come nel caso sopra menzionato di [|Java]; d'altro canto per i linguaggi interpretati ci sono tentativi per generare delle compilazioni (o semi-compilazioni) automatiche specifiche per la macchina su cui sono eseguiti. Esistono anche strumenti per automatizzare per quanto possibile la compilazione di uno stesso programma su diverse piattaforme, ad esempio [|GNU] [|autoconf]/[|automake], che permette di realizzare una distribuzione del codice sorgente che può essere configurata e compilata automaticamente su diverse piattaforme, in genere almeno tutti gli [|Unix].

Confronto tra compilazione e interpretazione
Un esempio di codice sorgente in [|Python]. L'[|evidenziazione] di alcune parti di codice è uno strumento comune fra i programmatori per orientarsi fra il codice. Questi due metodi di creazione ed esecuzione di un programma presentano entrambi vantaggi e svantaggi: il maggior vantaggio della compilazione è senz'altro l'efficienza nettamente superiore in termini di prestazioni, al prezzo del restare vincolati ad una **piattaforma** (combinazione di architettura hardware e sistema operativo) particolare; un linguaggio interpretato invece non ha, in linea di massima, questa dipendenza ma è più lento e richiede più memoria in fase di esecuzione.

Bytecode e P-code
Una soluzione intermedia fra compilazione e interpretazione è stata adottata nei due casi del linguaggio Java, con il suo bytecode, e dei linguaggi [|Visual Basic] e [|.NET] di Microsoft con il P-code. In tutti e due questi casi il codice sorgente dei programmi non viene compilato in linguaggio macchina, ma in un codice intermedio "ibrido" destinato a venire interpretato al momento dell'esecuzione del programma: il motivo di questo doppio passaggio è di avere la portabilità dei linguaggi interpretati ma anche, grazie alla pre-compilazione, un interprete più semplice e quindi più veloce. Nel caso del bytecode di Java siamo di fronte a un vero linguaggio assembler, che in origine doveva essere implementato in un modello di processore reale, poi non più realizzato; alcuni microprocessori moderni, come gli ARM con [|Jazelle] implementano molte istruzioni bytecode e sono quindi in grado di eseguire bytecode Java come normale assembler. Tuttavia il codice intermedio è più facile sia da interpretare che da compilare: per questo motivo sia per Java che per i linguaggi .NET sono stati sviluppati i compilatori JIT (Just In Time), che al momento del lancio di un programma Java, VB o .NET compilano al volo il codice intermedio e mandano in esecuzione un normale codice macchina nativo, eliminando completamente la necessità dell'interprete e rendendo i programmi scritti in questi linguaggi veloci quasi quanto i normali programmi compilati.

Classi di linguaggi
Ad oggi (2007) esistono circa 2500 linguaggi di programmazione più o meno noti e diffusi: questi vengono normalmente classificati in tre grandi famiglie basate sul [|paradigmi di programmazione] di riferimento: i linguaggi **imperativi**, quelli **funzionali** e quelli **logici**.

__ Imperativi __
Nei linguaggi imperativi l'istruzione è un comando esplicito, che opera su una o più variabili oppure sullo stato interno della macchina, e le istruzioni vengono eseguite in un ordine prestabilito. Scrivere un programma in un linguaggio imperativo significa essenzialmente occuparsi di cosa la macchina deve fare per ottenere il risultato che si vuole, e il programmatore è impegnato nel mettere a punto gli algoritmi necessari a manipolare i dati. Le strutture di controllo assumono la forma di //istruzioni di flusso// (GOTO, FOR, IF/THEN/ELSE ecc.) e il calcolo procede per iterazione piuttosto che per ricorsione. I valori delle variabili sono spesso assegnati a partire da costanti o da altre variabili (assegnamento) e raramente per passaggio di parametri (istanziazione). Tipici linguaggi imperativi:


 * [|Assembly]
 * [|ALGOL]
 * [|B]
 * [|BASIC]
 * [|BCPL]
 * [|COBOL]
 * [|Fortran]
 * [|Forth]
 * [|Hot Soup Processor]
 * [|PL/I]
 * [|POP]

__ Strutturati __
La programmazione strutturata è una tecnica il cui scopo è di limitare la complessità della struttura del controllo dei programmi. Il programmatore è vincolato ad usare solo le strutture di controllo canoniche definite dal [|Teorema di Böhm-Jacopini], ovvero la //sequenza//, la //selezione// e il //ciclo//, evitando le istruzioni di salto incondizionato.


 * [|Ada]
 * [|C]
 * [|Modula-2]
 * [|Oberon]
 * [|Pascal]

__ Orientati ad oggetti __
La programmazione a oggetti è basata su una evoluzione del concetto di [|tipo di dato astratto] caratterizzata da [|incapsulamento], [|ereditarietà], [|polimorfismo]. Oltre a linguaggi specializzati che implementano completamente i principi di tale metodologia (come Smalltalk o Java), molti linguaggi moderni incorporano alcuni concetti della programmazione a oggetti.


 * [|Ada95]
 * [|Attack]
 * [|BETA]
 * [|Clarion]
 * [|CLOS]
 * [|C++]
 * [|C#]
 * [|D]
 * [|DataFlex]
 * [|Delphi]
 * [|Eiffel]
 * [|Java]
 * [|Modula-3]
 * [|mShell]
 * [|Objective C]
 * [|OCaml]
 * [|OpenGenera]
 * [|PHP]
 * [|Python]
 * [|PowerBuilder]
 * [|REALbasic]
 * [|REBOL]
 * [|Ruby]
 * [|Scala]
 * [|Scriptol]
 * [|Simula]
 * [|Smalltalk]
 * [|Visual Basic]
 * [|Visual Basic .NET]

__ Funzionali __
I linguaggi funzionali sono basati sul concetto matematico di funzione. In un linguaggio funzionale puro l'assegnazione esplicita risulta addirittura completamente assente (si utilizza soltanto il passaggio dei parametri). In tale modello rivestono particolare importanza la [|ricorsione], e, come struttura dati, la lista (sequenza ordinata di elementi). Il più importante rappresentante di questa categoria è senz'altro il Lisp (LISt Processing).


 * [|Clarion]
 * [|Clean]
 * [|Curry]
 * [|Haskell]
 * [|Lisp]
 * [|Logo]
 * [|Scala]
 * [|Scheme]
 * [|Standard ML]
 * [|Caml]
 * [|OCaml]

__ Dichiarativi (o logici) __
Nei linguaggi logici l'istruzione è una //clausola// che descrive una relazione fra i dati: programmare in un linguaggio logico significa descrivere l'insieme delle relazioni esistenti fra i dati e il risultato voluto, e il programmatore è impegnato nello stabilire in che modo i dati devono evolvere durante il calcolo. Non c'è un ordine prestabilito di esecuzione delle varie clausole, ma è compito dell'interprete trovare l'ordine giusto. La struttura di controllo principale è rappresentata dal **cut**, che è detto //rosso// se modifica il comportamento del programma o //verde// se rende solo più efficiente il calcolo, che procede per ricorsione e non per iterazione. Le variabili ricevono il loro valore per istanziazione o da altre variabili già assegnate nella clausola (//unificazione//) e quasi mai per assegnamento, che è usato solo in caso di calcolo diretto di espressioni numeriche. Affinché sia possibile usarli in un programma dichiarativo, tutti i normali algoritmi devono essere riformulati in termini ricorsivi e di //backtracking//; questo rende la programmazione con questi linguaggi una esperienza del tutto nuova e richiede di assumere un modo di pensare radicalmente diverso, perché più che calcolare un risultato si richiede di dimostrarne il valore esatto. A fronte di queste richieste, i linguaggi dichiarativi consentono di raggiungere risultati eccezionali quando si tratta di manipolare gruppi di enti in relazione fra loro.
 * [|Curry]
 * [|Mercury]
 * [|Prolog]

Linguaggi esoterici

 * [|Befunge]
 * [|Brainfuck]
 * [|COW]
 * [|HQ9+]
 * [|HQ9++]
 * [|INTERCAL]
 * [|Malbolge]
 * [|Whitespace]
 * [|LOLCODE]

Linguaggi paralleli
I moderni [|supercomputer] e - ormai - tutti i calcolatori di fascia alta e media sono equipaggiati con più [|CPU]. Come ovvia conseguenza, questo richiede la capacità di sfruttarle; per questo sono stati sviluppati dapprima il [|multithreading], cioè la capacità di lanciare più parti dello stesso programma contemporaneamente su CPU diverse, e in seguito alcuni linguaggi studiati in modo tale da poter individuare da soli, in fase di compilazione, le parti di codice da lanciare in parallelo.
 * [|Occam]
 * [|Linda]
 * [|Axum]

Linguaggi di scripting
I linguaggi di questo tipo nacquero come //linguaggi batch//: vale a dire liste di comandi di programmi interattivi che invece di venire digitati uno ad uno su una riga di comando, potevano essere salvati in un file, che diventava così una specie di comando composto che si poteva eseguire in [|modalità batch] per automatizzare compiti lunghi e ripetitivi. I primi linguaggi di scripting sono stati quelli delle [|shell] [|Unix]; successivamente, vista l'utilità del concetto molti altri programmi interattivi iniziarono a permettere il salvataggio e l'esecuzione di file contenenti liste di comandi, oppure il salvataggio di registrazioni di comandi visuali (le cosiddette **Macro** dei programmi di videoscrittura, per esempio). Il passo successivo fu quello di far accettare a questi programmi anche dei comandi di salto condizionato e delle istruzioni di ciclo, regolati da simboli associati ad un certo valore: in pratica implementare cioè l'uso di variabili. Ormai molti programmi nati per tutt'altro scopo offrono agli utenti la possibilità di programmarli in modo autonomo tramite linguaggi di scripting più o meno proprietari. Molti di questi linguaggi hanno finito per adottare una sintassi molto simile a quella del C: altri invece, come il Perl e il Python, sono stati sviluppati ex novo allo scopo. Visto che nascono tutti come //feature// di altri programmi, tutti i linguaggi di scripting hanno in comune il fatto di essere [|Linguaggi interpretati], cioè eseguiti da un altro programma (il programma madre o un suo modulo).


 * [|AutoIt]
 * [|Applescript]
 * [|ActionScript]
 * [|Game Maker Language] (vedi [|Game Maker])
 * [|Hybris]
 * [|HyperTalk]
 * [|JavaScript]
 * [|JScript] (Implementazione [|Microsoft] di [|Javascript])
 * [|mIRC scripting]
 * [|Lua]
 * [|Perl]
 * [|PHP]
 * [|Python]
 * [|QBasic]
 * [|Rexx]
 * [|Ruby]
 * [|Tcl]
 * [|thinBasic]
 * [|Visual Basic for Applications] (VBA)
 * [|VBScript]

Valutare un linguaggio di programmazione
Non ha senso, in generale, parlare di linguaggi migliori o peggiori, o di linguaggi migliori in assoluto: ogni linguaggio nasce per affrontare una classe di problemi più o meno ampia, in un certo modo e in un certo ambito. Però, dovendo dire se un dato linguaggio sia adatto o no per un certo uso, è necessario valutare le caratteristiche dei vari linguaggi.

Caratteristiche intrinseche
Sono le qualità del linguaggio in sé, determinate dalla sua sintassi e dalla sua architettura interna. Influenzano direttamente il lavoro del programmatore, condizionandolo. Non dipendono né dagli strumenti usati (compilatore/interprete, IDE, linker) né dal sistema operativo o dal tipo di macchina. A volte, un programma molto complesso e poco leggibile in un dato linguaggio può diventare assolutamente semplice e lineare se riscritto in un linguaggio di classe differente, più adatta. L'esempio più comune di linguaggio robusto è il Pascal, che essendo nato a scopo didattico presuppone sempre che una irregolarità nel codice sia frutto di un errore del programmatore; mentre l'assembly è l'esempio per antonomasia di linguaggio totalmente libero, in cui niente vincola il programmatore (e se scrive codice pericoloso o errato, non c'è niente che lo avverta).
 * **Espressività**: la facilità e la semplicità con cui si può scrivere un dato algoritmo in un dato linguaggio; può dipendere dal tipo di algoritmo, se il linguaggio in questione è nato per affrontare certe particolari classi di problemi. In generale se un certo linguaggio consente di scrivere algoritmi con poche istruzioni, in modo chiaro e leggibile, la sua espressività è buona.
 * **Didattica**: la semplicità del linguaggio e la rapidità con cui lo si può imparare. Il BASIC, per esempio, è un linguaggio facile da imparare: poche regole, una sintassi molto chiara e limiti ben definiti fra quello che è permesso e quello che non lo è. Il Pascal non solo ha i pregi del BASIC ma educa anche il neo-programmatore ad adottare uno stile corretto che evita molti errori e porta a scrivere codice migliore. Al contrario, il C non è un linguaggio didattico perché pur avendo poche regole ha una semantica molto complessa, a volte oscura, che lo rende molto efficiente ed espressivo ma richiede tempo per essere padroneggiata.
 * **Leggibilità**: la facilità con cui, leggendo un codice sorgente, si può capire cosa fa e come funziona. La leggibilità dipende non solo dal linguaggio ma anche dallo stile di programmazione di chi ha creato il programma: tuttavia la sintassi di un linguaggio può facilitare o meno il compito. Non è detto che un linguaggio leggibile per un profano lo sia anche per un esperto: in generale le abbreviazioni e la concisione consentono a chi già conosce un linguaggio di concentrarsi meglio sulla logica del codice senza perdere tempo a leggere, mentre per un profano è più leggibile un linguaggio molto prolisso.
 * **Robustezza**: è la capacità del linguaggio di prevenire, nei limiti del possibile, gli errori di programmazione. Di solito un linguaggio robusto si ottiene adottando un controllo molto stretto sui tipi di dati e una sintassi chiara e molto rigida; la segnalazione e gestione di errori comuni a runtime dovuti a dati che assumono valori imprevisti ([|overflow], [|underflow]) o eccedono i limiti definiti (indici illegali per vettori o matrici) [|controllo dei limiti]; altri sistemi sono l'implementare un garbage collector, limitando (a prezzo di una certa perdita di efficienza) la creazione autonoma di nuove entità di dati e quindi l'uso dei puntatori, che possono introdurre bug molto difficili da scoprire.
 * **Modularità**: quando un linguaggio facilita la scrittura di parti di programma indipendenti (moduli) viene definito //modulare//. I moduli semplificano la ricerca e la correzione degli errori, permettendo di isolare rapidamente la parte di programma che mostra il comportamento errato e modificarla senza timore di introdurre conseguenze in altre parti del programma stesso. Questo si ripercuote positivamente sulla **manutenibilità** del codice; inoltre permette di riutilizzare il codice scritto in passato per nuovi programmi, apportando poche modifiche. In genere la modularità si ottiene con l'uso di sottoprogrammi (subroutine, procedure, funzioni) e con la programmazione ad oggetti.
 * **Flessibilità**: la possibilità di adattare il linguaggio, estendendolo con la definizione di nuovi comandi e nuovi operatori. I linguaggi classici come il BASIC, il Pascal e il Fortran non hanno questa capacità, che invece è presente nei linguaggi dichiarativi, in quelli funzionali e nei linguaggi imperativi ad oggetti più recenti come il C++ e Java.
 * **Generalità**: la facilità con cui il linguaggio si presta a codificare algoritmi e soluzioni di problemi in campi diversi. Di solito un linguaggio molto generale, per esempio il C, risulta meno espressivo e meno potente in una certa classe di problemi di quanto non sia un linguaggio specializzato in quella particolare nicchia, che in genere è perciò una scelta migliore finché il problema da risolvere non esce da quei confini.
 * **Efficienza**: la velocità di esecuzione e l'uso oculato delle risorse del sistema su cui il programma finito gira. In genere i programmi scritti in linguaggi molto astratti tendono ad essere lenti e voraci di risorse, perché lavorano entro un modello che non riflette la reale struttura dell'hardware ma è una cornice concettuale, che deve essere ricreata artificialmente; in compenso facilitano molto la vita del programmatore poiché lo sollevano dalla gestione di numerosi dettagli, accelerando lo sviluppo di nuovi programmi ed eliminando intere classi di errori di programmazione possibili. Viceversa un linguaggio meno astratto ma più vicino alla reale struttura di un computer genererà programmi molto piccoli e veloci ma a costo di uno sviluppo più lungo e difficoltoso.
 * **Coerenza**: l'applicazione dei principi base di un linguaggio in modo uniforme in tutte le sue parti. Un linguaggio coerente è un linguaggio facile da prevedere e da imparare, perché una volta appresi i principi base questi sono validi sempre e senza (o con poche) eccezioni.

Caratteristiche esterne
Oltre alle accennate qualità dei linguaggi, possono essere esaminate quelle degli ambienti in cui operano. Un programmatore lavora con strumenti software, la cui qualità e produttività dipende da un insieme di fattori che vanno pesati anch'essi in funzione del tipo di programmi che si intende scrivere.
 * **Diffusione**: il numero di programmatori nel mondo che usa il tale linguaggio. Ovviamente più è numerosa la comunità dei programmatori tanto più è facile trovare materiale, aiuto, librerie di funzioni, documentazione, consigli. Inoltre ci sono un maggior numero di software house che producono strumenti di sviluppo per quel linguaggio, e di qualità migliore.
 * **Standardizzazione**: un produttore di strumenti di sviluppo sente sempre la tentazione di introdurre delle variazioni sintattiche o delle migliorie più o meno grandi ad un linguaggio, originando un //dialetto// del linguaggio in questione e fidelizzando così i programmatori al suo prodotto: ma più dialetti esistono, più la comunità di programmatori si frammenta in sottocomunità più piccole e quindi meno utili. Per questo è importante l'esistenza di uno [|standard] per un dato linguaggio che ne garantisca certe caratteristiche, in modo da evitarne la dispersione. Quando si parla di //Fortran 77//, //Fortran 90//, //C 99// ecc. si intende lo standard sintattico e semantico del tale linguaggio approvato nel tale anno, in genere dall'[|ANSI] o dall'[|ISO].
 * **Integrabilità**: dovendo scrivere programmi di una certa dimensione, è molto facile trovarsi a dover integrare parti di codice precedente scritte in altri linguaggi: se un dato linguaggio di programmazione consente di farlo facilmente, magari attraverso delle procedure standard, questo è decisamente un punto a suo favore. In genere tutti i linguaggi "storici" sono bene integrabili, con l'eccezione di alcuni, come lo Smalltalk, creati più per studio teorico che per il lavoro reale di programmazione.
 * **Portabilità**: la possibilità che portando il codice scritto su una certa **piattaforma** (CPU + architettura + sistema operativo) su un'altra, questo funzioni subito, senza doverlo modificare. A questo scopo è molto importante l'esistenza di uno standard del linguaggio, anche se a volte si può contare su degli standard //de facto// come il C //K&R// o il Delphi.

FONTE: WIKIPEDIA; http://it.wikipedia.org/wiki/Linguaggio_di_programmazione AUTORE: VITTORIO