Linguaggi di programmazione non OOP

Ingegneria del Software
Linguaggi di programmazione non OOP
Barlini Davide-Carta Daniele-Casiero Fabio-Mascia Cristiano
Abstract
Scopo principale del lavoro è quello di riportare, nelle schede, una classificazione dei
linguaggi di programmazione non orientati agli oggetti. Per far ciò, si è pensato di
procedere gradualmente andando a focalizzare via via l’obiettivo. Si introduce il concetto
di linguaggio di programmazione andando ad elencare le cinque diverse generazioni di
evoluzione degli stessi.
Cercando di fornire una classificazione accettabile, si discute dei paradigmi di
programmazione citando il paradigma procedurale ed il paradigma dichiarativo e le loro
ulteriori articolazioni. La classificazione riportata è successivamente arricchita da nuovi tipi
come i “paralleli, concorrenti, distribuiti, applicativi, scripting, markup”. Per ognuno di essi
si sono spese due parole di introduzione. Sono infine presentati i linguaggi trovati, ognuno
dei quali ha una sua introduzione ed una scheda riassuntiva che ne individua la posizione
nella classificazione proposta.
1
Indice
Linguaggi di programmazione......................................................................3
Generazioni...................................................................................................4
Paradigma di programmazione ...................................................................5
Classificazione..............................................................................................7
I vari linguaggi................................................................................................ 15
Links nel web ................................................................................................ 37
Appendice: le schede.................................................................................... 42
2
Linguaggi di programmazione
L'attività di un programmatore è quella di risolvere un problema sotto forma di algoritmo e
di tradurlo in programma in un dato linguaggio1.
Il termine algoritmo entrato in uso negli anni ’50 sostituì la parola algorismo, (processo di
calcolare con i numeri arabi), derivato da una deformazione del nome di un matematico
arabo Abu Ja’far Mohammed ibn Mˆ usˆ a al- Khowˆ arizmˆ ý (825 d. C.), ma la definizione
del matematico Markov appare più appropriata.
"L'insieme delle regole precise che definiscono un procedimento di calcolo destinato ad
ottenere un risultato determinato a partire da dati iniziali certi".
I linguaggi di programmazione costituiscono l'unico formalismo mediante il quale l'uomo
può dialogare con i sistemi informatici, siano questi hardware che software.
L'area dei linguaggi è in continua evoluzione e molto attiva anche dal punto di vista della
ricerca poiché ogni nuova applicazione ed ogni nuova architettura (sia fisica che logica
come il W.W.W.) pongono nuovi problemi e sfide ai progettisti che devono individuare i
costrutti e le strutture più naturali per il tipo di problema che si vuole risolvere e per gestire
e sfruttare in modo semplice le nuove tecnologie.
L'aumento delle potenzialità degli strumenti di calcolo ha permesso il passaggio tra
elaborazione numerica e simbolica e lo sviluppo di diverse famiglie di linguaggi di
programmazione (imperativi, funzionali, logici). Ciascuna di queste può a sua volta essere
utilizzata mediante diverse filosofie: sequenziale, concorrente, orientata agli oggetti. Dalla
teoria dei linguaggi formali sono ereditate le tecniche automatiche che permettono di
tradurre in modo equivalente il codice scritto in un dato linguaggio in un altro linguaggio
(tipicamente di livello più "vicino" alla macchina).
I LINGUAGGI DI PROGRAMMAZIONE
Un linguaggio di programmazione è un insieme di simboli (alfabeto) e stringhe di simboli
(vocabolario) che possono essere connessi tra loro seguendo regole formali predefinite e
precise. Le regole per la costruzione delle frasi di un linguaggio sono espresse come
produzioni di un sistema formale denominato grammatica. Le regole grammaticali
descrivono solo come sono fatte le frasi di un linguaggio, cioè la sintassi, e di norma non
descrivono il significato delle frasi. Le regole grammaticali devono essere concepite in
modo da garantire la decidibilità del linguaggio.
I programmatori inesperti tendono ad "aggrovigliare" il programma introducendo numerosi
salti privi di regole (spaghetti programming). E' stato dimostrato (Teorema fondamentale
della programmazione strutturata di Jacopini e Böhm) che ogni programma può essere
codificato attenendosi esclusivamente a tre strutture fondamentali:
1. Sequenziale
2. Iterativa
3. Condizionale
Queste tre strutture possono essere concatenate una di seguito all'altra oppure nidificate
una dentro l'altra (non possono essere "intrecciate" o "accavallate").
Dopo aver scritto il sorgente attraverso un linguaggio di programmazione, è necessario
che sia tradotto in codice binario. Tale azione può avvenire prima della fase vera e propria
di esecuzione, come accade con il compilatore o durante la fase stessa di avanzamento,
come accade con l'interprete. L'interprete traduce istruzione per istruzione dal codice
sorgente al linguaggio macchina, mentre il compilatore traduce esattamente le istruzioni
del programma sorgente nelle corrispondenti istruzioni in linguaggio macchina.
1
Secondo l’approccio procedurale, vedasi in PARADIGMA DI PROGRAMMAZIONE.
3
Il linguaggio macchina è diverso a seconda del microprocessore (il tipo di CPU) presente
nel calcolatore, per cui i programmi eseguibili (in linguaggio macchina) sono strettamente
dipendenti dalla piattaforma hardware (oltre che dal particolare sistema operativo
adottato).
GENERAZIONI
Teoricamente si è dimostrato che tutti i linguaggi non banali sono, dal punto di vista della
capacità computazionale, equivalenti; in pratica un programma scritto in un certo
linguaggio può sempre essere codificato in qualsiasi altro linguaggio. Il linguaggio deve
essere non troppo difficile da imparare, deve essere possibile creare applicazioni in tempi
ragionevoli, deve produrre eseguibili efficienti. I linguaggi di programmazione sono un
sottoinsieme di quelli formali, essi possono essere definiti come il mezzo che ci permette
di comunicare al computer la sequenza di operazioni da effettuare per raggiungere un
obiettivo prefissato.
Una prima distinzione tra i linguaggi di programmazione possiamo farla tra i linguaggi a
basso e quelli ad alto livello. In genere si parla di programmazione a basso livello quando
si utilizza un linguaggio molto vicino al funzionamento interno della macchina, mentre di
programmazione di alto livello quando si utilizzano linguaggi più sofisticati ed astratti,
slegati dal funzionamento fisico dello stesso elaboratore. Si viene così a creare una
gerarchia di linguaggi, dai meno evoluti (il linguaggio macchina e l'assembler) a quelli più
evoluti (PASCAL, FORTRAN, COBOL, PERL);
I linguaggi di alto livello sono simili (esistono delle differenze) tra piattaforme differenti.
Un grande problema è la portabilità del software da un piattaforma ad un'altra:
Ø se le piattaforme sono uguali o compatibili si potrà distribuire il programma in
formato eseguibile;
Ø se le piattaforme sono incompatibili si dovrà distribuire il programma in formato
sorgente.
Si parla di “Generazioni di Linguaggi di Programmazione” col tacito consenso che un
linguaggio di, p.es., terza generazione deve per forza essere “migliore” di uno di seconda:
o
I generazione: vi appartengono i cosiddetti linguaggi macchina espressi con
sequenza di zeri e uni (es : 001011011011). Sono fortemente dipendenti dal
particolare computer, infatti ogni processore utilizza un suo diverso
linguaggio macchina.
o
II generazione è rappresentata dal cosiddetto linguaggio assembler , che
sostituisce le sequenze binarie del linguaggio della prima generazione con
lettere dell'alfabeto e numeri esadecimali (es : ADD 235H). Anche questo
tipo di linguaggio rimane comunque molto dipendente dal tipo di processore
e sempre di difficile comprensione per il programmatore.
o
III generazione sono linguaggi ad alto livello che godono di una certa
indipendenza dal processore ( FORTRAN, COBOL, C, PASCAL ). All'interno
di questa generazione si sono create alcune tendenze partite da linguaggi
non molto strutturati a linguaggi più evoluti; tali linguaggi usano delle variabili
per indicare la zona di memoria.
o
IV generazione - caratterizzati da una somiglianza ancora più spinta con il
linguaggio naturale, la minore rigidità formale, l'uso di un'interfaccia utenteelaboratore più trasparente dei compilatori. Sono metalinguaggi che usano
un insieme di programmi o altri metaprogrammi integrati in un tutto armonico
e funzionale a certi scopi ristretti: Shell di UNIX, FORTH, ecc.
4
o
V generazione - vi appartengono i linguaggi per l'intelligenza artificiale, sono
quelli più vicini al linguaggio del programmatore (es: PROLOG).
Generalmente, quando si parla di linguaggi di programmazione, si intende quelli di III
generazione.
Sembra che vi siano stati tre ambienti originanti, che hanno avuto pochi successi e molti
fallimenti:
o ambiente universitario tecnico/matematico: FORTRAN, ma anche ALGOL
o
ambiente universitario informatico: C, ma anche LISP, SNOBOL
o
comitati commerciali e militari: COBOL, ma anche PL/1.
Sulla base dell'ambito in cui è necessario risolvere il problema di programmazione, è
opportuno adottare un linguaggio piuttosto che un altro:
Ø Calcolo scientifico: FORTRAN, C
Ø Intelligenza Artificiale: PROLOG, LISP
Ø Applicazioni gestionali: COBOL, SQL, C
Ø Sistemi, device driver: ASSEMBLER, C
Ø Applicazioni su Web: PERL
Ø Applicazioni distribuite: C.
Va menzionata l'importanza storica del COBOL (COmmon Business Oriented Language),
per il fatto che e' stato un comitato a formalizzarlo, e questo ha stabilito un precedente per
la formazione di comitati, ed anche per il fatto che, grazie al supporto della IBM e degli altri
produttori di Mainframe, la diffusione e' stata globale e rapida.
PARADIGMA DI PROGRAMMAZIONE
Il significato scientifico del termine "paradigma" è relativamente recente :
"insieme di idee scientifiche collettivamente accettato per dare un senso al mondo dei
fenomeni".
Nel caso particolare dell’informatica si sente la necessità di distinguere fra diversi modi di
intendere la programmazione dato che non esiste un unico modello computazionale (il
classico Von Neumann) cui riferirsi. La questione si è posta già negli anni '60 con la
programmazione funzionale, ma il contributo più decisivo in questo senso è stato dato
probabilmente negli anni '70 dalla cosiddetta programmazione logica prima, e dal boom di
quella ad oggetti, dopo. Oggi i paradigmi di programmazione citati con una certa
frequenza sono almeno una decina, anche se non sempre sono chiari i loro confini o la
loro indipendenza. I paradigmi offrono una chiave di classificazione dei linguaggi: diremo
che un linguaggio afferisce ad un paradigma se consente di scrivere i programmi in
accordo ad esso.
Semplificando al massimo, possiamo limitarci a considerare due tipi di paradigmi di
programmazione :
Ø quelli di tipo dichiarativo che privilegiano il punto di vista per cui i programmi
devono essere delle specifiche eseguibili del problema. Ci si preoccupa cioè di
cosa risolvere; il "come" risolverli viene in qualche modo scaricato sull'esecutore del
linguaggio. In generale questo approccio comporta una certa inefficienza.
Ø quelli di tipo procedurale che privilegiano il punto di vista per cui i programmi sono
considerati alla stregua degli algoritmi. Ci si preoccupa quindi direttamente del
come risolvere il problema trascurando o sottointendendo le specifiche del
problema, cioè il "cosa".
I principali paradigmi di tipo dichiarativo sono quelli funzionale e quello logico, basati
rispettivamente sul concetto di espressione e di predicato.
5
I principali paradigmi procedurali sono quello imperativo e ad oggetti. Il paradigma di
programmazione imperativo è quello classico in cui rientrano i linguaggi macchina dei
comuni microprocessori e i linguaggi ad al alto livello più vecchi e diffusi come FORTRAN,
COBOL, BASIC, PASCAL. Quello ad oggetti è un'evoluzione di quello imperativo.
Entrambi i paradigmi sono infatti basati sul concetto di stato e sulla possibilità di
modificarlo attraverso l'esecuzione di comandi. Le differenze riguardano soprattutto la
"distribuzione" e le modalità per l'accesso dello stato complessivo .
Il paradigma di programmazione funzionale trova le origini storiche nel lambda-calcolo, il
linguaggio introdotto negli anni '30 dal matematico Alonzo Church come formalismo
universale e la cui caratteristica essenziale, ritrovabile anche in moderni linguaggi
funzionali, è che tutto è un'espressione, e come tale denota un valore ottenibile da un
processo di valutazione.
Il paradigma di programmazione logica si basa sull'idea di considerare i predicati logici del
primo ordine (ristretti ad una certa forma sintattica) come delle specifiche eseguibili. Negli
anni 60'-70' si è scoperto che ciò può avvenire in modo relativamente efficiente applicando
un'unica regola di inferenza, nota come principio di risoluzione (Robinson, 1960)2, poco
naturale per l'uomo, ma molto adatta per l'esecuzione automatica.
Rispetto alle normali computazioni, il "calcolo logico", ha le caratteristiche del cosiddetto
non-determinismo:
Ø può terminare con insuccesso
Ø può concludersi con più di un caso di successo
Rispetto alla varietà dei problemi e delle applicazioni concrete, ogni paradigma presenta
propri vantaggi e svantaggi. L'adozione di un linguaggio che metta a disposizione in modo
coerente un unico paradigma (linguaggio "puro") può comportare, in particolare, il ricorso a
tecniche oscure e/o inefficienti per sopperire alla mancanza di paradigmi diversi da quello
ospitato. In pratica si preferisce aggiungere caratteristiche "impure" a linguaggi già
esistenti che consentano di ospitare, almeno parzialmente, dei paradigmi "secondari"
rispetto a quello principale. A volte lo stesso scopo è raggiunto aggiungendo particolari
librerie. Ad esempio alcuni linguaggi ad oggetti mettono a disposizione delle librerie a
supporto della programmazione logica.
Un'altra soluzione, spesso adottata, è quella di interfacciarsi con altri linguaggi. Molti
PROLOG prevedono, ad esempio, l'interfacciamento con routine scritte in C o in PASCAL.
L'ideale sarebbe di disporre di linguaggi multiparadigma, cioè che consentano di applicare
il paradigma più adatto al sotto-problema che interessa "cucendo" poi le soluzioni con
appositi meccanismi di interfacciamento (integrazione) tra paradigmi.
Al momento esistono solo alcune proposte di ricerca e non sembra vicino il giorno in cui si
potrà contare su uno standard accettato e sufficientemente diffuso.
2
Principio di risoluzione(semplificato) dalla coppia di clausole (genitori) A
dedurre la clausola (risolvente) B or C.
or B, (not A) or C si può
6
CONFRONTO TRA LINGUAGGIO IMPERATIVO E FUNZIONALE
Imperativo
Funzionale
procedura
ciclo
test (if, case)
assegnamento
sequenzializzazione
array
Funzione
Ricorsione
espressioni condizionali, pattern matching
legame (param. formale-param. attuale)
composizione di funzioni
lista
CLASSIFICAZIONE
Classificazione linguaggi di programmazione
In
base
a
quanto
descritto
precedentemente
riportiamo
una
classificazione a livello concettuale
aggiungendo nuovi tipi di linguaggi
(applicativi, markup, scripting), che
per le loro caratteristiche possono
pensarsi “indipendenti” da quelli citati.
Nello schema proposto, i linguaggi
concorrenti, distribuiti e paralleli, sono
visti come “trasversali” ai tipi di
linguaggi presentati nei paradigmi
(imperativi,
ad
oggetti,
logici,
funzionali), intendendo per trasversale
una nuova dimensione di sviluppo che
aggiunge
ai
tipi
già
presenti
caratteristiche specifiche ulteriori.
Ø IMPERATIVI (PROCEDURALI): Il modello computazionale è basato sui
cambiamenti di stato della memoria della macchina. E’ centrale il concetto di
assegnazione di un valore ad una locazione di memoria. Il compito del
programmatore è costruire una sequenza di assegnazioni che producano lo stato
finale (in modo tale che questo rappresenti la soluzione del problema).
Ø PARALLELI: consentono di realizzare tutti quei programmi che possono essere
eseguiti in parallelo.
Ø CONCORRENTI: consentono di eseguire tutti quei programmi che entrano in
competizione per l’uso di una data risorsa.
Ø DISTRIBUITI: linguaggi largamente diffusi grazie allo sviluppo delle reti di
calcolatori e di Internet che possono essere visti come ambienti di calcolo globali.
Tali linguaggi devono offrire la possibilità di esprimere naturalmente nozioni di
località, capacità, sicurezza e velocità.
Ø FUNZIONALI (DICHIARATIVI): il programma è considerato come il calcolo del
valore di una 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, in pratica
7
Ø
Ø
Ø
Ø
Ø
l'utilizzo di funzioni che richiamano se stesse e, come struttura dati, la lista
(sequenza ordinata di elementi).
APPLICATIVI: progettati per andare incontro a richieste specifiche.
LOGICI (DICHIARATIVI): hanno come obiettivo la possibilità di eseguire le
specifiche direttamente, senza bisogno di raffinarle trasformandole in descrizioni
procedurali di più basso livello. Il modello computazionale è basato sui concetti di
funzione e relazione. Il programmatore non ragiona in termini di assegnazioni di
valori, ma di relazioni di entità e di valori di una funzione.
SCRIPTING: tipo di codice che può essere eseguito direttamente da un programma
(interprete) in grado di interpretare il linguaggio con cui è stato creato lo script. Non
è necessario compilare gli script per poterli eseguire.
MARKUP: lavorano su dati (di solito testi, o comunque materiale destinato alla
visualizzazione) dei quali specificano la funzione o il ruolo attraverso etichette,
denominate tag.
AD OGGETTI: metodo che porta ad architetture software basate sugli oggetti
manipolati da sistemi (ed anche da sottosistemi) software, piuttosto che su
architetture basate sulle funzioni che questi oggetti devono svolgere.
8
LINGUAGGI IMPERATIVI PROCEDURALI
Il nome di linguaggio imperativo o statement oriented (orientato al comando, all’istruzione)
deriva dal ruolo dominante in essi attribuito alle istruzioni imperative. L’azione unitaria in
un programma scritto in questo linguaggio è l’istruzione gli effetti delle singole istruzioni si
combinano per raggiungere i risultati desiderati. Esempi di linguaggi di programmazione
imperativi sono: BASIC, COBOL, FORTRAN, PASCAL. I linguaggi imperativi sono
strettamente legati al modello architetturale della macchina (Von Neumann) e
quest’influenza si può vedere in tre caratteristiche comuni:
1. Variabili3
2.
Assegnamento4
3. Iterazione5
Alla classe dei linguaggi imperativi appartengono quelli basati sulla nozione di istruzione di
macchina e di memorizzazione di valori in celle di memoria (linguaggi imperativi di basso
livello).
Un programma scritto in linguaggio macchina è costituito da un elenco di istruzioni che
l’elaboratore esegue in sequenza e che realizzano tre diversi tipi di operazioni :
1. il trasferimento di dati in unità centrale e memoria;
2. le operazioni aritmetiche eseguibili dall’unità di calcolo;
3. l’alterazione della normale sequenza di esecuzione delle istruzioni per mezzo
di salti (condizionati o meno) o con l’arresto del programma.
Anche nei linguaggi imperativi di alto livello si ritrovano i concetti su cui è basato il
linguaggio macchina. Infatti, le variabili sono astrazioni della cella di memoria e l’istruzione
di assegnazione corrisponde al trasferimento di un valore in memoria.
Dal punto di vista della strutturazione dei dati in un linguaggio imperativo il programmatore
ha a disposizione un insieme di tipi di dato primitivi e di meccanismi di composizione che
gli consentono di organizzare in modo agevole i dati relativi al suo problema.
Per quanto riguarda la strutturazione del controllo sono presenti un insieme di primitive
come l’iterazione e la selezione che, consentono la realizzazione di qualsiasi flusso di
controllo, definiscono in modo chiaro e leggibile la sequenza delle istruzioni da eseguire.
3 VARIABILI.
Un componente fondamentale dell'architettura di Von Neumann è la memoria, formata da una grande
quantità di celle che contengono i dati. Ogni cella ha un nome (l'indirizzo) che serve per individuarla
univocamente e ritrovare le informazioni in essa memorizzate. La necessità di dare un nome ad ogni cella è
più evidente se si programma in linguaggio assemblatore; i valori memorizzati in ogni cella sono accessibili
facendo riferimento al nome della cella desiderata. Nei linguaggi ad alto livello le nozioni di cella di memoria
e nome sono rappresentate dal concetto di variabile, forse il più importante nei linguaggi di programmazione.
Una variabile di un programma è essenzialmente una cella di memoria con un nome in cui sono memorizzati
dei valori. Così, anche se il nostro scopo, nella programmazione, è quello di produrre dei valori, non ci
limitiamo a questi, ma trattiamo anche delle celle in cui risiedono. I problemi come effetti collaterali e aliasing
sorgono proprio dall'esistenza delle variabili.
4 ASSEGNAMENTO.
Strettamente legata all'architettura della memoria è la nozione che ogni valore calcolato deve essere
«memorizzato», cioè assegnato a una cella. Ciò spiega la grande importanza dell'istruzione di
assegnamento nei linguaggi di programmazione. Le nozioni di basso livello di cella di memoria e
assegnamento permeano tutti i linguaggi di programmazione, e forzano il programmatore ad adottare uno
stile di pensiero modellato sui dettagli dell'architettura di von Neumann.
5 ITERAZIONE.
Un programma in un linguaggio imperativo di solito porta a termine il compito affidategli eseguendo
iterativamente una sequenza di passi elementari. Anche questo deriva dall'architettura di von Neumann, in
cui le istruzioni sono immagazzinate nella memoria; l'unico modo di realizzare qualcosa di complicato è la
ripetizione di una sequenza di istruzioni.
9
Questo tipo di linguaggi esprime come computare i risultati di un dato problema (linguaggi
procedurali). Si basa, essenzialmente, sulle procedure le quali a differenza delle funzioni
possono modificare l’istanza in ingresso. In questi linguaggi è posta maggior enfasi sulle
procedure (viste come scatole nere capaci di manipolare dati) rispetto ai dati. I linguaggi
procedurali sono modellati secondo i diagrammi di flusso che mostrano il passaggio dei
dati nel sistema da una procedura ad un'altra.
Esistono sei istruzioni fondamentali che caratterizzano i linguaggi procedurali:
1. Assegna: assegna ad una variabile (ad una locazione di memoria) il valore di
una espressione.
2. Leggi: legge in input dall'esterno un valore e lo memorizza in una variabile
(locazione di memoria).
3. Scrivi: scrive in output il valore di una espressione o di una variabile (locazione
di memoria).
4. Se... allora... altrimenti...: modifica il "flusso" del programma sulla base del
valore di una espressione logica.
5. Vai al passo...: modifica il "flusso" del programma incondizionatamente.
6. Fermati: termina l'esecuzione del programma.
Hanno riscontrato notevole successo nelle applicazioni scientifiche (es. calcolo equazioni
differenziali algebra lineare ecc.…).
I limiti di questi linguaggi sono:
Ø richiedono in ogni caso al programmatore di "pensare come il calcolatore", ovvero
di modellare il problema in base al modo di lavorare della macchina
Ø le procedure lavorano sugli stessi dati: questo può portare a problemi in fase di
manutenzione perché l’aggiornamento di una procedura può richiedere
l’aggiornamento dell’intero programma
Esempi di linguaggi imperativi procedurali:
ABC, ALEF, ALGOL, APL, APPLE SCRIPT, ASSEMBLY, BASIC, BCPL, C, CLU, CMS,
COBOL, CORAL, CPL, CT, FORMAC, FORTH, FORTRAN, ICI, ICON, IDL, INTERCAL,
JCL, JOVIAL, LIMBO, MESA, MODULA 2, MODULA 3, MUMPS, OBERON, PASCAL,
PILOT, PL/1, PROGRAPH, RUBY, SETL, SML, SNOBOL, TCL.
LINGUAGGI PER LA PROGRAMMAZIONE PARALLELA
Rientrano in questa categoria tutti quei linguaggi ottimizzati per la programmazione
parallela, ossia la possibilità di eseguire contemporaneamente più programmi (o più parti
dello stesso programma). Si prestano ad architetture di macchina evolute (o sistemi più
complessi come reti di calcolatori), in possesso cioè di più processori (ad esempio) da
assegnare a ciascun task (processo). E’ usuale, parlando di linguaggi paralleli, ritrovare
concetti di:
Ø multiprocessing: che possono essere eseguiti su macchine con processori
separati ma con la condivisione della memoria.
Esempi di linguaggi per la programmazione parallela:
ALEF, ALGOL68, C*, CILK, OCCAM.
LINGUAGGI CONCORRENTI
Sono linguaggi ottimizzati per la programmazione concorrente di piattaforme o sistemi che
dispongono di risorse limitate (processore), o in cui i task entrano in concorrenza per il
possesso della risorsa.
I linguaggi concorrenti differiscono da quelli paralleli anche dal modo in cui sono
creati/sincronizzati i processi ed in base alla modalità di interazione/sincronizzazione degli
stessi. E’ usuale, parlando di linguaggi concorrenti, ritrovare concetti di:
10
Ø multiprogramming: che possono
processore.
Esempio di linguaggio concorrente:
CONCURRENT PASCAL, SR.
essere
eseguiti
con
la
condivisione
del
LINGUAGGI DISTRIBUITI
La ricerca nell'ambito dei sistemi distribuiti ha ricevuto nuovo impeto dallo sviluppo, sia
tecnologico che di mercato, delle reti telematiche. Internet è la più diffusa e popolare di tali
reti, e rappresenta il più grande sistema distribuito mai costruito. I suoi protocolli di
comunicazione, permettono di astrarre strutture informative globali a partire da insiemi
eterogenei di calcolatori e di sottoreti. Per esempio, il protocollo FTP realizza un file
system globale, il protocollo Telnet realizza un multiprocessore globale, e il protocollo
HTTP realizza un dominio globale di ipertesti (il World Wide Web). Ben presto è sorta
l'esigenza di rendere programmabili tali strutture informative globali, cioè di utilizzarle
come “global computer”. Mentre i calcolatori tradizionali collegati in rete sono “semplici”
dispositivi di calcolo autonomi che accedono a risorse locali ed occasionalmente
comunicano tra loro, i global computer costituiscono piuttosto una piattaforma di calcolo
globale, integrando e coordinando risorse sia locali che remote. Essi possiedono sia le
caratteristiche dei sistemi distribuiti (distribuzione delle componenti, concorrenza,
mancanza di uno stato globale, e asincronia dei cambiamenti di stato locali), che quelle
dei sistemi aperti (eterogeneità e autonomia delle componenti, cambiamento dinamico
della configurazione del sistema, mobilità di programmi e dati). Le problematiche poste da
questi tipi di sistemi sono da una parte la “mobilità del codice” che caratterizza una nuova
generazione di applicazioni distribuite e dall'altra il coordinamento di componenti
distribuite. In letteratura sono stati proposti dei linguaggi di programmazione di nuova
concezione, generalmente chiamati Mobile Code Languages (MCLs), dotati di meccanismi
che permettono mobilità del codice e riconfigurazione a tempo d'esecuzione del legame
tra componenti software dell'applicazione e la loro locazione fisica nella rete. Resta aperto
il problema di definire un contesto linguistico uniforme ed espressivo dove poter descrivere
sia politiche di coordinamento che componenti quali dati, capaci quindi di essere
trasmessi, elaborati ed eseguiti su nodi distinti della rete. Contributi in questa direzione
sono stati proposti recentemente.
Esempi di MCLs sono: telescript (general magic 1996), il primo linguaggio basato su
codice mobile, Java (linguaggio ad oggetti Sun 1994), che permette la programmazione di
applicazioni per il WWW, Obliq (linguaggio ad oggetti Luca Cardelli, 1993), che permette
la costruzione di uno stato “distribuito” sui nodi di una rete; Agent Tcl, che estende il
linguaggio di scripting Tcl permettendo la mobilità di codice che è eseguito con garanzie di
sicurezza. 6
Esempi di linguaggi distribuiti:
ERLANG, LIMBO, MUMPS, REBOL.
LINGUAGGI FUNZIONALI (DICHIARATIVI)
Un linguaggio di programmazione funzionale si basa sulle proprietà matematiche delle
funzioni.
Esso è caratterizzato dalle seguenti componenti:
§ un insieme di funzioni primitive7,
§ un insieme di forme funzionali8,
6
TELESCRIPT, JAVA, OBLIQ, AGENT TCL sono orientati agli oggetti e per tanto non sono presi in ulteriore
considerazione.
7 Le funzioni primitive sono predefinite dal linguaggio e applicabili direttamente.
11
§
§
l’operazione di applicazione9,
un insieme di strutture dati10.
La scarsa varietà di tipi di dati disponibili è una caratteristica dei linguaggi di
programmazione funzionali; sono pochi, ma hanno una struttura semplice e regolare.
L'essenza della programmazione funzionale è la definizione di nuove funzioni tramite le
forme funzionali. Oltre ai quattro componenti visti, un linguaggio funzionale fornisce anche
un meccanismo per collegare un nome alle nuove funzioni definite dall'utente. Questa
caratteristica, peraltro non essenziale, influisce sul modo di usare linguaggio, evitando di
dover ripetere la definizione di una funzione ogni volta che la si applica. Lo stile di
programmazione offerto dai linguaggi di programmazione funzionali basato sulle funzioni
matematiche non è legato alla particolare architettura di macchina, è quindi
completamente diverso da quello dei linguaggi imperativi (basati sul modello di Von
Neumann).
I linguaggi funzionali, per dirsi veramente tali, devono prevedere le funzioni di ordine
superiore: accettare funzioni come argomento, restituire funzioni come risultato e
incorporare le funzioni nelle strutture dati. Queste possibilità, previste con certe limitazioni
anche in altri paradigmi, consentono spesso di ottenere del codice con sorprendenti
caratteristiche di eleganza e di generalità. Occorre tenere presente che i moderni linguaggi
funzionali prevedono la lazy evaluation ("valutazione pigra" o non-strict) cioè la possibilità
di ritardare la valutazione degli argomenti attuali di una funzione fino al momento in cui
essi si rendono effettivamente necessari.
La parola "funzionale" si deve al fatto che ogni simbolo di operazione che compare in
un'espressione corrisponde ad una funzione, sia nel senso matematico del termine che in
quello informatico ("sottoprogramma che restituisce un valore"). Le espressioni e i
sottoprogrammi funzionali sono del resto presenti anche nei primi linguaggi procedurali. Il
risultato è quello di avere dei programmi che godono della seguente proprietà, nota come
"sostituibilità di uguali con uguali" nel tradizionale ambito algebrico: “in una espressione H
si possono sempre sostituire le occorrenze di una sottoespressione E con il suo valore V
senza che cambi il valore di H.”
Per il fatto che i linguaggi funzionali sono basati sul concetto di funzione matematica e su
quello di applicazione ad una funzione di argomenti , essi sono spesso indicati linguaggi
“applicativi”. In questa classificazione per linguaggio applicativo si è inteso un significato
diverso, ossia riferito ad applicazioni di sviluppo e per linguaggio funzionale il linguaggio
funzionale per antonomasia: il LISP (In origine il LISP conosciuto come LISP puro, era
completamente funzionale. Per aumentare l’efficienza in esecuzione, però, nelle attuali
versioni del linguaggio sono state inserite caratteristiche non funzionali.).
Il LISP è un buon esempio di come poche e semplici primitive unite a potenti possibilità di
strutturazione dei dati, possano portare a un linguaggio allo stesso tempo potente ed
elegante.
Esempi di linguaggi funzionali:
APL, AUTOLISP, AWK, BEFUNGE, BLISS, CHARITY, CPL, ERLANG, EUPHORIA,
FORMAC, HASKELL, IDL, LISP, LOGO , MIRANDA, ML, POP, REBOL, SCHEME, SML,
SUPERLOGO.
8 Le forme funzionali sono tutti quei meccanismi che si possono utilizzare per combinare funzioni e crearne
di nuove.
9 L’operazione di applicazione è il meccanismo predefinito che permette di applicare una funzione ai suoi
argomenti e ottenere un risultato.
10 Le strutture dati rappresentano tutti i possibili elementi degli insiemi dominio e condominio di ogni
funzione.
12
LINGUAGGI APPLICATIVI
Come già detto precedentemente, non intendiamo per programmi applicativi il sinonimo
dei linguaggi funzionali (come molti testi e varie fonti riportano) bensì tutti quei programmi
nati o meglio sviluppati per usi specifici.
In genere i programmi applicativi hanno delle proprie funzioni. Alcune di queste richiedono
di eseguire un certo numero di istruzioni in sequenza. Se tale sequenza è di uso molto
comune, un modo per renderne più comodo e rapido l'accesso consiste nel creare delle
macroistruzioni. Una macroistruzione o macro è una sequenza di istruzioni memorizzate in
un singolo comando. Questo comando è a tutti gli effetti un programma interpretato vero e
proprio. La differenza tra questo e un programma eseguibile è che le istruzioni del
programma eseguibile sono comprensibili direttamente al processore, mentre le istruzioni
della macro sono comprensibili al programma applicativo o al sistema operativo.
I macrolinguaggi sono la forma in cui le macro sono espresse, per poter essere
memorizzate in un file. L'interprete del macrolinguaggio è il programma applicativo stesso
(o anche il sistema operativo). Esso avrà un comando particolare, esegui macro, che
avvierà l'interpretazione. Altri macrolinguaggi sono dei veri e propri linguaggi di
programmazione tradizionali, estesi con i comandi del programma applicativo. Per
esempio, i programmi applicativi di Microsoft Office possono tutti eseguire macro scritte in
Visual Basic for Applications o VBA11
Esempi di linguaggi applicativi:
ACSL, AMOS, AUTOLISP, AWK, GPSS, GUILE, ICON, IDL, LOGO, LUA, MATLAB,
OCTAVE, PILOT, RPG, SNOBOL, SQL, SUPERLOGO, TEX, VERILOG, VHDL.
LINGUAGGI PER LA PROGRAMMAZIONE LOGICA (DICHIARATIVI)
I linguaggi di programmazione dichiarativi nacquero con lo scopo primario di permettere di
definire le specifiche di un problema. Alcuni di questi linguaggi furono concepiti con il solo
scopo definitorio, senza dunque fornire la possibilità di esecuzione del codice. Altri invece
nacquero e si evolvettero come linguaggi di programmazione veri e propri, in grado ovvero
di eseguire effettivamente la specifica fornita, e di permettere in breve tempo e con bassi
costi di avere in mano un prototipo che realizzi fin da principio il funzionamento del
prodotto software finale.
La programmazione logica, nella sua accezione più semplice, si può descrivere nel
seguente modo: il programmatore dichiara (linguaggio dichiarativo) semplicemente i fatti e
le proprietà che descrivono il problema da risolvere. Queste informazioni sono poi usate
dal sistema per risolvere il problema (per inferire una soluzione), senza che siano
necessari aiuti o consigli su come gestire le informazioni fornite. Per descrivere il problema
si usa un formalismo di tipo logico, come per esempio il calcolo dei predicati (detti anche
asserzioni).
Il linguaggio opera per mezzo di comandi descrittivi relativamente ai dati e per mezzo di
relazioni tra i dati. L’algoritmo è nascosto dalla semantica del linguaggio, consistente di
istruzioni che specificano l'obiettivo desiderato.
Per esempio scrivendo “3 = x + 2”, l’equazione è una condizione che x deve rispettare.
L'interprete (in questo caso sarà un programma di soluzione di equazioni) deve trovare da
solo il valore da assegnare a x.
Il programma è considerato come la dimostrazione della verità di una asserzione; il
sorgente è costituito da una sequenza di asserzioni, di fatti e regole. Non è necessario
indicare esplicitamente il flusso di esecuzione, ma dato un obiettivo di partenza (il goal) è il
sistema che cerca di individuare i fatti e le regole rilevanti. Il fatto che vi sia una netta
11 VBA è un vero linguaggio Basic. È esteso con l'aggiunta di istruzioni per la programmazione sotto
interfaccia grafica (quindi è Visual). Infine, è esteso con l'aggiunta di istruzioni per l'esecuzione dei comandi
specifici di ciascun programma applicativo, p.es. Word o Excel (quindi è for Applications).
13
separazione tra la parte dichiarativa (il cosa fare) e la parte procedurale (il come) rende un
programma scritto in un linguaggio logico particolarmente leggibile. I linguaggi logici
risultano particolarmente adatti a risolvere problemi che riguardano entità e le loro
relazioni. Nelle normali applicazioni risultano essere di difficile utilizzo, anche perché
comportano un modo di programmare completamente diverso dal solito. L'esemplare più
noto di questa famiglia è il PROLOG (PROgramming in LOGic).
Altri linguaggi logici:
MERCURY
LINGUAGGI DI SCRIPTING
Uno script è un normale file di testo che contiene una sequenza di comandi (istruzioni) che
saranno eseguiti da una shell (interprete).
Nella classificazione proposta, si intende per linguaggi di scripting tutti quei linguaggi
aventi la caratteristica comune di scrivere degli script in base alla definizione appena data.
Per tale motivo molti tipi di linguaggi, che trovano in altre classificazioni la loro
“indipendenza”, sono qui visti come scripting. Molti linguaggi definiti come scripting
possono essere classificati mediante i paradigmi precedentemente proposti in base alla
filosofia procedurale o dichiarativa che seguono. In genere quando si parla di linguaggi di
scripting, si intendono quei linguaggi di ausilio per applicazioni Web o interazione con
database. Di linguaggi scripting ne esistono parecchi, alcuni più simili a veri e propri
linguaggi di programmazione, altri meno articolati. Il PERL, ad esempio, è il tipico caso di
linguaggio complesso, ma molto efficace, utilizzato per la creazione di cgi (common
gateway interface.
Esempi di linguaggi di scripting:
APPLE SCRIPT, CSH, GUILE, ICI, JCL, LUA, PERL, PHP, SCHEME, TCL.
LINGUAGGI MARKUP
Il codice sorgente di un linguaggio di markup contiene delle istruzioni per definire il ruolo
delle parti del testo (markup) da visualizzare contrassegnando il testo per mezzo di alcuni
elementi che prendono il nome di tag. Ad esempio in HTML attraverso questi elementi e
relativi attributi è possibile formattare un testo e trasformarlo in ipertesto.
L’esempio più tipico di questi linguaggi è HTML (Hypertext Markup Language).
Esempi di linguaggi di markup:
HTML, MUMPS, SGML, XML.
14
I VARI LINGUAGGI
ABC
Linguaggio imperativo originariamente progettato per essere un sostituto del BASIC. ABC
è adatto alla programmazione generale di tutti i giorni. Non è un linguaggio di
programmazione di sistema. E' un ottimo linguaggio di insegnamento, e poiché è
interattivo è eccellente anche per la creazione di prototipi. E' molto più veloce dello UNIX
'bc' per fare calcoli.
I programmi ABC sono tipicamente molto compatti, circa un quarto della dimensione
dell'equivalente programma in PASCAL o in C. Tuttavia, questo non va a scapito della
leggibilità del programma, ma al contrario. ABC è semplice da imparare per il piccolo
numero (5) di types nel linguaggio. I 5 types sono:
1. numeri: di lunghezza illimitata;
2. testi(stringhe): di lunghezza illimitata;
3. composti: record senza nomi di campo;
4. liste: insieme scelto di uno qualunque dei types di items (bags o multi-sets);
5. tavole: arrays generalizzati con uno dei type di chiave, uno dei type di items
(mappings finiti).
ACSL
(Advanced Continuous Simulation Language) Linguaggio applicativo per simulazioni di
tipo matematico creato nel 1981 dalla Mitchell and Gauthier Associates. Inizialmente fu
implementato come semplice preprocessore del FORTRAN per il modellamento di sistemi
continui. L'ACSL è stato usato sino al 1990. Il linguaggio è un misto di elementi di
specificazione di sistema e blocchi di processing procedurale. I nuovi prodotti ACSL
presentano una nuova visuale front-end ma usano ancora sintassi come quella del
FORTRAN per i loro stessi programmi. L'ACSL è un linguaggio di proprietà della MSA
Software.
ALEF
Linguaggio di programmazione strutturato a blocchi creato intorno al 1995 da P.
Winterbottom per conto dei Laboratori Bell di Lucent. E’ un linguaggio compilato per la
programmazione simultanea in apparenza simile al C, progettato per lo sviluppo di
applicazioni network sotto il sistema operativo PLAN 9. I data types supportati da ALEF
includono interi, reali, chars, stringhe, tuples, strutture, unioni, arrays, e canali di varie
dimensioni. Il linguaggio supporta la definizione di data types astratti, ADT parametrizzati e
funzioni. I costrutti di controllo dell'ALEF includono un vasto insieme di condizionali, goto,
e dichiarazioni di loop, cosi come sistemi di handling error e sincronizzazione di lavori
paralleli. ALEF è anche caratterizzato da un unico statement di tail recursion (ricorsione di
coda). ALEF è stato allargato ad una larga varietà di hardware tramite il sistema operativo
PLAN 9, e anche allo SGI IRIX. Il sistema di sviluppo del linguaggio ALEF è disponibile
come parte della distribuzione del PLAN 9.
ALGOL
(ALGOrithmic Language, linguaggio algoritmico)
Il primo linguaggio rivolto alla programmazione strutturata fu introdotto nel 1958, era stato
concepito come linguaggio di programmazione universale, in grado cioè di poter essere
usato su tutti i computer. Alla prima versione, l'ALGOL 58, seguì due anni dopo quella
definitiva, l'ALGOL 60. Uscirà anche l'ALGOL 68, ma oggi si può considerare questo
linguaggio praticamente scomparso. Con le sue strutture di controllo del flusso di gestione
e l'articolazione del programma in blocchi funzionali autonomi, diventò lo standard di
15
riferimento per il confronto dei linguaggi successivi. E' considerato il precursore del
PASCAL.
ALGOL 68
ALGOL68 è un linguaggio strutturato a blocchi creato tra gli anni 1965-68 da A. Van
Wijngaarden. ALGOL68 era una versione largamente estesa ed arricchita del linguaggio
strutturato a blocchi ALGOL. Molte capacità furono aggiunte al framework del suono
dell'ALGOL60 per creare un linguaggio più efficace per applicazioni generali e
programmazione di sistemi. L'ALGOL68 introduceva un vasto numero di nuove
caratteristiche rispetto alle precedenti versioni: sintassi e semantica formalizzate, costrutti
per la programmazione parallela, nuovi data types e metodi di strutturazione, e
dichiarazione di type. I primitivi data types supportati dall'ALGOL68 includono booleani,
interi, reali, numeri complessi e richiami. Gli arrays dinamici, le strutture, e le unioni sono
disponibili la costruzione strutture dati complesse. ALGOL68 supporta inoltre moduli di
compilazione separati, come faceva l'ALGOL60. Come il suo antenato, anche l'ALGOL68
è fortemente tipizzato. Esistono poche implementazioni dell'ALGOL68 oltre a vari suoi
dialetti, inclusi alcuni per PC e mainframes.
AMOS
L'AMOS è un dialetto BASIC per computer AMIGA che cerca di catturare, attraverso il suo
vocabolario, un certo numero di quelle funzioni che potrebbero essere necessarie nella
creazione di giochi o nel software multimediale. Tra le proprietà principali del linguaggio vi
sono sicuramente la flessibilità, l'immediata accessibilità alla maggior parte delle risorse
del computer e la facilità con la quale si impara.
APL
Nel 1961 la IBM realizza la versione completa del linguaggio "APL" (Aprogramming
Language) inizialmente utilizzato per la soluzione di problemi matematici a livello
scolastico. Successivamente viene adottato dalle principali compagnie aeree per la
programmazione degli orari e di percorsi di volo.
APPLE SCRIPT
E’ un linguaggio di scripting sviluppato per Macintosh. E’ in grado di “capire” frasi in
italiano o in altre lingue, può tradurre automaticamente da un dialetto (lingua) ad un altro.
APPLESCRIPT, per le sue caratteristiche, è utile a tutti gli utenti Macintosh se accoppiato
con Finder.
ASSEMBLY
Il linguaggio macchina, il primo utilizzato in ordine cronologico, non richiede interventi
aggiuntivi tra programmatore ed elaboratore: le istruzioni vengono redatte in modo che la
CPU possa decodificarle ed eseguirle direttamente. Un programma in linguaggio
macchina è costituito da una serie di 0 e 1. Le difficoltà di questo metodo di
programmazione sono legate alla difficoltà di correggere un listato che è poco leggibile al
programmatore stesso, il quale è inoltre costretto a sapere i codici delle istruzioni e degli
indirizzi di memoria che vanno calcolati. Ogni operazione viene scritta in termini di
istruzioni elementari della CPU e i testi dei programmi sorgente si allungano a dismisura.
Per superare queste difficoltà è nato l'Assembler, linguaggio di programmazione di
seconda generazione. E' un linguaggio simbolico, in cui le istruzioni sono rappresentate da
nomi che richiamano una parola inglese e i dati sono identificati da lettere assegnate a
campi di memoria centrale. L'Assembler è un linguaggio orientato alla macchina e per
programmare è necessario conoscere a fondo la struttura dell'elaboratore; inoltre, il
16
rapporto tra istruzioni Assembler e istruzioni di CPU è in genere 1:1 e il programma
Assembler deve essere quindi molto dettagliato.
AUTOLISP
L'AUTOLISP nasce alla fine degli anni'80 come dialetto del LISP e come linguaggio esteso
all'applicazione AutoCAD(tm) e altri programmi Autodesk. Era in origine supportato
solamente dalle versioni 11-13 di AutoCAD. In aggiunta alle normali caratteristiche del
LISP, AUTOLISP offre molte facilitazioni per la manipolazione degli oggetti nel disegno
CAD e più in generale nei files CAD, e per l'interazione con l'utente attraverso l'interfaccia
AutoCAD. AUTOLISP è molto popolare tra la comunità di utilizzatori di Autodesk.
AWK
Il nome AWK deriva dalle iniziali dei suoi tre inventori originali, Aho, Weinberger e
Kernighan, tutti personaggi abbastanza famosi nel campo della computer-science. L'idea
che sta alla base di AWK è quello di elaborare una riga alla volta dei files di input,
eseguendo azioni diverse a seconda che la riga stessa soddisfi certe condizioni o
contenga certi patterns. I programmi scritti in AWK sono strutturati un po' diversamente
rispetto a quelli dei linguaggi tradizionali. Non esiste infatti un inizio e una fine del
programma stesso, e non è necessario dichiarare le variabili, gestire tutta la solita trafila
dell'I/O e del parsing dei dati. A tutto questo ci pensa automaticamente AWK. Quello che
resta da fare al programmatore è solamente specificare come devono essere elaborati i
dati di input a seconda dei vari patterns in essi contenuti. Un programma AWK è quindi
costituito solamente da una lista di regole composte da un pattern ed una corrispondente
azione da eseguire se il pattern è soddisfatto. La potenza di AWK rispetto ad altri
strumenti simili (grep, sed, cut, ecc.) è la possibilità di definire delle azioni completamente
arbitrarie da effettuare sui dati di input utilizzando un vero linguaggio di programmazione,
senza tuttavia essere costretti a dover gestire tutte le complicazioni tipiche dei linguaggi
tradizionali. Il linguaggio di AWK è inoltre dotato di un ricco insieme di funzioni di base, fra
cui quelle per la gestione di pattern matching ed espressioni regolari, e permette di gestire
in modo molto semplice stringhe ed array associativi. È infine possibile definire delle
proprie funzioni, come in qualsiasi linguaggio di programmazione che si rispetti, ed e'
sempre possibile richiamare un programma esterno quando non si è in grado di fare una
cosa direttamente con AWK.
BASIC
(Beginner's All-purpose Symbolic Instruction Code, codice di istruzioni simboliche per
principianti adatto per tutte le applicazioni)
Sviluppato nel 1964 da un gruppo di ricercatori coordinati dai due insegnanti John Kamey
e Thomas Kurtz del Dartmouth College, nel New Hampshire, come strumento per
l'insegnamento della programmazione, è un linguaggio di tipo conversazionale, ovvero
fortemente interattivo con l'utente. Permette di avvicinarsi alla programmazione senza
particolare sforzo, anche a chi è privo di conoscenze nel settore dell'informatica. La
semplicità di apprendimento e di uso, unita ad una grande adattabilità a diversi tipi di
applicazioni, giustificano la sua grande diffusione.
BCPL
Nel 1963, in Inghilterra, durante un progetto che coinvolgeva ricercatori di Cambridge e
dell'Università di Londra, fu sviluppato un linguaggio chiamato CPL, cioè "Combined
Programming Language''. CPL era basato su ALGOL 60, uno dei primi linguaggi di
programmazione moderni ben definiti. Quattro anni più tardi, nel 1967, un programmatore
di Cambridge, Martin Richards, creò BCPL, ``Basic CPL'' e BCPL diede origine a un altro
17
linguaggio, che divenne noto con la singola lettera B. Il linguaggio B fu ripreso ai
Laboratori Bell, dove Ken Thompson e Dennis M. Ritchie lo modificarono e lo
ridenominarono NB. All'inizio degli anni '70, Thompson utilizzò NB per riscrivere la parte
basilare di Unix per la seconda edizione. Poco tempo dopo, a partire dall'NB, Ritchie
sviluppò il C, che divenne presto il linguaggio per scrivere nuove utility e applicazioni oltre
al Sistema Operativo. Questo nuovo linguaggio, oltre ad essere ad alto livello e strutturato,
offriva costrutti che permettevano di manipolare i bit e i byte e di interagire direttamente
con l'hardware. Concepire un linguaggio di programmazione completamente nuovo non
avrebbe permesso di avvalersi direttamente dei pregi dell'esistente e non avrebbe
garantito il superamento di tutti i difetti; inoltre avrebbe richiesto molto più tempo.
BEFUNGE
BEFUNGE è stato creato da Chris Pressey nel 1993. BEFUNGE è un linguaggio di
programmazione interpretato di basso livello che usa un unico modello dati e un insieme di
istruzioni per realizzare computazioni su una griglia di coordinate. Il modello di macchina
BEFUNGE ipotizza l'esistenza di uno stack di pushdown, e una griglia di celle
bidimensionale. Ogni cella può contenere un numero di dati, che può essere trattato come
un istruzione o come dato a seconda dell'esecuzione del programma. “L'Instruction
Pointer" può muoversi in ognuna delle quattro direzioni: su, giù, destra, sinistra. L'insieme
delle istruzioni del BEFUNGE include la manipolazione dello stack, aritmetica, una
rudimentale I/O, rami condizionali (sia in verticale che in orizzontale) e molte altre
operazioni. Nel BEFUNGE-93 la dimensione della griglia era fissata: 80x24, ma il
BEFUNGE-97 consente una dimensione di griglia indefinita.
BLISS
Il BLISS è un linguaggio di programmazione strutturato a blocchi nato verso il 1970 alla
DEC, Digital Equipment Corp. BLISS è in linguaggio procedurale di basso livello
sviluppato e usato dalla DEC per il system programming. E’ Largamente usato dalla DEC
per lo sviluppo di software OS, strumenti per PDP, DECsystem, linee VAX per computers
approssimativamente tra gli anni 1971-1988. Non è più stato così largamente usato.
BLISS supporta vari data types, ma non per questo rafforza il type checking. Possiede un
potente macro sistema che veniva pesantemente usato nel system coding, ma che
rendeva più difficile il compito del compilatore di questo linguaggio. Poiché è stato
concepito come un linguaggio di programmazione di sistema, possedeva delle
caratteristiche che consentivano al programmatore di fare ciò che veniva inteso come il
lavoro del compilatore negli anni '90: allocazione dei registri, definizione dei data structure
packing, etc.
C
Creato da Dennis M. Ritchie nel 1972 durante lo sviluppo dell'UNIX, è un linguaggio
strutturato per la programmazione di sistemi (compilatori, sistemi operativi, ecc.) Pur
essendo un linguaggio di alto livello, è in grado di controllare anche le operazioni più
elementari di una macchina. E' derivato dal linguaggio BCPL (Basic Combined
Programming Language).
C*
Il C* è un tipo di linguaggio per la programmazione parallela e per il multi-programming. Le
sue origini risalgono al 1987 ad opera della Thinking Machines Corporation.
C* è un dialetto del C con caratteristiche aggiuntive riguardanti la sintassi e la semantica
per supportare il processing parallelo. E' stato progettato per lo sviluppo di applicazioni
sulla Connection Machine line di computer paralleli SIMD. Due proprietà fondamentali
18
distinguono C* dal C originale: data elements paralleli, e domini di computazione parallela.
Nel C* ogni variabile può essere o 'mono'(scalare) o 'poli'(parallela). Il programmatore può
definire un numero qualunque di nomi di domini, con domini locali paralleli e variabili
scalari, e quindi definire computazioni che si sviluppino in quei domini.
C* supporta gli stessi data types e strutture di controllo del C.
CHARITY
è un linguaggio di programmazione tuttora in via di sviluppo da parte del Charity
Development Group presso il Department of Computer Science, University of Calgary,
Canada. E’ di tipo funzionale nello stile, nel senso che i programmatori che hanno
familiarità con i paradigmi funzionali (programmatori logici e funzionali) trovano CHARITY
facile da imparare. E’ basato sulla teoria dei forti datatypes categorici. Questi ultimi sono
divisi in due classi: i datatypes induttivi (creati dal costruttore nella maniera familiare) e i
datatypes co-induttivi (buttati giù dai distruttori). I programmi sopra questi datatypes sono
rispettivamente espressi da folds (catamorfismi), e da unfolds (anamorfismi). Le principali
caratteristiche del linguaggio CHARITY possono essere così riassunte:
Ø "puro", e supporta una valutazione semplice;
Ø higher-order;
Ø Tutte le computazioni CHARITY hanno una fine(up to user input).
Si può dire che CHARITY realizza un elegante, puro framework per lo sviluppo software,
per l'insegnamento, e la ricerca di nuovi linguaggi. Questo framework supporta il diretto
ragionamento sui programmi ed è altamente responsabile della specificazione,
trasformazione e verifica dei programmi.
CILK
CILK è insieme un linguaggio multithreaded e un runtime system. Il linguaggio specifica un
grafo dataflow, ed il runtime system esegue il grafo in parallelo. Il linguaggio CILK è C con
un paio di nuove keyword, spawn e sync (in realtà ci sono altre estensioni per la scrittura
di programmi non-deterministici e per l'esecuzione speculativa. Aggiungere spawn ad una
chiamata di funzione specifica che la funzione chiamata può essere eseguita in parallelo
alla funzione chiamante. L'istruzione sync specifica che tutte le funzioni (procedure, nella
terminologia di CILK) che sono state invocate con spawn devono essere completate prima
che l'esecuzione possa continuare.
CLU
è un linguaggio strutturato a blocchi compilato creato tra gli anni 1974-77 da B. Liskov.
E’ imperativo con caratteristiche aggiuntive per la definizione della gestione di data types
astratti. E' stato concepito per lo sviluppo di applicazioni generali, ed anche come mezzo
di ricerca nel design di linguaggi per computer.
Quando era un discendente dell'ALGOL , il CLU possedeva una sintassi che era simile in
molti aspetti a quella dell'ALGOL 60, ma aggiungeva l'astrazione dei data types, exception
handling, e altre proprietà avanzate.
Il nome CLU è l'abbreviazione di "CLUster", che fu scelto perché il programma CLU
consiste normalmente di procedure, clusters iteratori. CLU supporta un numero di
caratteristiche avanzate per i linguaggi strutturati del suo tempo, inclusa la garbage
collection, una forma di successione, iteratori, forte typing, generici, e garbage collection.
Il sistema operativo di ricerca SWIFT era scritto in CLU, così come altri strumenti e
utilities.
CMS
Il CMS è un linguaggio strutturato a blocchi realizzato dalla Rand Corporation intorno al
1974 per conto della US Navy. Il CMS è un linguaggio imperativo procedurale usato quasi
19
esclusivamente per applicazioni real-time e finalizzate per la US Navy. Un modulo CMS
consiste di due moduli: un blocco di dichiarazione globale "SYS-DD" e blocco codice
"SYS-PROC". Sia i dati globali che locali, cosi come le procedure, possono comparire nel
blocco SYS-PROC. A seconda del compilatore, vi sono varie facilities per l'inclusione di
codici sorgente e il cross-module linking. Nel VMS i data types includono: interi, numeri a
virgola fissa e mobile, stringhe di lunghezza fissa, ed enumerazioni. Gli identificatori sono
fortemente tipizzati, la maggior parte delle versioni del CMS hanno una facile
dichiarazione dei types. L'unica data types aggregato è l'array. Il CMS ha un
convenzionale complemento di dichiarazioni imperative per il controllo del flusso, ma con
una sintassi particolare. Le dichiarazioni di loop offrono speciali facilities di exit/resume; é
perfino possibile far partire nuovamente un loop anche dopo esserne usciti. CMS offre
inoltre diversi tipi di dichiarazioni di salti.
COBOL
(Common Business Oriented Language, linguaggio comune orientato alle applicazioni
commerciali)
E' stato il primo programma di vasta diffusione per applicazioni commerciali,
amministrative e gestionali. Realizzato nel 1959 su commessa del governo degli Stati
Uniti, doveva rispondere all'esigenza di programma unico per tutti i settori dell'apparato
militare americano. Venne sviluppato dopo sette mesi di lavoro e i primi compilatori furono
disponibili un anno più tardi.
CONCURRENT PASCAL
Il CONCURRENT PASCAL è un linguaggio adatto alla programmazione concorrente o al
multi-programming. Le sue origini risalgono al 1974, e sono da attribuire a P. Brinch
Hansen. Il CONCURRENT PASCAL è un dialetto della struttura del linguaggio PASCAL,
esteso per supportare data types astratti, multi-tasking, e monitors. E' stato concepito per
la programmazione di sistemi operativi e per la ricerca. La sintassi del CONCURRENT
PASCAL è essenzialmente la stessa del PASCAL originale, eccetto per le proprietà ADT e
di simultaneità, e qualche altra proprietà. Il linguaggio è fortemente tipizzato e sicuro:
Records e puntatori variabili cosi come nel PASCAL originale non sono supportati. Il
CONCURRENT PASCAL aggiunge le seguenti nuove fondamentali proprietà: process
types, monitors, class types, dichiarazioni di init e di ciclo e code.
Alcune proprietà fondamentali del PASCAL sono state perse: la ricorsione, gli statements
di goto, i packed arrays, i puntatori e i file types. La versione originale del CONCURRENT
PASCAL era implementata su vari mini-computers e mainframes hardware negli anni '70.
CORAL
Linguaggio di programmazione imperativo procedurale nato tra gli anni 1964-66 presso la
Royal Signals & Radar Establishment, Malvern UK. E’ un linguaggio di programmazione
strutturato e compilato, della famiglia ALGOL, usato per lo sviluppo di sistemi real-time.
Viene descritto come un linguaggio semplice e leggero derivato dall'ALGOL e dal JOVIAL.
Supporta le convenzionali strutture di controllo, e i data types macchina come gli interi,
floats e puntatori. Include inoltre una facility per l'aggiunta di codice assembly in-line,
possibilmente dovuto all'uso tipico per scrivere software di controllo. CORAL fu
implementato per molti differenti mini-computers negli anni '70, e fu anche reso disponibile
sul VAX sotto il sistema VMS. Oggigiorno non sembrano esserci versioni gratuite
disponibili del CORAL.
CPL
(Combined Programming Language)
20
E’ un linguaggio di programmazione molto complesso, sintatticamente basato sull’
ALGOL-60, dotato di un subset puramente funzionale. E' un linguaggio fortemente
tipizzato ma possiede un type "generale" che consente una leggera forma di polimorfismo.
Le funzioni possono essere definite sia come normali che con ordine applicativo. CPL
supporta arrays tipizzati e strutture liste polimorfiche. La selezione di liste avviene
attraverso strutture di matching. Il CPL è stato parzialmente implementato sul computer
Titan(Atlas 2) a Cambridge. Ha condotto al più semplice BCPL.
CSH
Linguaggio interpretato appartenente alla categoria dei linguaggi Scripting progettato e
implementato come parte degli sforzi per lo sviluppo del sistema BSD UNIX. Fu
originariamente progettato come un linguaggio Command interattivo, ma è anche
largamente usato per automatizzare l'amministrazione di sistemi e compiti di sviluppo
software in ambienti Unix. Supporta solamente un primitivo data type: la stringa. Ha
operatori aritmetici che possono trattare le stringhe come numeri interi in alcuni costrutti.
Come altri linguaggi in ambiente Unix, CSH ha due spazi per le variabili: locale ed
esportato(ambiente). In un programma CSH tutte le variabili locali hanno lo stesso data
type: un vettore di stringhe. Nel CSH le dichiarazioni sono normalmente delimitate da linee
di confine, ma spesso possono essere usate anche delle semi-colonne. I costrutti di
controllo del flusso supportati includono if-then-else, due tipi di loop, goto, un'istruzione di
case ed un'istruzione molto semplice per interrupt handling. Tutti i costrutti di controllo del
flusso, così come la sintassi delle espressioni sono modellati approssimativamente su
quelli del linguaggio C. Diversamente dalla maggior parte degli altri linguaggi di
programmazione non possiede un'esplicita sintassi per le subroutines. Invece, ogni
separato file sorgente può essere trattato come un tipo di subroutine. CSH è disponibile
essenzialmente per tutti i sistemi Unix e relativi sistemi operativi. A dispetto del suo largo
uso, buoni tutorials di programmazione su shell C non sono altrettanto largamente
disponibili sul web.
CT
Il linguaggio di programmazione CT è un linguaggio imperativo procedurale come il C,
PASCAL, FORTRAN, e Basic ma notevolmente migliorato da capacità multimediali, inclusi
supporti easy-to-use per le grafiche a colori, interazioni col mouse, e talvolta movies in
QuickTime o video in formato Windows. Quindi il linguaggio CT offre una facile creazione
di programmi multimediali, con la relativa portabilità su Macintosh, Windows, Linux, e Unix.
L'ambiente di programmazione CT offre un aiuto on-line con esempi di programmi
esempio eseguibili, un editor grafico per la generazione automatica di comandi grafici,
un'ulteriore compilazione per consentire un rapido turn-around, e un dettagliata diagnosi
degli errori.
ERLANG
ERLANG è un linguaggio di programmazione realizzato per lo sviluppo di robusti
programmi che possano essere distribuiti tra differenti computers in una rete. Così
chiamato in onore del matematico danese Agner Krarup Erlang, il linguaggio fu sviluppato
dall' Ericsson Computer Sciences Lab per la costruzione di software destinato ai propri
prodotti di telecomunicazioni. In uso per un certo numero di anni presso la Ericsson e altre
compagnie, ERLANG è oggi insegnato in oltre 80 università colleges sparsi in tutto il
mondo ed è disponibile gratuitamente come Open Source code. ERLANG è simile al
JAVA in quanto usa una macchina virtuale e supporta il multithreading. Tuttavia, mentre la
comunità di sviluppo del JAVA si focalizza principalmente sulle applicazioni WEB,
ERLANG si indirizza sul mercato per il progetto di servers robusti e sistemi sicuri.
21
ERLANG può essere descritto come linguaggio di programmazione funzionale, nel senso
che dà più importanza alla valutazione delle espressioni piuttosto che all'esecuzione dei
comandi. Le espressioni usano funzioni per derivare i valori base.
EUPHORIA
E’ un tipo di linguaggio di scripting, creato intorno al 1993 da R. Craig presso la Rapid
Deployment Software.
EUPHORIA è un linguaggio per PC, interpretato e strutturato a blocchi. E' stato concepito
per lo sviluppo di applicazioni generali e la programmazione di giochi.
Il modello dati usato da EUPHORIA è estremamente semplice: tutti gli elementi dati sono
o atomi o sequenze. Tutti gli atomi sono numerici: chars, interi, floats. Le sequenze
possono essere di lunghezza qualunque e possono contenere atomi o altre sequenze.
Una stringa è semplicemente una sequenza di caratteri. Strutture dati molto più complesse
possono essere costruite da sequenze nidificate. Indexing e lo slicing sono caratteristiche
molto importanti, cosi come la capacità di distribuire operazioni scalari su sequenze di
numeri. EUPHORIA realizza il type checking, può fornire i domini degli indici di una
sequenza e i valori di ritorno di una funzione. Infine, esso consente al programmatore di
definire operazionalmente dei data types astratti, dichiarando per ognuno di questi type
una funzione booleana che determini la membership del type. EUPHORIA è concepito per
essere un linguaggio molto semplice da imparare. Supporta di rado caratteristiche di
controllo sequenziale: loops e condizionali. Non supporta alcuna caratteristica avanzata
come il thread, l'exception, o funzioni di ordine più elevato.
FORMAC
Linguaggio applicativo matematico adatto alla simulazione. Fu creato da Jean Samnet nel
1964 per conto della IBM. Il FORMAC è un dialetto del FORTRAN con un vasto insieme di
estensioni per la computazione simbolica e manipolazione di espressioni. Fu progettato e
implementato negli anni '60 per supportare la computazione scientifica e ingegneristica sui
mainframes IBM. I data types supportati includevano tutti i types numerici del FORTRAN,
più i numeri razionali, simboli, arrays, ed espressioni. I programmi FORMAC potevano
includere subroutines e funzioni, e potevano usare altre facilities del FORTRAN come le
aree comuni. Il FORMAC fu inizialmente implementato come un preprocessore in testa al
FORTRAN; le chiamate di funzioni formula e simboliche venivano trasformate in chiamate
ad una libreria di manipolazione simbolica. Per le relazioni di I/O, il FORMAC poteva
avvantaggiassi delle usuali facilities del FORTRAN, e poteva anche stampare le sue
espressioni simboliche. Alla fine degli anni '60, i ricercatori IBM crearono un simile
preprocessore per il PL/I, chiamato PL/I-FORMAC. Diversamente dai successivi sistemi
matematici simbolici, il FORMAC supportava la creazione di espressioni ma non di metaespressioni. Questo è indicativo del suo stato iniziale nell'evoluzione della computazione
simbolica, e a dispetto della mancanza di caratteristiche ebbe una grossa influenza sui
suoi immediati successori. Il FORMAC è stato usato sino ai primi anni '90.
FORTH
(dall'inglese fourth, quarto)
E' stato realizzato verso la fine degli anni Sessanta dall'astronomo Charles Moore per
controllare strumenti scientifici il cui posizionamento va effettuato con grande precisione.
E' nato quindi come linguaggio per il controllo di strumenti di misura e l'acquisizione di dati.
FORTRAN
(FORmula TRANslator, traduttore di formule)
22
Fu sviluppato nel 1954 da John Backus e il team di collaboratori messagli a disposizione
dall'IBM. Due anni più tardi venne reso disponibile il primo compilatore, per l'elaboratore
IBM 704x. Da allora in poi vennero commercializzate successive versioni del FORTRAN,
alcune delle quali avevano il compito di imporre uno standard sul mercato, come il
FORTRAN 66 e il FORTRAN 77. Il linguaggio è idoneo ad applicazioni scientificomatematiche: è stato il primo linguaggio di programmazione in ambito scientifico. Il
FORTRAN permise di orientare la ricerca sui linguaggi di programmazione, ritenuti dai
programmatori dell'epoca non utilmente impiegabili. I primi ambiti di applicazione furono di
carattere amministrativo e gestionale.
FORTRAN77
Il FORTRAN 77 ,al contrario del forse più noto BASIC, non è direttamente eseguibile ma
necessita di una prima fase di compilazione per il controllo della ortografia e di una
successiva fase di mapping che ne controlla la sua struttura con il sistema operativo della
macchina stessa. Dopo questi due passaggi si ottiene un modulo che è direttamente
eseguibile. Il FORTRAN77 permette una programmazione STRUTTURATA e per la sua
struttura algebrica è particolarmente adatto alle applicazioni scientifiche. La struttura di un
programma non si manifesta solo nella sua suddivisione in SUBROUTINE e FUNCTION
ma nella presenza di una certa gerarchia nelle diverse parti che lo compongono.
La traduzione di un metodo di calcolo (algoritmo) con una sequenza di istruzioni che il
calcolatore può interpretare e che termina con la parola end definisce una struttura di
calcolo cioè un programma. Il programma principale (main), le subroutine e le function
costituiscono le unità di programma. Le istruzioni si possono suddividere in 2 categorie:
eseguibili ,cioè che descrivono una azione che il programma può eseguire; non eseguibili,
cioè che definiscono delle variabili o delle strutture di dati o delle dichiarazioni.
GPSS
GPSS stà per "General Purpose Simulation System". Il sistema creato nel 1961, sostenuto
e sviluppato da Geoffrey Gordon (IBM) per più di dieci anni. Anche le versioni GPSS/360 e
GPSS/V furono sviluppate presso la IBM. Oggigiorno esistono versioni di GPSS per quasi
ogni tipo di sistema operativo. L’interfaccia grafica semplifica la disposizione WWW, lo
rende di largo uso, diventando completamente indipendente dalla piattaforma. Durante la
metà degli anni '70 James Henrikson (Wolverine Software Corp.) sviluppò il suo GPSS/H.
Le caratteristiche che lo differenziano dai suoi predecessori sono la sua efficienza in
runtime,
aumentata
significativamente,
e
l'integrazione
di
un
linguaggio
di
programmazione universale. Come linguaggio di programmazione il GPSS/H può essere
usato per generare files traccia di animazione, che portano un po’ di vita nei layouts di
animazione Proof.
GUILE
GUILE è una implementazione SCHEME disponibile in una libreria, in modo tale che
qualunque applicazione può avere al suo interno un interprete SCHEME. È il linguaggio di
estensione ufficiale del Progetto GNU e viene utilizzato da molte applicazioni Gnome.
Aggiungere un linguaggio di estensione al proprio programma può suonare molto
complesso, ma GUILE rende il tutto molto facile. (Molte applicazione Gnome supportano
anche PERL e Python; è molto facile supportare svariati linguaggi quando si è aggiunto il
primo. Ma GUILE occupa un posto particolare nel cuore dei programmatori di Gnome.)
HASKELL
Linguaggio di programmazione funzionale o lambda-based venne creato nel 1990
dall'HASKELL Committee, composto da Hughes, Wadler e Peterson.
23
L'HASKELL non è un linguaggio strettamente funzionale, progettato dagli esponenti più
rappresentativi della comunità della programmazione funzionale. La motivazione alla
nascita dell'HASKELL era l'intento di unificare la programmazione funzionale attraverso
l'introduzione di un linguaggio moderno, standard e aperto.
HASKELL è un linguaggio fortemente tipizzato con un ricco type system. Come in tutti i
linguaggi funzionali, le computazioni vengono svolte solamente da espressioni: ogni
espressione ha un type. I data types primitivi supportati dal linguaggio includono: interi,
reali, caratteri, liste, enumerazioni, coppie ordinate e vari mappings di funzione. Le
implementazioni del linguaggio HASKELL realizzano il type cheking statico prima
dell'esecuzione. Le funzioni HASKELL sono definite come mappings tra parti dello spazio
del type. Ovviamente, sono supportate la composizione, le curried functions, le forme
lambda e funzioni di ordine più elevato. HASKELL usa la lazy evaluation. Esso consente
anche la definizione di operatori come funzioni (overloading di operatori), una proprietà
conveniente che è inusuale in sistemi di programmazione funzionale. La modularità è
espressamente supportata. I programmi consistono di moduli nominati(named). La facility
del modulo fornisce distinti nomi degli spazi e un mezzo per la definizione di data types
astratti incapsulati. Le proprietà dei moduli consentono qualche grado di programmazione
orientata agli oggetti.
HTML
Il linguaggio HTML (Hyper Text Markup Language) permette di realizzare "pagine" di
informazioni sia testuali che grafiche in cui si possono attivare dei link ad altre pagine
diffuse in rete; questo agevola il recupero delle informazioni e garantisce, grazie ad una
serie di protocolli (il più noto dei quali è HTTP -Hyper Text Transfer Protocol-), la
possibilità di accesso da parte degli utenti a un enorme numero di documenti. HTML è il
codice base per l'elaborazione delle informazioni su Internet.
A voler essere precisi HTML non è un vero e proprio linguaggio di programmazione, è un
formato di dati che consente lo scambio di informazioni attraverso il World Wide Web. I tag
HTML sono semplicemente dei marcatori che comunicano al browser alcune informazioni
di formattazione. HTML, dunque, non può essere definito un linguaggio di
programmazione, ma un sistema di markup (contrassegno). Vale la pena spendere due
parole anche sullo standard XHTML.
XHTML é un nuovo standard di riferimento del W3C che ha ufficializzato nel documento
"XHTML 1.0: The Extensible HyperText Markup Language", definendole "una
riformulazione di HTML 4.0 in XML 1.0". Il W3C ha voluto avvicinare XML al modello
attuale di HTML, rimuovendo le limitazioni che finora hanno impedito la diffusione di XML.
Prima fra tutte, quella che vede XML incompatibile con la stragrande maggioranza di
browser in circolazione. La volontà dichiarata del W3C (consorzio di aziende per lo
sviluppo di standard per il Web) è quello di sostituire al più presto HTML con un linguaggio
basato su XML.
ICI
L'ICI è un linguaggio imperativo procedurale interpretato con reminiscenze del C. E'
essenzialmente un linguaggio di scripting, concepito per lo sviluppo di applicazioni.
La sintassi dell'ICI è simile a quella del C, ma fornisce un modello di dati di livello più alto
teso a ridurre gli sforzi e gli errori del programmatore. In ICI i data types primitivi includono
interi, reali, stringhe, files, safe pointers e espressioni regolari. Gli aggregati di data types
sono arrays, insiemi e tabelle associative. Gli insiemi possono essere eterogenei, nidificati
e supportano le usuali operazioni d'insieme: unione, intersezione, etc. In ICI tutte le
strutture dati sono dinamiche e l'ambiente del linguaggio provvede alla gestione della
memoria e alla garbage collection. Le strutture di controllo includono i soliti loops e le
24
dichiarazioni condizionali, più un semplice costrutto di gestione degli errori. Il linguaggio
supporta subroutines e moduli nested. Tutte le variabili sono lessicalmente finalizzate alla
subroutine o al livello del modulo, ma diversamente dalla maggior parte dei linguaggi
strutturati, l'ICI consente di correggere il programma in corso.
Benchè non sia un linguaggio object-based, molte caratteristiche della programmazione a
oggetti possono essere emulate usando strutture dati con caratteristiche di successione
chiamate super strutture. Per supportare lo sviluppo di applicazioni, sono presenti dei files
di I/O e un'interfaccia di sistema simili a quelli del C. Il linguaggio possiede anche una
modesta libreria standard di funzioni built-in.
ICON
E’ un linguaggio di programmazione ad alto livello che assomiglia a molti altri linguaggi di
programmazione ma offre molte caratteristiche che permettono un grosso guadagno in
produttività. Al contrario del nome, Icon non è un linguaggio di programmazione visuale; il
suo look-and-feel deriva dal PASCAL e dal C. La cosa importante di ICON è che la sua
sintassi è facile da imparare. La semantica di ICON, che generalizza le idee di SNOBOL,
aggiungendo considerevole potenza alla notazione familiare trovata nei maggiori linguaggi
di programmazione. Questo è notevole perché molti linguaggi lo fanno con una sintassi
così differente che i programmatori devono imparare un nuovo modo di pensare prima di
usarli. ICON è stato sviluppato in diversi anni all'Università dell'Arizona da un team gestito
da Ralph Griswold. Oggi gira su molte piattaforme ed è utilizzato dai ricercatori per
algoritmi, compilatori, dai linguisti come dagli amministratori di sistema e dagli
appassionati.
IDL
E’ stato sviluppato per l'esecuzione di ricerche scientifiche, è array-oriented ed ha un
linguaggio di programmazione di quarta generazione. IDL è disponibile per numerose
piattaforme, tra le quali: Microsoft Windows, Unix, VMS.
Tra le proprietà principali possiamo evidenziare:
linguaggio di programmazione procedurale con possibilità di eseguire comandi interattivi e
di chiamare routines;
funzioni matematiche built-in per la gestione di matrici (es. inversione) , differenziazione,
integrazione e gestione dei numeri complessi;
2D plot: Line plots, scatter plots, histograms, bar graphs, polar plots, con controlli di colori,
fonti etc ;
Contour plots, filled contours, shaded surface representations;
GUI toolkit per interfacce definibili dall'utente e che rendono l'applicazione indipendente
dalla piattaforma di costruzione;
statistica: deviazione standard, distribuzione di probabilità (binomiale, gaussiana, T di
Student), analisi della varianza, etc.
INTERCAL
Il nome intero del compilatore è "Compiler Language With No Pronounceable Acronym",
che per ovvie ragioni viene abbreviato con INTERCAL.
Il linguaggio di programmazione INTERCAL fu progettato la mattina del 26 maggio 1972
da Donald R. Woods and James M. Lyon alla Princeton University.
Diciotto anni dopo Eric S. Raymond realizzò una versione UNIX-hosted di un compilatore
INTERCAL. Da allora l'implementazione del C-INTERCAL è stata mantenuta ed ampliata
da una comunità internazionale di "tecno-masochisti", che include Louis Howell, Steve
Swales, Michael Ernst, e Brian Raiter. La nascita di INTERCAL fu ispirata da
un'ambizione: avere un linguaggio compilatore che non avesse nulla in comune con
25
qualunque altro dei linguaggi principali. Per "principale", s'intendeva qualunque linguaggio
con cui gli autori avessero familiarità, es., FORTRAN, BASIC, COBOL, ALGOL, SNOBOL,
APL, LISP, e PL/I. Per la maggior parte, INTERCAL è rimasto fedele a questo obiettivo,
condividendo solamente gli elementi base come le variabili, gli arrays, e l'abilità di
compiere operazioni di I/O, ed evitando tutte operazioni convenzionali.
JCL
Il Job Control Language (JCL) è il linguaggio con cui l'utente comunica al sistema
operativo la definizione di ogni lavoro da compiere. In particolare, esso permette di
Identificare:
Ø il singolo lavoro (scheda JOB)
Ø Rendere noto come un job è stato suddiviso in diverse unità elaborative o step
(scheda EXEC)
Ø Evidenziare quali sono le risorse richieste dal job e da ogni singolo step (scheda
DD)
Ø Comunicare dove risiedono i dati da elaborare
Ø Ottimizzare l'uso delle unità, dei volumi e dello spazio su unità ad accesso diretto
Ø Passare data-set da uno step all'altro
Ø Copiare informazioni già fornite in precedenza con un sistema di riferi mento
all'indietro
Ø Richiamare, specificandone semplicemente il nome su di una scheda EXEC, gruppi
di schede costituenti uno o più step con la possibilità di apportarvi modifiche
temporanee (procedure catalogate e in stream)
In breve, un JCL rappresenta nient'altro che la descrizione del flusso di istruzioni
necessarie per richiedere al sistema operativo l'esecuzione di un programma al quale
vengono riservate determinate risorse (tempo CPU, spazio su disco, eventuali unità a
nastro, stampanti). In sostanza potremmo assimilare un listato JCL ad un programma
batch eseguito nel mondo MsDos; tuttavia, nonostante la possibilità del DOS di
reindirizzare input ed output su periferiche diverse e di eseguire operazioni anche
complesse come operare scelte in base ai codici di ritorno, un listato DOS è decisamente
più semplice e intuitivo di un listato JCL, ed il parallelo proposto per assimilarli nella
struttura sequenziale dei comandi deve necessariamente fermarsi a quel punto. In un
listato JCL, è infatti possibile descrivere il tipo di periferica richiesta, il tempo-macchina
oltre il quale il job viene concluso automaticamente dal sistema con un messaggio di
errore (ABEND, o ABnormal END), il tipo di condivisione di un file o di un intero data-set.
JOVIAL
JOVIAL stà per " Jule's Own Version of IAL". Il linguaggio fu infatti creato da Jule's I.
Schwartz tra gli anni 1959-1960. E’ basato fondamentalmente sull'ALGOL 60, con
estensioni per ciò che riguarda la programmazione in real-time su larga scala. Gli elementi
dati sono registrazioni, ingressi(records), e tavole. JOVIAL viene usato largamente dalle
US AIR FORCE. La maggior parte del software per gli AWACS è in JOVIAL, e gira su
sistemi IBM(360 compatibile).
LIMBO
Linguaggio di programmazione pensato per far girare applicazioni a sistemi distribuiti su
piccoli computers. LIMBO supporta programmazione modulare, forte controllo dei type al
momento della compilazione e dell'esecuzione, comunicazione tra i processi attraverso
canali caratterizzati, e semplici types di dati astratti. E' stato progettato per garantire
un'esecuzione sicura anche su piccole macchine prive di protezione della memoria
hardware.
26
Nella sua implementazione iniziale per il sistema operativo INFERNO, i programmi oggetti
generati dal compilatore LIMBO giravano usando un interprete per una fissata macchina
virtuale. INFERNO e l'associata macchina virtuale giravano o stando soli su un semplice
hardware o come applicazione sotto un convenzionale sistema operativo come Unix,
Windows 95, Windows NT, e Plan 9. Per svariate architetture, incluse INTEL x86 e MIPS, i
programmi oggetti LIMBO vengono trasformati "al volo" in istruzioni per l'hardware
sottostante
LISP
In informatica, è l'acronimo di List Processing, un linguaggio di programmazione sviluppato
nel 1958 da John McCarthy presso il Massachussets Institute of Technology (MIT) e usato
soprattutto per manipolare liste di dati. Completamente diverso dai linguaggi procedurali
messi a punto fino al momento della sua introduzione (FORTRAN, ALGOL), LISP è un
linguaggio nel quale ogni espressione è un elenco di richiami a funzioni elementari. È stato
considerato a lungo il linguaggio standard per gli studi sull'intelligenza artificiale ed è
tuttora molto usato nel campo della ricerca scientifica. Il LISP è anzitutto particolarmente
adatto allo sviluppo incrementale. Il programmatore può scrivere una funzione in termini di
altre funzioni, sia già definite sia non ancora definite, e cosi realizzare e provare
continuamente. Non è necessaria la dichiarazione della struttura dei dati né delle variabili
prima del loro uso. Il debugging è eccellente: quando insorge un problema il LISP invita il
programmatore ad esplorare l'ambiente relativo e tutta la sua potenza resta a disposizione
per risolverlo. In effetti un errore si manifesta come un punto d'interruzione da cui partire
per esaminare il problema. Un'altra particolarità è in grado di gestire automaticamente i
suoi spazi di memoria. I programmi in LISP possono creare o manipolare altri programmi
in LISP, in quanto dati e programmi sono rappresentati allo stesso modo. Può usare
simboli arbitrari, senza specificarli e trattarli come array di caratteri ed il programmatore
può attribuire loro proprietà e manipolare le relazioni definite tra essi. Infine si può
facilmente estendere e le funzioni create dal programmatore vengono trattate come quelle
definite nel sistema. Ci si potrebbe chiedere a questo punto come mai il LISP, nonostante
la sua età ed i suoi vantaggi, abbia solo da poco cominciato ad essere usato nella
programmazione tradizionale. . Una prima ragione è che, fino a poco tempo fa, era
disponibile solo su macchine potenti e costose .La seconda ragione è che gran parte dei
sistemi in LISP sono poco adatti all'elaborazione in tempo reale e dove la sicurezza è
importante, aspetti che oggi sono oggetto di una intensa attività di ricerca.
LOGO
(dal greco logos, pensiero, discorso)
Progettato nel 1967 da Seymour Papert al MIT nell'ambito di un progetto di ricerca
finanziato dalla National Science Foundation è, prima di tutto, un metodo psicologico per
l'alfabetizzazione informatica. Attraverso la creazione di immagini tramite un cursore (una
tartaruga) mosso da istruzioni elementari derivate dal LISP, cattura l'attenzione e stimola
all'uso del computer anche i bambini in età prescolare. Sia il FORTH che il LOGO
presentano notevoli somiglianze in quanto vennero originariamente progettati per
controllare due apparecchi, rispettivamente un telescopio e una tartaruga da pavimento.
LUA
Appartiene alla categoria dei linguaggi Scripting, elaborato nel 1994 da W. Celes, R.
Ierusalimschy, L.H. de Figueiredo al PUC-Rio. E’ un linguaggio strutturato e interpretato
progettato per lavorare in altre applicazioni. E' stato concepito per essere usato come
un'estensione specialmente per applicazioni con requisiti per la memorizzazione di dati
strutturati. Poiché è stato inteso per essere usato come linguaggio estensione per altre
27
applicazioni, LUA non possiede la notazione di 'main' program o di punto di entry; mentre
si assume che tutti i codici vengono invocati dall'applicazione principale. La sintassi del
LUA è qualcos a di simile a quella del PASCAL, ma il sistema dei data type è molto
diverso. Come molto linguaggi di scripting, è vagamente tipizzato: le variabili non hanno
bisogno di essere dichiarate, e possono assumere qualunque tipo di valore. I data types
supportati includono i numeri reali, stringhe, funzioni, e tabelle(arrays associativi).
Possiede anche un distinto valore tipo 'nil', e un ulteriore data type 'userdata' che può
memorizzare puntatori C per l'uso da parte dell'applicazione principale. Gli arrays
associativi di LUA sostituiscono altri data types come arrays e tuples. Le strutture di
controllo supportate includono vari costrutti condizionali e di looping. Il linguaggio non
possiede costrutti per la gestione degli errori, mentre gli errori vengono solitamente
indirizzati verso funzioni di gestione predefinite. Come il PERL, LUA supporta il multiplo
ritorno di valori da funzioni e da un numero variabile di argomenti di funzioni.
Programmare in LUA è molto semplice: tutte le variabili sono o globali o locali rispetto ad
una particolare applicazione. Il default è globale, le variabili locali vanno esplicitamente
dichiarate. La definizione di funzioni sono giusto l'assegnazione di variabili globali. I data
values in LUA sono tali da supportare speciali estensioni per l'applicazione principale. I
tags possono essere usati per definire speciali sistemi di gestione per data types, o per
mettere a punto relazioni di successione o di delega.
MATLAB
La nascita di MATLAB (Symbolic math system) risale al 1964 (in seguito comparse la
versione MATLAB 68). MATLAB è il migliore ambiente per il calcolo numerico disponibile
sul mercato, affermatosi come uno strumento essenziale per più di 400.000 professionisti.
La felice combinazione di affidabili tecniche numeriche e di grafica avanzata, consente agli
utilizzatori di analizzare e visualizzare i dati; analizzare e ottimizzare i disegni e gli
algoritmi dei sistemi ingegneristici; esplorare nuovi concetti nella ricerca scientifica; creare
modelli matematici, risolvere sistemi di equazioni; eseguire calcoli scientifici ed
ingegneristici. Come ambiente di visualizzazione, MATLAB consente di creare sofisticati
grafici a colori utilizzando moderni strumenti grafici 3D, come la sfumatura delle superfici,
gli pseudocolori, le sorgenti di luce, i contorni 3D, l'image processing, l'animazione, la
visualizzazione volumetrica ed altro ancora. Questi strumenti a 3D, 4D e perfino 5D,
permettono un'analisi estremamente dettagliata anche di grosse quantità di dati. I grafici
possono essere animati per meglio illustrare i cambiamenti in relazione al tempo o ad
un'altra variabile. Si possono specificare le sorgenti di luce e i colori, al fine di rendere più
dettagliati i dati e facilitare l'interpretazione.
MERCURY
Il linguaggio MERCURY fu sviluppato nell'ambito dell'omonimo progetto nel 1993 presso
l'Università di Melbourne. E’ un linguaggio di programmazione logico con alcune
caratteristiche di linguaggio funzionale. E' stato progettato per dargli i vantaggi della
semantica dei linguaggi dichiarativi e la velocità e l'error -checking dei linguaggi
procedurali. La sintassi del MERCURY è simile a quella del PROLOG, ma supporta
costrutti addizionali con cui dichiarare tipo, modo, e altri vincoli. Diversamente dalla
maggior parte dei linguaggi di programmazione logici, MERCURY non è interpretato, il
compilatore traduce i moduli del codice in C trasportabile. Questo gli da al una addizionale
trasportabilità e velocità, ma impedisce di creare ed elaborare nuovi codici “al volo”.
MESA
Fu creato nel 1977 presso la Xerox PARC. E' un linguaggio di programmazione concepito
per sistemi e applicazioni particolari. Il MESA possiede una sintassi simile a quella del
28
PASCAL e una semantica simile a quella dell'ALGOL-68. I moduli MESA consentono la
compilazione separata. Nel MESA il type checking può essere disabilitato.
MIRANDA
E’ un linguaggio di programmazione funzionale o lambd-based, creato nel 1985 da David
Turner presso l’Università di Kent.
E’ stato concepito per l'insegnamento della programmazione funzionale e per lo sviluppo
di applicazioni. Come linguaggio puramente funzionale non possiede costrutti imperativi di
controllo. Gli “scripts” di MIRANDA consistono di un insieme di equazioni che definiscono
varie strutture dati e operazioni. I data types disponibili includono booleani, identificatori
(simboli), interi, caratteri, reali, stringhe, liste, tuples, e funzioni. E’ un linguaggio
fortemente tipizzato(typed). MIRANDA fornisce una potente sintassi di definizione per le
liste dette comprensioni di lista, diversamente dal LISP e dalla versione originale del ML,
usa una valutazione molto semplice per tutte le espressioni. Questo consente al sistema
del linguaggio di supportare infinite liste e indefiniti parametri. Supporta molte
caratteristiche di livello più elevato che vengono richieste a linguaggi funzionali avanzati:
curried functions, funzioni prima classe, sofisticati modelli di matching per l’applicazione
delle regole, e definizione di tipi algebrici. La sintassi di MIRANDA è molto elegante e
compatta. La sintassi base per l'applicazione delle funzioni è prefissata, ma la notazione
non-fissa può essere usata nella maggior parte dei casi.
ML
E’ il nome per una famiglia di linguaggi funzionali: ML, SML, SML/NJ, CAML, EML e altri.
Le proprietà e l'utilizzo delle differenti versioni varia in qualcosa. I linguaggi ML sono
generalmente interpreti. ML è un linguaggio funzionale puro. Supporta molte delle capacità
avanzate che si richiedono ad un buon linguaggio funzionale: ricorsione, forte typing, una
buona varietà di data types built -in, facilities per costruire aggregati e types funzionali,
composizione di funzioni, funzioni di ordine elevato e gestione delle eccezioni(exception
handling). Fornisce files e network I/O per supportare la scrittura di programmi reali; la
scrittura di dati costituisce un contro effetto della valutazione dell'output di una funzione.
Supporta inoltre caratteristiche memorizzazione variabile. Tutti i sistemi ML condividono
una libreria comune di funzioni built-in e moduli chiamati “SML Basis Library”. La libreria
base fornisce varie manipolazioni dati, I/O, gestione di stringhe, e funzioni di interfaccia di
sistemi operativi. Il sofisticato type sistem del ML dà al programmatore la capacità di
definire semplici funzioni che automaticamente vengono applicate al tipo giusto di dati.
Supporta inoltre una leggera forma di polimorfismo. Molti altri linguaggi funzionali
progettati dopo supportano un approccio di tipo pattern-matching per l'applicazione di
funzioni. Il nome ML stava originariamente per Meta-Language.
MODULA2
Fu sviluppato nel 1978 come linguaggio di sistema per la workstation LILITH. Il concetto
centrale è il modulo che può essere usato per "incapsulare" un set di sub-programmi e
strutture dati, e restringere la loro visibilità dalle altre porzioni di programmi. Ogni modulo
ha una parte di definizione che fornisce l'interfaccia, ed una parte di implementazione. Il
linguaggio provvede ad una limitata simultaneità del single -processor (monitors,
coroutines e espliciti trasferimenti di controllo) e accessi hardware (indirizzi assoluti ed
interrupts).
MODULA3
E’ un membro della famiglia di linguaggi PASCAL. Progettato alla fine degli anni '80
presso la Digital Equipment Corporation and Olivetti, MODULA3 corregge molte delle
29
deficienze del PASCAL e di MODULA2 per il software engineering pratico. In particolare,
MODULA3 mantiene la semplicità de i type e l'affidabilità dei precedenti linguaggi, mentre
realizza funzioni che facilitano la gestione delle eccezioni, la simultaneità e la garbage
collection. E’ sia un pratico linguaggio di implementazione per vasti progetti software che
un eccellente linguaggio di insegnamento.
MUMPS
Linguaggio adatto per database e text-processing creato nel 1969 da Octo Barnett M.D.
presso il Mass. General Hospital. MUMPS, noto anche solamente come 'M', è un
linguaggio interpretato, imperativo procedurale con caratteristiche aggiuntive per la
programmazione event-driven, il text handling, e la gestione di database. La sintassi del
linguaggio è molto semplice ma artificiosa. Le variabili possono essere semplici numeri,
records, liste o enormi database. L'accesso alle variabili globali è trasparente, liberando
così il programmatore dalla preoccupazione degli esiti della gestione dei database. Nel
MUMPS sono presenti le usuali strutture di controllo sequenziale. Sono inclusi i soliti
operatori aritmetici, ma la reale forza del MUMPS nella sua string handling. Possiede un
flessibile insieme di istruzioni per il pattern matching, il sorting, e la manipolazione di
stringhe(anche se non sviluppata come nello SNOBOL o ICON).E’ stato progettato per
supportare la multi-programmazione e la computazione distribuita. Esistono anche
implementazioni GUI disponibili per il linguaggio.
OBERON
Fu progettato da Wirth nel 1988, come discendente del linguaggio MODULA2. E’
contemporaneamente sia un linguaggio di programmazione imperativo procedurale che un
moderno operating system per workstations di singoli utenti. I suoi punti di forza sono:
Ø un integrato e modulare ambiente di programmazione
Ø un'interfaccia testuale utente molto versatile.
OCCAM
Linguaggio di programmazione che facilita la scrittura di programmi paralleli, consentendo
al programmatore di specificare se i processi vanno eseguiti sequenzialmente o in
parallelo. Basato sul CSP e EPL, fu originariamente sviluppato per il Transputer INMOS.
OCCAM (così chiamato per il filosofo inglese William of Occam), fu creato da David May
nel 1982. Le espressioni sono processi che possono essere combinati in serie o in
parallelo. I processi comunicano via chiamata attraverso canali unidirezionali. Non vi è
precedenza di operatori. Un compilatore portabile e gratuito chiamato SPOC è stato
recentemente realizzato dall'Università di Southampton e altri compilatori sono in fase di
sviluppo.
OCTAVE
Linguaggio di programmazione ad alto livello per il calcolo matematico, usato
fondamentalmente in modo interattivo. Viene usato attraverso un terminale a caratteri,
come una console virtuale di GNU/Linux, ma per ottenere dei grafici si avvale di Gnuplot.
L'interazione tra Gnuplot e OCTAVE è trasparente, se quest'ultimo viene utilizzato in una
finestra di terminale all'interno del sistema grafico X.
PASCAL
(dal nome di Blaise Pascal, matematico francese del 1600)
E' stato chiamato così in onore del matematico (1623-1662) autore a soli 19 anni della
Pascalina, uno dei primi strumenti per il calcolo automatico.
30
Il linguaggio PASCAL fu in origine progettato da Niklaus Wirth, un professore svizzero, alla
fine degli anni '70. Quando il PASCAL fu progettato, esistevano già molti altri linguaggi di
programmazione, ma pochi largamente usati: FORTRAN, C, ASSEMBLY, COBOL. L'idea
chiave del nuovo linguaggio di programmazione fu l'ordine, raggiunto tramite un forte
concetto di tipizzazione dei dati, il controllo delle dichiarazioni e la programmazione
strutturata. Il linguaggio fu anche sviluppato come strumento di insegnamento nelle
scuole. Il famoso compilatore Pascal di Borland, chiamato Turbo Pascal, fu introdotto nel
1985. Il compilatore Turbo Pascal fu un best-seller dell'epoca e rese il linguaggio popolare
particolarmente nella piattaforma PC, grazie anche all'unione di semplicità e pot enza. Il
Turbo Pascal introdusse un ambiente di sviluppo integrato (IDE) in cui era possibile
editare il codice (in un editor WordStar compatibile), compilare, vedere gli errori e saltare
alle linee contenenti gli stessi. Oggi questo può sembrare banale e scontato, ma in
precedenza si doveva uscire dall'editor tornando al DOS, compilare, annotarsi le righe di
errore e aprire di nuovo l'editor puntando alle righe incriminate. Inoltre Borland vendeva
Turbo Pascal per 49 dollari, dove Microsoft vendeva il suo compilatore Pascal per alcune
centinaia di dollari. I molti anni del successo del Turbo Pascal contribuirono alle decisione
di Microsoft di cancellare la linea dei suoi compilatori Pascal.
PERL
Linguaggio di programmazione scripting creato da Larry Wall verso la fine degli anni '80
allo scopo di analizzare file di testo per estrarne informazioni e quindi usarle per generare
report, statistiche e prospetti informativi in generale
Il nome PERL, acronimo di "Practical Extraction and Report Language", sintetizza in
maniera esemplare la caratteristica principale di questo linguaggio. Si tratta infatti di un
eccezionale strumento di sviluppo, dotato di un'ampia serie di funzioni per l'analisi dei dati
in formato testuale, utile soprattutto al programmatore impegnato nell'analisi di file di log o
nella creazione di espressioni regolari. Sebbene il PERL sia stato sviluppato all'interno del
sistema operativo Unix, il suo successo è stato tale da garantirne la diffusione anche su
altre piattaforme come Dos e Windows95/NT. La "migrazione" in Linux è stata pressoché
immediata ed è entrato a far parte di tutte le sue distribuzioni.
PHP
Linguaggio di scripting server-side che consente lo sviluppo sia di siti generati
dinamicamente, sia di applicazioni che incorporano connessioni a database e data
processing. La flessibilità e scalabilità ne fanno uno dei più popolari linguaggi di scripting
server-side su piattaforme Unix/Linux. Inoltre, la precisa definizione della sua sintassi e dei
suoi costrutti lo rendono più amichevole di altri linguaggi tipo PERL, Python, C/C++ o ASP.
L'acronimo sta per Hypertext Pre-processor. La nascita del PHP ci riporta indietro ai primi
giorni del Web, nel 1994, quando Rasmus Lerdorf utilizzò una serie di script PERL per
registrare le visite che un suo curriculum on line riceveva. L'anno seguente egli rilasciò
una serie di utility chiamata Personal Home Page Tools, riscrisse il parser e incorporò un
altro dei suoi tool, FI (Form Interpreter, utilizzato per processare l'input da form HTML), per
poi portare tutto questo sulla versione 2 del PHP/FI nell'estate del '95. Un paio di anni
dopo, la responsabilità dello sviluppo del PHP fu trasferita ad un ben distribuito e
organizzato team di lavoro, che migliorò ulteriormente il parser e migliorò le potenzialità e
la sintassi del linguaggio, creando ciò che oggi conosciamo come PHP4. Le caratteristiche
peculiari di questo linguaggio sono le seguenti:
Ø Il PHP è un linguaggio di scripting: i programmi scritti in linguaggio PHP, denominati
brevemente script, vengono eseguiti tramite un apposito software, "l'interprete"
PHP.
31
Ø E' un linguaggio "HTML-embedded: questa caratteristica si riferisce al fatto che il
codice PHP è immerso nell'HTML.
Ø Opera server-side, cioè lato server: semplicemente significa che l'elaborazione di
uno script avviene sul server, prima che questi spedisca la pagina al browser (il
"client"). Di conseguenza, chi accede ad una pagina PHP non ha la possibilità di
leggere le istruzioni in essa contenute: essendo state processate, ciò che il client
vedrà sarà il risultato dell'elaborazione.
PILOT
(Programmed Inquiry Language or Teaching). Linguaggio sviluppato negli anni sessanta
da una equipe di ricercatori del S. Francisco Medical Center (California) per facilitare la
realizzazione di corsi di istruzione secondo le metodologie CAI. Il PILOT consente ai
docenti, con scarse cognizioni di informatica, di realizzare lezioni interattive di tipo
skinneriano col computer, in modo semplice ed efficace. Possiede grafica, animazione,
colore, suono. E' dotato di un elementare repertorio di istruzioni per operare con sicurezza
e potenza. Di questo linguaggio esistono versioni per Commodore, PC-IBM, Apple.
PL/1
Un gruppo di ricercatori della IBM mette in opera il "PL/1" (Programming Language One)
che racchiude e migliora le caratteristiche di FORTRAN e COBOL. Originariamente venne
utilizzato per sviluppare programmi nei grossi calcolatori ma, in seguito, sarà adottato
anche nei minicalcolatori. Il PL/1 segnò una tappa fondamentale per il superamento della
rigida specificità commerciale e scientifica dei linguaggi precedenti e per la real izzazione
di linguaggi di programmazione destinati ad un gruppo più vasto di utenti. Si tratta di un
linguaggio che permette di gestire gli errori, utilizzato in ambiente accademico e nella
ricerca.
POP
(Package for Online Programming). La prima versione della famiglia POP risale al 1966, e
fu appunto il POP-1. E' nato ad Edimburgo e usava la notazione polacca inversa. Nel 1967
Robin Popplestone sviluppava la seconda versione: il POP-2.
Questo era un linguaggio innovativo che incorporava molte idee di Landin, inclusi i flussi,
le chiusure e le funzioni. Usava una sintassi simile a quella dell'ALGOL. La prima
implementazione fu chiamata Multi-POP, basata su una funzione REVPOL scritta in POP1, e produceva un output in notazione inversa polacca.
Il POP-10 venne creato nel 1973 da Julian Davies. Discendente del POP-2, venne usato
nel sistema PDP-10. Il POP-11 nacque nel 1975 sempre ad opera di Robin Popplestone. Il
POP-11 è per molte ragioni molto simile al FORTH (stack-oriented, estensibile, efficiente).
Per altri versi è molto simile anche al LISP(funzionale, tipizzato dinamicamente, interattivo,
garbage-collected). E possiede una sintassi simile a quella del PASCAL(strutturato a
blocchi).
PROGRAPH
Deriva dalla contrazione di Programming in Graphics. Fu sviluppato da Tomasz
Pietrzykowski presso il Technical U di Halifax. E' un linguaggio di flusso di dati visuale. Le
icone di programmazione sono connesse da datalinks attraverso i quali viaggia
l'informazione. Fu inizialmente (1982) implementato in PASCAL, più tardi in PROLO G.
Le versioni correnti sono in C e in PROGRAPH. Disponibile per MAC, e presto anche per
WINDOWS e UNIX.
32
PROLOG
(PROgramming in LOGic, programmare in logica)
E' stato sviluppato da Alain Colmerauer presso l'Università di Marsiglia nel 1970 per la
ricerca nel campo dell'Intelligenza Artificiale, in particolare per la produzione di Sistemi
Esperti: sistemi che partendo da una base di conoscenze acquisiste attraverso
l'esperienza umana, forniscono consulenze e supporto agli apparati decisionali. Ha
raggiunto grande notorietà perché è stato scelto dai giapponesi come linguaggio base per
i computer della quinta generazione. "Programmare in logica" vuole dire non specificare le
operazioni da eseguire per risolvere i problemi proposti, in quanto le procedure risolutive
vengono svolte automaticamente dal computer. I programmi in PROLOG non seguono
l’abituale flusso di controllo sequenziale, ma adottano una tecnica di ricerca inversa
(backtracking): il PROLOG cerca la soluzione in base a una serie di regole concatenate,
ponendosi di volta in volta un nuovo obiettivo da raggiungere.
REBOL
Realizza un modello universale per applicazioni distribuite sulla rete. REBOL inaugura una
nuova era di applicazioni condivise, collaborative ed interative, applicazioni che sono a
basso costo, veloci da creare ed eseguibili su ogni piattaforma. REBOL offre uno
standard, un modello unificato per lo scambio di informazioni per tutti i sistemi di internet.
RPG
Sviluppato dalla IBM come "strumento di utilità", RPG sta per report program generator
(programma generatore di stampe). La nascita risale al1965 ed il compilatore è utilizzabile
solamente su sistemi IBM 360 e questo spiega già in parte l'ostruzionismo che l' RPG ha
avuto almeno dai concorrenti IBM. In effetti il linguaggio racchiudeva delle potenzialità che
nemmeno la IBM ha saputo apprezzare per molti anni. Una caratteristica peculiare dell'
RPG è il ciclo fisso di esecuzione delle istruzioni: input, calcolo, output, con tutta la
gestione delle condizioni particolari. Con l'avvento dell' RPG III, prima, e ILE RPG, poi, il
linguaggio si è dimostrato valido anche per affrontare problematiche di applicazioni
moderne ad oggetti e di soluzioni ERP.
SCHEME
E’ un linguaggio utile per rappresentare un problema, più che per realizzare un
programma completo. La standardizzazione di questo linguaggio è riferita
fondamentalmente a un documento che viene aggiornato periodicamente: RnRS, ovvero
Revised-n Report on the Algorithmic Language Scheme, dove n è il numero di questa
revisione (attualmente dovrebbe trattarsi della quinta). Tuttavia, la standardizzazione
riguarda gli aspetti fondamentali del linguaggio, mentre ogni realizzazione che utilizza
Scheme introduce le estensioni necessarie alle circostanze. SCHEME è un linguaggio di
programmazione discendente dal LISP, inventato da Guy Lewis Steele Jr. e Gerald Jay
Sussman nel 1995 presso il MIT. E’ importante soprattutto in quanto lo si ritrova utilizzato
in situazioni estranee alla realizzazione di programmi veri e propri; in particolare, i fogli di
stile DSSSL. MIT Scheme e Kawa sono due tra i principali interpreti SCHEME.
SETL
(SET language) Fu creato nei primi anni '70. E' un linguaggio orientato agli insiemi di
altissimo livello. I tipi di dati includono sets(collezioni/insiemi non-ordinati), tuples
(collezioni ordinate) e maps (collezioni di coppie ordinate). Le espressioni possono
includere quantificator i( "for each" e "exist"). Il primo traduttore ADA fu scritto in SETL.
33
SGML
Standard Generalized Markup Language è un potente linguaggio per la codifica di testi in
Machine Readable Form, ed è uno standard internazionale ufficiale. La definizione di
questo linguaggio trae origine dal lavoro di Charles Goldfarb per lo sviluppo del linguaggio
GML nei laboratori di ricerca della IBM. Nel 1980 l'ente nazionale americano per la
standardizzazione (ANSI) decise di procedere alla definizione di uno standard per la
rappresentazione elettronica e la comunicazione di documenti, chiamando alla direzione
del progetto lo stesso Goldfarb. A partire dal 1984 l'intero progetto fu assunto come
proprio dall'International Organization for Standardization (ISO), che allo scopo ha
costituito un gruppo specifico denominato ISO/IEC JTC1/SC18/WG8. Questa
commissione ha rilasciato nel 1986, con il nome di codice ISO 8879, lo standard ufficiale
dello SGML.
SML
SML è la definizione standardizzata per il potente linguaggio funzionale ML.
ML si è sviluppato in vari modi durante la seconda metà degli anni '80; un comune dialetto
e un insieme base di proprietà vennero standardizzate nel 1990. Tale standard fu
revisionato nel 1997; i sistemi di linguaggio che seguono questo nuovo standard sono
chiamati implementazioni SML '97.
SNOBOL
(StriNg Oriented SymBOlyc Language). Linguaggio di programmazione simbolico,
orientato alle stringhe, è stato sviluppato nei Bell Laboratories all'inizio degli anni '60. Lo
SNOBOL consente la facile gestione del suono e la simulazione di automi SNOBOL ed è
utilizzato particolarmente nella linguistica, nel calcolo combinatorio, nella realizzazione di
coursware CAI e nella teoria dei giochi.
SQL
(Structured Query Language) E’ un sub-linguaggio (o linguaggio ospitato) che consente
l'esecuzione di tutte le operazioni necessarie per la gestione e l'utilizzo di una base dati
relazionale (database relazionale). Il termine "structured" (strutturato) è riferito al fatto che
si può inserire un'istruzione all'interno di un'altra. SQL è un linguaggio di interrogazione
(estrapola dati da un database); ha funzionalità di Dml (Data Manipulating Language,
linguaggio di manipolazione dei dati), ovvero un insieme di funzioni per la modifica dei dati
contenuti nel database. Inoltre sono state definite delle estensioni dei principali linguaggi di
programmazione, che consentono di includere nei programmi comandi SQL. In questi casi
l'uso di SQL viene definito incorporato (o embedded). E’ utilizzabile anche fuori da altri
linguaggi, in tal caso ci troviamo in Sql diretto (direct Sql); questo metodo prevede che il
utente fornisca interattivamente un'istruzione alla volta ad un interprete che la esegue e
risponde con visualizzazioni o messaggi; è un linguaggio interpretato dai Dbms; è privo di
qualsiasi istruzione di controllo tipica dei linguaggi procedurali (if-then-else, while-do,
for...).
SR
(Synchronizing Resources). E’ un linguaggio per la stesura di programmi simultanei. I
principali costrutti del linguaggio sono le risorse(resources) e le operazioni. Le risorse
comprendono i processi e le variabili che essi condividono; le operazioni provvedono ai
meccanismi primari per l'interazione del processo. SR fornisce un'innovativa integrazione
dei meccanismi per la chiamata e il servizio delle operazioni. Conseguentemente, sono
supportate tutte le chiamate di procedure locali e remote, i rendezvous, passaggio di
messaggi, creazione di processi dinamici e semafori. Supporta inoltre variabili globali e
34
operazioni condivise. E’ stato impiegato in un certo numero di università e laboratori per
corsi di lavoro e progetti di ricerca coinvolti nella programmazione simultanea. E' stato
usato nei corsi di programmazione simultanea per rinforzare i concetti con piccoli progetti
di programmazione e con progetti più grandi come esperimenti di algoritmi paralleli,
database replicati, simulazioni distribuite, e parti di sistemi operativi distribuiti come file
systems e interpreti dei comandi. E’ anche stato usato come strumento in diverse tesi
master e dissertazioni di dottorandi per condurre esperimenti in parallelo programmazione
distribuita e per implementare sistemi più vasti come sistemi per linguaggi di
programmazione misti, una per l'implementazione distribuita di algoritmi grafici, ed
esperimenti con strutture di programmi upcall.
SUPERLOGO
Linguaggio didattico per sistema operativo MS/DOS, prodotto dalla società SIS.CO. di
Roma. Si presenta come un sistema integrato che possiede come ambienti naturali, oltre
alla classica tartaruga, un word processor e notevoli capacità di gestione delle immagini.
SUPERLOGO ha una filosofia educativa semplice ma profonda che riunisce in sé le più
importanti acquisizioni della scienza cognitiva con il metodo pedagogico centrato
sull'attività dell'allievo e della sua inesauribile capacità di imparare.
TCL
(Tool Command Language). E' un linguaggio di programmazione interpretato, simile al
PERL ma più razionale. Trae origine dal C e da SHELL di Unix. Le applicazioni TCL sono
da considerarsi multipiattaforma. TCL é un linguaggio di programmazione interpretato di
facile apprendimento, utilizzabile sulle maggiori piattaforme e sistemi operativi esistenti.
Permette di creare velocemente programmi di vario genere, dai più semplici ai più
complessi con GUI (Graphical User Interface) ed é gratuito. TCL (che si pronuncia "ticl") è
un linguaggio di scripting. Per quanto vi siano alcuni tentativi di creare compilatori per TCL
(in realtà non sono veri e propri compilatori, bensì parser che operano alcune
trasformazioni aggiuntive), questo è un linguaggio interpretato: un motore (per esempio la
TCL-Shell) interpreta i comandi durante l’esecuzione del programma. Ciò offre tutti i
vantaggi dei linguaggi interpretati, tra i più importanti la portabilità e la possibilità di
costruire e rifinire l’applicazione in modo interattivo.
TEX
TEX non è un programma per scrivere testi, ma per comporli tipograficamente. Mentre un
comune word-processor offre una soluzione di scrittura per tutte le esigenze, dal creare un
bigliettino di auguri al redire una raccolta di poesie, TEX si concentra (e raggiunge il suo
meglio) nella composizione di testi scientifici o comunque fortemente strutturati: articoli,
relazioni o interi libri. Per scrivere un file TEX si usa Emacs, vi o il vostro editor preferito;
poi, TEX sostituisce (per quanto può una macchina) il lavoro del tipografo: arrangia i
caratteri in righe, e queste in pagine, inserisce le figure nel testo e compone le note a piè
di pagina; TEX permette di variare un gran numero di parametri che controllano questa
composizione: le dimensioni della pagina, la grandezza del carattere, la spaziatura, ecc.
VERILOG
Linguaggio di descrizione hardware usato per progettare e documentare/spiegare sistemi
elettronici. VERILOG HDL consente ai progettisti di progettare a vari livelli di astrazione. E'
l'HDL più largamente diffuso con la sua comunità di oltre 50 mila designers. VERILOG
HDL nacque all'Automated Integrated Design Systems successivamente rinominato
Gateway Design Automation) nel 1985. La Gateway Design Automation crebbe
rapidamente con il successo del Verilog-XL e fu acquisita dalla Cadence Design Systems,
35
San Jose, CA nel 1989. Il Verilog fu inventato come un linguaggio di simulazione. L'uso
del Verilog per scopi di sintesi fu un fatto completamente successivo. Abbondano le voci
riguardo ad una possibile fusione tra la Gateway e la Synopsis nei primi giorni, quando
nessuna delle due sembrava lasciar alcuna speranza di successo dell'altra.
Probabilmente a causa della continua pressione del mercato, la Cadence Design Systems
decise nel 1990 di aprire al pubblico il linguaggio Verilog, dando così luogo alla nascita
dell'OVI (Open Verilog International). Fino a quel momento il VERILOG HDL era stato un
linguaggio di proprietà, essendo appunto di proprietà della Cadence Design Systems.
Quando nel 1991 fu creato l'OVI un piccolo numero di compagnie iniziarono a lavorare sui
simulatori Verilog, includendo Chronologic Simulation, Frontline Design Automation, e
altre. La prima di queste arrivò sul mercato nel 1992, e adesso ci sono svariati tipi di
simulatori Verilog disponibili da molte sorgenti. Nel 1993 fu nominato un gruppo di lavoro
dell'IEEE sotto il controllo del Design Automation Sub-Committee per produrre lo standard
Verilog IEEE 1364. VERILOGdivenne standard IEEE 1364 nel 1995.
VHDL
(Hardware Description Language) linguaggio per descrivere i circuiti elettronici
(principalmente quelli digitali) sia a livello di schema logico, sia dal punto di vista
comportamentale. Si può dire che c'è una corrispondenza abbastanza stretta tra lo
schema logico di progetto di un circuito digitale ed un programmi VHDL. Il linguaggio
VHDL è simile ad Ada o al PASCAL, suggerisce di scrivere le specifiche comportamentali
come programmi ovvero usando uno stile procedurale. In quest'ottica si sente dire che
VHDL supporta una descrizione procedurale. In VHDL è stato incorporato un linguaggio di
programmazione perché VHDL vuole essere un linguaggio di specifica completo che
permetta di seguire lo sviluppo di una architettura dalla specifica comportamentale dei
requisiti fino alla stesura dello schema logico che implementa.
XML
XML nasce per dare uno standard ipertestuale/multimediale alla rete, cosa che non è
riuscita a fare l’HTML. Più che un linguaggio è un metalinguaggio, ovvero un linguaggio
utilizzato per definire altri linguaggi o applicazioni. Lo sviluppo dell’ XML è iniziato nel 1996
ed è diventato uno standard del W3C dal Febbraio del 1998. La tecnologia XML non è poi
cosi nuova, infatti prima di esso c'era l’ SGML, e ovviamente l'HTML. Gli sviluppatori di
XML hanno semplicemente preso le parti migliori dell’ SGML, guidati dall'esperienza
dell'HTML, e hanno prodotto qualcosa che non è meno potente dell’ SGML, ma molto più
regolare e semplice da usare. Alcune evoluzioni, d'altronde, sono difficili da distinguere
dalle rivoluzioni... Si può’ dire che l’SGML è usato principalmente per le documentazioni
tecniche e meno per altri tipi di informazioni, per l'XML è esattamente l'opposto.
36
LINKS NEL WEB
ABC
http://www.cwi.nl/~steven/abc/
ALGOL60
http://glossario.supereva.it/index.htm
ALGOL68
http://glossario.supereva.it/index.htm
Amos
http://www.amiworld.it/corsi/amos/amos01.html
APL
http://mytech.mondadori.com/mytech/dizionario/definizione.asp?Link=0408&lnk=Dizionario
ASSEMBLY
http://www.dicea.unifi.it/pub/pluto/ildp/HOWTO/Assembly-HOWTO-2.html
AWK
http://www.univ.trieste.it/~nircdc/doc/oldunix/DUcpl.15.1.html
BASIC
http://www.bioinfovet.unimi.it/binfovet/bioin/biatica/basic.htm
http://www.agora.stm.it/G.Corsi/index/b.htm
BCPL,C
http://www.telug.it/marco/LinuxIntro/LinuxIntro/node22.html
BEFUNGE
http://www.catseye.mb.ca/esoteric/befunge/
BLISS
http://etabeta.iroe.fi.cnr.it/accesso/accesso.htm
CILK
http://supertech.lcs.mit.edu/cilk/
CLU
http://www.ptf.com/ptf/products/UNIX/current/0225.0.html#0
http://citeseer.nj.nec.com/context/479298/0
CMS
http://burks.brighton.ac.uk/burks/foldoc/49/20.htm
COBOL58
http://www.racine.ra.it/curba/rivoluzioni/informatica/2_generazione/linguaggi_di_programm
azione.htm
CONCURRENT PASCAL
37
http://burks.brighton.ac.uk/burks/foldoc/63/23.htm
CORAL
http://www.cs.indiana.edu/database/Coral/Coral.html
CPL
http://www.oasis-open.org/cover/cpl.html
CSH
http://www.perl.com/pub/language/versus/csh.html
CT
http://cil.andrew.cmu.edu/ct.html
ELF
http://www.linuxjournal.it/wirefree/0004057.htm
ERLANG
http://www.dimi.uniud.it/~francesc/UCLG/prevseminar.htm
EUPHORIA
http://www.hippy.freeserve.co.uk/euphoria.htm
FORMAC
http://www.acm.org/pubs/citations/proceedings/plan/154766/p209-sammet/
http://ase.isu.edu/ase01_07/ase01_07/bookcase/ref_sh/foldoc/subjects/11.htm
FORTH
http://www.racine.ra.it/curba/rivoluzioni/informatica/3_generazione/linguaggi_di_programm
azione_3.htm#FORTH
FORTRAN 56
http://www.list2000.com.tr/it/computers_net/programming_languages/fortran/index.asp
FORTRAN 77
http://guide.supereva.it/fortran/fortran_77/
http://www.agora.stm.it/G.Corsi/index/f.htm
GPSS
http://isgwww.cs.uni-magdeburg.de/~pelo/s1e/sa3/sa3.shtml
GUILE
http://www.gnu.org/software/guile/guile.html#whatisit
HTML
http://www.crs4.it/~mameli/THESIS/lhtml.html
http://www.di.unipi.it/~simi/corsodiinformatica/html/
ICI
http://www.lib.uchicago.edu/keith/crisis/langs/ICI.html
38
ICON
http://www.cs.arizona.edu/icon/
http://www.lib.uchicago.edu/keith/crisis/langs/Icon.html
IDL
http://www.rsinc.com/idl/
INTERCAL
http://www.ptf.com/ptf/products/UNIX/current/0319.0.html
JCL
http://www.okstate.edu/cis_info/cis_manual/jcl_toc.html
JOVIAL
http://www.seadeo.com/
LIMBO
http://translate.google.com/translate_c?hl=it&u=http://inferno.lucent.com/inferno/limbo.html
&prev=/search%3Fq%3Dlinguaggio%2B%2Blimbo%26start%3D50%26hl%3Dit%26safe%
3Doff%26sa%3DN
LISP
http://www8.informatik.uni-erlangen.de/html/lisp/histlit1.html
LOGO
http://www.unipa.it/~facscfor/plebe/logo_intr/s7node2.html
LUA
http://igwe5.vub.ac.be/lua/
MATLAB
http://programmarein.supereva.it/indmat/matlab.htm
MERCURY
http://www.cs.mu.oz.au/research/mercury/information/doc/reference_manual_toc.html
MESA
http://www.dobe.org/us/az/mesa/cat/119/past
MIRANDA
http://www.cs.ukc.ac.uk/pubs/1995/59/
ML
http://www.mcdougallittell.com/lit/liactspe.htm
MODULA 2
http://murray.newcastle.edu.au/users/staff/peter/m2/Modula2.html
MODULA 3
http://www.research.compaq.com/SRC/modula-3/html/bib.html#m3-Har92
39
MUMPS
http://www.cpan.org/modules/by-category/09_Language_Interfaces/Language/LanguageMumps-1.06.readme
OCCAM
http://www.racine.ra.it/curba/rivoluzioni/informatica/4_generazione/Linguaggi.htm
PASCAL
http://www.racine.ra.it/curba/rivoluzioni/informatica/3_generazione/linguaggi_di_programm
azione_3.htm#PASCAL
http://www.allnet.it/AppuntiLinux/a2222.html#title2811
PERL
http://www.html.it/faq/perl/index.html
http://www.pluto.linux.it/ildp/journal/pj9801/perl.html
PHP
http://www.devshed.com/Server_Side/PHP/
PILOT
http://www.racine.ra.it/curba/rivoluzioni/informatica/3_generazione/linguaggi_di_programm
azione_3.htm
PL/1
http://www.racine.ra.it/curba/rivoluzioni/informatica/2_generazione/linguaggi_di_programm
azione.htm
POP
http://barada.canisius.edu/~meyer/CCSCNE/finalHTML/meyer.html
PROGRAPH
http://www.cpan.org/modules/by-category/09_Language_Interfaces/Language/LanguageMumps-1.06.readme
PROLOG
http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/lang/prolog/0.html
REBOL
http://www.rebol.com/
http://www.amiworld.it/corsi/rebol/introduzione.htm
RPG
http://www-1.ibm.com/servers/eserver/iseries/db2/qrpgsrc.htm
SCHEME
http://www.racine.ra.it/curba/rivoluzioni/informatica/4_generazione/Linguaggi.htm
http://www.linuxdidattica.org/linguaggi/a2prog31.html#index1479
SETL
http://birch.eecs.lehigh.edu/~bacon/doc.html
40
SML
http://www.interfacecontrol.com/sml/Sml/mainpage.htm
SNOBOL
http://cs.fit.edu/~dclay/cse5040/snobol.html
SQL
http://www.nupedia.com/article/short/The+SNOBOL+4+Programming+Language/
http://lagash.dft.unipa.it/AL/al244.htm
SR
http://www.mcs.drexel.edu/~shartley/OSusingSR/
TCL
http://online.infomedia.it/riviste/dev/71/articolo24/articolo.htm
TEX
http://www.ntg.nl/english.html
VERILOG
http://www.verilog.com
VHDL
http://www.ntg.nl/english.html
http://www.xilinx.com/support/training/abstracts/2.1/vhdl/abvhlangcncpts.htm
http://www.interq.or.jp/japan/se-inoue/e_cpld4_3.htm
VRML
http://www.lucia.it/vrml/tutorial/lections/lections/chap3.html
41
APPENDICE: Le schede
Nelle schede riassuntive seguenti (dei linguaggi di programmazione trattati) è stato preso
in considerazione:
ANNO DI NASCITA12: anno di nascita e creatori del linguaggio.
GENITORI13: quei linguaggi che hanno portato alla creazione del nuovo linguaggio.
TIPO DI LINGUAGGIO: tipo di linguaggio in base alla classificazione proposta.
PROGRAMMAZIONE IN GRANDE(G)/PICCOLO(P): La programmazione in piccolo è
associata a quei linguaggi che hanno scopo prettamente didattico o linguaggi di
simulazione. Negli altri casi la programmazione è sempre in grande.
IN BREVE: Brevi commenti di complemento, a quanto detto in precedenza, sul linguaggio
considerato.
ABC
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
1987 Guerts, Meertens, Pemberton
B
Linguaggio imperativo
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Ha una struttura a blocchi. E’ stato creato per sostituire il
BASIC, molto semplice indirizzato ai principianti. Utilizzato in
ambienti Unix e per prototipi.
I tipi di dati utilizzati sono: stringhe, liste, array, record e
infiniti numeri. Per facilitare la programmazione top down
viene supportato un meccanismo per la dichiarazione di
operazioni in linea. Non è realmente distinto dal suo
ambiente di programmazione.
Al contrario della maggior parte dei linguaggi, che usano dei
comandi per indicare l’inizio e la fine del codice, l’ABC usa le
rientranze.
12
L’ anno di nascita di un linguaggio di programmazione è molto generico in quanto fonti riportano la data
del progetto altre la data della prima realizzazione, altre ancora ne riportano la data della prima descrizione
ufficiale.
13 I genitori sono i linguaggi dai quali un linguaggio eredita parte delle strutture dati e proprietà, sui quali
vengono poi sviluppate e aggiunte le restanti strutture dati al nuovo linguaggio.
42
ACSL
ANNO DI NASCITA
Mitchell & Gauthier, 1981
GENITORI
FORTRAN
TIPO DI LINGUAGGIO
Linguaggio applicativo per simulazione matematiche
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
ACSL è usato prevalentemente da specialisti nell'area
ingegneristica, biomedica, scientifica in genere. La sua
principale prerogativa è la capacità con cui è in grado di
modellare sistemi complessi con algoritmi numerici di
integrazione. E' una prodotto commerciale, ma sono
disponibili versioni demo di sue varianti.
43
ALEF
ANNO DI NASCITA
P. Winterbottom, Bell Labs (Lucent), 1995
GENITORI
C
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale, parallelo
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Nonostante somigli al C dal punto di vista lessicale, ALEF
sviluppa un differente tipo di dati e modello di esecuzione:
supporta tipi puntatori (chiamati fat pointers), processi
paralleli, blocchi protetti, tipi di dato astratti, run-time type
information, e altre facilitazioni che il C non ha.
44
Algol 60
ANNO DI NASCITA
1960
GENITORI
FORTRAN
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio di programmazione (1960), sintetico, con
struttura a blocchi, nidificazione, variabili statiche, tipi di dati
definibili, espressioni condizionali come IF...THEN...ELSE,
FOR...NEXT.
Ha avuto molte estensioni (come ALGOL 60 Modified,
ALGOL 60 Revised, ALGOL C, ALGOL D, ALGOL N,
ALGOL W, ALGOL X, ALGOL Y).
Dall'ALGOL hanno tratto ispirazione linguaggi come C e
Pascal.
L'ALGOL 60 è un linguaggio apparso alcuni anni dopo
l'introduzione del FORTRAN.
Questo nuovo linguaggio all'epoca era più complesso ed
ebbe una grande influenza sul progetto dei futuri linguaggi
di programmazione; i suoi autori prestarono molta
attenzione alla regolarità della sin tassi, alla struttura
modulare e ad altre caratteristiche di solito associate ai
linguaggi strutturati ad alto livello.
Sfortunatamente, l'ALGOL 60 non si diffuse mai veramente
negli Stati Uniti, a parere di molti per l'astrazione e la
genericità del linguaggio.
45
Algol 68
ANNO DI NASCITA
1968
GENITORI
ALGOL 60
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale, parallelo
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Mantiene
le
caratteristiche principali di ALGOL60:
linguaggio
di
programmazione
procedurale,
usato
principalmente per problemi matematici. Non ebbe una
grande diffusione ma ha esercitato grande influenza
culturale su alcuni linguaggi moderni come il PASCAL,
l'Ada e il C.
46
AMOS
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
BASIC
Applicativo
3 GL
IN P
Usato per la creazione di videogiochi.
E’ suddiviso in due parti distinte: la prima, rappresentata da
un editor sul quale noi stendiamo il nostro programma, la
seconda è invece un ambiente che chiameremo modo
diretto, cioè una specie di Shell del WB, nel quale è
possibile usare i comandi a disposizione di AMOS
direttamente alla premuta dell'invio.
47
APL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1960
--Linguaggio funzionale, imperativo procedurale
3GL
IN G
Acronimo
di
A
Programming
Language
(letteralmente, un linguaggio di programmazione).
Linguaggio introdotto nel 1968 per applicazioni
scientifiche e matematiche. L'APL è un linguaggio
basato su sottoprogrammi ,utilizza un grande
insieme di caratteri e una sintassi concisa ed è
disponibile per l'utilizzo su macchine compatibili
con i PC.
48
APPLE SCRIPT
ANNO DI NASCITA
Apple Computer, 1993 (MacOS System 7), 1994 (MacOS
7.5)
GENITORI
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale, scripting
GENERAZIONE
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
APPLESCRIPT è un linguaggio di programmazione per
Macintosh che permette il controllo di programmi esistenti
nonché la creazione di programmi a sé stanti che
interagiscono con i programmi esistenti. Nonostante si tratti
di un linguaggio di programmazione, la conoscenza di
elementi tecniche non è requisito indispensabile. Infatti, al
posto di strani comandi APPLESCRIPT usa frasi in italiano o
in altre lingue, e può tradurre automaticamente da un dialetto
(lingua) ad un'altro
49
ASSEMBLY
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1959
Linguaggio macchina
Imperativo procedurale
2GL
IN G
Si possono realizzare le “viscere” dei sistemi operativi,
degli interpreti, dei compilatori e dei giochi, laddove un
compilatore C non riesce a fornire l'espressività richiesta.
E’ necessario conoscere tutto l’hardaware, le schede, la
cpu del calcolatore.
50
AUTOLISP
ANNO DI NASCITA
Autodesk, fine anni 80
GENITORI
LISP
TIPO DI LINGUAGGIO
Linguaggio applicativo, funzionale
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Dialetto del LISP usato come estensione di linguaggio per
AutoCAD(tm) e altri prodotti della Autodesk. Supportato
pienamente da AutoCAD 11-13(versioni).
51
AWK
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1977 Aho, Weinberger, Kernighan
--Linguaggi applicativo, funzionale
4GL
IN P
AWK è un linguaggio di programmazione nato
fondamentalmente per l'analisi e la rielaborazione di file di
testo organizzati in una qualche forma tabellare. AWK
potrebbe essere usato per fare anche di più, solo che
quando si supera un certo limite di complessità, non è più
conveniente il suo utilizzo.
AWK è un interprete, nel senso che i programmi fatti
secondo questo linguaggio, vengono eseguiti direttamente,
senza essere compilati, come nel caso degli script di shell.
Un programma AWK può essere scritto in un file di testo
normale, oppure può essere fornito come argomento della
riga di comando dell'interprete: il binario `awk'. Un
programma AWK può contenere la dichiarazione di funzioni
definite liberamente. Queste dichiarazioni vanno fatte al di
fuori delle regole normali. Il linguaggio AWK può gestire
anche gli array, che comunque sono di tipo associativo. I
programmi in AWK sono generalmente brevi, pertanto il
linguaggio si presta alla prototipazione ed alla realizzazione
di semplici utility usa-e-getta.
52
BASIC 56
ANNO DI NASCITA
1965
GENITORI
FORTRAN
TIPO DI LINGUAGGIO
Linguaggi imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
BASIC (Beginner's All-purpose Symbolic Instruction Code) Linguaggio di programmazione che si avvale di parole
inglesi del linguaggio comune. Fu sviluppato nel 1964 da J.
Kemeny e T. Kurtz al Dartmouth College per essere
destinato ai principianti. Di derivazione FORTRAN, e' un
linguaggio, semplice e potente, facilmente strutturabile. E'
utilizzato per applicazioni di ogni tipo sia sui personal
computers sia sui "main frame" tanto da essere diventato il
linguaggio più' diffuso al mondo. Il BASIC è un linguaggio
ottimale per la realizzazione di programmi brevi, ma mostra
i suoi limiti nei programmi complessi. In ambiente MS-DOS
è uno standard di fatto il GW-BASIC. Per la sua interattività
e per la facilità della programmazione è molto diffuso nelle
scuole.
53
BCPL
ANNO DI NASCITA
1967 Richards
GENITORI
CPL, ALGOL 60
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio fondamentale che ha dato origine al C. Il
linguaggio B fu ripreso ai Laboratori Bell, dove Ken
Thompson e Dennis M. Ritchie lo modificarono e lo
ridenominarono NB. All'inizio degli anni '70, Thompson
utilizzò NB per riscrivere la parte basilare di Unix per la
seconda edizione. Poco tempo dopo, a partire dall'NB,
Ritchie sviluppò il C, che divenne presto il linguaggio per
scrivere nuove utility e applicazioni oltre al Sistema
Operativo.
I tipi di dato utilizzati sono: numeri interi, reali, bit, flussi di
dati I/O, stringhe e vettori.
54
BEFUNGE
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1993 Chris Pressey,
IN BREVE
E’ un linguaggio di programmazione che utilizza una pila e
una griglia bidimensionale. Ogni elemento (cellula) della
griglia può contenere o dati o un istruzione. Si hanno diverse
versioni del linguaggio ad ognuna è associata una griglia di
dimensioni diverse
Esistono anche Unefunge (Unidimensionale) e trefunge
(tridimensionale).
Funzionale
3 GL
G
55
BLISS
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1970 Wulf, Russell ed altri
C
Funzionale
3 GL
G
IN BREVE
Linguaggio sviluppato dalla Dec per la programmazione di
sistema
Utilizzava un sistema a microistruzioni molto potente tanto
che è stato usato per la codifica di sistema, rendendo più
semplice la compilazione per linguaggi più difficili.
Inizialmente
noto
come
linguaggio
della
DEC,
successivamente è uscita una versione free Bliss-32.
56
C
ANNO DI NASCITA
1974
GENITORI
ALGOL 68 , BCPL
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Nel 1972, presso i Bell Laboratories, Dennis Ritchie
progettava e realizzava la prima versione del linguaggio C.
Ritchie aveva ripreso e sviluppato molti dei principi e dei
costrutti sintattici del linguaggio BCPL, sviluppato da Martin
Richards, e del linguaggio B, sviluppato da Ken Thompson,
l'autore del sistema operativo Unix. Successivamente gli
stessi Ritchie e Thompson riscrissero in C il codice di Unix.
Il C si distingueva dai suoi predecessori per il fatto di
implementare una vasta gamma di tipi di dati (carattere,
interi,
numeri
in
virgola
mobile,
strutture)
non
originariamente previsti dagli altri due linguaggi. Da allora
ad oggi il C ha subito trasformazioni: la sua sintassi è stata
affinata, soprattutto in conseguenza della estensione
object-oriented (C++). Nel 1983, l’Istituto Nazionale
Americano per gli Standard (ANSI) ha costituito un comitato
per una definizione del linguaggio C non ambigua e non
dipendente dalla macchina: il risultato è lo standard ANSI
per il C.
57
C*
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1987, Pensare Machines Corp.
C
Parallelo
3 GL
G
IN BREVE
Dialetto del C, di cui estende la sintassi e la semantica per
l’elaborazione in parallelo. Le differenze maggiori con il C
sono: elementi di dati paralleli e settori paralleli di calcolo. I
tipi di dati sono gli stessi del C
58
CHARITY
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
----Linguaggio funzionale
3GL
IN G
CHARITY è basato sulla teoria dei datatypes .
Questi sono suddivisi in due sottoclassi:
inductive datatypes(sviluppati dai progettisti
familiare) e coinductive datatypes
in
modo
59
CILK
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
Joerg, Leiserson, et al, MIT, 1995
C
Parallelo
3 GL
IN G
E’ un “dialetto” del C, aggiunge parecchie nuove parole
chiavi per sostenere multi-threading dinamico e asincrono.
Rispetto al C viene aggiunta la capacità di chiamata in
parallelo. Può essere utilizzato in ambiente Unix e
Windows NT
60
CLU
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1974-77 B. Liskov
Algol
Imperativo Procedurale
3 GL
G
IN BREVE
E’ un linguaggio che ha una sintassi molto simile a quella
dell’Algol 60 cui aggiunge tipi di dato astratti e alcune
caratteristiche avanzate. CLU è l’abbreviazione di CLUster,
infatti, la programmazione utilizza procedure, clusters e
interazioni.
Il SO SWIFT è stato scritto in CLU
61
CMS
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1974 Rand Corporation US Navy
IN BREVE
E’ un linguaggio di programmazione utilizzato quasi
esclusivamente in real time, utilizzato dalla forza navale degli
USA. I tipi di dati supportati sono:
Ø numeri interi
Ø numeri a virgola fissa e mobile
Ø stringhe
Il suo periodo è stato tra il 1976 e 1986, sono nate parecchie
varianti
CMS-2/Y e CMS-2/M per macchine a 16 bit e CMS-2/L per
macchine a 32 bit
Imperativo procedurale
3 GL
G
62
COBOL 58
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1958
--Linguaggio imperativo procedurale
3GL
G
IN BREVE
COBOL: Common Business Oriented Language, linguaggio
di programmazione implementato nel 1959-60, molto
diffuso anche oggi in ambiente aziendale.
Il COBOL, come il FORTRAN, è static o ossia la memoria
richiesta per l'esecuzione del programma è già nota in
compilazione.
Nonostante gli aggiornamenti e "tool" di sviluppo, che
permettono ai programmi scritti con questo linguaggio di
operare con database relazionati ed internet, le applicazioni
COBOL
vengono
definite
legacy.
Il COBOL ha introdotto per primo il prodotto cartesiano. I
costruttori del prodotto cartesiano per questo linguaggio
sono i record.
Le ennuple di attributi quali (nome, cognome, indirizzo,
città, cap, etc.) vengono de scritte da record.
63
CONCURRENT PASCAL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1975 Brinch Hansen
PASCAL
Linguaggio concorrente
3GL
IN G
Possiamo considerarlo un “dialetto” del PASCAL, rispetto
al quale vengono aggiunti:
-Elaborazione multitask
-Dati astratti
-Supporto video
-istruzione di ciclo
64
CORAL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1964 Roberts
ALGOL, JOVIAL
Logico Imperativo procedurale
4GL
IN P
Linguaggio che ha dato le origini al BCPL.
Adottato dall’esercito inglese fino all’arrivo di Ada.
Versioni Coral 64 e 66.
65
CPL
ANNO DI NASCITA
1963 (Università di Cambridge e Londra)
GENITORI
ALGOL 60
TIPO DI LINGUAGGIO
Imperativo procedurale, funzionale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio che ha dato le origini al BCPL
66
CSH
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
SH, C, PERL
Scripting
3 GL
P
E’ stato progettato per la gestione e lo sviluppo di software in
ambiente Unix. Supporta un solo tipo di dato primitivo: le
stringhe.
Il CSH non ha dei comandi particolari per i sottoprogrammi a
differenza della maggior parte dei linguaggi. Molto popolare
è anche il “csh of Twenex” noto come tcsh
67
CT
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1990-94 Andersen, Sherwood et al, Carnegie-Mellon
PASCAL, C, FORTRAN
Linguaggio imperativo procedurale
3GL
IN G
Si tratta di un linguaggio nel quale sono riscontrabili
caratteristiche del C, del PASCAL e del FORTRAN ma
notevolmente potenziato da capacità multimediali quali
:supporto grafico di facile impiego, interazioni del mouse.
Ideato per animazioni, interfaccia utente e presentazioni
multimediali.
Tipi di dato:
-numeri interi
-numeri reali
-stringhe
-booleani
Da notare che molti comandi servono per l’elaborazione di
video, suoni, dati grafici.
68
ERLANG
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
--LISP
Linguaggio funzionale, distribuito
3G
IN G
ERLANG è un linguaggio funzionale utilizzato nell'industria,
in particolare nell'implementazione di sistemi distribuiti. Il
sistema di transizione indotto da un programma ERLANG
ha, in generale, un numero infinito di stati e il model
checking non è più, di conseguenza, un problema
decidibile. E' stato studiato un sottoinsieme di ERLANG,
$\mu$-Erlang, dimostrando per esso l'indecidibilità del
Model Checking e applicando ad esso una tecnica di
interpretazione astratta. Sono state infine svolte alcune
semplici sperimentazioni, utilizzando il Model Checker
NuSMV.
69
EUPHORIA
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1993. Craig, Rapid Deployment Software
BASIC, C, PERL
Funzionale
3 GL
P
IN BREVE
E’ utilizzato per lo sviluppo di video game.
Il linguaggio considera tutti gli elementi come atomi e
sequenze, permette, inoltre, la definizione di dati astratti,
dichiarando per ognuno una funzione booleana. EUPHORIA
sta per: End User Programming with Hierarchical Objects for
Robust Interpreted Applications
70
FORMAC
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1964 Jean Sammet et al, IBM
FORTRAN
Imperativo procedurale, funzionale
3 GL
G
IN BREVE
E’ una variante del FORTRAN con parecchie estensioni,
soprattutto nell’ambito dei calcoli. I tipi di dato supportati
sono gli stessi del FORTRAN più i numeri razionali, i simboli
71
FORTH
ANNO DI NASCITA
1970 Charles Moore
GENITORI
--TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
In origine destinato alla programmazione delle osservazioni
astronomiche mediante il telescopio e, in seguito, adattato
per l’impiego nei microcomputer e in robotica. I programmi,
nonostante la sua efficienza, possono risultare difficili da
leggere. Versioni Forth 79 e 83.
72
FORTRAN 56
ANNO DI NASCITA
1956 J. Backus
GENITORI
--TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
FORTRAN (FORmula TRANslation) - Traduttore di formule.
Linguaggio imperativo orientato alla matematica, alla
ricerca scientifica e tecnologica, basato sull'impiego di
notazioni simili a quelle dell'algebra e dell'analisi
infinitesimale. E' un linguaggio modulare che consente di
utilizzare sottoprogrammi esterni, è poco interattivo ed è
dotato di ricorsività. E’ stato sviluppato, in ambiente IBM,
negli anni cinquanta da J. Backus e messo definitivamente
a punto dopo anni di studi e di ricerche. E' stato il primo dei
linguaggi di programmazione a divenire standard nelle
applicazioni tecnico-scientifiche.
73
FORTRAN 77
ANNO DI NASCITA
1977
GENITORI
FORTRAN 56 (influenze ALGOL 60 )
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Il FORTRAN è ancora in evoluzione; FORTRAN77 è uno
standard internazionale conforme alla quasi totalità dei
compilatori attuali, ma è già disponibile un nuovo standard,
FORTRAN90, che non è ancora completamente sviluppato.
Tuttavia molti compilatori già implementano alcune delle
nuove features del FORTRAN90 come estensioni del
FORTRAN77.
74
GPSS
ANNO DI NASCITA
1961
GENITORI
LISP
TIPO DI LINGUAGGIO
Linguaggio applicativo, funzionale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
GPSS(General Purpose Simulation System)
Linguaggio di simulazione realizzato nel 1961 da Geoffrey
Gordon(IBM) e successivamente sviluppato per circa un
decennio. Si tratta di un linguaggio di simulazione e come
tale, in grado di facilitare il compito del programmatore
capace di scrivere con poche righe di programma interi
modelli o sottomodelli che altrimenti richiederebbero tempi
di stesura assai più lunghi ,con conseguente aumento delle
probabilità di errore.
A questi vantaggi, tuttavia, si possono contrapporre alcuni
inconvenienti quali la minore efficienza e la scarsa
diffusione del linguaggio stesso dovuta al fatto che soltanto
un numero ristretto di persone è in grado di padroneggiare
efficacemente questo tipo di linguaggio.
75
GUILE
ANNO DI NASCITA
GENITORI
SCHEME
TIPO DI LINGUAGGIO
Linguaggio applicativo, scripting
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
È il linguaggio di estensione ufficiale del Progetto GNU e
viene utilizzato da molte applicazioni Gnome
76
HASKELL
ANNO DI NASCITA
1990 Hughes, Wadler e Peterson
GENITORI
--TIPO DI LINGUAGGIO
Linguaggio funzionale
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Perché si usa HASKELL?
Viene utilizzato nella realizzazione di sistemi software
di grandi dimensioni la cui realizzazione è difficile e
costosa.
E’particolarmente
adatto
alla
realizzazione
di
programmi che devono essere altamente modificabili
e mantenibili.
Cosa offre?
Aumento del rendimento del programmatore
Codice più corto, più libero, più mantenibile
Pochi errori
Più alta affidabilità
Riduzione del “semantic gap” tra programmatore e
linguaggio
Tempi d’esecuzione più corti
77
HTML
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
‘90
SGML
Markup
3 GL
G
IN BREVE
HTML sta per HyperText Markup Language è un formato per
i documenti della rete, nasce all'inizio degli anni ‘90, abbinato
in particolare al primo navigatore: Mosaic. Da quel momento
a oggi il formato HTML ha subito diversi aggiornamenti; si
ricorda in particolare la versione 2.0 del 1995 e la versione
3.2 del 1997. Allo stato attuale, lo sviluppo di questo
standard è condotto da W3C (World Wide Web Consortium).
Lo spirito alla base dello sviluppo dell'HTML da parte del
W3C, come ente indipendente, è quello di ottenere un
formato multimediale-ipertestuale adatto per la lettura
attraverso qualunque tipo di mezzo.
HTML è un linguaggio che ha fatto dilagare il Web ma che
per esempio non potrà mai imporsi come linguaggio
universale per la costruzione di applicazioni sul Web; è infatti
un linguaggio nato sostanzialmente per un publishing
elementare, ma ben presto ha dovuto lasciare spazio allo
sviluppo di tecnologie parallele che potessero assicurare in
fondo la sua sopravvivenza: stiamo parlando dei vari
Javascript e plugin tipo Shockvawe o Acrobat reader, che in
pratica hanno piano trasformato l' HTML in un assemblatore
di tecnologie, piuttosto che un linguaggio vero e proprio. Da
questi problemi nasce XML.
78
ICI
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1992 Tim Long
C, Python, PERL
Imperativo procedurale, scripting
3 GL
G
IN BREVE
E’ un linguaggio di scripting destinato soprattutto allo
sviluppo d’applicazioni. Ha una sintassi molto simile al C,
però è progettato in modo da ridurre gli errori di
programmazione. I tipi di dati supportati sono:
numeri interi e reali
stringhe
archivi
Fa inoltre largo uso di insiemi e le relative operazioni
79
ICON
ANNO DI NASCITA
’70 Griswold
GENITORI
SNOBOL, PASCAL, C
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale, applicativo
GENERAZIONE
3GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
È il linguaggio di estensione ufficiale del Progetto GNU e
viene utilizzato da molte applicazioni Gnome.
Tipi di dato:
-numeri interi e reali
-stringhe
-insiemi
-liste
-record
Creato per ambiente Unix si è subito diffuso in MS Dos,
Windows e Mac.
80
IDL
ANNO DI NASCITA
1981 Nestor, Lamb, Wulf
GENITORI
TIPO DI LINGUAGGIO
Imperativo procedurale, applicativo
GENERAZIONE
4GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
IDL ( Interactive Data analysis Language) è un ambiente per
computazione
scientifiche
che
unisce
matematica,
visualizzazione dei dati, grafici scientifici, un tool per la
creazione e la gestione di interfacce grafiche per l'analisi e la
visualizzazione di dati scientifici.
81
INTERCAL
ANNO DI NASCITA
1972 Woods Lyon
GENITORI
TIPO DI LINGUAGGIO
Imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Non ha niente in comune con i maggiori linguaggi di
programmazione, difficile da utilizzare e da leggere.
Ammette solo due tipi di dato primitivi: gli interi senza segno
da 16 e 32 bit.
82
JCL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
--Imperativo procedurale, scripting
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio per la programmazione di sistema OS/360 IBM
In generale difficile da utilizzare.
83
JOVIAL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
1959/61 Schwartz
ALGOL 60
Imperativo Procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Usato dall’aeronautica USA, poi venne sostituito da ADA,
PASCAL
Versioni Jovial: 1,2, 3.
84
LIMBO
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
--C, PASCAL
Linguaggio imperativo procedurale, distribuito
3GL
IN G
Il LIMBO è un nuovo linguaggio di programmazione,
progettato da Sean Dorward e da da Phil Winterbottom.
Un’applicazione LIMBO consiste di uno o più moduli
ciascuno dei quali fornisce una parte di implementazione.
Un modulo che include un altro modulo include la relativa
parte di dichiarazione.
85
LISP
ANNO DI NASCITA
1962 John McCarthy
GENITORI
--TIPO DI LINGUAGGIO
Linguaggio funzionale (PER ECCELLENZA)
GENERAZIONE
4GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
(LISt Processor, elaboratore di liste)
Linguaggio
sviluppato
per
applicazioni
nel
campo
dell'Intelligenza Artificiale fra il 1957 e il 1960 da John
McCarthy. E' stato il primo linguaggio "non imperativo", ovvero
in grado di trattare liste di qualsiasi natura, numeri compresi.
Un programma in questo linguaggio è un insieme di funzioni
matematiche composte fra loro in modo che ciascuna di esse
ricavi i propri dati da quella precedente. Il LISP possiede una
sintassi semplice e uniforme che lo rende ideale per
manipolare informazioni e confrontare problemi
86
LOGO
ANNO DI NASCITA
1967
GENITORI
LISP
TIPO DI LINGUAGGIO
Linguaggio funzionale applicativo
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
LOGO è un linguaggio per scopi didattici, ma questo non
significa che manchi di alcune funzionalità (come per esempio il
BASIC), anzi, possiede tante funzioni, soprattutto per la
manipolazione di simboli non numerici, mancanti nella maggior
parte degli altri. Le limitazioni di LOGO sono tutte nelle
prestazioni. E’ un linguaggio interpretato ed interattivo, per
rendere più facile ed immediato il suo uso, ma questo penalizza
la velocità. Un algoritmo in Logo è quindi in generale più lento
che per esempio in C. Su LOGO è rimasto famoso il motto no
threshold no ceiling, ovvero che non ha limiti superiori ed
inferiori, ed infatti è stato utilizzato con successo con bambini in
età pre -scolare, così come sono state sviluppate ricerche
avanzate in campi come Natural Language Processing.
87
LUA
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1994 W. Celes, R. Ierusalimschy, L.H. de Figueiredo, PUCRio
PASCAL, PERL
applicativo, scripting
3 GL
IN P
E’ un linguaggio utilizzato per estendere delle applicazioni,
quindi non esiste un programma principale in LUA. Molto
simile al PASCAL ha però una sostanziale differenza nei tipi
di dato. Le variabili possono non essere dichiarate e
possono assumere qualunque valore.
88
MATLAB
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1964
Linpak, Eispack
Linguaggio applicativo
4GL
IN P
MATLAB è un linguaggio ad alto rendimento per la
computazione tecnica. Integra il calcolo, la visualizzazione
e la programmazione in un ambiente di facile impiego in cui
i problemi e le soluzioni sono espressi in notazione
matematica familiare. MATLAB è un sistema interattivo in
cui l'elemento di base è un array quindi non richiede il
dimensioning. Ciò permette la risoluzione di molti problemi
di calcolo tecnici, in particolare quelli con le formulazioni
vettorali e matriciali, attraverso algoritmi molto più semplici
e snelli rispetto a quelli che sarebbero necessari in un
programma in linguaggio scalare non interattivo quali C o il
FORTRAN. Si è evoluto durante gli anni con contributi dati
da molti utenti. In ambienti universitari è l'attrezzo didattico
standard per corsi introduttivi e corsi avanzati, nella
matematica, nell'ingegneria e nella scienza.
89
MERCURY
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1993 Mercury Project, University of Melbourne
PROLOG, C
Logico
3 GL
G
IN BREVE
E’ un linguaggio classificato come logico, ma alcune
caratteristiche lo portano ad essere anche funzionale. Ha
una sintassi molto simile al PROLOG.
Il MERCURY viene distribuito con alcuni sistemi Linux, ma
ha bisogno di un buon compilatore C, infatti il compilatore del
MERCURY genera un codice in C.
90
MESA
ANNO DI NASCITA
1977 Xerox Park
GENITORI
PASCAL, ALGOL 68
TIPO DI LINGUAGGIO
Imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
MESA fu utilizzato internamente dalla Xerox per sviluppare
Viewpoint, la Xerox Star, MDE, e il controllore per un highend copier..
91
MIRANDA
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
1985 David Turner, University of Kent
ML
Funzionale
3 GL
G
IN BREVE
E’ un linguaggio progettato sia per la programmazione
funzionale che per lo sviluppo di applicazioni. Tipi di dati:
Ø booleani
Ø numeri interi e reali
Ø caratteri
Ø stringhe
Ø liste
E’ disponibile in molti sistemi Unix, Linux compreso
92
ML
ANNO DI NASCITA
1973 Edimburgo (Gordon Milner Wadswort Cardelli Burstall
McQueen Sanella)
GENITORI
TIPO DI LINGUAGGIO
Funzionale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
In realtà ML rappresenta una famiglia di linguaggi funzionali:
ML, SML, SML/NJ, CAML, EML ed altri
Si basa su parecchie librerie e supporta molti tipi di dato
93
MODULA 2
ANNO DI NASCITA
1978 Wirth
GENITORI
PASCAL, MESA
TIPO DI LINGUAGGIO
Imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio che enfatizza la programmazione modulare. Ad
alto livello, si basa sul PASCAL, caratterizzato dalla
mancanza di funzioni standard e di procedure.
94
MODULA 3
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1980
PASCAL, MODULA2
Linguaggio imperativo procedurale
3GL
IN G
Progettato verso la fine degli anni 80 presso la Digital
Equipment Corporation e presso la Olivetti corregge molte
delle mancanze del PASCAL e di MODULA2 riguardo la
tecnologia della programmazione pratica.
MODULA3 è un linguaggio di programmazione pratico per
la realizzazione di grandi progetti del software.
95
MUMPS, M
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
Octo Barnett M.D. et al, Mass. General Hospital, 1969
Linguaggio imperativo procedurale, markup, distribuito
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio molto semplice usato originariamente elaborare e
visualizzare dati di tipo medico.
Tipo di dati:
record, liste, numeri
La maggior parte delle versioni di MUMPS sono commerciali,
esistono però delle versioni free per Unix, Vms, Dos e
Windows.
96
OBERON
ANNO DI NASCITA
1988 Wirth
GENITORI
PASCAL, MODULA2
TIPO DI LINGUAGGIO
Imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Rispetto al MODULA2, OBERON elimina molte cose:
records di varianti, types di enumerazione, i loop “for”. Per
contro
aggiunge:
record
types
estensibili,
arrays
multidimensioneali aperti e garbage collection.
97
OCCAM
ANNO DI NASCITA
1982 David May
GENITORI
CSP, EPL
TIPO DI LINGUAGGIO
Linguaggio parallelo
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
E’il più diffuso fra i linguaggi paralleli:in tali linguaggi vi sono
dei meccanismi espliciti per indicare compiti che possono
essere effettuati in parallelo.
98
OCTAVE
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
--MATLAB
Linguaggio applicativo
4GL
IN P
Linguaggio applicativo, il suo utilizzo principale è nel
calcolo numerico dove si dimostra versatile ed efficace. E’ il
clone di MATLAB nel senso che è in grado di operarne in
modo perfettamente identico con gli stessi comandi. Quindi
per chiunque non voglia comprare il costoso MATLAB può
optare per il gratuito OCTAVE ottenendo gli stessi risultati.
99
PASCAL 70
ANNO DI NASCITA
1971 Wirth
GENITORI
ALGOL 60
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio di programmazione sviluppato dal Prof. N. Wirth
nel 1970 al politecnico di Zurigo. Il PASCAL è elegante,
versatile, potente; consente la programmazione strutturata
con la tecnica "top down" e la modularità. E' il più utilizzato
nelle università per la soluzione di problemi, anche molto
complessi. E' stato scelto dal ministero della Pubblica
Istruzione come linguaggio ufficiale del Piano Informatico
Nazionale. La versione di maggior successo è l'UCDS
Pascal realizzato dall'Università di San Diego (California).
100
PERL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
Fine anni 80 Lary Wall
Ha dentro di sé caratteristiche prelevate da numerosi
linguaggi. Chi ha programmato con le shell script
riconoscerà qualcosa della Bourne shell e della C shell,
così come certe altre istruzioni ricordano il sed, l'AWK, il C,
passando addirittura per alcuni dialetti del BASIC.
Linguaggio scripting
3 GL
IN G
Il PERL è un linguaggio di programmazione scritto da Larry
Wall con l'ausilio di centinaia di altre persone sparse per il
mondo unite solo da una simile passione ed una
connessione
alla
grande
rete.
La caratteristica peculiare di questo linguaggio è la libertà di
espressione che consente al programmatore. E’ un
linguaggio “ridondante” dal punto di vista delle strutture
logiche e di flusso. Questo rende più facile per un
programmatore accostarsi al linguaggio.
101
PHP
ANNO DI NASCITA
1994 Lerdorf
GENITORI
C , JAVA , PERL
TIPO DI LINGUAGGIO
Scripting
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Il funzionamento è molto simile a quello della tecnologia ASP
(proprietaria della Microsoft), offrendo però molte più
funzionalità. Un altro vantaggio è che si tratta di una
tecnologia "aperta", disponibile sia per piattaforme Unix che
Windows. I siti realizzati possono quindi essere trasferiti da
una macchina Unix ad una Windows senza particolari
difficoltà. Una delle funzionalità più importanti del linguaggio
PHP consiste nella possibilità di interfacciarsi con tutti i
principali Database presenti sul mercato. Linguaggio
scripting, non browser dipendente. Permette lo sviluppo di
pagine dinamiche.Opera nel lato server, quindi prima che le
pagine giungano al browser.
102
PILOT
ANNO DI NASCITA
1969 S. Francisco Medical Center (California)
GENITORI
--TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale, applicativo
GENERAZIONE
3GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Programmed Inquiry, Language Or Teaching (Linguaggio o
insegnamento, indagine programmata) Linguaggio di
program mazione
usato
principalmente
per
creare
applicazioni per istruzioni guidate dal computer. Sintassi
molto scarna. Si tratta di un linguaggio che permette di
preparare programmi di insegnamento e di apprendimento
con il supporto del computer e di quiz per esami.
103
PL-1
ANNO DI NASCITA
1964
GENITORI
FORTRAN, ALGOL 60, COBOL
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
(Programming Language)
Incorpora le migliori caratteristiche del FORTRAN e del
COBOL, ma ha avuto limitata diffusione a causa della sua
notevole complessità, che lo rende difficile da imparare.
104
POP
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
1966 Edimburgo
funzionale
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio interpretato con notazione polacca inversa
Versioni Pop: 1,2,10,9x
105
PROGRAPH
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
1982 Pietrzykowski
Pascal
Imperativo procedurale
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
106
PROLOG
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
1972 Colmerauer Roussel Università di Marsiglia
--Dichiarativo logico
5 GL
IN G
Il PROLOG è definito come linguaggio descrittivo,
perché un programma implementato in questo
linguaggio è costituito da una descrizione del
problema, anziché da una serie di passi che
specificano il modo in cui il computer deve lavorare
per risolvere il problema, come accade nei linguaggi
imperativi. Il programmatore non può gestire la
sequenza
di
esecuzione,
in
questo
senso
consideriamo il prolog come dichiarativo.
Tipi di dato:
Ø Numeri
Ø Stringhe
Ø Simboli
Ø Oggetti compositi
Versioni Prolog: I, II, III, +, ++…
107
REBOL
ANNO DI NASCITA
Giugno 1997 Carl Sassenrath
GENITORI
SCHEME, LISP e FORTH
TIPO DI LINGUAGGIO
Linguaggio funzionale, distribuiti
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio progettato per lo sviluppo e la progettazione di
applicazioni e servizi di rete. Ciò che rende decisamente
interessante il linguaggio sono sicuramente tre aspetti:
1. il supporto nativo ai protocolli di rete;
2. il supporto al parsing basato su grammatiche;
3. i tipi di dato consentiti.
I protocolli di rete supportati sono:
Ø Finger;
Ø Whois;
Ø Daytime;
Ø SMTP;
Ø POP;
Ø HTTP;
Ø FTP;
Ø NNTP.
Il linguaggio ha una sintassi simile a quella del linguaggio
LOGO e quindi vicina a quella del LISP
108
RPG
ANNO DI NASCITA
1965 Ibm
GENITORI
TIPO DI LINGUAGGIO
Applicativo
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Nato per la gestione delle stampe, dopo 3 versioni il
linguaggio si dimostrò utile non solo per questo, infatti un
programma di medie difficoltà scritto in assembler richiedeva
un mese uomo, in COBOL sette in rpg 1.
Vengono supportati i seguenti tipi di dato:
Ø Numeri interi e reali
Ø Stringhe
Ø Record
Versioni Rpg: 2, 3, 400
109
SCHEME
ANNO DI NASCITA
1995
GENITORI
LISP
TIPO DI LINGUAGGIO
Linguaggio funzionale, scripting
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Scheme è un linguaggio di programmazione discendente dal
LISP, inventato da Guy Lewis Steele Jr. e Gerald Jay
Sussman nel 1995 presso il MIT. Scheme è importante
soprattutto in quanto lo si ritrova utilizzato in situazioni
estranee alla realizzazione di programmi veri e propri; in
particolare, i fogli di stile DSSSL. Il linguaggio Scheme ha una
filosofia che si basa fondamentalmente sul suo tipo di
notazione. È un dialetto del LISPed è particolarmente indicato
per sviluppare programmi inerenti all'Intelligenza Artificiale. Di
grande efficacia didattica grazie alla sua estrema semplicità
una volta conosciute le essenziali parole chiave.
110
SETL
ANNO DI NASCITA
1969; Jacob T. Schwartz, Courant Institute, 1970
GENITORI
--TIPO DI LINGUAGGIO
Imperativo procedurale
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio altamente dinamico
Tipi di dati:
Ø Numeri interi e reali
Ø Stringhe
Ø Booleani
Implementazioni disponibili per Unix, Dos e Macintosh.
Il primo traduttore Ada è stato scritto in SETL
111
SGML
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
1986 Charles Goldfarb
GML
Markup
3 GL
IN G
Lo Structured Generalized Markup Language, detto
comunemente SGML, è un metalinguaggio, definito in
svariati e corposi standard ISO, che consente di descrivere
formalmente un linguaggio tipo markup (es. HTML).
Più precisamente lo SGML è un sistema di generic markup.
E’ un linguaggio astratto che consente la definizione di un
insieme di tag (marcatori) per descrivere la struttura logica
di un testo piuttosto che la sua forma grafica. Tale struttura
astratta deve essere definita per ogni tipo di documento, e
individua una classe di documenti che presentano le
medesime caratteristiche strutturali. La struttura astratta del
testo nell’ SGML viene specificata dichiarando gli elementi
che la costituiscono e le relazioni gerarchiche tra loro in
una parte specifica del documento SGML, denominata
Document Type Definition
112
SML
ANNO DI NASCITA
1984 Milner
GENITORI
ML
TIPO DI LINGUAGGIO
Funzionale, imperativo procedurale
GENERAZIONE
3GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
E’ la versione standardizzata di Ml.
Altra versione Sml/NJ: Standard ML del New Jersey
Varie estensioni: Sml # (aggiunge polimorfismo)
113
SNOBOL
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
1962 Griswold and Faber, Bell Labs
Linguaggio imperativo procedurale, applicativo
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
Consente la facile gestione del suono e la simulazione di
automi. E' utilizzato particolarmente nella linguistica, nel
calcolo combinatorio, nella realizzazione di coursware CAI e
nella teoria dei giochi.
La versione più importante è la 4(‘70), la potenza del
linguaggio e le sue caratteristiche sono tali da rendere un
programma illeggibile dopo la scrittura.
114
SQL
ANNO DI NASCITA
1974 Donald Chamberlin
GENITORI
TIPO DI LINGUAGGIO
Applicativo
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN
GRANDE(G)/PICCOLO(P)
IN BREVE
Attualmente è in corso un processo di revisione del
linguaggio da parte dei comitati ANSI e ISO, che dovrebbe
portare alla definizione di ciò che al momento è noto come
SQL3. Le caratteristiche principali di questa nuova
incarnazione
di
SQL dovrebbero
essere
la
sua
trasformazione in un linguaggio stand-alone (mentre ora
viene usato come linguaggio ospitato in altri linguaggi) e
l'introduzione di nuovi tipi di dato più complessi per
permettere, ad esempio, il trattamento di dati multimediali.
Usato come interfaccia per altri linguaggi (Ada, C, COBOL)
115
SR
ANNO DI NASCITA
‘90
GENITORI
TIPO DI LINGUAGGIO
Linguaggio Concorrente
GENERAZIONE
4 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
(Synchronizing Resources). E’ un linguaggio per la stesura di
programmi concorrenti
116
SUPERLOGO
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
--LOGO
Linguaggio funzionale, applicativo
4G
IN P
SUPERLOGO - Linguaggio didattico per sistema operativo
MS/DOS, prodotto dalla societa' SIS.CO. di Roma.
117
TCL
ANNO DI NASCITA
1989
GENITORI
PERL
TIPO DI LINGUAGGIO
Linguaggio imperativo procedurale, scripting
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN G
GRANDE(G)/PICCOLO(P)
IN BREVE
Ideato da John Ousterhout nel 1989, oggi ingegnere della Sun.
Si tratta di un linguaggio di script, scritto interamente in C, la
cui sintassi ricorda molto il PERL. La sua caratteristica
principale consiste nella sua capacità di integrarsi in qualsiasi
programma C, a tal punto che quest'ultimo può usare
l'interprete tcl per eseguire uno script. A differenza del PERL,
TCL è dotato di una propria shell attivabile lanciando il
comando tclsh. Il prompt di Linux diventa un segno di
percentuale % e il sistema attende che siano impartiti comandi
validi, permettendo una sorta di programmazione interattiva
abbastanza limitata. Infatti il modo più comune per
programmare consiste nello scrivere il codice con un editor,
salvare e rendere eseguibile il file appena creato.
118
TEX
ANNO DI NASCITA
1982 Donald E. Knuth
GENITORI
TIPO DI LINGUAGGIO
Applicativo
GENERAZIONE
3 GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio di programmazione con cui si possono preparare
complesse macro per la manipolazione e la composizione
del testo. Molto usato per le formule matematiche.
Esistono varie versioni free per Unix, Mac, Linux, Windows.
Versioni: Tex 78, 82
119
VERILOG
ANNO DI NASCITA
1985 Phil Moorby
GENITORI
TIPO DI LINGUAGGIO
Applicativo
GENERAZIONE
3GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio di simulazione descrizione hardware
Fino al 1991 era un linguaggio privato, in seguito al formarsi
del Ovi molte piccole aziente utilizzano VERILOG.
Nel 1993 diventa lo standard 1364 dello IEEE.
120
VHDL
ANNO DI NASCITA
1985; IEEE Standard 1076, 1987
GENITORI
TIPO DI LINGUAGGIO
Applicativo
GENERAZIONE
3GL
PROGRAMMAZIONE
IN P
GRANDE(G)/PICCOLO(P)
IN BREVE
Linguaggio di simulazione e di modellistica destinato allo
studio ed al disegno dei circuiti integrati digitali. Il nome è un
acronimo di linguaggio di descrizione del hardware VHSIC.
E’ ampiamente utilizzato nelle applicazioni CAD per lo
sviluppo di circuiti digitali anche di notevole complessità
I vantaggi di realizzare il proprio progetto in VHDL è che il
linguaggio consente una discreta astrazione dall'HW sul
quale verrà poi sintetizzato il progetto.
121
XML
ANNO DI NASCITA
GENITORI
TIPO DI LINGUAGGIO
GENERAZIONE
PROGRAMMAZIONE
GRANDE(G)/PICCOLO(P)
IN BREVE
Febbraio 1998
SGML, HTML
Markup
3 GL
IN G
XML è l’acronimo di eXtensible Markup Language.
Creato in seno al W3C (World Wide Web Consortium), tale
sistema è stato ufficializzato con il rilascio della "XML
Recommendation 1.0". L’interesse generato da questo
nuovo linguaggio deriva dalla malcelata insofferenza verso
i limiti dell’HTML, ed in particolare della sua scarsa
personalizzazione.
L’XML è importante in due classi di applicazioni Web: la
creazione di documenti e lo scambio dei dati.
La sintassi dell’XML è molto simile a quella dell’HTML, ma
molto più rigida e severa; non è limitato a un insieme fisso
di tipi di elementi, ma permette di definire e utilizzare
elementi e attributi personalizzati; per far questo è fornita
una sintassi con cui è possibile specificare gli elementi e gli
attributi che possono essere utilizzati all’interno dei
documenti
L’XML può essere utilizzato come piattaforma per lo
scambio di dati tra le applicazioni.
122