Transcript Programmazione “VINTAGE”

Programmazione “VINTAGE”
…
Quando i programmatori erano geni e non
polli allevati in batteria
...
Luigi Catuogno
HCSSLug Salerno
[[email protected]]
Erano gli anni cinquanta....
Erano gli anni cinquanta...
1951 – Klaatu e Gort
atterrano a
Washington. Gli alieni
esistono... e ce l'hanno
con noi.
Erano gli anni cinquanta...
1953 - Il 2 giugno
veniva incoronata la
Regina Elisabetta II
Erano gli anni cinquanta
1954 – Godzilla attacca
il Giappone
Erano gli anni cinquanta...
1957 – il 4 ottobre,
l'Unione
Sovietica
lanciava sua sfida alla
scienza
occidantale,
mettendo in orbita il
primo statellite artificiale:
lo “SPUTNIK”.
Iniziava la “corsa allo
spazio”.
Erano gli anni cinquanta...
1958 – il 20 febbraio
viene promulgata la
“Legge Merlin” che
chiude le case di
tolleranza.
Erano gli anni cinquanta...
Tra il 54 e il 57 furono sviluppati, in ambiente
militare e scientifico, numerosi linguaggi di
programmazione.
●
FORTRAN (John Backus, IBM, 1954)
–
Fortran 9*, Fortran 2008
●
FLOW-MATIC (Grace Hopper, 1955)
●
COMTRAN (Bob Bemer, 1957)
●
Tra il 1956 e il 1958 John McCarthy lavora al LISP
LISP
John McCarthy (1927-2011)
Turing Award 1971
Steve Russell (1937)
LISP
●
●
●
LISt Processing
–
Ideato da John McCarthy nel 1958
–
Primo interprete LISP realizzato da Steve Russell nel
1959
–
Primo compilatore LISP completo realizzato da Tim
Hart e Mike Levin nel 1962
Paradigma di programmazione funzionale
E' il linguaggio più utilizzato nelle applicazioni di
intelligenza artificiale
LISP
●
Ha riscosso uno straordinario successo
–
Nonostante sia il secondo linguaggio ad alto livello più
vecchio (dopo il FORTRAN), è ancora molto diffuso in
numerosi dialetti
●
●
●
–
Franz LISP
MIT Scheme
Common LISP
Standard
●
●
ANSI Common LISP [ANSI INCITS 226-1994(R2004)]
IEEE SCHEME [IEEE 1178-1990 (R1995)]
LISP
●
Varianti “specializzate”:
–
AutoLISP
●
–
Emacs-LISP
●
–
Dialetto specializzato nella creazione e manipolazione di oggetti
3D nell'applicativo AutoCAD
Dialetto LISP utilizzato per la realizzazione e configurazione di
funzionalità estese dei text editor della famiglia Emacs
Nyquist
●
Dialetto LISP utilizzato per la sintesi dei suoni, gestione e
manipolazione di file MIDI, etc. E' anche utilizzato per la
realizzazione di effect plug-ins per l'applicazione Audacity.
LISP
●
●
●
Un programma LISP è composto da
espressioni simboliche dette S-espressioni
In LISP non c'è distinzione tra espressioni e
istruzioni
Le espressioni
–
Sono rappresentate in notazione prefissa
–
Sono contenute in liste
LISP
●
Tipi di dati
–
Atomi
●
●
–
Liste
●
●
Numeri
Simboli
Sequenze ordinate di atomi/liste
Espressioni
–
Liste il cui primo elemento è un operatore
LISP
>(+ 1 3)
4
>
>(list 1 2 3 4 5 6 7)
(1 2 3 4 5 6 7)
>
+ ­ / * : operatori aritmetici
(list ..): costruttore di liste
' : operatore quote
>(list '(1 2 3) 'a '(5 (6 z)))
((1 2 3) a (5 (6 z)))
>
>(list (+ 10 1 100) (* 5 6))
(111 30)
>
(eval ): valuta una lista come espressione
(print ..): visualizza il risultato di una espressione (built­in)
>(eval (list '+ (+ 10 1 100) (* 5 6)))
141
>
>(print “Hello!”)
Hello!
>
LISP
>(defun F (x y)
(/ (­ x y) (+ x y)))
>(F 3 2)
­1/5
>
(if (expr cond.) (expr­then) (expr­else)) operatori aritmetici
(defun nomef (lista param)(expr)): definizione di funzioni
>(defun fatt (x)
(if (= x 0) (1)
(* x (fatt (­ x 1)))))
>(fatt 3)
6
>
>(sqrt 2) 1.4142135
>(sqrt ­1.0)
#C(0 1.0)
>
(fn. Matem.): sqrt, sin, cos ….
(fn. Stringhe.): length, reverse
subseq ….
>(reverse “abcd”) “dcba”
>(subseq “Hello” 2 4)
“ll”
>(length “Hello”)
5
>
LISP
>(append '(a b) '(c d))
(a b c d)
>(cons 1 '(2 3 4))
(1 2 3 4)
(op liste): append, cons, car, cadr …
(dotimes (var max exit)(exp)): Itera 0<=var<max sull'espressione exp. Al termine restituisce il risultato dell' espr. exit.
>(car '(1 2 3 4 5))
1
>(cdr '(1 2 3 4 5))
(2 3 4 5)
>(cadr '(1 2 3 4 5))
2
>(cddr '(1 2 3 4 5))
(3 4 5)
>
>(dotimes (x 4 x)
(print (fatt x)))
1
1
2
6
4
>
LISP
>(dolist (x '(a b c d e))
(print x)
A
B
C
D
E
>(dotimes (x 4 x)
(print (fatt x)))
1
1
2
6
4
>
>
(dolist (var (list­items) (exp)): append, cons, car, Itera sull' espressione exp con var assume i valori in list­items
(dotimes (var max exit)(exp)): Itera 0<=var<max sull'espressione exp. Al termine restituisce il risultato dell' espr. exit.
LISP
●
LISP MACHINE
–
MIT (1973) e diverse
compagnie
●
●
●
–
Hardware ottimizzato per
software AI scritto in LISP
●
●
Knight LISP Machine (1973)
XeroX
Texas Instruments
Lisp Machines INC.
●
●
Grarbage Collection
Tagged Architecture
Words da 24 a 40 bit
Istruzioni speciali
LISP
●
LISP MACHINE
–
Sistema operativo e
applicazioni scritti in LISP
●
●
–
Rapido declino all'inizio
dell'era dei PC
●
Symbolics – Serie 3600 (1983)
Genera/Open Genera (1982)
Emacs (1976)
Non una delle compagnie
nate per produrre LISP
Machines è sopravvissuta
Linguaggi funzionali odierni...
●
●
ML – MetaLanguage (1973) e I derivati CAML
e OCAML
Erlang (1986), linguaggio di programmazione
“proprietario” di Ericsson, per lo sviluppo della
parte software dei prodotti dell'azienda.
1959
Barbie entra in
commercio
1959
Una equipe guidata da
Grace Murray Hopper
progetta il COBOL
COBOL
Grace Murray Hopper (1906-1992), et al.
COBOL
●
●
●
●
COmmon Business-Oriented Language
Realizzato da una commissione di esperti guidata da Grace M. Hopper nel
1959, come sintesi di diversi linguaggi business-oriented esistenti all'epoca:
–
COMTRAN (COMmercial Translator) [Bob Bemer, 1957]
–
FLOW-MATIC [G. Hopper et al. , 1955]
–
FACT [Honeywell, 1959]
Ha avuto un grandissimo successo soprattutto negli anni '60 e '70
–
Caratterizzato da estrema affidabilità, è ancora oggi utilizzato in applicazioni
bancarie e commerciali.
–
Negli anni si è evoluto incorporando le principali innovazioni apparse nel panorama
dei linguaggi (programmazione strutturata, Object-Oriented Programming)
L'ultimo standard è stato definito nel 2002
COBOL
●
●
Il COBOL è caratterizzato da una grammatica alquanto prolissa e discorsiva.
–
Grace Hopper sosteneva che i linguaggi di programmazione dovessero essere il più
possibie vicini alla lingua umana piuttosto che al linguaggio macchina
–
Nel tempo molte rigidità del linguaggio (tabulazioni fisse, segni di interpunzione ed
“intercalari”) sono state sfumate o rimosse.
Un programma COBOL è diviso in 4 sezioni (division)
–
Identification Division
●
–
Environment Division
●
–
Descrive le risorse (devices, memorie di massa) utilizzati dal programma
Data Division
●
–
Serve per l'identificazione dei programmi in ambiente multiprogrammato
Descrive il formato dei dati elaborati dal programma (File e dati temporanei)
Procedure Division
●
Contiene le istruzioni ed il flusso logico necessari per produrre l'output dai dati in input
COBOL
●
Il COBOL originario
–
linguaggio non strutturato
–
tipi di dati numerici e letterali:
●
●
●
1000.00, 34-, 'Stringa'
I dati sono organizzati gerarchicamente in File, Recod e
Campi
Dimensione, formato, tipologia e disposizione dei campi
nei record sono descritti dalle cosiddette “clausole
picture”
COBOL
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
IDENTIFICATION DIVISION.
PROGRAM'ID. 'SAMPLE'.
ENVIRONMENT DIVISION.
FILE­CONTROL. SELECT EMPLOYEE­CARDS ASSIGN TO READER.
SELECT PAYROLL­FILE ASSIGN TO TAPE 1.
DATA DIVISION.
FD EMPLOYEE­CARDS
01 EMPLOYEE­RECORD.
02 EMPLOYEE­NAME
PICTURE A(20).
02 HOURS­WORKED
PICTURE 9(2).
02 HOURLY­RATE
PICTURE 9V99.
FD PAYROLL­FILE
01 PAYROLL­RECORD.
02 NAME­OUT
PICTURE A(20).
02 HOURS­OUT
PICTURE 9(2).
02 RATE­OUT
PICTURE 9V99.
02 WEEKLY­WAGES
PICTURE 999V99.
PROCEDURE­DIVISION.
START. READ EMPLOYEE­CARDS AT END GO TO FINISH.
...
COBOL
01
18
19
20
21
22
23
24
25
26
IDENTIFICATION DIVISION.
...
PROCEDURE­DIVISION.
START. READ EMPLOYEE­CARDS AT END GO TO FINISH.
MOVE EMPLOYEE­NAME TO NAME­OUT.
MOVE HOURS­WORKED TO HOURS­OUT.
MOVE HOURLY­RATE TO RATE­OUT.
MULTIPLY HOURS­WORKED BY HOURLY­RATE GIVING WEEKLY­WAGES.
WRITE PAYROLL­RECORD.
GO TO START.
FINISH. STOP RUN.
COBOL
EMPLOYEE­CARDS
NAME­OUT
HOURS­OUT
RATE­OUT
WEEKLY­WAGES
EMPLOYEE­NAME
HOURS­WORKED
HOURLY­RATE
PAYROLL­FILE
MULTIPLY
COBOL
●
Alcuni compilatori (Free) disponibili in rete:
–
OpenCOBOL
●
–
TinyCOBOL
●
–
http://opencobol.org
http://tiny-cobol.sourceforge.net
COBOL for GCC
●
http://cobolforgcc.sourceforge.net
A cavallo tra i 50 e i 60...
●
Raffinamento dei principali linguaggi.
–
FORTRAN II (1958) e FORTRAN IV (1962)
–
COBOL 61 (1961)
●
Nuovi linguaggi
●
ALGOL
–
Algol 58 e Algol 60
ALGOL
Friedrich L. Bauer
(1924)
Alan Jay Perlis
(1922-1990)
Turing Award 1966
Klaus Samelson (1918-1980)
John Warner Backus
(1924-2007)
Turing Award 1977
Charles Katz
Heinz Rutishauser (1918-1970)
Joseph Henry Wegstein
Hermann Bottenbruch
ALGOL
●
ALGOrithmic Language
●
Definito da una commissione “bilaterale” di esperti provenienti da:
●
●
–
Association for Computing Machinery (ACM) - USA
–
Gesellschaft für Angewandte Mathematik und Mechanik (Society of Applied
Mathematics and Mechanics) (GAMM) – DE
Scopo: fornire uno strumento per descrivere formalmente gli
algoritmi
Sebbene non sia attualmente più utilizzato è stato forse il
linguaggio più influente che sia mai stato realizzato.
–
●
Introduzione della programmazione strutturata a blocchi
Principali revisioni:
–
Algol 58, Algol 60, Algol 68
ALGOL
●
Il linguaggio ALGOL è stato la base di
partenza per numerosi linguaggi successo che
ne hanno ereditato la morfologia e gran parte
della grammatica:
–
SIMULA
●
Il primo linguaggio ad oggetti
–
PASCAL (e derivati)
–
ADA
ALGOL
begin
integer N;
Read Int(N);
begin
real array Data[1:N];
real sum, avg;
integer i;
sum:=0;
for i:=1 step 1 until N do
begin real val;
Read Real(val);
Data[i]:=if val<0 then ­val else val
end;
for i:=1 step 1 until N do
sum:=sum + Data[i];
avg:=sum/N;
Print Real(avg)
end
end ●
Ciascuna revision del
linguaggio ALGOL è
stata implementata in
diversi dialetti,
talvolta piuttosto
diversi tra loro
–
ALGOL-W [Wirth,
Hoare- 1966],
variante dell'Algol 60
diede poi origine al
PASCAL
ALGOL
●
●
Algol 68 era un linguaggio molto vasto,
ambizioso e complesso.
–
Definizione di nuovi tipi
–
Supporto alla programmazione concorrente
–
Sintassi meno rigida e verbosa
Molte delle idee chiave di ALGOL 68
confluirono nel progetto del linguaggio ADA
Arrivano I favolosi anni 60
1961 – Jurij Gagarin è il
primo uomo in orbita
intorno alla terra.
1965 – Aleksej Leonov
compie la prima
“passeggiata spaziale”
Gli americani
rosicano...
Arrivano I favolosi anni 60...
1962 – James Bond ottiene la sua “Licenza di
uccidere”
Arrivano I favolosi anni 60
1962 – E' autorizzata la
somministrazine del
vaccino anti-polio di
Albert Sabin (1906-1993).
Sabin non volle
brevettare la sua
invenzione per renderla
accessibile a tutti I
bambini del mondo
Arrivano I favolosi anni 60...
1963 – A Dallas, JFK,
35-esimo Presidente
degli USA, muore
(sembra) per mano di
Lee Harvey Oswald
Arrivano I favoloso anni 60
1964 – Mary Quandt
inventa la minigonna
Arrivano I favolosi anni 60...
1969 - Neil Armstrong è
il primo uomo a mettere
piede sulla Luna.
I Sovietici (ancora)
rosicano
Arrivano I favolosi anni 60...
●
Gli antenati dei moderni lignuaggi di
programmazione nascono in questi anni
–
SIMULA (1962) Primo linguaggio a oggetti
–
BASIC (1964)
–
BCPL (1967) Capostipite della famiglia dei
linguaggi “con le parentesi graffe”
●
●
Linguaggio B (1969)
Linguaggio C (1972)
–
Obective-C (1982), C++ (1983), Java (1995)
BASIC
Thomas Eugene Kurtz (1928)
John George Kemeny (1926-1992)
BASIC
●
●
●
●
Beginners' All-purpose Symbolic Instruction
Code
Originariamente progettato da John George
Kemeny e Thomas Eugene Kurz al Dartmouth
College NH (USA) nel 1964
Linguaggio di impiego generale destinato a
principianti
In parte ispirato al linguaggio FORTRAN II
BASIC
●
Linguaggio di enorme successo soprattutto negli anni ottanta
●
Ambiente interattivo per “Home computers”
●
–
Ambiente di sviluppo
–
Sistema operativo
Prodotto in numerosi dialetti
–
DartmouthBasic [Kemeny-Kurtz, 1964]
–
Tiny Basic [Dennis Allison, 1975]
–
Altair Basic [Gates-Allen-Davidoff, 1975]
●
Microsoft Basic [Gates-Allen, 1975]
–
–
–
–
IBM BASIC A [IBM, 1981]
GW-BASIC [Microsoft, 1983]
MSX BASIC [Microsoft, 1984]
SuperBasic [Jan Jones-Sinclair research, 1984]
BASIC
●
●
●
Nei primi anni novanta è stato protagonista di una straordinaria
evoluzione
Evoluzione del linguaggio in varie direzioni:
–
Programmazione strutturata a blocchi
–
Object oriented
–
Event driven
Ambiente di sviluppo
–
Ambiente testuale integrato
–
Ambiente grafico
–
Embedded (microcontrollori)
●
PIC-BASIC
BASIC
●
Turbo BASIC [Robert Zale-Borland, 1985]
–
Compatibile con GW-BASIC + programmazione strutturata
–
Ambiente MS-DOS
–
Ambiente integrato + Compilatore
●
●
●
PowerBASIC [Robert Zale, 1989]
QuickBASIC [Microsoft, 1985]
–
Evoluzione di GWBASIC + programmazione strutturata
–
Ambiente integrato + Compilatore
–
Interprete: QBASIC
Visual Basic [Microsoft, 1991]
–
Ambiente di sviluppo per Microsoft Windows
–
Paradigma di programmazione Object-oriented e event-driven
BASIC
●
Altre versioni:
–
Gambas [Benoit Minisini, 1999]
●
●
●
●
–
Interprete + ambiente integrato grafico
Linux, FreeBSD
Simile a Visual Basic
Object oriented, event-driver
FreeBASIC [Andre Victor, 2004]
●
●
●
Compilatore 32-bit per Windows, Linux, FreeBSD
Compatibile QuickBasic
Object Oriented
BASIC
10 READ A1, A2, A3, A4
15 LET D = A1 * A4 ­ A3 * A2
20 IF D = 0 THEN 65
30 READ B1, B2
37 LET X1 = (B1 * A4 ­ B2 * A2)
42 LET X2 = (A1 * B2 ­ A3 * B1) / D
55 PRINT X1, X2
60 GO TO 30
65 PRINT "NO UNIQUE SOLUTION"
70 DATA 1, 2, 4
80 DATA 2, ­7, 5
85 DATA 1, 3, 4, ­7
90 END
Esempio tratto da: A Manual for BASIC, the elementary algebraic language
designed for use with the Dartmouth Time Sharing System”, Dartmouth College
Computation Center, October, 1964.
BASIC
1. While loop con l'istruzione goto
(Dartmouth Basic)
3. While loop (quick/turbo basic)
100 print "while x<10 do..."
110 x=0
120 print "Inizio loop": goto 150
130 print using "body ­­> x=##"; x
140 x=x+1
150 if x<10 then goto 130
160 print using "End loop: x=##"; x
print "while x<10 do..."
x=0
while x<10
print using "body­­> x=##"; x
x=x+1
wend
print using "End loop: x=##"; x
2. While loop (gwbasic)
4. While loop (Visual Basic)
120 print "while x<10 do..."
130 x=0
140 print "Inizio loop"
150 while x<10
160 print using "body­­> x=##"; x
170 x=x+1
180 wend
190 print using "End loop: x=##"; x
Dim x As Integer = 0
Print "while x<10 do..."
Do While x<10
print using "body­­> x=##"; x
x=x+1
Loop
print using "End loop: x=##"; x
BASIC
1. Chiamata a subroutine con gosub
(MSX Basic 1.0)
2. Chiamata a subroutine
(Sinclair QL SuperBASIC)
100 PRINT "Subroutine menu"
110 A$=””
120 PRINT "­­­ 1: Subroutine A"
130 PRINT "­­­ 2: subroutine B"
140 PRINT "­­­ X: exit"
160 INPUT "Scelta: ", A$
170 IF A$="X" THEN GOTO 300
180 IF A$="1" THEN GOSUB 1000
190 IF A$="2" THEN GOSUB 2000
200 GOTO 100
300 PRINT “Fine programma”
310 END
1000 PRINT "eseguo subroutine A"
1010 RETURN
2000 PRINT "eseguo subroutine B"
2010 RETURN
100 REPEAT menu
110 Print "Subroutine menu"
130 Print "­­­ 1: Subroutine A"
140 Print "­­­ 2: subroutine B"
150 Print "­­­ X: exit"
160 Input "Scelta: ", A$
180 IF A$="1" THEN Opzione1
190 IF A$="2" THEN Opzione2
200 IF A$=”X” THEN EXIT menu
190 END REPEAT menu
310 END
1000 DEFine PROCedure Opzione1
1010 PRINT “eseguo subroutine A”
1020 END DEFine Opzione1
2000 DEFine PROCedure Opzione2
2010 PRINT “eseguo subroutine B”
2020 END DEFine Opzione2
BASIC
3. Chiamata a subroutine
(Turbo Basic)
4. Chiamata a subroutine
(Gambas)
DO
print "Subroutine menu"
print "­­­ 1: Subroutine A"
print "­­­ 2: Subroutine B"
print "­­­ X: exit"
input "Scelta: ", A$
if A$="1" then CALL Opzione1
if A$="2" then CALL Opzione2
if A$="X" then end
LOOP UNTIL A$="X"
END
SUB Opzione1
print "eseguo subroutine A"
END SUB
SUB Opzione2
print "eseguo subroutine B"
END SUB
PUBLIC SUB Main()
DIM A$ AS String = ""
DO
PRINT "Subroutine menu"
...
SELECT CASE A$
CASE "1"
Opzione1
CASE "2"
Opzione2
END SELECT LOOP UNTIL A$ = "X"
END
PUBLIC SUB Opzione1()
PRINT "eseguo subroutine A"
END
PUBLIC SUB Opzione2()
PRINT "eseguo subroutine B"
END
L'età dell'oro del BASIC
L'età d'oro del BASIC
PILOT
John Amsden Starkweather (1925-2001)
PILOT
●
●
●
●
Programmed Inquiry, Learning Or Teaching
Sviluppato da John Amsden Starkweather nel
1968, Professore di psicologia alla UCSF
Derivato da un precedente linguaggio per la
realizzazione di test di apprendimento
(Computest) del 1962
Linguaggio con finalità didattiche (talvolta
accostato al LOGO)
PILOT
●
Alcuni requisiti:
–
Uso di comandi semplici rispondenti a chiare
necessità
–
Facilità di apprendimento: i principianti dovrebbero
essere in grado di scrivere programmi dopo un ora
di istruzione e pratica
–
Il linguaggio deve fornire immediato feedback al
programmatore
●
Il software di sviluppo deve sempre includere un interprete
interattivo
PILOT
●
●
Caratterizzato da una estrema semplicità
Ha avuto una certa diffusione negli anni 70-80, in
cui rappresentava un'alternativa al BASIC
–
●
Atari PILOT [Atari, 1983] distribuito su cartridge per la
famiglia Atari 8-bit
Standard IEEE 1154-1991 – Standard for
Programmed Inquiry, Learning, or Teaching
(PILOT).
–
Lo standard è stato ritirato (ultima versione 2002).
Atari PILOT
PILOT
●
Materiale su PILOT è ancora reperibile su internet
●
Pilot resource center
●
–
“The world's only web page devoted to PILOT (it's true!)”
–
http://rpilot.sourceforge.net/pilot.html
Interpreti:
–
RPILOT [Rob Linwood, 1998]
–
●
●
●
Confluito in Sky PILOT [Linwood, 2005], apparentemente abortito.
GPL
Ultima versione 1.4.2
Compilazione su Linux odierni con “qualche intoppo”
PILOT: il linguaggio
Key letter
Key word
Descrizione
T
Type
Visualizza testo
A
Accept
Accetta input da tastiera
M
Match
Lista di elementi da confrontare
J
Jump
Salto
U
Use
Chiamata a subroutine
C
Compute
Assegnamento
G
Graphic
Operazioni grafiche
F
File
File I/O
R
Remark
Commento
Y
Yes
Visualizza un testo se il precedente match è riuscito
N
No
Visualizza un testo se il precedente match à fallito
E
End
Terminazione di subroutine o di programma
PILOT: il linguaggio
●
Tipi di dato:
–
Numeri
●
–
Caratteri/stringhe
●
●
Variabili intere: #a, #b, #media
Variabili stringa: $nome, $cognome
Label:
–
Nel testo del programma: *main, *check
–
Nelle istruzioni di salto: main, check
PILOT: il linguaggio
●
Istruzioni:
*<label>
:
<key-letter>|<key-word>(<condition>): [<arg> [<arg>..]]
<key-letter>|<key-word> [<arg> [<arg>..]]
–
Esempi:
*main
TYPE: Salve Mondo!
C(#d<>0): #quot=1000/#d
J: main
PILOT: il linguaggio
R: Un classico...
T: Salve Mondo!
R: Input dati e assegnamento
T: Inserisci due numeri:
A: #primo
A: #secondo
C: #somma=#primo+#secondo
T: Il risultato e': #somma
R: Salto condizionato
T: Inserisci un numero da 1 a 10
A: #num
J(#num <1): error
J(#num >10): error
T: Ok!
E:
*error
T: Error!
E:
PILOT: il linguaggio
R: Istruzioni condizionate
C: #ris=0
T: Immetti dividendo
A: #dnd
J(#dnd=0): endpro
T: Immetti divisore
A: #dsr
C(#dsr<>0): #ris= #dnd/#dsr
*endpro
T: Il risultato e' #ris
R: Calcolo del fattoriale
C: #ris=1
T: Inserisci un numero >=0:
A: #inum
C: #num=#inum
J(#num<0): error
J(#num=0): exit
*iter
J(#num=1): exit
C: #ris=#num*#ris
C: #num=#num­1
J: iter
*exit
T: #inum fattoriale = #ris
E:
*error
T: Numero non valido
E:
PILOT: il linguaggio
R: Esempio di menu' e subroutine
*main
T: MENU PRINCIPALE
T: A ­ prima scelta
T: B ­ seconda scelta
T: Q ­ esci
A: $op
M: A B Q
J(#matched=0): badch
U(#which=1): doa
U(#which=2): dob
E(#which=3):
J: main
*badch
T: scelta sbagliata
J: main
*doa
T: eseguo A
E:
*dob
T: eseguo B
E:
Anni settanta...
1970 – Semifinale di coppa del mondo: Italia –
Germania 4-3
Anni settanta...
1973 – Esce “the dark
side of the moon” dei
Pink Floyd
Anni settanta...
●
1976 – Debutto del Concorde
Anni settanta...
1977 – Guerre stellari.
La forze è con noi...
Anni settanta e ottanta
●
Vedono il consolidarsi delle principali “famiglie di
linguaggi”
–
FORTRAN
●
–
ALGOL-PASCAL
●
–
Pascal (1970), MODULA-2 (1979), ADA (1983)
BCPL
●
–
FORTRAN77, BASIC
C, C++, …
SIMULA
●
Simula72, Smaltalk(1972)
Linguaggi “di scripting”
●
PL/1 (IBM, 1964)
–
●
Bourn Shell (1977)
–
●
PL/M (Digital Research, 1972), Rexx (1979)
Awk (1979), perl (1987), Ruby (1993)
Python (1991)
Il resto è storia...